def set_items(gene_sets, sets_to_display, genes, callback):
model_items = []
if not genes:
return
for gene_set in sorted(gene_sets):
if gene_set.hierarchy not in sets_to_display:
continue
callback()
matched_set = gene_set.genes & genes
if len(matched_set) > 0:
category_column = QStandardItem()
term_column = QStandardItem()
count_column = QStandardItem()
genes_column = QStandardItem()
category_column.setData(", ".join(gene_set.hierarchy), Qt.DisplayRole)
term_column.setData(gene_set.name, Qt.DisplayRole)
term_column.setData(gene_set.name, Qt.ToolTipRole)
term_column.setData(gene_set.link, LinkRole)
term_column.setForeground(QColor(Qt.blue))
count_column.setData(matched_set, Qt.UserRole)
count_column.setData(len(matched_set), Qt.DisplayRole)
genes_column.setData(len(gene_set.genes), Qt.DisplayRole)
genes_column.setData(
set(gene_set.genes), Qt.UserRole
) # store genes to get then on output on selection
model_items.append([count_column, genes_column, category_column, term_column])
return model_items
def _update_scores(self):
model = self.score_table.model
model.clear()
if self.data is None or self.data.domain.class_var is None:
scorers = []
else:
scorers = usable_scorers(self.data.domain.class_var)
self.score_table.update_header(scorers)
errors = []
for inputid, pred in self.predictors.items():
name = learner_name(pred.predictor)
head = QStandardItem(name)
# head.setData(key, Qt.UserRole)
row = [head]
results = self.predictors[inputid].results
if isinstance(results, str):
head.setToolTip(results)
head.setText("{} (error)".format(name))
head.setForeground(QBrush(Qt.red))
else:
for scorer in scorers:
item = QStandardItem()
try:
score = scorer_caller(scorer, results)()[0]
item.setText(f"{score:.3f}")
except Exception as exc: # pylint: disable=broad-except
item.setToolTip(str(exc))
if scorer.name in self.score_table.shown_scores:
errors.append(str(exc))
row.append(item)
self.score_table.model.appendRow(row)
self.Error.scorer_failed("\n".join(errors), shown=bool(errors))
def get_collections(gene_sets, genes, partial_result, progress_callback):
for gene_set in gene_sets:
category_column = QStandardItem()
name_column = QStandardItem()
matched_column = QStandardItem()
genes_column = QStandardItem()
category_column.setData(", ".join(gene_set.hierarchy), Qt.DisplayRole)
name_column.setData(gene_set.name, Qt.DisplayRole)
name_column.setData(gene_set.name, Qt.ToolTipRole)
name_column.setData(gene_set.link, LinkRole)
name_column.setForeground(QColor(Qt.blue))
if genes:
matched_set = gene_set.genes & genes
matched_column.setData(matched_set, Qt.UserRole)
matched_column.setData(len(matched_set), Qt.DisplayRole)
genes_column.setData(len(gene_set.genes), Qt.DisplayRole)
genes_column.setData(
gene_set.genes,
Qt.UserRole) # store genes to get then on output on selection
progress_callback.emit()
partial_result.emit(
[category_column, genes_column, matched_column, name_column])
def __file_item(self, exists):
item = QStandardItem()
item.setData(self.current_path(), Qt.DisplayRole)
item.setToolTip(self.current_path())
item.setEditable(False)
if not exists:
item.setToolTip("Missing from file system")
item.setForeground(QBrush(QColor(Qt.red)))
return item
def set_items(gene_sets, sets_to_display, genes, ref, count_treshold,
callback):
model_items = []
if not genes:
return
for gene_set in gene_sets:
if gene_set.hierarchy not in sets_to_display:
continue
enrichemnt_result = gene_set.set_enrichment(
ref, genes.intersection(ref))
callback()
if len(enrichemnt_result.query) >= count_treshold:
category_column = QStandardItem()
name_column = QStandardItem()
count_column = QStandardItem()
genes_column = QStandardItem()
ref_column = QStandardItem()
pval_column = QStandardItem()
fdr_column = QStandardItem()
enrichemnt_column = QStandardItem()
category_column.setData(", ".join(gene_set.hierarchy),
Qt.DisplayRole)
name_column.setData(gene_set.name, Qt.DisplayRole)
name_column.setData(gene_set.name, Qt.ToolTipRole)
name_column.setData(gene_set.link, LinkRole)
name_column.setForeground(QColor(Qt.blue))
count_column.setData(len(enrichemnt_result.query),
Qt.DisplayRole)
count_column.setData(set(enrichemnt_result.query), Qt.UserRole)
genes_column.setData(len(gene_set.genes), Qt.DisplayRole)
genes_column.setData(
set(gene_set.genes), Qt.UserRole
) # store genes to get then on output on selection
ref_column.setData(len(enrichemnt_result.reference),
Qt.DisplayRole)
pval_column.setData(enrichemnt_result.p_value, Qt.DisplayRole)
pval_column.setData(enrichemnt_result.p_value, Qt.ToolTipRole)
enrichemnt_column.setData(enrichemnt_result.enrichment_score,
Qt.DisplayRole)
enrichemnt_column.setData(enrichemnt_result.enrichment_score,
Qt.ToolTipRole)
model_items.append([
count_column, ref_column, pval_column, fdr_column,
enrichemnt_column, genes_column, category_column,
name_column
])
return model_items
def run(gene_sets: GeneSets, selected_gene_sets: List[Tuple[str, ...]], genes,
state: TaskState) -> Results:
results = Results()
items = []
step, steps = 0, len(gene_sets)
if not genes:
return results
state.set_status('Calculating...')
for gene_set in sorted(gene_sets):
step += 1
if step % (steps / 10) == 0:
state.set_progress_value(100 * step / steps)
if gene_set.hierarchy not in selected_gene_sets:
continue
if state.is_interruption_requested():
return results
matched_set = gene_set.genes & genes
if len(matched_set) > 0:
category_column = QStandardItem()
term_column = QStandardItem()
count_column = QStandardItem()
genes_column = QStandardItem()
category_column.setData(", ".join(gene_set.hierarchy),
Qt.DisplayRole)
term_column.setData(gene_set.name, Qt.DisplayRole)
term_column.setData(gene_set.name, Qt.ToolTipRole)
# there was some cases when link string was not empty string but not valid (e.g. "_")
if gene_set.link and urlparse(gene_set.link).scheme:
term_column.setData(gene_set.link, LinkRole)
term_column.setForeground(QColor(Qt.blue))
count_column.setData(matched_set, Qt.UserRole)
count_column.setData(len(matched_set), Qt.DisplayRole)
genes_column.setData(len(gene_set.genes), Qt.DisplayRole)
genes_column.setData(
set(gene_set.genes),
Qt.UserRole) # store genes to get then on output on selection
items.append(
[count_column, genes_column, category_column, term_column])
results.items = items
return results
def update_stats_model(self):
# Update the results_model with up to date scores.
# Note: The target class specific scores (if requested) are
# computed as needed in this method.
model = self.score_table.model
# clear the table model, but preserving the header labels
for r in reversed(range(model.rowCount())):
model.takeRow(r)
target_index = None
if self.data is not None:
class_var = self.data.domain.class_var
if self.data.domain.has_discrete_class and \
self.class_selection != self.TARGET_AVERAGE:
target_index = class_var.values.index(self.class_selection)
else:
class_var = None
errors = []
has_missing_scores = False
names = []
for key, slot in self.learners.items():
name = learner_name(slot.learner)
names.append(name)
head = QStandardItem(name)
head.setData(key, Qt.UserRole)
results = slot.results
if results is not None and results.success:
train = QStandardItem("{:.3f}".format(
results.value.train_time))
train.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
train.setData(key, Qt.UserRole)
test = QStandardItem("{:.3f}".format(results.value.test_time))
test.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
test.setData(key, Qt.UserRole)
row = [head, train, test]
else:
row = [head]
if isinstance(results, Try.Fail):
head.setToolTip(str(results.exception))
head.setText("{} (error)".format(name))
head.setForeground(QtGui.QBrush(Qt.red))
if isinstance(results.exception, DomainTransformationError) \
and self.resampling == self.TestOnTest:
self.Error.test_data_incompatible()
self.Information.test_data_transformed.clear()
else:
errors.append("{name} failed with error:\n"
"{exc.__class__.__name__}: {exc!s}".format(
name=name, exc=slot.results.exception))
if class_var is not None and class_var.is_discrete and \
target_index is not None:
if slot.results is not None and slot.results.success:
ovr_results = results_one_vs_rest(slot.results.value,
target_index)
# Cell variable is used immediatelly, it's not stored
# pylint: disable=cell-var-from-loop
stats = [
Try(scorer_caller(scorer, ovr_results, target=1))
for scorer in self.scorers
]
else:
stats = None
else:
stats = slot.stats
if stats is not None:
for stat, scorer in zip(stats, self.scorers):
item = QStandardItem()
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
if stat.success:
item.setData(float(stat.value[0]), Qt.DisplayRole)
else:
item.setToolTip(str(stat.exception))
if scorer.name in self.score_table.shown_scores:
has_missing_scores = True
row.append(item)
model.appendRow(row)
# Resort rows based on current sorting
header = self.score_table.view.horizontalHeader()
model.sort(header.sortIndicatorSection(), header.sortIndicatorOrder())
self._set_comparison_headers(names)
self.error("\n".join(errors), shown=bool(errors))
self.Warning.scores_not_computed(shown=has_missing_scores)
def _update_stats_model(self):
# Update the results_model with up to date scores.
# Note: The target class specific scores (if requested) are
# computed as needed in this method.
model = self.view.model()
# clear the table model, but preserving the header labels
for r in reversed(range(model.rowCount())):
model.takeRow(r)
target_index = None
if self.data is not None:
class_var = self.data.domain.class_var
if self.data.domain.has_discrete_class and \
self.class_selection != self.TARGET_AVERAGE:
target_index = class_var.values.index(self.class_selection)
else:
class_var = None
errors = []
has_missing_scores = False
for key, slot in self.learners.items():
name = learner_name(slot.learner)
head = QStandardItem(name)
head.setData(key, Qt.UserRole)
if isinstance(slot.results, Try.Fail):
head.setToolTip(str(slot.results.exception))
head.setText("{} (error)".format(name))
head.setForeground(QtGui.QBrush(Qt.red))
errors.append("{name} failed with error:\n"
"{exc.__class__.__name__}: {exc!s}".format(
name=name, exc=slot.results.exception))
row = [head]
if class_var is not None and class_var.is_discrete and \
target_index is not None:
if slot.results is not None and slot.results.success:
ovr_results = results_one_vs_rest(slot.results.value,
target_index)
# Cell variable is used immediatelly, it's not stored
# pylint: disable=cell-var-from-loop
stats = [
Try(scorer_caller(scorer, ovr_results))
for scorer in self.scorers
]
else:
stats = None
else:
stats = slot.stats
if stats is not None:
for stat in stats:
item = QStandardItem()
if stat.success:
item.setText("{:.3f}".format(stat.value[0]))
else:
item.setToolTip(str(stat.exception))
has_missing_scores = True
row.append(item)
model.appendRow(row)
self.error("\n".join(errors), shown=bool(errors))
self.Warning.scores_not_computed(shown=has_missing_scores)
def _update_stats_model(self):
# Update the results_model with up to date scores.
# Note: The target class specific scores (if requested) are
# computed as needed in this method.
model = self.view.model()
# clear the table model, but preserving the header labels
for r in reversed(range(model.rowCount())):
model.takeRow(r)
target_index = None
if self.data is not None:
class_var = self.data.domain.class_var
if self.data.domain.has_discrete_class and \
self.class_selection != self.TARGET_AVERAGE:
target_index = class_var.values.index(self.class_selection)
else:
class_var = None
errors = []
has_missing_scores = False
for key, slot in self.learners.items():
name = learner_name(slot.learner)
head = QStandardItem(name)
head.setData(key, Qt.UserRole)
if isinstance(slot.results, Try.Fail):
head.setToolTip(str(slot.results.exception))
head.setText("{} (error)".format(name))
head.setForeground(QtGui.QBrush(Qt.red))
errors.append("{name} failed with error:\n"
"{exc.__class__.__name__}: {exc!s}"
.format(name=name, exc=slot.results.exception))
row = [head]
if class_var is not None and class_var.is_discrete and \
target_index is not None:
if slot.results is not None and slot.results.success:
ovr_results = results_one_vs_rest(
slot.results.value, target_index)
# Cell variable is used immediatelly, it's not stored
# pylint: disable=cell-var-from-loop
stats = [Try(scorer_caller(scorer, ovr_results))
for scorer in self.scorers]
else:
stats = None
else:
stats = slot.stats
if stats is not None:
for stat in stats:
item = QStandardItem()
if stat.success:
item.setText("{:.3f}".format(stat.value[0]))
else:
item.setToolTip(str(stat.exception))
has_missing_scores = True
row.append(item)
model.appendRow(row)
self.error("\n".join(errors), shown=bool(errors))
self.Warning.scores_not_computed(shown=has_missing_scores)
def run(
gene_sets: GeneSets, selected_gene_sets: List[Tuple[str, ...]], genes, state: TaskState, reference_genes=None
) -> Results:
results = Results()
items = []
step, steps = 0, len(gene_sets)
def set_progress():
nonlocal step
step += 1
state.set_progress_value(100 * (step / steps))
if not genes:
return results
state.set_status('Calculating...')
for gene_set in sorted(gene_sets):
set_progress()
if gene_set.hierarchy not in selected_gene_sets:
continue
if state.is_interruption_requested():
return results
reference_genes = [] if reference_genes is None else reference_genes
enrichemnt_result = gene_set.set_enrichment(reference_genes, genes.intersection(reference_genes))
if len(enrichemnt_result.query) > 0:
category_column = QStandardItem()
term_column = QStandardItem()
count_column = QStandardItem()
genes_column = QStandardItem()
ref_column = QStandardItem()
pval_column = QStandardItem()
fdr_column = QStandardItem()
enrichment_column = QStandardItem()
category_column.setData(", ".join(gene_set.hierarchy), Qt.DisplayRole)
term_column.setData(gene_set.name, Qt.DisplayRole)
term_column.setData(gene_set.name, Qt.ToolTipRole)
# there was some cases when link string was not empty string but not valid (e.g. "_")
if gene_set.link and urlparse(gene_set.link).scheme:
term_column.setData(gene_set.link, LinkRole)
term_column.setForeground(QColor(Qt.blue))
count_column.setData(len(enrichemnt_result.query), Qt.DisplayRole)
count_column.setData(set(enrichemnt_result.query), Qt.UserRole)
genes_column.setData(len(gene_set.genes), Qt.DisplayRole)
genes_column.setData(set(gene_set.genes), Qt.UserRole) # store genes to get then on output on selection
ref_column.setData(len(enrichemnt_result.reference), Qt.DisplayRole)
pval_column.setData(enrichemnt_result.p_value, Qt.DisplayRole)
pval_column.setData(enrichemnt_result.p_value, Qt.ToolTipRole)
enrichment_column.setData(enrichemnt_result.enrichment_score, Qt.DisplayRole)
enrichment_column.setData(enrichemnt_result.enrichment_score, Qt.ToolTipRole)
items.append(
[
count_column,
ref_column,
pval_column,
fdr_column,
enrichment_column,
genes_column,
category_column,
term_column,
]
)
results.items = items
return results
