def test_compare_string(self): zoo = Table('zoo') zoo1 = zoo[0]['name'] # aardvark zoo2 = zoo[1]['name'] # antelope self.assertTrue(zoo1 < zoo2) self.assertTrue(zoo1 >= "aardvark")
def generateGraph(self): self.Error.clear() self.Warning.clear() matrix = None if self.graphMatrix is None: if hasattr(self, "infoa"): self.infoa.setText("No data loaded.") if hasattr(self, "infob"): self.infob.setText("") if hasattr(self, "infoc"): self.infoc.setText("") self.pconnected = 0 self.nedges = 0 self.graph = None return nEdges = len(self.graphMatrix) * self.kNN if nEdges > 200000: self.graph = None self.Error.number_of_edges(nEdges) else: items = None matrix = self.graphMatrix if matrix is not None and matrix.row_items is not None: row_items = self.graphMatrix.row_items if isinstance(row_items, Table): if self.graphMatrix.axis == 1: items = row_items else: items = [[v.name] for v in row_items.domain.attributes] else: items = [[str(x)] for x in self.graphMatrix.row_items] if len(items) != self.graphMatrix.shape[0]: self.Warning.invalid_number_of_items() items = None if items is None: items = list(range(self.graphMatrix.shape[0])) if not isinstance(items, Table): items = Table( Domain([], metas=[StringVariable('label')]), items) self.Warning.kNN_too_large.clear() if self.kNN >= self.graphMatrix.shape[0]: self.Warning.kNN_too_large(self.graphMatrix.shape[0] - 1) nb_data = len(matrix) row_index = [] col_index = [] distances_data = [] for i in range(nb_data): distances = [] for j in range(nb_data): distances.append((self.graphMatrix[i][j], j)) distances.sort() for k in range(self.kNN): row_index.append(i) col_index.append(distances[k][1]) distances_data.append(distances[k][0]) row = np.array(row_index) col = np.array(col_index) weights = np.array(distances_data) edges = sp.csr_matrix((weights, (row, col))) graph = Network(items, edges) self.graph = graph if self.graph is None: self.pconnected = 0 self.nedges = 0 else: self.pconnected = self.graph.number_of_nodes() self.nedges = self.graph.number_of_edges() if hasattr(self, "infoa"): self.infoa.setText("Data items on input: %d" % self.graphMatrix.shape[0]) if hasattr(self, "infob"): self.infob.setText("Network nodes: %d (%3.1f%%)" % (self.pconnected, self.pconnected / float(self.graphMatrix.shape[0]) * 100)) if hasattr(self, "infoc"): self.infoc.setText("Network edges: %d (%.2f edges/node)" % ( self.nedges, self.nedges / float(self.pconnected) if self.pconnected else 0)) self.Warning.large_number_of_nodes.clear() if self.pconnected > 1000 or self.nedges > 2000: self.Warning.large_number_of_nodes() self.send_network()
def __call__(self, data, ret=Value): 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 if isinstance(data, np.ndarray): prediction = self.predict(np.atleast_2d(data)) elif isinstance(data, scipy.sparse.csr.csr_matrix): prediction = self.predict(data) elif isinstance(data, Instance): if data.domain != self.domain: data = Instance(self.domain, data) data = Table(data.domain, [data]) prediction = self.predict_storage(data) elif isinstance(data, Table): if data.domain != self.domain: data = data.from_table(self.domain, data) prediction = self.predict_storage(data) elif isinstance(data, (list, tuple)): if not isinstance(data[0], (list, tuple)): data = [data] data = Table(self.original_domain, data) data = Table(self.domain, data) 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, cvar in enumerate(self.domain.class_vars): probs[:, i, :], _ = bn.bincount(np.atleast_2d(value[:, i]), max_card - 1) else: probs, _ = bn.bincount(np.atleast_2d(value), len(self.domain.class_var.values) - 1) if ret == Model.ValueProbs: return value, probs else: return probs # Return what we need to if ret == Model.Probs: return probs if isinstance(data, Instance) and not multitarget: value = Value(self.domain.class_var, value[0]) if ret == Model.Value: return value else: # ret == Model.ValueProbs return value, probs
def moved(self): point = self.widget.rect().bottomRight() global_point = self.widget.mapToGlobal(point) self.move(global_point - QPoint(self.width(), 0)) class DropDownToolButton(QToolButton): def __init__(self, parent, var, lc): QToolButton.__init__(self, parent) self.desc_text = '' self.popup = CheckBoxPopup(var, lc, parent, self) self.setMenu(QMenu()) # to show arrow self.clicked.connect(self.open_popup) def open_popup(self): self.popup.moved() self.popup.show() def set_text(self): metrics = QFontMetrics(self.font()) self.setText( metrics.elidedText(self.desc_text, Qt.ElideRight, self.width() - 15)) def resizeEvent(self, QResizeEvent): self.set_text() if __name__ == "__main__": # pragma: no cover WidgetPreview(OWSelectRows).run(Table("zoo"))
def test_warnings(self): domain = Domain([ContinuousVariable("x")]) self.assertWarns(OrangeDeprecationWarning, Table, domain) self.assertWarns(OrangeDeprecationWarning, Table, domain, Table()) self.assertWarns(OrangeDeprecationWarning, Table, domain, [[12]]) self.assertWarns(OrangeDeprecationWarning, Table, np.zeros((5, 5)))
def setUpClass(cls): cls.data = Table("iris") cls.distances = Euclidean(cls.data) cls.init = torgerson(cls.distances) cls.args = (cls.distances, 300, 25, 0, cls.init)
def test_string_variables(self): self.send_signal(self.widget.Inputs.data, Table("zoo"))
items["Iteration limt"] = self.max_iter if self.limit_iter else "unlimited" return items def _report_kernel_parameters(self, items): gamma = self.gamma or self._default_gamma if self.kernel_type == 0: items["Kernel"] = "Linear" elif self.kernel_type == 1: items["Kernel"] = \ "Polynomial, ({g:.4} x⋅y + {c:.4})<sup>{d}</sup>".format( g=gamma, c=self.coef0, d=self.degree) elif self.kernel_type == 2: items["Kernel"] = "RBF, exp(-{:.4}|x-y|²)".format(gamma) else: items["Kernel"] = "Sigmoid, tanh({g:.4} x⋅y + {c:.4})".format( g=gamma, c=self.coef0) if __name__ == "__main__": import sys from AnyQt.QtWidgets import QApplication a = QApplication(sys.argv) ow = OWSVM() ow.resetSettings() d = Table(sys.argv[1] if len(sys.argv) > 1 else 'iris') ow.set_data(d) ow.show() a.exec_() ow.saveSettings()
else: self.invalidate() def send_report(self): # False positives (Setting is not recognized as int) # pylint: disable=invalid-sequence-index if self.optimize_k and self.selected_row() is not None: k_clusters = self.k_from + self.selected_row() else: k_clusters = self.k init_method = self.INIT_METHODS[self.smart_init][0] init_method = init_method[0].lower() + init_method[1:] self.report_items(( ("Number of clusters", k_clusters), ("Optimization", "{}, {} re-runs limited to {} steps".format( init_method, self.n_init, self.max_iterations)))) if self.data is not None: self.report_data("Data", self.data) if self.optimize_k: self.report_table( "Silhouette scores for different numbers of clusters", self.table_view) def onDeleteWidget(self): self.cancel() super().onDeleteWidget() if __name__ == "__main__": # pragma: no cover WidgetPreview(OWKMeans).run(Table("iris.tab"))
def test_empty(self): autompg = Table('auto-mpg') learn = MeanLearner() clf = learn(autompg[:0]) y = clf(autompg[0]) self.assertTrue(y == 0)
def test_discrete(self): iris = Table('iris') learn = MeanLearner() self.assertRaises(ValueError, learn, iris)
def setUp(self): self.zoo = Table("zoo")
params['Random seed for shuffling'] = self.random_state return list(params.items()) def update_model(self): super().update_model() coeffs = None if self.model is not None: if self.model.domain.class_var.is_discrete: coeffs = create_coef_table(self.model) else: attrs = [ContinuousVariable("coef")] domain = Domain(attrs, metas=[StringVariable("name")]) cfs = list(self.model.intercept) + list( self.model.coefficients) names = ["intercept"] + \ [attr.name for attr in self.model.domain.attributes] coeffs = Table(domain, list(zip(cfs, names))) coeffs.name = "coefficients" self.Outputs.coefficients.send(coeffs) @classmethod def migrate_settings(cls, settings, version): if version < 2: settings["max_iter"] = settings.pop("n_iter", 5) settings["tol_enabled"] = False if __name__ == "__main__": # pragma: no cover WidgetPreview(OWSGD).run(Table("iris"))
def setUpClass(cls): cls.ionosphere = Table('ionosphere')
self.Outputs.preprocessor.send(prep) def clear(self): super().clear() self.projector = self.projection = None if __name__ == "__main__": class OWProjectionWidgetWithName(OWDataProjectionWidget): name = "projection" def get_embedding(self): if self.data is None: return None self.valid_data = np.any(np.isfinite(self.data.X), 1) x_data = self.data.X x_data[x_data == np.inf] = np.nan x_data = np.nanmean(x_data[self.valid_data], 1) y_data = np.ones(len(x_data)) return np.vstack((x_data, y_data)).T app = QApplication([]) ow = OWProjectionWidgetWithName() table = Table("iris") ow.set_data(table) ow.set_subset_data(table[::10]) ow.handleNewSignals() ow.show() app.exec_() ow.saveSettings()
def send_data(self): if self.optimize_k: row = self.selected_row() k = self.k_from + row if row is not None else None else: k = self.k km = self.clusterings.get(k) if self.data is None or km is None or isinstance(km, str): self.Outputs.annotated_data.send(None) self.Outputs.centroids.send(None) return domain = self.data.domain cluster_var = DiscreteVariable( get_unique_names(domain, "Cluster"), values=["C%d" % (x + 1) for x in range(km.k)] ) clust_ids = km(self.data) clust_col = clust_ids.X.ravel() silhouette_var = ContinuousVariable( get_unique_names(domain, "Silhouette")) if km.silhouette_samples is not None: self.Warning.no_silhouettes.clear() scores = np.arctan(km.silhouette_samples) / np.pi + 0.5 clust_scores = [] for i in range(km.k): in_clust = clust_col == i if in_clust.any(): clust_scores.append(np.mean(scores[in_clust])) else: clust_scores.append(0.) clust_scores = np.atleast_2d(clust_scores).T else: self.Warning.no_silhouettes() scores = np.nan clust_scores = np.full((km.k, 1), np.nan) new_domain = add_columns(domain, metas=[cluster_var, silhouette_var]) new_table = self.data.transform(new_domain) new_table.get_column_view(cluster_var)[0][:] = clust_col new_table.get_column_view(silhouette_var)[0][:] = scores centroid_attributes = [ attr.compute_value.variable if isinstance(attr.compute_value, ReplaceUnknowns) and attr.compute_value.variable in domain.attributes else attr for attr in km.pre_domain.attributes] centroid_domain = add_columns( Domain(centroid_attributes, [], domain.metas), metas=[cluster_var, silhouette_var]) centroids = Table( centroid_domain, km.centroids, None, np.hstack((np.full((km.k, len(domain.metas)), np.nan), np.arange(km.k).reshape(km.k, 1), clust_scores)) ) if self.data.name == Table.name: centroids.name = "centroids" else: centroids.name = f"{self.data.name} centroids" self.Outputs.annotated_data.send(new_table) self.Outputs.centroids.send(centroids)
def setUp(self): self.widget = self.create_widget(OWDistanceMatrix) self.iris = Table("iris")[:5] self.distances = Euclidean(self.iris)
def setUpClass(cls): cls.data = Table(test_filename("datasets/test5.tab"))
def setUp(self): self.widget = self.create_widget(owcolor.OWColor) self.iris = Table("iris")
def setUpClass(cls): cls.zoo = Table("zoo") # disc. features, disc. class cls.housing = Table("housing") # cont. features, cont. class cls.monk = Table("monks-1") cls.adult = Table("adult_sample")
def setUp(self): self.widget = self.create_widget( OWLouvainClustering, stored_settings={'auto_commit': False}) self.iris = Table('iris')[::5]
def setUpClass(cls): cls.ionosphere = Table('ionosphere') cls.iris = Table('iris') cls.zoo = Table('zoo')
def test_report(self): widget = self.widget data = Table("iris")[::5] self.send_signal(widget.Inputs.data, data) widget.send_report()
def setUp(self): self.iris = Table('iris')
def test_invalid_call_with_kwargs(self): self.assertRaises(TypeError, Table, Y=[]) self.assertRaises(TypeError, Table, "iris", 42) self.assertRaises(TypeError, Table, Table(), 42)
def setUp(self): self.widget = self.create_widget(OWConcatenate) self.iris = Table("iris") self.titanic = Table("titanic")
settings.migrate_str_to_variable(context, names="lat_attr", none_placeholder="") settings.migrate_str_to_variable(context, names="lon_attr", none_placeholder="") settings.migrate_str_to_variable(context, names="class_attr", none_placeholder="(None)") # those settings can have two none placeholder attr_placeholders = [("color_attr", "(Same color)"), ("label_attr", "(No labels)"), ("shape_attr", "(Same shape)"), ("size_attr", "(Same size)")] for attr, place in attr_placeholders: if context.values[attr][0] == place: context.values[attr] = ("", context.values[attr][1]) settings.migrate_str_to_variable(context, names=attr, none_placeholder="") if version < 3: settings.rename_setting(context, "lat_attr", "attr_lat") settings.rename_setting(context, "lon_attr", "attr_lon") settings.rename_setting(context, "color_attr", "attr_color") settings.rename_setting(context, "label_attr", "attr_label") settings.rename_setting(context, "shape_attr", "attr_shape") settings.rename_setting(context, "size_attr", "attr_size") if __name__ == "__main__": data = Table("India_census_district_population") WidgetPreview(OWMap).run(data)
def setUp(self): super().setUp() self.widget = self.create_widget(OWOutliers) self.iris = Table("iris") self.heart_disease = Table("heart_disease")
def setUpClass(cls): cls.iris = Table("iris")
def test_data_name(self): table1 = Table('iris') table2 = TabReader(table1.__file__).read() self.assertEqual(table1.name, 'iris') self.assertEqual(table2.name, 'iris')