Python Table.from_table方法代码示例

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import from_table [as 别名]
    def send_data(self):
        """
        Function sends data with clusters column and data with centroids
        position to the output
        """
        km = self.k_means
        if km is None or km.clusters is None:
            self.Outputs.annotated_data.send(None)
            self.Outputs.centroids.send(None)
        else:
            clust_var = DiscreteVariable(
                self.output_name,
                values=["C%d" % (x + 1) for x in range(km.k)])
            attributes = self.data.domain.attributes
            classes = self.data.domain.class_vars
            meta_attrs = self.data.domain.metas
            if classes:
                meta_attrs += classes
            classes = [clust_var]
            domain = Domain(attributes, classes, meta_attrs)
            annotated_data = Table.from_table(domain, self.data)
            annotated_data.Y[self.selected_rows] = km.clusters

            centroids = Table(Domain(km.data.domain.attributes), km.centroids)
            self.Outputs.annotated_data.send(annotated_data)
            self.Outputs.centroids.send(centroids)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import from_table [as 别名]
    def ctree(self, model=None):
        self.clear()
        self.closeContext()
        self.model = model
        if model is None:
            self.info.setText('No tree.')
            self.tree = None
            self.root_node = None
            self.dataset = None
        else:
            self.tree = model.skl_model.tree_
            self.domain = model.domain
            self.dataset = getattr(model, "instances", None)
            if self.dataset is not None and self.dataset.domain != self.domain:
                self.clf_dataset = \
                    Table.from_table(self.model.domain, self.dataset)
            else:
                self.clf_dataset = self.dataset
            class_var = self.domain.class_var
            if class_var.is_discrete:
                self.scene.colors = [QColor(*col) for col in class_var.colors]
            self.openContext(self.domain.class_var)
            self.root_node = self.walkcreate(self.tree, 0, None)
            self.info.setText(
                '{} nodes, {} leaves'.
                format(self.tree.node_count,
                       numpy.count_nonzero(
                            self.tree.children_left == TREE_LEAF)))

            self.scene.fix_pos(self.root_node, self._HSPACING, self._VSPACING)
            self.activate_loaded_settings()
            self.scene_view.centerOn(self.root_node.x(), self.root_node.y())
            self.update_node_tooltips()
        self.scene.update()
        self.send("Data", None)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import from_table [as 别名]
    def send_data(self, row=None):
        if self.optimize_k:
            if row is None:
                row = self.selected_row()
            km = self.optimization_runs[row][1]
        else:
            km = self.km
        if not self.data or not km:
            self.send("Annotated Data", None)
            self.send("Centroids", None)
            return

        clust_var = DiscreteVariable(
            self.output_name, values=["C%d" % (x + 1) for x in range(km.k)])
        clust_ids = km(self.data)
        domain = self.data.domain
        attributes, classes = domain.attributes, domain.class_vars
        meta_attrs = domain.metas
        if self.place_cluster_ids == self.OUTPUT_CLASS:
            if classes:
                meta_attrs += classes
            classes = [clust_var]
        elif self.place_cluster_ids == self.OUTPUT_ATTRIBUTE:
            attributes += (clust_var, )
        else:
            meta_attrs += (clust_var, )

        domain = Domain(attributes, classes, meta_attrs)
        new_table = Table.from_table(domain, self.data)
        new_table.get_column_view(clust_var)[0][:] = clust_ids.X.ravel()

        centroids = Table(Domain(km.pre_domain.attributes), km.centroids)

        self.send("Annotated Data", new_table)
        self.send("Centroids", centroids)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import from_table [as 别名]
    def set_rf(self, model=None):
        """When a different forest is given."""
        self.clear()
        self.model = model

        if model is not None:
            if isinstance(model, RandomForestClassifier):
                self.forest_type = self.CLASSIFICATION
            elif isinstance(model, RandomForestRegressor):
                self.forest_type = self.REGRESSION
            else:
                raise RuntimeError('Invalid type of forest.')

            self.forest_adapter = self._get_forest_adapter(self.model)
            self.color_palette = self._type_specific('_get_color_palette')()
            self._draw_trees()

            self.dataset = model.instances
            # this bit is important for the regression classifier
            if self.dataset is not None and \
                    self.dataset.domain != model.domain:
                self.clf_dataset = Table.from_table(
                    self.model.domain, self.dataset)
            else:
                self.clf_dataset = self.dataset

            self._update_info_box()
            self._type_specific('_update_target_class_combo')()
            self._update_depth_slider()

            self.selected_tree_index = -1

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import from_table [as 别名]
 def set_data(self, data):
     self.closeContext()
     self.clear_messages()
     self.data = data
     self.cont_data = None
     self.selection = ()
     if data is not None:
         if len(data) < 2:
             self.Warning.not_enough_inst()
         else:
             domain = data.domain
             cont_attrs = [a for a in domain.attributes if a.is_continuous]
             cont_dom = Domain(cont_attrs, domain.class_vars, domain.metas)
             cont_data = Table.from_table(cont_dom, data)
             remover = Remove(Remove.RemoveConstant)
             cont_data = remover(cont_data)
             if remover.attr_results["removed"]:
                 self.Information.removed_cons_feat()
             if len(cont_data.domain.attributes) < 2:
                 self.Warning.not_enough_vars()
             else:
                 self.cont_data = SklImpute()(cont_data)
     self.set_feature_model()
     self.openContext(self.cont_data)
     self.apply()
     self.vizrank.button.setEnabled(self.cont_data is not None)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import from_table [as 别名]
 def test_continuous_metas(self):
     domain = self.iris.domain
     metas = domain.attributes[:-1] + (StringVariable("str"),)
     domain = Domain([], domain.class_var, metas)
     data = Table.from_table(domain, self.iris)
     self.send_signal(self.widget.Inputs.data, data)
     self.widget.controls.order_by_importance.setChecked(True)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import from_table [as 别名]
