def apply(self): """Output the transformed data.""" if not self.attribute: self.send("Data", None) return domain = self.data.domain rules = self.active_rules # Transposition + stripping valid_rules = [label or pattern or n_matches for (label, pattern), n_matches in zip(rules, self.match_counts)] patterns = [pattern for (_, pattern), valid in zip(rules, valid_rules) if valid] names = [name for name, valid in zip(self.class_labels(), valid_rules) if valid] transformer = self.TRANSFORMERS[type(self.attribute)] compute_value = transformer( self.attribute, patterns, self.case_sensitive, self.match_beginning) new_class = DiscreteVariable( self.class_name, names, compute_value=compute_value) new_domain = Domain( domain.attributes, new_class, domain.metas + domain.class_vars) new_data = Table(new_domain, self.data) self.send("Data", new_data)
def test_report_widgets_unsupervised_dist(self): rep = OWReport.get_instance() data = Table("zoo") dist = Euclidean(data) widgets = self.dist_widgets self.assertEqual(len(widgets), 2) self._create_report(widgets, rep, dist)
def test_report_widgets_visualize(self): app = QApplication(sys.argv) rep = OWReport.get_instance() data = Table("zoo") widgets = self.visu_widgets self.assertEqual(len(widgets), 10) self._create_report(widgets, rep, data, app)
def setUp(self) -> None: test_data_path = os.path.join(os.path.dirname(__file__), 'datasets') self.widget = self.create_widget(OWAsSurvivalData) self.send_signal(self.widget.Inputs.data, Table(f'{test_data_path}/toy_example.tab')) self.assertEqual(self.widget.controls.time_var.count(), 1) self.assertEqual(self.widget.controls.event_var.count(), 2)
def test_main(): app = QtGui.QApplication([]) data = Table("iris") w = OWDataSampler() w.set_data(data) w.show() return app.exec_()
def test_incorrect_input_data(self): self.send_signal(self.widget.Inputs.data, Table(f'{self.test_data_path}/toy_example.tab')) self.assertTrue(self.widget.Error.missing_survival_data.is_shown()) self.assertIsNone(self.widget.data) self.assertIsNone(self.widget.time_var) self.assertIsNone(self.widget.event_var)
def setUp(self) -> None: self.test_data_path = os.path.join(os.path.dirname(__file__), 'datasets') # create widgets self.as_survival = self.create_widget(OWAsSurvivalData) self.widget = self.create_widget(OWKaplanMeier) # handle survival data self.send_signal(self.as_survival.Inputs.data, Table(f'{self.test_data_path}/toy_example.tab')) simulate.combobox_activate_item( self.as_survival.controls.time_var, self.as_survival._data.columns.Time.name) simulate.combobox_activate_item( self.as_survival.controls.event_var, self.as_survival._data.columns.Event.name) self.send_signal(self.widget.Inputs.data, self.get_output(self.as_survival.Outputs.data)) # check survival data time_var, event_var = get_survival_endpoints(self.widget.data.domain) self.assertEqual(time_var.name, 'Time') self.assertEqual(event_var.name, 'Event') self.assertIn(time_var, self.widget.data.domain.class_vars) self.assertIn(event_var, self.widget.data.domain.class_vars) # check if missing data detected self.assertTrue(self.widget.Warning.missing_values_detected.is_shown()) self.widget.auto_commit = True # If we don't do this function ViewBox.mapSceneToView fails with num py.linalg.LinAlgError: Singular matrix vb = self.widget.graph.getViewBox() vb.resize(200, 200)
def __init__(self, parent=None, signalManager=None, settings=None): super().__init__(parent, signalManager, settings) self.data = None self.undoStack = QtGui.QUndoStack(self) self.plot = PaintDataPlot(self.mainArea, "Painted Plot", widget=self) self.classValuesModel = ColoredListModel( ["Class-1", "Class-2"], self, self.plot, flags=QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsEditable) self.classValuesModel.dataChanged.connect(self.classNameChange) self.data = Table( Domain([ ContinuousVariable(self.attr1), ContinuousVariable(self.attr2) ], DiscreteVariable("Class", values=self.classValuesModel))) self.toolsStackCache = {} self.initUI() self.initPlot() self.updatePlot()
def sendData(self): data = self.data values = set([str(ex.get_class()) for ex in data]) if len(values) == 1: # Remove the useless class variable. domain = Domain(data.domain.attributes) data = Table(domain, data) self.send("Data", data)
def test_main(): a = QtGui.QApplication(sys.argv) ow = OWDataTable() iris = Table("iris") brown = Table("brown-selected") housing = Table("housing") ow.show() ow.raise_() ow.set_dataset(iris, iris.name) ow.set_dataset(brown, brown.name) ow.set_dataset(housing, housing.name) rval = a.exec() # ow.saveSettings() return rval
def test_report_widgets_visualize(self): _warnings = warnings.catch_warnings() _warnings.__enter__() warnings.simplefilter("ignore", OrangeDeprecationWarning) rep = OWReport.get_instance() data = Table("zoo") widgets = self.visu_widgets self._create_report(widgets, rep, data) _warnings.__exit__()
def main(): # pragma: no cover """Simple test for manual inspection of the widget""" import sys from AnyQt.QtWidgets import QApplication a = QApplication(sys.argv) table = Table("zoo") ow = OWCreateClass() ow.show() ow.set_data(table) a.exec() ow.saveSettings()
def test_report_widgets_model(self): rep = OWReport.get_instance() data = Table("titanic") widgets = self.model_widgets w = self.create_widget(OWTreeGraph) clf = TreeLearner(max_depth=3)(data) clf.instances = data w.ctree(clf) w.create_report_html() rep.make_report(w) self._create_report(widgets, rep, data)
def test_report_widgets_regression(self): rep = OWReport.get_instance() data = Table("housing") widgets = self.regr_widgets w = self.create_widget(OWTreeGraph) mod = RegressionTreeLearner(max_depth=3)(data) mod.instances = data w.ctree(mod) w.create_report_html() rep.make_report(w) self._create_report(widgets, rep, data)
def test_report_widgets_regression(self): rep = OWReport.get_instance() data = Table("housing") widgets = self.regr_widgets w = OWRegressionTreeGraph() mod = TreeRegressionLearner(max_depth=3)(data) mod.instances = data w.ctree(mod) w.create_report_html() rep.make_report(w) self.assertEqual(len(widgets) + 1, 5) self._create_report(widgets, rep, data)
def test_report_widgets_classify(self): rep = OWReport.get_instance() data = Table("zoo") widgets = self.clas_widgets w = OWClassificationTreeGraph() clf = TreeLearner(max_depth=3)(data) clf.instances = data w.ctree(clf) w.create_report_html() rep.make_report(w) self.assertEqual(len(widgets) + 1, 8) self._create_report(widgets, rep, data)
def _create_table(words, scores: Mapping[str, np.array]) -> Table: """ Create an Orange table from the word scores :param words: list of words :param scores: mapping of {label: score_array}. Use ordereddict to preserve column order :return: a Table object """ values = list(scores.values()) order = (-values[0]).argsort() data = np.column_stack(values)[order] words = np.array(words).reshape(len(words), 1)[order] domain = Domain([ContinuousVariable(label) for label in scores], metas=[StringVariable("term")]) return Table(domain, data, metas=words)
def test_report_widgets_evaluate(self): rep = OWReport.get_instance() data = Table("zoo") widgets = self.eval_widgets cv = CrossValidation(k=3, store_data=True) results = cv(data, [LogisticRegressionLearner()]) results.learner_names = ["LR l2"] w = self.create_widget(OWTestAndScore) w.insert_learner(0, LogisticRegressionLearner()) w.set_train_data(data) w.set_test_data(data) w.create_report_html() rep.make_report(w) self._create_report(widgets, rep, results)
def test_disable_saving_empty(self): """Test if save and print buttons are disabled on empty report""" rep = OWReport.get_instance() self.assertFalse(rep.save_button.isEnabled()) self.assertFalse(rep.print_button.isEnabled()) table = OWDataTable() table.set_dataset(Table("iris")) table.create_report_html() rep.make_report(table) self.assertTrue(rep.save_button.isEnabled()) self.assertTrue(rep.print_button.isEnabled()) rep.clear() self.assertFalse(rep.save_button.isEnabled()) self.assertFalse(rep.print_button.isEnabled())
def test_set_data(self): variables = self.data.domain.variables class_variables = self.data.domain.class_vars continuous_variables = [var for var in variables if var.is_continuous] self.widget.set_data(self.data) self.assertEqual(self.data, self.widget.data) self.assertEqual(continuous_variables, self.widget.x_var_model._list) self.assertEqual(continuous_variables, self.widget.y_var_model._list) self.assertEqual(self.widget.x_var_index, 0) self.assertEqual( self.widget.y_var_index, len(continuous_variables) - 1 if len(class_variables) == 0 else len(continuous_variables) - len(class_variables)) # check for none data self.widget.set_data(None) self.assertEqual(self.widget.data, None) # data set with continuous class to check if nclass > 0 variables = self.data_housing.domain.variables class_variables = self.data_housing.domain.class_vars continuous_variables = [var for var in variables if var.is_continuous] self.widget.set_data(self.data_housing) self.assertEqual(self.data_housing, self.widget.data) self.assertEqual(continuous_variables, self.widget.x_var_model._list) self.assertEqual(continuous_variables, self.widget.y_var_model._list) self.assertEqual(self.widget.x_var_index, 0) self.assertEqual( self.widget.y_var_index, len(continuous_variables) - 1 if len(class_variables) == 0 else len(continuous_variables) - len(class_variables)) # check with data with all none data = Table( Domain([ContinuousVariable('a'), ContinuousVariable('b')]), [[None, None], [None, None]]) self.widget.set_data(data) self.widget.apply() self.assertIsNone(self.widget.plot_item) self.assertIsNone(self.widget.scatterplot_item)
def main(): from Orange.modelling import TreeLearner from AnyQt.QtWidgets import QApplication import sys app = QApplication(sys.argv) ow = OWPythagorasTree() data = Table(sys.argv[1] if len(sys.argv) > 1 else 'iris') model = TreeLearner(max_depth=1000)(data) model.instances = data ow.set_tree(model) ow.show() ow.raise_() ow.handleNewSignals() app.exec_()
def test_report_widgets_evaluate(self): rep = OWReport.get_instance() data = Table("zoo") widgets = self.eval_widgets results = CrossValidation(data, [LogisticRegressionLearner()], store_data=True) results.learner_names = ["LR l2"] w = self.create_widget(OWTestLearners) set_learner = getattr(w, w.Inputs.learner.handler) set_train = getattr(w, w.Inputs.train_data.handler) set_test = getattr(w, w.Inputs.test_data.handler) set_learner(LogisticRegressionLearner(), 0) set_train(data) set_test(data) w.create_report_html() rep.make_report(w) self._create_report(widgets, rep, results)
def upload(filename): annotations = {'tabular': {}, 'other': {}} with urllib.request.urlopen(os.path.join(URL_REMOTE, filename + '.info')) as url: data = json.loads(url.read().decode()) annotations['tabular']['title'] = data['title'] annotations['tabular']['cells'] = data['instances'] annotations['tabular']['genes'] = data['num_of_genes'] annotations['tabular']['tax_id'] = data['taxid'] annotations['tabular'][ 'target'] = data['target'] if data['target'] else '' annotations['tabular']['tags'] = ', '.join(data['tags']) annotations['other']['description'] = data['description'] annotations['other']['references'] = ' | '.join(data['references']) annotations['other']['source'] = data['source'] annotations['other']['collection'] = data['collection'] annotations['other']['year'] = data['year'] annotations['other']['instances'] = data['instances'] annotations['other']['variables'] = data['variables'] data = Table(os.path.join(URL_REMOTE, filename)) if '.tab.gz' in filename: filename = filename.replace('.tab.gz', '.pickle') data.save(filename) dataset = res.run('data-table-upload', input={'src': filename}) # dataset = res.data.get(id=1) annotations['tabular']['file_name'] = filename annotations['tabular']['file_size'] = os.stat(filename).st_size # descriptor schema slug dataset.descriptor_schema = 'data_info' dataset.descriptor = annotations dataset.save() # cleanup os.remove(filename)
def test_report_widgets_evaluate(self): app = QApplication(sys.argv) rep = OWReport.get_instance() data = Table("zoo") widgets = self.eval_widgets results = CrossValidation(data, [LogisticRegressionLearner()], store_data=True) results.learner_names = ["LR l2"] w = OWTestLearners() set_learner = getattr(w, w.inputs[0].handler) set_train = getattr(w, w.inputs[1].handler) set_test = getattr(w, w.inputs[2].handler) set_learner(LogisticRegressionLearner(), 0) set_train(data) set_test(data) w.create_report_html() rep.make_report(w) self.assertEqual(len(widgets) + 1, 4) self._create_report(widgets, rep, results, app)
def redo(self): self.label = self.classValuesModel.pop(self.index) examples = [ ex for ex in self.data if str(ex.get_class()) != self.label ] newdomain = Domain([ ContinuousVariable(self.widget.attr1), ContinuousVariable(self.widget.attr2) ], DiscreteVariable("Class", values=self.classValuesModel)) newdata = Table(newdomain) for ex in examples: if str(ex.get_class()) != self.label and \ str(ex.get_class()) in self.classValuesModel: newdata.append( Instance(newdomain, [float(ex[a]) for a in ex.domain.attributes] + [str(ex.get_class())])) self.widget.data = newdata self.widget.updatePlot() self.widget.updateCursor()
def main(): from AnyQt.QtWidgets import QApplication import sys app = QApplication(sys.argv) ow = OWPythagorasTree() data = Table(sys.argv[1] if len(sys.argv) > 1 else 'iris') if data.domain.has_discrete_class: from Orange.classification.tree import SklTreeLearner as TreeLearner else: from Orange.regression.tree import SklTreeRegressionLearner as TreeLearner model = TreeLearner(max_depth=1000)(data) model.instances = data ow.set_tree(model) ow.show() ow.raise_() ow.handleNewSignals() app.exec_()
def redo(self): self.classValuesModel.append(self.newClassLabel) newdomain = Domain([ ContinuousVariable(self.widget.attr1), ContinuousVariable(self.widget.attr2) ], DiscreteVariable("Class", values=self.classValuesModel)) newdata = Table(newdomain) instances = [ Instance(newdomain, [float(ex[a]) for a in ex.domain.attributes] + [str(ex.get_class())]) for ex in self.data ] newdata.extend(instances) self.widget.data = newdata self.widget.removeClassLabel.setEnabled(len(self.classValuesModel) > 1) newindex = self.classValuesModel.index(len(self.classValuesModel) - 1) self.widget.classValuesView.selectionModel().select( newindex, QtGui.QItemSelectionModel.ClearAndSelect) self.widget.updatePlot() self.widget.updateCursor()
def redo(self): newdomain = Domain([ ContinuousVariable(self.widget.attr1), ContinuousVariable(self.widget.attr2) ], DiscreteVariable("Class", values=self.classValuesModel)) newdata = Table(newdomain) for ex in self.data: print(ex.get_class()) if str(ex.get_class()) not in self.classValuesModel: self.oldLabelName = str(ex.get_class()) instance = Instance( newdomain, [float(ex[a]) for a in ex.domain.attributes] + [self.changedLabel]) newdata.append(instance) else: newdata.append( Instance(newdomain, [float(ex[a]) for a in ex.domain.attributes] + [str(ex.get_class())])) self.widget.data = newdata self.widget.updatePlot()
def initial_start_dir(self): if self.filename and os.path.exists(os.path.split(self.filename)[0]): return self.filename else: data_name = getattr(self.data, 'name', '') if data_name: data_name += self.writer.EXTENSIONS[0] return os.path.join(self.last_dir or _userhome, data_name) def valid_filters(self): if self.data is None or not self.data.is_sparse(): return self.get_filters() else: return { filt: writer for filt, writer in self.get_filters().items() if writer.SUPPORT_SPARSE_DATA } def default_valid_filter(self): valid = self.valid_filters() if self.data is None or not self.data.is_sparse() \ or (self.filter in valid and valid[self.filter].SUPPORT_SPARSE_DATA): return self.filter return next(iter(valid)) if __name__ == "__main__": # pragma: no cover WidgetPreview(OWSave).run(Table("iris"))
def is_sortable(table): if isinstance(table, SqlTable): return False elif isinstance(table, Orange.data.Table): return True else: return False def test_model(): app = QApplication([]) view = QTableView( sortingEnabled=True ) data = Orange.data.Table("lenses") model = TableModel(data) view.setModel(model) view.show() view.raise_() return app.exec() if __name__ == "__main__": # pragma: no cover WidgetPreview(OWDataTable).run( [(Table("iris"), "iris"), (Table("brown-selected"), "brown-selected"), (Table("housing"), "housing")])