def selectionChanged(self, *args): super().selectionChanged(*args) rows = list({ index.row() for index in self.selectionModel().selectedRows(0) }) if not rows: owwidget.Outputs.data.send(None) return model = self.model().tolist() filters = [ Values([ FilterDiscrete(self._vars[col], {model[row][col]}) for col in range(len(self._vars)) ]) for row in self.model().mapToSourceRows(rows) ] data = Values(filters, conjunction=False)(owwidget.data) annotated = create_annotated_table(owwidget.data, data.ids) owwidget.Outputs.selected_data.send(data) owwidget.Outputs.data.send(annotated)
def get_filtered_data(self): if not self.data or not self.selection or not self.pivot.pivot_table: return None cond = [] for i, j in self.selection: f = [] for at, val in [(self.row_feature, self.pivot.pivot_table.X[i, 0]), (self.col_feature, j)]: if isinstance(at, DiscreteVariable): f.append(FilterDiscrete(at, [val])) elif isinstance(at, ContinuousVariable): f.append(FilterContinuous(at, FilterContinuous.Equal, val)) cond.append(Values(f)) return Values(cond, conjunction=False)(self.data)
def commit(self): if len(self.selection): cluster_ids = set() column_ids = set() for (ir, ic) in self.selection: cluster_ids.add(ir) column_ids.add(ic) new_domain = Domain([ self.data.domain[self.columns.values[col]] for col in column_ids ], self.data.domain.class_vars, self.data.domain.metas) selected_data = Values([ FilterDiscrete(self.cluster_var, [self.clusters[ir]]) for ir in cluster_ids ], conjunction=False)(self.data) selected_data = selected_data.transform(new_domain) annotated_data = create_annotated_table( self.data.transform(new_domain), np.where(np.in1d(self.data.ids, selected_data.ids, True))) else: selected_data = None annotated_data = create_annotated_table(self.data, []) if self.ca is not None and self._task is None: table = self.ca.create_contingency_table() else: table = None self.Outputs.selected_data.send(selected_data) self.Outputs.annotated_data.send(annotated_data) self.Outputs.contingency.send(table)
def test_values(self): vs = self.iris.domain.variables f1 = FilterContinuous(vs[0], FilterContinuous.Less, 5) f2 = FilterContinuous(vs[1], FilterContinuous.Greater, 3) f3 = FilterDiscrete(vs[4], [2]) f12 = Values([f1, f2], conjunction=False, negate=True) f123 = Values([f12, f3]) d12 = f12(self.iris) d123 = f123(self.iris) self.assertGreater(len(d12), len(d123)) self.assertTrue((d123.X[:, 0] >= 5).all()) self.assertTrue((d123.X[:, 1] <= 3).all()) self.assertTrue((d123.Y == 2).all()) self.assertEqual(len(d123), (~((self.iris.X[:, 0] < 5) | (self.iris.X[:, 1] > 3)) & (self.iris.Y == 2)).sum())
def _gather_conditions(self): conditions = [] attr = self.attribute group_attr = self.group_var for data_range in self.selection: if attr.is_discrete: # If some value was removed from the data (in case settings are # loaded from a scheme), do not include the corresponding # filter; this is appropriate since data with such value does # not exist anyway if not data_range.value: condition = IsDefined([attr], negate=True) elif data_range.value not in attr.values: continue else: condition = FilterDiscrete(attr, [data_range.value]) else: condition = FilterContinuous(attr, FilterContinuous.Between, data_range.low, data_range.high) if data_range.group_value: if not data_range.group_value: grp_filter = IsDefined([group_attr], negate=True) elif data_range.group_value not in group_attr.values: continue else: grp_filter = FilterDiscrete(group_attr, [data_range.group_value]) condition = Values([condition, grp_filter], conjunction=True) conditions.append(condition) return conditions
def setUpClass(cls): super().setUpClass() cls.data = Table("https://datasets.biolab.si/sc/aml-1k.tab.gz") genes_path = serverfiles.localpath_download( "marker_genes", "panglao_gene_markers.tab") filter_ = FilterString("Organism", FilterString.Equal, "Human") cls.genes = Values([filter_])(Table(genes_path)) cls.iris = Table("iris")
def commit(self): self.conditions = [item.filter for item in self.box_scene.selectedItems() if item.filter] selected, selection = None, [] if self.conditions: selected = Values(self.conditions, conjunction=False)(self.dataset) selection = np.in1d( self.dataset.ids, selected.ids, assume_unique=True).nonzero()[0] self.Outputs.selected_data.send(selected) self.Outputs.annotated_data.send( create_annotated_table(self.dataset, selection))
def setUpClass(cls): super().setUpClass() Variable._clear_all_caches() cls._init_data() cls.signal_name = "Reference Data" cls.signal_data = cls.data cls.same_input_output_domain = False genes_path = serverfiles.localpath_download("marker_genes", "panglao_gene_markers.tab") filter_ = FilterString("Organism", FilterString.Equal, "Human") cls.genes = Values([filter_])(Table(genes_path)) cls.genes.attributes[TAX_ID] = "9606"
def commit(self): conditions = self._gather_conditions() if conditions: selected = Values(conditions, conjunction=False)(self.dataset) selection = np.in1d(self.dataset.ids, selected.ids, assume_unique=True).nonzero()[0] else: selected, selection = None, [] self.Outputs.selected_data.send(selected) self.Outputs.annotated_data.send( create_annotated_table(self.dataset, selection))
def commit(self): if len(self.selection): cells = [] for ir, r in enumerate(self.rows.values): for ic, c in enumerate(self.columns.values): if (ir, ic) in self.selection: cells.append( Values([ FilterDiscrete(self.rows, [r]), FilterDiscrete(self.columns, [c]) ])) selected_data = Values(cells, conjunction=False)(self.data) annotated_data = create_annotated_table( self.data, np.where(np.in1d(self.data.ids, selected_data.ids, True))) else: selected_data = None annotated_data = create_annotated_table(self.data, []) self.Outputs.contingency.send(self.table) self.Outputs.selected_data.send(selected_data) self.Outputs.annotated_data.send(annotated_data)
def commit(self): conditions = self._gather_conditions() if conditions: selected = Values(conditions, conjunction=False)(self.dataset) selection = np.in1d( self.dataset.ids, selected.ids, assume_unique=True).nonzero()[0] else: selected, selection = None, [] summary = len(selected) if selected else self.info.NoOutput details = format_summary_details(selected) if selected else "" self.info.set_output_summary(summary, details) self.Outputs.selected_data.send(selected) self.Outputs.annotated_data.send( create_annotated_table(self.dataset, selection))
def commit(self): self.conditions = [ item.filter for item in self.box_scene.selectedItems() if item.filter ] selected, selection = None, [] if self.conditions: selected = Values(self.conditions, conjunction=False)(self.dataset) selection = [ i for i, inst in enumerate(self.dataset) if inst in selected ] self.Outputs.selected_data.send(selected) self.Outputs.annotated_data.send( create_annotated_table(self.dataset, selection))
def commit(self): self.conditions = [ item.filter for item in self.box_scene.selectedItems() if item.filter ] selected, selection = None, [] if self.conditions: selected = Values(self.conditions, conjunction=False)(self.dataset) selection = [ i for i, inst in enumerate(self.dataset) if inst in selected ] self.send("Selected Data", selected) self.send(ANNOTATED_DATA_SIGNAL_NAME, create_annotated_table(self.dataset, selection))
def commit(self): self.conditions = [item.filter for item in self.box_scene.selectedItems() if item.filter] selected, selection = None, [] if self.conditions: selected = Values(self.conditions, conjunction=False)(self.dataset) selection = np.in1d( self.dataset.ids, selected.ids, assume_unique=True).nonzero()[0] summary = len(selected) if selected else self.info.NoOutput details = format_summary_details(selected) if selected else "" self.info.set_output_summary(summary, details) self.Outputs.selected_data.send(selected) self.Outputs.annotated_data.send( create_annotated_table(self.dataset, selection))
def commit(self): if self.data is None: self.Outputs.selected_data.send(None) self.Outputs.annotated_data.send(None) self.Outputs.contingency.send(None) return if len(self.selection_indices): cluster_ids = set() gene_ids = set() for (ir, ic) in self.selection_indices: if not self.transpose: cluster_ids.add(ir) gene_ids.add(ic) else: cluster_ids.add(ic) gene_ids.add(ir) columns = self.clusters if self.transpose else [str(x) for x in self.matrix.domain.attributes] rows = self.clusters if not self.transpose else [str(x) for x in self.matrix.domain.attributes] new_domain = Domain([self.data.domain[columns[i]] for i in gene_ids], self.data.domain.class_vars, self.data.domain.metas) selected_data = Values([FilterDiscrete(self.cluster_var, [rows[i]]) for i in cluster_ids], conjunction=False)(self.data) selected_data = selected_data.transform(new_domain) annotated_data = create_annotated_table(self.data, np.where(np.in1d(self.data.ids, selected_data.ids, True))) else: selected_data = None annotated_data = create_annotated_table(self.data, []) clusters_values = list(set(self.clusters)) table = ClusterAnalysis.contingency_table( self.matrix, DiscreteVariable("Gene" if self.transpose else self.cluster_var.name, clusters_values), [str(x) for x in self.matrix.domain.attributes], [[clusters_values.index(c)] for c in self.clusters] ) self.Outputs.selected_data.send(selected_data) self.Outputs.annotated_data.send(annotated_data) self.Outputs.contingency.send(table)
def test_reprs(self): flid = IsDefined(negate=True) flhc = HasClass() flr = Random() fld = FilterDiscrete(self.attr_disc, None) flsv = SameValue(self.attr_disc, self.value_disc, negate=True) flc = FilterContinuous(self.vs[0], FilterContinuous.Less, 5) flc2 = FilterContinuous(self.vs[1], FilterContinuous.Greater, 3) flv = Values([flc, flc2], conjunction=False, negate=True) flvf = ValueFilter(self.attr_disc) fls = FilterString("name", FilterString.Equal, "Aardvark", case_sensitive=False) flsl = FilterStringList("name", ["Aardvark"], case_sensitive=False) flrx = FilterRegex("name", "^c...$") filters = [flid, flhc, flr, fld, flsv, flc, flv, flvf, fls, flsl, flrx] for f in filters: repr_str = repr(f) new_f = eval(repr_str) self.assertEqual(repr(new_f), repr_str)
def commit(self): averages = None if self.data is not None: if self.group_var is None: averages = self.average_table(self.data) else: parts = [] for value in self.group_var.values: svfilter = SameValue(self.group_var, value) v_table = self.average_table(svfilter(self.data)) parts.append(v_table) # Using "None" as in OWSelectRows # Values is required because FilterDiscrete doesn't have # negate keyword or IsDefined method deffilter = Values( conditions=[FilterDiscrete(self.group_var, None)], negate=True) v_table = self.average_table(deffilter(self.data)) parts.append(v_table) averages = Orange.data.Table.concatenate(parts, axis=0) self.Outputs.averages.send(averages)
def commit(self): if len(self.selection): cluster_ids = set() gene_ids = set() for (ir, ic) in self.selection: if not self.transpose: cluster_ids.add(ir) gene_ids.add(ic) else: cluster_ids.add(ic) gene_ids.add(ir) new_domain = Domain( [self.data.domain[self.genes[i]] for i in gene_ids], self.data.domain.class_vars, self.data.domain.metas) selected_data = Values([ FilterDiscrete(self.cluster_var, [self.clusters[i]]) for i in cluster_ids ], conjunction=False)(self.data) selected_data = selected_data.transform(new_domain) annotated_data = create_annotated_table( self.data.transform(new_domain), np.where(np.in1d(self.data.ids, selected_data.ids, True))) else: selected_data = None annotated_data = create_annotated_table(self.data, []) if self.matrix is not None: table = ClusterAnalysis.contingency_table( self.matrix, DiscreteVariable(self.cluster_var.name, np.array(self.clusters)), np.array(self.genes)[self.gene_order], self.cluster_order[..., np.newaxis]) else: table = None self.Outputs.selected_data.send(selected_data) self.Outputs.annotated_data.send(annotated_data) self.Outputs.contingency.send(table)
def bench_adult_filter_pre_pandas(self): age_filter = FilterContinuous(self.adult.domain["age"], FilterContinuous.Greater, 30) workclass_filter = FilterDiscrete(self.adult.domain["workclass"], [0]) combined = Values([age_filter, workclass_filter]) combined(self.adult)
def __init__(self, conditions, *args): super().__init__(*args) self.filter = Values(conditions) if conditions else None self.setFlag(QGraphicsItem.ItemIsSelectable)
def onDeleteWidget(self): self.shutdown() super().onDeleteWidget() if __name__ == "__main__": from Orange.projection import PCA from orangecontrib.bioinformatics.utils import serverfiles data_path = "https://datasets.orange.biolab.si/sc/aml-1k.tab.gz" table_data = Table(data_path) table_data.attributes[TAX_ID] = "9606" ref_data = table_data[::2] pca = PCA(n_components=2) pca_model = pca(ref_data) proj = pca_model(ref_data) new_dom = Domain( ref_data.domain.attributes, ref_data.domain.class_vars, chain(ref_data.domain.metas, proj.domain.attributes) ) ref_data = ref_data.transform(new_dom) genes_path = serverfiles.localpath_download("marker_genes", "panglao_gene_markers.tab") filter_ = FilterString("Organism", FilterString.Equal, "Human") table_genes = Values([filter_])(Table(genes_path)) table_genes.attributes[TAX_ID] = "9606" WidgetPreview(OWAnnotateProjection).run( set_data=ref_data, set_secondary_data=table_data[1:200:2], set_genes=table_genes )