def remove_unused_values(var, data):
    column_data = Table.from_table(
        Domain([var]),
        data
    )
    array = column_data.X.ravel()
    mask = np.isfinite(array)
    unique = np.array(np.unique(array[mask]), dtype=int)

    if len(unique) == len(var.values):
        return var

    used_values = [var.values[i] for i in unique]
    translation_table = np.array([np.NaN] * len(var.values))
    translation_table[unique] = range(len(used_values))

    base_value = -1
    if 0 >= var.base_value < len(var.values):
        base = translation_table[var.base_value]
        if np.isfinite(base):
            base_value = int(base)

    return DiscreteVariable("{}".format(var.name),
                            values=used_values,
                            base_value=base_value,
                            compute_value=Lookup(var, translation_table)
                            )

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import from_table [as 别名]
    def test_CrossValidationByFeature(self):
        data = Table("iris")
        attrs = data.domain.attributes
        domain = Domain(attrs[:-1], attrs[-1], data.domain.class_vars)
        data_with_disc_metas = Table.from_table(domain, data)
        rb = self.widget.controls.resampling.buttons[OWTestLearners.FeatureFold]

        self.send_signal(self.widget.Inputs.learner, ConstantLearner(), 0)
        self.send_signal(self.widget.Inputs.train_data, data)
        self.assertFalse(rb.isEnabled())
        self.assertFalse(self.widget.features_combo.isEnabled())
        self.get_output(self.widget.Outputs.evaluations_results, wait=5000)

        self.send_signal(self.widget.Inputs.train_data, data_with_disc_metas)
        self.assertTrue(rb.isEnabled())
        rb.click()
        self.assertEqual(self.widget.resampling, OWTestLearners.FeatureFold)
        self.assertTrue(self.widget.features_combo.isEnabled())
        self.assertEqual(self.widget.features_combo.currentText(), "iris")
        self.assertEqual(len(self.widget.features_combo.model()), 1)
        self.get_output(self.widget.Outputs.evaluations_results, wait=5000)

        self.send_signal(self.widget.Inputs.train_data, None)
        self.assertFalse(rb.isEnabled())
        self.assertEqual(self.widget.resampling, OWTestLearners.KFold)
        self.assertFalse(self.widget.features_combo.isEnabled())

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import from_table [as 别名]
 def move_primitive_metas_to_X(self, data):
     if data is not None:
         new_attrs = [a for a in data.domain.attributes + data.domain.metas
                      if a.is_primitive()]
         new_metas = [m for m in data.domain.metas if not m.is_primitive()]
         data = Table.from_table(Domain(new_attrs, data.domain.class_vars,
                                        new_metas), data)
     return data

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import from_table [as 别名]
 def check_data(self):
     self.Warning.clear()
     if isinstance(self.data, Table) and isinstance(self.selected_data, Table):
         self.selected_data_transformed = Table.from_table(self.data.domain, self.selected_data)
         if self.selected_data_transformed.X.size > 0:
             self.apply()
         else:
             self.clear()
             self.Warning.no_feature_overlap()
     else:
         self.clear()

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import from_table [as 别名]
 def test_scoring_method_check_box(self):
     """Check scoring methods check boxes"""
     boxes = [self.widget.cls_scoring_box] * 7 + \
             [self.widget.reg_scoring_box] * 2
     for check_box, box in zip(self.widget.score_checks, boxes):
         self.assertEqual(check_box.parent(), box)
     self.send_signal(self.widget.Inputs.data, self.iris)
     self.assertEqual(self.widget.score_stack.currentWidget(), boxes[0])
     self.send_signal(self.widget.Inputs.data, self.housing)
     self.assertEqual(self.widget.score_stack.currentWidget(), boxes[7])
     data = Table.from_table(Domain(self.iris.domain.variables), self.iris)
     self.send_signal(self.widget.Inputs.data, data)
     self.assertNotIn(self.widget.score_stack.currentWidget(), boxes)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import from_table [as 别名]
 def check_data(self):
     self.warning(1)
     if isinstance(self.data, Table) and \
             isinstance(self.selected_data, Table):
         self.selected_data_transformed = Table.from_table(self.data.domain, self.selected_data)
         if self.selected_data_transformed.X.size > 0 and \
                 not np.isnan(self.selected_data_transformed.X).all():
             self.apply()
         else:
             self.clear()
             self.warning(1, 'No features overlap!')
     else:
         self.clear()

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import from_table [as 别名]
 def __call__(self, data):
     """
     Return transformed column from the data by extracting the column view
     from the data and passing it to the `transform` method.
     """
     inst = isinstance(data, Instance)
     if inst:
         data = Table(data.domain, [data])
     if self.variable.is_primitive():
         domain = Domain([self.variable])
         data = Table.from_table(domain, data)
         col = data.X
     else:
         domain = Domain([], metas=[self.variable])
         data = Table.from_table(domain, data)
         col = data.metas
     if not sp.issparse(col):
         col = col.squeeze(axis=1)
     transformed = self.transform(col)
     if inst:
         transformed = transformed[0]
     return transformed

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import from_table [as 别名]
    def test_empty_data(self):
        """ Check widget for dataset with no rows and for dataset with no attributes """
        self.send_signal(self.widget.Inputs.data, self.iris[:0])
        self.assertTrue(self.widget.Error.no_instances.is_shown())

        domain = Domain([], None, self.iris.domain.variables)
        new_data = Table.from_table(domain, self.iris)
        self.send_signal(self.widget.Inputs.data, new_data)
        self.assertTrue(self.widget.Error.no_features.is_shown())
        self.assertFalse(self.widget.Error.no_instances.is_shown())

        self.send_signal(self.widget.Inputs.data, None)
        self.assertFalse(self.widget.Error.no_features.is_shown())

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import from_table [as 别名]
    def test_scoring_method_problem_type(self):
        """Check scoring methods check boxes"""
        self.send_signal(self.widget.Inputs.data, self.iris)
        self.assertEqual(self.widget.problem_type_mode, ProblemType.CLASSIFICATION)
        self.assertEqual(self.widget.measuresStack.currentIndex(), ProblemType.CLASSIFICATION)

        self.send_signal(self.widget.Inputs.data, self.housing)
        self.assertEqual(self.widget.problem_type_mode, ProblemType.REGRESSION)
        self.assertEqual(self.widget.measuresStack.currentIndex(), ProblemType.REGRESSION)

        data = Table.from_table(Domain(self.iris.domain.variables), self.iris)
        self.send_signal(self.widget.Inputs.data, data)
        self.assertEqual(self.widget.problem_type_mode, ProblemType.UNSUPERVISED)
        self.assertEqual(self.widget.measuresStack.currentIndex(), ProblemType.UNSUPERVISED)