Python Table.X方法代码示例

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import X [as 别名]
    def test_prepare_freeviz_data(self):
        table = Table("iris")
        FreeViz.prepare_freeviz_data(table)

        table.X = table.X * np.nan
        self.assertEqual(FreeViz.prepare_freeviz_data(table), (None, None, None))

        table.X = None
        FreeViz.prepare_freeviz_data(table)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import X [as 别名]
 def test_sparse(self):
     table = Table("iris")
     table.X = sp.csr_matrix(table.X)
     self.assertTrue(sp.issparse(table.X))
     self.assertFalse(self.widget.Warning.sparse_not_supported.is_shown())
     self.send_signal(self.widget.Inputs.data, table)
     self.assertTrue(self.widget.Warning.sparse_not_supported.is_shown())

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import X [as 别名]
 def test_sparse_data(self):
     table = Table("iris")
     table.X = sp.csr_matrix(table.X)
     self.assertTrue(sp.issparse(table.X))
     self.send_signal(self.widget.Inputs.data, table)
     self.assertTrue(self.widget.Error.sparse_data.is_shown())
     self.send_signal(self.widget.Inputs.data_subset, table[::30])
     self.assertEqual(len(self.widget.subset_data), 5)
     self.send_signal(self.widget.Inputs.data, None)
     self.assertFalse(self.widget.Error.sparse_data.is_shown())

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import X [as 别名]
 def test_sparse_data(self):
     data = Table("iris")
     data.X = sparse.csr_matrix(data.X)
     self.assertTrue(sparse.issparse(data.X))
     self.send_signal("Data", data)
     self.widget.apply_button.button.click()
     self.assertTrue(self.widget.Error.sparse_not_supported.is_shown())
     self.send_signal("Data", None)
     self.widget.apply_button.button.click()
     self.assertFalse(self.widget.Error.sparse_not_supported.is_shown())

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import X [as 别名]
 def test_sparse_subset_data(self):
     """
     Scatter Plot can handle sparse subset data.
     GH-2773
     """
     data = Table("iris")
     w = self.widget
     data.X = sp.csr_matrix(data.X)
     self.send_signal(w.Inputs.data, data)
     self.send_signal(w.Inputs.data_subset, data[::30])
     self.assertEqual(len(w.graph.subset_indices), 5)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import X [as 别名]
 def test_sparse_data(self, timeout=DEFAULT_TIMEOUT):
     """Test widget for sparse data"""
     table = Table("iris")
     table.X = sp.csr_matrix(table.X)
     self.assertTrue(sp.issparse(table.X))
     self.send_signal(self.widget.Inputs.data, table)
     if self.widget.isBlocking():
         spy = QSignalSpy(self.widget.blockingStateChanged)
         self.assertTrue(spy.wait(timeout))
     self.send_signal(self.widget.Inputs.data_subset, table[::30])
     self.assertEqual(len(self.widget.subset_indices), 5)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import X [as 别名]
 def test_sparse_data(self):
     """
     Show warning msg when data is sparse.
     GH-2298
     GH-2163
     """
     data = Table("iris")[::25]
     data.X = sp.csr_matrix(data.X)
     self.send_signal(self.widget.Inputs.data, data)
     self.assertTrue(self.widget.Warning.sparse_not_supported.is_shown())
     self.send_signal(self.widget.Inputs.data, None)
     self.assertFalse(self.widget.Warning.sparse_not_supported.is_shown())

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import X [as 别名]
    def test_empty_groups(self):
        """Test if groups with zero elements are not shown"""
        table = Table("cyber-security-breaches")
        self.send_signal(self.widget.Inputs.data, table)
        self.__select_variable("US State")
        self.__select_group("US State")
        self.assertEqual(52, len(self.widget.boxes))

        # select rows with US State equal to TX or MO
        use_indexes = np.array([0, 1, 25, 26, 27])
        table.X = table.X[use_indexes]
        self.send_signal(self.widget.Inputs.data, table)
        self.assertEqual(2, len(self.widget.boxes))

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import X [as 别名]
    def test_domain_edit_on_sparse_data(self):
        iris = Table("iris")
        iris.X = sp.csr_matrix(iris.X)

        f = tempfile.NamedTemporaryFile(suffix='.pickle', delete=False)
        pickle.dump(iris, f)
        f.close()

        self.widget.add_path(f.name)
        self.widget.load_data()

        output = self.get_output(self.widget.Outputs.data)
        self.assertIsInstance(output, Table)
        self.assertEqual(iris.X.shape, output.X.shape)
        self.assertTrue(sp.issparse(output.X))

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import X [as 别名]
    def test_sparse_data(self):
        data = Table("iris")
        data.X = sp.csr_matrix(data.X)
        self.widget.set_data(data)
        decomposition = DECOMPOSITIONS[self.widget.decomposition_idx]
        self.assertTrue(decomposition.supports_sparse)
        self.assertFalse(self.widget.normalize_box.isEnabled())

        buttons = self.widget.decomposition_box.group.box.buttons
        for i, decomposition in enumerate(DECOMPOSITIONS):
            if not decomposition.supports_sparse:
                self.assertFalse(buttons[i].isEnabled())

        data = Table("iris")
        self.widget.set_data(data)
        self.assertTrue(all([b.isEnabled() for b in buttons]))
        self.assertTrue(self.widget.normalize_box.isEnabled())

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import X [as 别名]
    def test_sparse(self):
        """
        Test sparse data.
        GH-2152
        GH-2157
        """
        table = Table("iris")
        table.X = sp.csr_matrix(table.X)
        self.assertTrue(sp.issparse(table.X))
        table.Y = sp.csr_matrix(table._Y)  # pylint: disable=protected-access
        self.assertTrue(sp.issparse(table.Y))
        self.send_signal(self.widget.Inputs.data, table)
        self.widget.set_subset_data(table[:30])
        data = self.get_output("Data")

        self.assertTrue(data.is_sparse())
        self.assertEqual(len(data.domain), 5)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import X [as 别名]
    def test_sparse_data(self):
        """
        Sparse support.
        GH-2160
        GH-2260
        """
        table = Table("iris")
        self.send_signal(self.widget.Inputs.data, table)
        self.assertEqual(len(self.widget.discrete_data.domain), len(table.domain))
        output = self.get_output("Data")
        self.assertFalse(output.is_sparse())

        table.X = sp.csr_matrix(table.X)
        self.send_signal(self.widget.Inputs.data, table)
        self.assertEqual(len(self.widget.discrete_data.domain), 2)
        output = self.get_output("Data")
        self.assertTrue(output.is_sparse())

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import X [as 别名]
    def test_save_uncompressed(self):
        widget = self.widget
        widget.auto_save = False

        spiris = Table("iris")
        spiris.X = sp.csr_matrix(spiris.X)

        for selected_filter, writer in widget.filters.items():
            widget.write = writer
            ext = writer.EXTENSIONS[0]
            with named_file("", suffix=ext) as filename:
                widget.get_save_filename = Mock(
                    return_value=(filename, selected_filter))

                self.send_signal(widget.Inputs.data, self.iris)
                widget.save_file_as()
                self.assertEqual(len(Table(filename)), 150)

                if writer.SUPPORT_SPARSE_DATA:
                    self.send_signal(widget.Inputs.data, spiris)
                    widget.save_file()
                    self.assertEqual(len(Table(filename)), 150)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import X [as 别名]
    def test_sparse(self):
        """
        Merge should work with sparse.
        GH-2295
        GH-2155
        """
        data = Table("iris")[::25]
        data_ed_dense = Table("titanic")[::300]
        data_ed_sparse = Table("titanic")[::300]
        data_ed_sparse.X = sp.csr_matrix(data_ed_sparse.X)
        self.send_signal("Data", data)

        self.send_signal("Extra Data", data_ed_dense)
        output_dense = self.get_output("Data")
        self.assertFalse(sp.issparse(output_dense.X))
        self.assertFalse(output_dense.is_sparse())

        self.send_signal("Extra Data", data_ed_sparse)
        output_sparse = self.get_output("Data")
        self.assertTrue(sp.issparse(output_sparse.X))
        self.assertTrue(output_sparse.is_sparse())

        output_sparse.X = output_sparse.X.toarray()
        self.assertTablesEqual(output_dense, output_sparse)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import X [as 别名]
 def test_sparse_data(self):
     data = Table("iris")
     data.X = sparse.csr_matrix(data.X)
     self.assertTrue(sparse.issparse(data.X))
     self.widget.manifold_method_index = 2
     self.send_signal(self.widget.Inputs.data, data)
     self.widget.apply_button.button.click()
     self.assertTrue(self.widget.Error.sparse_methods.is_shown())
     self.send_signal(self.widget.Inputs.data, None)
     self.widget.apply_button.button.click()
     self.assertFalse(self.widget.Error.sparse_methods.is_shown())
     # GH 2158
     self.widget.manifold_method_index = 0
     self.assertEqual(
         'TSNE',
         self.widget.MANIFOLD_METHODS[self.widget.manifold_method_index].__name__)
     self.send_signal(self.widget.Inputs.data, data)
     self.widget.apply_button.button.click()
     self.assertFalse(self.widget.Error.sparse_methods.is_shown())
     self.assertFalse(self.widget.Error.sparse_tsne_distance.is_shown())
     self.assertIsInstance(self.get_output(self.widget.Outputs.transformed_data), Table)
     self.widget.params_widget.parameters['metric'] = 'chebyshev'
     self.widget.apply_button.button.click()
     self.assertTrue(self.widget.Error.sparse_tsne_distance.is_shown())