Python Table.transform方法代码示例

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import transform [as 别名]
 def prepare_data():
     data = Table("iris")
     values = list(range(15))
     class_var = DiscreteVariable("iris5", values=[str(v) for v in values])
     data = data.transform(Domain(attributes=data.domain.attributes, class_vars=[class_var]))
     data.Y = np.array(values * 10, dtype=float)
     return data

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import transform [as 别名]
    def __call__(self, data: Table, **kwargs) -> Table:
        # If we want to transform new data, ensure that we use correct domain
        if data.domain != self.pre_domain:
            data = data.transform(self.pre_domain)

        embedding = self.transform(data.X, **kwargs)
        return Table(self.domain, embedding.view(), data.Y, data.metas)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import transform [as 别名]
    def test_data_with_similarity(self):
        widget = self.widget
        indices = np.array([5, 10, 15, 100])

        data = Table("iris")
        widget.data = data

        widget.distances = np.arange(1000, 1150).astype(float)
        neighbours = widget._data_with_similarity(indices)
        self.assertEqual(neighbours.metas.shape, (4, 1))
        np.testing.assert_almost_equal(
            neighbours.metas.flatten(), indices + 1000)
        np.testing.assert_almost_equal(neighbours.X, data.X[indices])

        domain = data.domain
        domain2 = Domain([domain[2]], domain.class_var, metas=domain[:2])
        data2 = data.transform(domain2)
        widget.data = data2

        widget.distances = np.arange(1000, 1150).astype(float)
        neighbours = widget._data_with_similarity(indices)
        self.assertEqual(len(neighbours.domain.metas), 3)
        self.assertEqual(neighbours.metas.shape, (4, 3))
        np.testing.assert_almost_equal(
            neighbours.get_column_view("distance")[0], indices + 1000)
        np.testing.assert_almost_equal(neighbours.X, data2.X[indices])

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import transform [as 别名]
 def test_metas(self):
     data = Table("iris")
     domain = data.domain
     domain = Domain(attributes=domain.attributes[:3],
                     class_vars=domain.class_vars,
                     metas=domain.attributes[3:])
     data = data.transform(domain)
     self.send_signal(self.widget.Inputs.data, data)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import transform [as 别名]
 def test_no_features(self):
     w = self.widget
     data = Table("iris")
     domain = Domain(attributes=data.domain.attributes[:1], class_vars=data.domain.class_vars)
     data2 = data.transform(domain)
     self.assertFalse(w.Error.no_features.is_shown())
     self.send_signal(w.Inputs.data, data2)
     self.assertTrue(w.Error.no_features.is_shown())
     self.send_signal(w.Inputs.data, None)
     self.assertFalse(w.Error.no_features.is_shown())

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import transform [as 别名]
 def test_data_nan_column(self):
     """
     Do not crash when a column has a nan value.
     GH-40
     """
     data = Table("iris")
     domain = Domain(attributes=data.domain.attributes[:2], class_vars=data.domain.class_vars)
     data = data.transform(domain)
     data[:, 0] = np.nan
     self.send_signal(self.widget.Inputs.data, data)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import transform [as 别名]
 def test_attrs_appear_in_corner_text(self):
     iris = Table("iris")
     domain = iris.domain
     new_domain = Domain(
         domain.attributes[1:], iris.domain.class_var, domain.attributes[:1])
     new_domain.metas[0].attributes = {"c": "foo"}
     new_domain.attributes[0].attributes = {"a": "bar", "c": "baz"}
     new_domain.class_var.attributes = {"b": "foo"}
     self.widget.set_corner_text = Mock()
     self.send_signal(self.widget.Inputs.data, iris.transform(new_domain))
     self.assertEqual(
         self.widget.set_corner_text.call_args[0][1], "\na\nb\nc")

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import transform [as 别名]
 def test_metas_zero_column(self):
     """
     Prevent crash when metas column is zero.
     GH-2775
     """
     data = Table("iris")
     domain = data.domain
     domain = Domain(domain.attributes[:3], domain.class_vars, domain.attributes[3:])
     data = data.transform(domain)
     data.metas[:, 0] = 0
     w = self.widget
     self.send_signal(w.Inputs.data, data)
     simulate.combobox_activate_item(w.controls.attr_x, domain.metas[0].name)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import transform [as 别名]
 def test_no_attributes(self):
     """
     Rank should not fail on data with no attributes.
     GH-2745
     """
     data = Table("iris")[::30]
     domain = Domain(attributes=[], class_vars=data.domain.class_vars)
     new_data = data.transform(domain)
     self.assertFalse(self.widget.Error.no_attributes.is_shown())
     self.send_signal(self.widget.Inputs.data, new_data)
     self.assertTrue(self.widget.Error.no_attributes.is_shown())
     self.send_signal(self.widget.Inputs.data, data)
     self.assertFalse(self.widget.Error.no_attributes.is_shown())

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import transform [as 别名]
 def test_testOnTest_incompatible_domain(self):
     iris = Table("iris")
     self.send_signal(self.widget.Inputs.train_data, iris)
     self.send_signal(self.widget.Inputs.learner, LogisticRegressionLearner(), 0)
     self.get_output(self.widget.Outputs.evaluations_results, wait=5000)
     self.assertFalse(self.widget.Error.test_data_incompatible.is_shown())
     self.widget.resampling = OWTestLearners.TestOnTest
     # test data with the same class (otherwise the widget shows a different error)
     # and a non-nan X
     iris_test = iris.transform(Domain([ContinuousVariable()],
                                       class_vars=iris.domain.class_vars))
     iris_test.X[:, 0] = 1
     self.send_signal(self.widget.Inputs.test_data, iris_test)
     self.get_output(self.widget.Outputs.evaluations_results, wait=5000)
     self.assertTrue(self.widget.Error.test_data_incompatible.is_shown())

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import transform [as 别名]
 def test_handle_metas(self):
     """
     Scatter Plot Graph can handle metas
     GH-2699
     """
     w = self.widget
     data = Table("iris")
     domain = Domain(
         attributes=data.domain.attributes[:2],
         class_vars=data.domain.class_vars,
         metas=data.domain.attributes[2:]
     )
     data = data.transform(domain)
     # Sometimes floats in metas are saved as objects
     data.metas = data.metas.astype(object)
     self.send_signal(w.Inputs.data, data)
     simulate.combobox_activate_item(w.cb_attr_x, data.domain.metas[1].name)
     simulate.combobox_activate_item(w.controls.graph.attr_color, data.domain.metas[0].name)
     w.update_graph()

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import transform [as 别名]
    def test_empty_data(self):
        """No crash on empty data"""
        data = Table("iris")[::3]
        widget = self.widget
        widget.default_method_index = Method.Model

        self.send_signal(self.widget.Inputs.data, data, wait=1000)
        imp_data = self.get_output(self.widget.Outputs.data)
        np.testing.assert_equal(imp_data.X, data.X)
        np.testing.assert_equal(imp_data.Y, data.Y)

        self.send_signal(self.widget.Inputs.data, Table(data.domain), wait=1000)
        imp_data = self.get_output(self.widget.Outputs.data)
        self.assertEqual(len(imp_data), 0)

        # only meta columns
        data = data.transform(Domain([], [], data.domain.attributes))
        self.send_signal("Data", data, wait=1000)
        imp_data = self.get_output("Data")
        self.assertEqual(len(imp_data), len(data))
        self.assertEqual(imp_data.domain, data.domain)
        np.testing.assert_equal(imp_data.metas, data.metas)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import transform [as 别名]
    def test_sparse(self):
        """
        Do not crash on sparse data. Convert used
        sparse columns to numpy array.
        GH-45
        """
        w = self.widget

        def send_sparse_data(data):
            data.X = sp.csr_matrix(data.X)
            data.Y = sp.csr_matrix(data.Y)
            self.send_signal(w.Inputs.data, data)

        # one class variable
        send_sparse_data(Table("iris"))

        # two class variables
        data = Table("iris")
        domain = Domain(
            attributes=data.domain.attributes[:3],
            class_vars=data.domain.attributes[3:] + data.domain.class_vars
        )
        send_sparse_data(data.transform(domain))

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import transform [as 别名]
    def __call__(self, data, ret=Value):
        def fix_dim(x):
            return x[0] if one_d else x

        if not 0 <= ret <= 2:
            raise ValueError("invalid value of argument 'ret'")
        if ret > 0 and any(v.is_continuous for v in self.domain.class_vars):
            raise ValueError("cannot predict continuous distributions")

        # Call the predictor
        one_d = False
        if isinstance(data, np.ndarray):
            one_d = data.ndim == 1
            prediction = self.predict(np.atleast_2d(data))
        elif isinstance(data, scipy.sparse.csr.csr_matrix):
            prediction = self.predict(data)
        elif isinstance(data, (Table, Instance)):
            if isinstance(data, Instance):
                data = Table(data.domain, [data])
                one_d = True
            if data.domain != self.domain:
                if self.original_domain.attributes != data.domain.attributes \
                        and data.X.size \
                        and not np.isnan(data.X).all():
                    data = data.transform(self.original_domain)
                    if np.isnan(data.X).all():
                        raise DomainTransformationError(
                            "domain transformation produced no defined values")
                data = data.transform(self.domain)
            prediction = self.predict_storage(data)
        elif isinstance(data, (list, tuple)):
            if not isinstance(data[0], (list, tuple)):
                data = [data]
                one_d = True
            data = Table.from_list(self.original_domain, data)
            data = data.transform(self.domain)
            prediction = self.predict_storage(data)
        else:
            raise TypeError("Unrecognized argument (instance of '{}')"
                            .format(type(data).__name__))

        # Parse the result into value and probs
        multitarget = len(self.domain.class_vars) > 1
        if isinstance(prediction, tuple):
            value, probs = prediction
        elif prediction.ndim == 1 + multitarget:
            value, probs = prediction, None
        elif prediction.ndim == 2 + multitarget:
            value, probs = None, prediction
        else:
            raise TypeError("model returned a %i-dimensional array",
                            prediction.ndim)

        # Ensure that we have what we need to return
        if ret != Model.Probs and value is None:
            value = np.argmax(probs, axis=-1)
        if ret != Model.Value and probs is None:
            if multitarget:
                max_card = max(len(c.values)
                               for c in self.domain.class_vars)
                probs = np.zeros(value.shape + (max_card,), float)
                for i in range(len(self.domain.class_vars)):
                    probs[:, i, :] = one_hot(value[:, i])
            else:
                probs = one_hot(value)
            if ret == Model.ValueProbs:
                return fix_dim(value), fix_dim(probs)
            else:
                return fix_dim(probs)

        # Return what we need to
        if ret == Model.Probs:
            return fix_dim(probs)
        if isinstance(data, Instance) and not multitarget:
            value = Value(self.domain.class_var, value[0])
        if ret == Model.Value:
            return fix_dim(value)
        else:  # ret == Model.ValueProbs
            return fix_dim(value), fix_dim(probs)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import transform [as 别名]
