Esempio n. 1
0
 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)
Esempio n. 2
0
 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)
Esempio n. 3
0
 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)
Esempio n. 5
0
def test_main():
    app = QtGui.QApplication([])
    data = Table("iris")
    w = OWDataSampler()
    w.set_data(data)
    w.show()
    return app.exec_()
Esempio n. 6
0
 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)
Esempio n. 7
0
    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)
Esempio n. 8
0
    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()
Esempio n. 9
0
 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)
Esempio n. 10
0
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
Esempio n. 11
0
 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__()
Esempio n. 12
0
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()
Esempio n. 13
0
    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)
Esempio n. 14
0
    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)
Esempio n. 15
0
    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)
Esempio n. 16
0
    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)
Esempio n. 17
0
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)
Esempio n. 18
0
    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)
Esempio n. 19
0
    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())
Esempio n. 20
0
    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)
Esempio n. 21
0
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_()
Esempio n. 22
0
    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)
Esempio n. 24
0
    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)
Esempio n. 25
0
    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()
Esempio n. 26
0
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_()
Esempio n. 27
0
    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()
Esempio n. 28
0
 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()
Esempio n. 29
0
    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"))
Esempio n. 30
0
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")])