class ProjectionWidgetTestMixin:
    """Class for projection widget testing"""

    def init(self):
        Variable._clear_all_caches()
        self.data = Table("iris")

    def _select_data(self):
        rect = QRectF(QPointF(-20, -20), QPointF(20, 20))
        self.widget.graph.select_by_rectangle(rect)
        return self.widget.graph.get_selection()

    def _compare_selected_annotated_domains(self, selected, annotated):
        selected_vars = selected.domain.variables
        annotated_vars = annotated.domain.variables
        self.assertLessEqual(set(selected_vars), set(annotated_vars))

    def test_setup_graph(self):
        """Plot should exist after data has been sent in order to be
        properly set/updated"""
        self.send_signal(self.widget.Inputs.data, self.data)
        self.assertIsNotNone(self.widget.graph.scatterplot_item)

    def test_default_attrs(self, timeout=DEFAULT_TIMEOUT):
        """Check default values for 'Color', 'Shape', 'Size' and 'Label'"""
        self.send_signal(self.widget.Inputs.data, self.data)
        self.assertIs(self.widget.attr_color, self.data.domain.class_var)
        self.assertIsNone(self.widget.attr_label)
        self.assertIsNone(self.widget.attr_shape)
        self.assertIsNone(self.widget.attr_size)
        if self.widget.isBlocking():
            spy = QSignalSpy(self.widget.blockingStateChanged)
            self.assertTrue(spy.wait(timeout))
        self.send_signal(self.widget.Inputs.data, None)
        self.assertIsNone(self.widget.attr_color)

    def test_attr_models(self):
        """Check possible values for 'Color', 'Shape', 'Size' and 'Label'"""
        self.send_signal(self.widget.Inputs.data, self.data)
        controls = self.widget.controls
        self.assertEqual(len(controls.attr_color.model()), 8)
        self.assertEqual(len(controls.attr_shape.model()), 3)
        self.assertTrue(5 < len(controls.attr_size.model()) < 8)
        self.assertEqual(len(controls.attr_label.model()), 8)

        # color and label should contain all variables
        # size should contain only continuous variables
        # shape should contain only discrete variables
        for var in self.data.domain.variables + self.data.domain.metas:
            self.assertIn(var, controls.attr_color.model())
            self.assertIn(var, controls.attr_label.model())
            if var.is_continuous:
                self.assertIn(var, controls.attr_size.model())
                self.assertNotIn(var, controls.attr_shape.model())
            if var.is_discrete:
                self.assertNotIn(var, controls.attr_size.model())
                self.assertIn(var, controls.attr_shape.model())

    def test_attr_label_metas(self, timeout=DEFAULT_TIMEOUT):
        """Set 'Label' from string meta attribute"""
        cont = Continuize(multinomial_treatment=Continuize.AsOrdinal)
        data = cont(Table("zoo"))
        self.send_signal(self.widget.Inputs.data, data)
        if self.widget.isBlocking():
            spy = QSignalSpy(self.widget.blockingStateChanged)
            self.assertTrue(spy.wait(timeout))
        simulate.combobox_activate_item(self.widget.controls.attr_label,
                                        data.domain[-1].name)

    def test_handle_primitive_metas(self):
        """Set 'Color' from continuous meta attribute"""
        d, attrs = self.data.domain, self.data.domain.attributes
        data = self.data.transform(Domain(attrs[:2], d.class_vars, attrs[2:]))
        self.send_signal(self.widget.Inputs.data, data)
        simulate.combobox_activate_item(self.widget.controls.attr_color,
                                        data.domain.metas[0].name)

    def test_datasets(self, timeout=DEFAULT_TIMEOUT):
        """Test widget for datasets with missing values and constant features"""
        for ds in datasets.datasets():
            self.send_signal(self.widget.Inputs.data, ds)
            if self.widget.isBlocking():
                spy = QSignalSpy(self.widget.blockingStateChanged)
                self.assertTrue(spy.wait(timeout))

    def test_none_data(self):
        """Test widget for empty dataset"""
        self.send_signal(self.widget.Inputs.data, self.data[:0])

    def test_plot_once(self, timeout=DEFAULT_TIMEOUT):
        """Test if data is plotted only once but committed on every input change"""
        table = Table("heart_disease")
        self.widget.setup_plot = Mock()
        self.widget.commit = Mock()
        self.send_signal(self.widget.Inputs.data, table)
        self.widget.setup_plot.assert_called_once()
        self.widget.commit.assert_called_once()

        if self.widget.isBlocking():
            spy = QSignalSpy(self.widget.blockingStateChanged)
#.........这里部分代码省略.........