def number_of_clusters_change(self): """ Function that change number of clusters if required """ if self.data is None: return if self.number_of_clusters > len(self.data): # if too less data for clusters number self.Warning.cluster_points() self.set_empty_plot() self.step_box.setDisabled(True) self.run_box.setDisabled(True) else: self.Warning.cluster_points.clear() self.step_box.setDisabled(False) self.run_box.setDisabled(False) if self.k_means is None: # if before too less data k_means is None self.k_means = Kmeans(self.concat_x_y()) if self.k_means.k < self.number_of_clusters: self.k_means.add_centroids(self.number_of_clusters - self.k_means.k) elif not self.k_means.k == self.number_of_clusters: self.k_means.delete_centroids(self.k_means.k - self.number_of_clusters) self.replot() self.send_data() self.button_text_change()
def set_data(self, data): """ Function receives data from input and init part of widget if data are ok. Otherwise set empty plot and notice user about that Parameters ---------- data : Orange.data.Table or None input data """ self.data = data def reset_combos(): self.cbx.clear() self.cby.clear() def init_combos(): """ function initialize the combos with attributes """ reset_combos() for var in data.domain.variables if data is not None else []: if var.is_primitive() and var.is_continuous: self.cbx.addItem(gui.attributeIconDict[var], var.name) self.cby.addItem(gui.attributeIconDict[var], var.name) # remove warnings about too less continuous attributes and not enough data self.Warning.clear() if self.auto_play_thread: self.auto_play_thread.stop() if data is None or len(data) == 0: reset_combos() self.set_empty_plot() self.set_disabled_all(True) elif sum(True for var in data.domain.attributes if isinstance(var, ContinuousVariable)) < 2: reset_combos() self.Warning.num_features() self.set_empty_plot() self.set_disabled_all(True) else: init_combos() self.set_disabled_all(False) self.attr_x = self.cbx.itemText(0) self.attr_y = self.cbx.itemText(1) if self.k_means is None: self.k_means = Kmeans(self.concat_x_y()) else: self.k_means.set_data(self.concat_x_y()) self.number_of_clusters_change()
def number_of_clusters_change(self): """ Function that change number of clusters if required """ if self.data is None: return if self.number_of_clusters > len(self.data): # if too less data for clusters number self.Warning.cluster_points() self.set_empty_plot() self.step_box.setDisabled(True) self.run_box.setDisabled(True) else: self.Warning.cluster_points.clear() self.step_box.setDisabled(False) self.run_box.setDisabled(False) if self.k_means is None: # if before too less data k_means is None self.k_means = Kmeans(self.concat_x_y()) if self.k_means.k < self.number_of_clusters: self.k_means.add_centroids( self.number_of_clusters - self.k_means.k) elif not self.k_means.k == self.number_of_clusters: self.k_means.delete_centroids( self.k_means.k - self.number_of_clusters) self.replot() self.send_data() self.button_text_change()
def set_data(self, data): """ Function receives data from input and init part of widget if data are ok. Otherwise set empty plot and notice user about that Parameters ---------- data : Orange.data.Table or None input data """ self.data = data def reset_combos(): self.cbx.clear() self.cby.clear() def init_combos(): """ function initialize the combos with attributes """ reset_combos() for var in data.domain if data is not None else []: if var.is_primitive() and var.is_continuous: self.cbx.addItem(gui.attributeIconDict[var], var.name) self.cby.addItem(gui.attributeIconDict[var], var.name) self.warning(1) # remove warning about too less continuous attributes self.warning(2) # remove warning about not enough data if data is None or len(data) == 0: reset_combos() self.set_empty_plot() self.set_disabled_all(True) elif sum(True for var in data.domain.attributes if isinstance(var, ContinuousVariable)) < 2: reset_combos() self.warning(1, "Widget requires at least two numeric features") self.set_empty_plot() self.set_disabled_all(True) else: init_combos() self.set_disabled_all(False) self.attr_x = self.cbx.itemText(0) self.attr_y = self.cbx.itemText(1) if self.k_means is None: self.k_means = Kmeans(self.concat_x_y()) else: self.k_means.set_data(self.concat_x_y()) self.number_of_clusters_change()
def number_of_clusters_change(self): """ Function that change number of clusters if required """ if self.numberOfClusters > len(self.data): # if too less data for clusters number self.warning(2, "Please provide at least number of points equal to " "number of clusters selected or decrease number of clusters") self.set_empty_plot() self.commandsBox.setDisabled(True) else: self.warning(2) self.commandsBox.setDisabled(False) if self.k_means is None: # if before too less data k_means is None self.k_means = Kmeans(self.concat_x_y()) if self.k_means.k < self.numberOfClusters: self.k_means.add_centroids(self.numberOfClusters - self.k_means.k) elif not self.k_means.k == self.numberOfClusters: self.k_means.delete_centroids(self.k_means.k - self.numberOfClusters) self.replot() self.send_data()
def setUp(self): self.data = Table('iris') new_domain = Domain(self.data.domain.attributes[:2]) self.data = Table(new_domain, self.data) # self.centroids = [[5.2, 3.1], [6.5, 3], [7, 4]] self.kmeans = Kmeans(self.data, centroids=None)
class TestKmeans(unittest.TestCase): def setUp(self): self.data = Table('iris') new_domain = Domain(self.data.domain.attributes[:2]) self.data = Table(new_domain, self.data) # self.centroids = [[5.2, 3.1], [6.5, 3], [7, 4]] self.kmeans = Kmeans(self.data, centroids=None) def test_k(self): centroids = [[5.2, 3.1], [6.5, 3], [7, 4]] self.kmeans.add_centroids(centroids) self.assertEqual(self.kmeans.k, 3) self.assertEqual(self.kmeans.k, len(self.kmeans.centroids)) def test_centroids_belonging_points(self): centroids = [[5.2, 3.6]] self.kmeans.add_centroids(centroids) # if only one cluster all points in 0th element of first dimension np.testing.assert_equal(self.kmeans.centroids_belonging_points, np.array([self.data.X])) # try with two clusters and less data self.kmeans.set_data(self.data[:3]) self.kmeans.add_centroids([[4.7, 3.0]]) desired_array = np.array([np.array([[5.100, 3.500]]), np.array([[4.900, 3.000], [4.700, 3.200]])]) for i, arr in enumerate(self.kmeans.centroids_belonging_points): np.testing.assert_equal(arr, desired_array[i]) def test_step_completed(self): centroids = [[5.2, 3.1], [6.5, 3], [7, 4]] self.kmeans.add_centroids(centroids) self.assertEqual(self.kmeans.step_completed, True) self.kmeans.step() self.assertEqual(self.kmeans.step_completed, False) self.kmeans.step() self.assertEqual(self.kmeans.step_completed, True) def test_set_data(self): self.kmeans.set_data(self.data) self.assertEqual(self.kmeans.data, self.data) self.assertEqual(self.kmeans.centroids_history, []) self.assertEqual(self.kmeans.stepNo, 0) self.assertEqual(self.kmeans.step_completed, True) self.assertEqual(self.kmeans.centroids_moved, False) # try with none data self.kmeans.set_data(None) self.assertEqual(self.kmeans.data, None) self.assertEqual(self.kmeans.centroids_history, []) self.assertEqual(self.kmeans.clusters, None) self.assertEqual(self.kmeans.stepNo, 0) self.assertEqual(self.kmeans.step_completed, True) self.assertEqual(self.kmeans.centroids_moved, False) def test_find_clusters(self): self.kmeans.add_centroids([[5.2, 3.6]]) # if only one cluster all points in 0th element of first dimension np.testing.assert_equal(self.kmeans.find_clusters(self.kmeans.centroids), np.zeros(len(self.data))) # try with two clusters and less data self.kmeans.set_data(self.data[:3]) self.kmeans.add_centroids([[4.7, 3.0]]) np.testing.assert_equal(self.kmeans.find_clusters(self.kmeans.centroids), np.array([0, 1, 1])) def test_step(self): centroids = [[5.2, 3.1], [6.5, 3], [7, 4]] self.kmeans.add_centroids(centroids) centroids_before = np.copy(self.kmeans.centroids) clusters_before = np.copy(self.kmeans.clusters) self.kmeans.step() self.assertEqual(self.kmeans.step_completed, False) self.assertEqual(self.kmeans.centroids_moved, True) np.testing.assert_equal(centroids_before, self.kmeans.centroids_history[-1]) # clusters doesnt change in every odd step np.testing.assert_equal(clusters_before, self.kmeans.clusters) centroids_before = np.copy(self.kmeans.centroids) self.kmeans.step() self.assertEqual(self.kmeans.step_completed, True) self.assertEqual(self.kmeans.centroids_moved, False) np.testing.assert_equal(centroids_before, self.kmeans.centroids) centroids_before = np.copy(self.kmeans.centroids) self.kmeans.step() self.kmeans.step_back() np.testing.assert_equal(centroids_before, self.kmeans.centroids) def test_step_back(self): centroids = [[5.2, 3.1], [6.5, 3], [7, 4]] self.kmeans.add_centroids(centroids) # check if nothing happens when step = 0 centroids_before = np.copy(self.kmeans.centroids) clusters_before = np.copy(self.kmeans.clusters) self.kmeans.step_back() np.testing.assert_equal(centroids_before, self.kmeans.centroids) np.testing.assert_equal(clusters_before, self.kmeans.clusters) # check if centroids remain in even step self.kmeans.step() self.kmeans.step() centroids_before = self.kmeans.centroids self.kmeans.step_back() np.testing.assert_equal(centroids_before, self.kmeans.centroids) self.assertEqual(self.kmeans.step_completed, False) self.assertEqual(self.kmeans.centroids_moved, False) # check if clusters remain in even step clusters_before = self.kmeans.clusters self.kmeans.step_back() np.testing.assert_equal(clusters_before, self.kmeans.clusters) self.assertEqual(self.kmeans.step_completed, True) self.assertEqual(self.kmeans.centroids_moved, True) def test_random_positioning(self): self.assertEqual(self.kmeans.random_positioning(4).shape, (4, 2)) self.assertEqual(self.kmeans.random_positioning(1).shape, (1, 2)) self.assertEqual(self.kmeans.random_positioning(0).shape, (0,)) self.assertEqual(self.kmeans.random_positioning(-1).shape, (0,)) def test_add_centroids(self): self.kmeans.add_centroids([[5.2, 3.1]]) self.assertEqual(self.kmeans.k, 1) self.kmeans.add_centroids([[6.5, 3], [7, 4]]) self.assertEqual(self.kmeans.k, 3) self.kmeans.add_centroids(2) self.assertEqual(self.kmeans.k, 5) self.kmeans.add_centroids() self.assertEqual(self.kmeans.k, 6) step_before = self.kmeans.stepNo self.assertEqual(step_before, self.kmeans.stepNo) self.kmeans.step() self.kmeans.add_centroids() self.assertEqual(step_before + 2, self.kmeans.stepNo) self.assertEqual(self.kmeans.centroids_moved, False) def test_delete_centroids(self): self.kmeans.add_centroids([[6.5, 3], [7, 4], [5.2, 3.1]]) self.kmeans.delete_centroids(1) self.assertEqual(self.kmeans.k, 2) self.kmeans.delete_centroids(2) self.assertEqual(self.kmeans.k, 0) self.kmeans.delete_centroids(2) self.assertEqual(self.kmeans.k, 0) def test_move_centroid(self): self.kmeans.add_centroids([[6.5, 3], [7, 4], [5.2, 3.1]]) self.kmeans.move_centroid(1, 3, 3.2) np.testing.assert_equal(self.kmeans.centroids[1], np.array([3, 3.2])) self.assertEqual(self.kmeans.k, 3) self.kmeans.step() self.kmeans.move_centroid(2, 3.2, 3.4) self.assertEqual(self.kmeans.centroids_moved, False) self.assertEqual(self.kmeans.stepNo, 2)
def restart(self): """ Function triggered on data change or restart button pressed """ self.k_means = Kmeans(self.concat_x_y()) self.number_of_clusters_change()
def set_data(self, data): """ Function receives data from input and init part of widget if data are ok. Otherwise set empty plot and notice user about that Parameters ---------- data : Orange.data.Table or None input data """ self.data = data def get_valid_attributes(data): attrs = [ var for var in data.domain.attributes if var.is_continuous ] return [var for var in attrs if sum(~np.isnan(data[:, var])) > 0] def reset_combos(): self.cbx.clear() self.cby.clear() def init_combos(): """ function initialize the combos with attributes """ reset_combos() valid_class_vars = [ var for var in data.domain.class_vars if data is not None and var.is_continuous ] for var in chain(valid_attributes, valid_class_vars): self.cbx.addItem(gui.attributeIconDict[var], var.name) self.cby.addItem(gui.attributeIconDict[var], var.name) # remove warnings about too less continuous attributes and not enough data self.Warning.clear() if self.auto_play_thread: self.auto_play_thread.stop() if data is None or len(data) == 0: reset_combos() self.set_empty_plot() self.set_disabled_all(True) return valid_attributes = get_valid_attributes(data) if len(valid_attributes) < 2: reset_combos() self.Warning.num_features() self.set_empty_plot() self.set_disabled_all(True) else: init_combos() self.set_disabled_all(False) self.attr_x = self.cbx.itemText(0) self.attr_y = self.cbx.itemText(1) if self.k_means is None: self.k_means = Kmeans(self.concat_x_y()) else: self.k_means.set_data(self.concat_x_y()) self.number_of_clusters_change()
class OWKmeans(OWWidget): """ K-means widget """ name = "Interactive k-Means" description = "Widget demonstrates working of k-means algorithm." keywords = ["kmeans", "clustering", "interactive"] icon = "icons/InteractiveKMeans.svg" want_main_area = False priority = 300 # inputs and outputs class Inputs: data = Input("Data", Table) class Outputs: annotated_data = Output("Annotated Data", Table, default=True) centroids = Output("Centroids", Table) class Warning(OWWidget.Warning): num_features = Msg( "Widget requires at least two numeric features with valid values") cluster_points = Msg( "The number of clusters can't exceed the number of points") # settings number_of_clusters = settings.Setting(3) auto_play_enabled = False auto_play_thread = None # data data = None selected_rows = None # rows that are selected for kmeans (not nan rows) # selected attributes in chart attr_x = settings.Setting('') attr_y = settings.Setting('') # other settings k_means = None auto_play_speed = settings.Setting(1) lines_to_centroids = settings.Setting(True) graph_name = 'scatter' output_name = "cluster" STEP_BUTTONS = ["Reassign Membership", "Recompute Centroids"] AUTOPLAY_BUTTONS = ["Run", "Stop"] # colors taken from chart.options.colors in Highchart # (if more required check for more in chart.options.color) colors = [ "#1F7ECA", "#D32525", "#28D825", "#D5861F", "#98257E", "#2227D5", "#D5D623", "#D31BD6", "#6A7CDB", "#78D5D4" ] # signals step_trigger = pyqtSignal() stop_auto_play_trigger = pyqtSignal() def __init__(self): super().__init__() # options box self.options_box = gui.widgetBox(self.controlArea, "Data") opts = dict(widget=self.options_box, master=self, orientation=Qt.Horizontal, callback=self.restart, sendSelectedValue=True, maximumContentsLength=15) self.cbx = gui.comboBox(value='attr_x', label='X: ', **opts) self.cby = gui.comboBox(value='attr_y', label='Y: ', **opts) self.centroids_box = gui.widgetBox(self.controlArea, "Centroids") self.centroid_numbers_spinner = gui.spin( self.centroids_box, self, 'number_of_clusters', minv=1, maxv=10, step=1, label='Number of centroids:', alignment=Qt.AlignRight, callback=self.number_of_clusters_change) self.restart_button = gui.button(self.centroids_box, self, "Randomize Positions", callback=self.restart) gui.separator(self.centroids_box) self.lines_checkbox = gui.checkBox(self.centroids_box, self, 'lines_to_centroids', 'Show membership lines', callback=self.complete_replot) # control box gui.separator(self.controlArea, 20, 20) self.step_box = gui.widgetBox(self.controlArea, "Manually step through") self.step_button = gui.button(self.step_box, self, self.STEP_BUTTONS[1], callback=self.step) self.step_back_button = gui.button(self.step_box, self, "Step Back", callback=self.step_back) self.run_box = gui.widgetBox(self.controlArea, "Run") self.auto_play_speed_spinner = gui.hSlider(self.run_box, self, 'auto_play_speed', label='Speed:', minValue=0, maxValue=1.91, step=0.1, intOnly=False, createLabel=False) self.auto_play_button = gui.button(self.run_box, self, self.AUTOPLAY_BUTTONS[0], callback=self.auto_play) gui.rubber(self.controlArea) # disable until data loaded self.set_disabled_all(True) # graph in mainArea self.scatter = Scatterplot(click_callback=self.graph_clicked, drop_callback=self.centroid_dropped, xAxis_gridLineWidth=0, yAxis_gridLineWidth=0, tooltip_enabled=False, debug=False) # Just render an empty chart so it shows a nice 'No data to display' self.scatter.chart() self.mainArea.layout().addWidget(self.scatter) def concat_x_y(self): """ Function takes two selected columns from data table and merge them in new Orange.data.Table Returns ------- Orange.data.Table table with selected columns """ attr_x = self.data.domain[self.attr_x] attr_y = self.data.domain[self.attr_y] cols = [] for attr in (attr_x, attr_y): subset = self.data[:, attr] cols.append(subset.Y if subset.Y.size else subset.X) x = np.column_stack(cols) not_nan = ~np.isnan(x).any(axis=1) x = x[not_nan] # remove rows with nan self.selected_rows = np.where(not_nan) domain = Domain([attr_x, attr_y]) return Table(domain, x) def set_empty_plot(self): self.scatter.clear() def set_disabled_all(self, disabled): """ Function disable all controls """ self.options_box.setDisabled(disabled) self.centroids_box.setDisabled(disabled) self.step_box.setDisabled(disabled) self.run_box.setDisabled(disabled) @Inputs.data def set_data(self, data): """ Function receives data from input and init part of widget if data are ok. Otherwise set empty plot and notice user about that Parameters ---------- data : Orange.data.Table or None input data """ self.data = data def get_valid_attributes(data): attrs = [ var for var in data.domain.attributes if var.is_continuous ] return [var for var in attrs if sum(~np.isnan(data[:, var])) > 0] def reset_combos(): self.cbx.clear() self.cby.clear() def init_combos(): """ function initialize the combos with attributes """ reset_combos() valid_class_vars = [ var for var in data.domain.class_vars if data is not None and var.is_continuous ] for var in chain(valid_attributes, valid_class_vars): self.cbx.addItem(gui.attributeIconDict[var], var.name) self.cby.addItem(gui.attributeIconDict[var], var.name) # remove warnings about too less continuous attributes and not enough data self.Warning.clear() if self.auto_play_thread: self.auto_play_thread.stop() if data is None or len(data) == 0: reset_combos() self.set_empty_plot() self.set_disabled_all(True) return valid_attributes = get_valid_attributes(data) if len(valid_attributes) < 2: reset_combos() self.Warning.num_features() self.set_empty_plot() self.set_disabled_all(True) else: init_combos() self.set_disabled_all(False) self.attr_x = self.cbx.itemText(0) self.attr_y = self.cbx.itemText(1) if self.k_means is None: self.k_means = Kmeans(self.concat_x_y()) else: self.k_means.set_data(self.concat_x_y()) self.number_of_clusters_change() def restart(self): """ Function triggered on data change or restart button pressed """ self.k_means = Kmeans(self.concat_x_y()) self.number_of_clusters_change() def step(self): """ Function called on every step """ self.k_means.step() self.replot() self.button_text_change() self.send_data() def step_back(self): """ Function called for step back """ self.k_means.step_back() self.replot() self.button_text_change() self.send_data() self.number_of_clusters = self.k_means.k def button_text_change(self): """ Function changes text on ste button and chanbe the button text """ self.step_button.setText( self.STEP_BUTTONS[self.k_means.step_completed]) if self.k_means.step_no <= 0: self.step_back_button.setDisabled(True) elif not self.auto_play_enabled: self.step_back_button.setDisabled(False) def auto_play(self): """ Function called when autoplay button pressed """ self.auto_play_enabled = not self.auto_play_enabled self.auto_play_button.setText( self.AUTOPLAY_BUTTONS[self.auto_play_enabled]) if self.auto_play_enabled: self.options_box.setDisabled(True) self.centroids_box.setDisabled(True) self.step_box.setDisabled(True) self.auto_play_thread = Autoplay(self) self.step_trigger.connect(self.step) self.stop_auto_play_trigger.connect(self.stop_auto_play) self.auto_play_thread.start() else: self.stop_auto_play() def stop_auto_play(self): """ Called when stop autoplay button pressed or in the end of autoplay """ self.options_box.setDisabled(False) self.centroids_box.setDisabled(False) self.step_box.setDisabled(False) self.auto_play_enabled = False self.auto_play_button\ .setText(self.AUTOPLAY_BUTTONS[self.auto_play_enabled]) self.button_text_change() def replot(self): """ Function refreshes the chart """ if self.data is None or not self.attr_x or not self.attr_y: return km = self.k_means if not km.centroids_moved: self.complete_replot() return # when centroids moved during step self.scatter.update_series(0, self.k_means.centroids) if self.lines_to_centroids: for i, (c, pts) in enumerate( zip(km.centroids, km.centroids_belonging_points)): self.scatter.update_series( 1 + i, list( chain.from_iterable( ([p[0], p[1]], [c[0], c[1]]) for p in pts))) def complete_replot(self): """ This function performs complete replot of the graph without animation """ try: attr_x = self.data.domain[self.attr_x] attr_y = self.data.domain[self.attr_y] except KeyError: return # plot centroids options = dict(series=[]) n_colors = len(self.colors) km = self.k_means options['series'].append( dict(data=[{ 'x': p[0], 'y': p[1], 'marker': { 'fillColor': self.colors[i % n_colors] } } for i, p in enumerate(km.centroids)], type="scatter", draggableX=True, draggableY=True, cursor="move", zIndex=10, marker=dict(symbol='square', radius=8))) # plot lines between centroids and points if self.lines_to_centroids: for i, (c, pts) in enumerate( zip(km.centroids, km.centroids_belonging_points)): options['series'].append( dict(data=list( chain.from_iterable( ([p[0], p[1]], [c[0], c[1]]) for p in pts)), type="line", lineWidth=0.2, enableMouseTracking=False, color="#ccc")) # plot data points for i, points in enumerate(km.centroids_belonging_points): options['series'].append( dict(data=points, type="scatter", color=rgb_hash_brighter(self.colors[i % len(self.colors)], 0.3))) # highcharts parameters kwargs = dict( xAxis_title_text=attr_x.name, yAxis_title_text=attr_y.name, tooltip_headerFormat="", tooltip_pointFormat="<strong>%s:</strong> {point.x:.2f} <br/>" "<strong>%s:</strong> {point.y:.2f}" % (self.attr_x, self.attr_y)) # plot self.scatter.chart(options, **kwargs) def replot_series(self): """ This function replot just series connected with centroids and uses animation for that """ km = self.k_means k = km.k series = [] # plot lines between centroids and points if self.lines_to_centroids: for i, (c, pts) in enumerate( zip(km.centroids, km.centroids_belonging_points)): series.append( dict(data=list( chain.from_iterable( ([p[0], p[1]], [c[0], c[1]]) for p in pts)), type="line", showInLegend=False, lineWidth=0.2, enableMouseTracking=False, color="#ccc")) # plot data points for i, points in enumerate(km.centroids_belonging_points): series.append( dict(data=points, type="scatter", showInLegend=False, color=rgb_hash_brighter(self.colors[i % len(self.colors)], 0.5))) self.scatter.add_series(series) self.scatter.remove_last_series(k * 2 if self.lines_to_centroids else k) def number_of_clusters_change(self): """ Function that change number of clusters if required """ if self.data is None: return if self.number_of_clusters > len(self.data): # if too less data for clusters number self.Warning.cluster_points() self.set_empty_plot() self.step_box.setDisabled(True) self.run_box.setDisabled(True) else: self.Warning.cluster_points.clear() self.step_box.setDisabled(False) self.run_box.setDisabled(False) if self.k_means is None: # if before too less data k_means is None self.k_means = Kmeans(self.concat_x_y()) if self.k_means.k < self.number_of_clusters: self.k_means.add_centroids(self.number_of_clusters - self.k_means.k) elif not self.k_means.k == self.number_of_clusters: self.k_means.delete_centroids(self.k_means.k - self.number_of_clusters) self.replot() self.send_data() self.button_text_change() def graph_clicked(self, x, y): """ Function called when user click in graph. Centroid have to be added. """ if self.k_means is not None and self.data is not None: self.k_means.add_centroids([x, y]) self.number_of_clusters += 1 self.replot() self.send_data() self.button_text_change() def centroid_dropped(self, _index, x, y): """ Function called when centroid with _index moved. """ self.k_means.move_centroid(_index, x, y) self.complete_replot() self.send_data() self.button_text_change() 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) def send_report(self): if self.data is None: return caption = report.render_items_vert( (("Number of centroids:", self.number_of_clusters), )) self.report_plot(self.scatter) self.report_caption(caption)
class OWKmeans(OWWidget): """ K-means widget """ name = "Interactive k-Means" description = "Widget demonstrates working of k-means algorithm." icon = "icons/mywidget.svg" want_main_area = False # inputs and outputs inputs = [("Data", Orange.data.Table, "set_data")] outputs = [("Annotated Data", Table, widget.Default), ("Centroids", Table)] # settings numberOfClusters = settings.Setting(1) autoPlay = False # data data = None # selected attributes in chart attr_x = settings.Setting('') attr_y = settings.Setting('') # other settings k_means = None autoPlaySpeed = settings.Setting(1) lines_to_centroids = settings.Setting(0) graph_name = 'scatter' outputName = "cluster" button_labels = {"step1": "Reassign membership", "step2": "Recompute centroids", "step_back": "Step back", "autoplay_run": "Run", "autoplay_stop": "Stop", "random_centroids": "Randomize"} colors = ['#2f7ed8', '#0d233a', '#8bbc21', '#910000', '#1aadce', '#492970', '#f28f43', '#77a1e5', '#c42525', '#a6c96a'] def __init__(self): super().__init__() # options box self.optionsBox = gui.widgetBox(self.controlArea) self.cbx = gui.comboBox(self.optionsBox, self, 'attr_x', label='X:', orientation=Qt.Horizontal, callback=self.restart, sendSelectedValue=True) self.cbx.setSizePolicy(QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)) self.cby = gui.comboBox(self.optionsBox, self, 'attr_y', label='Y:', orientation='horizontal', callback=self.restart, sendSelectedValue=True) self.cby.setSizePolicy(QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)) self.centroidsBox = gui.widgetBox(self.controlArea, "Centroids") self.centroidNumbersSpinner = gui.spin(self.centroidsBox, self, 'numberOfClusters', minv=1, maxv=10, step=1, label='Number of centroids:', callback=self.number_of_clusters_change) self.centroidNumbersSpinner.setSizePolicy(QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)) self.restartButton = gui.button(self.centroidsBox, self, self.button_labels["random_centroids"], callback=self.restart) self.linesCheckbox = gui.checkBox(self.centroidsBox, self, 'lines_to_centroids', 'Show membership lines', callback=self.complete_replot) # control box self.commandsBox = gui.widgetBox(self.controlArea) self.stepButton = gui.button(self.commandsBox, self, self.button_labels["step2"], callback=self.step) self.stepBackButton = gui.button(self.commandsBox, self, self.button_labels["step_back"], callback=self.step_back) self.autoPlayButton = gui.button(self.commandsBox, self, self.button_labels["autoplay_run"], callback=self.auto_play) self.autoPlaySpeedSpinner = gui.hSlider(self.commandsBox, self, 'autoPlaySpeed', minValue=0, maxValue=1.91, step=0.1, intOnly=False, createLabel=False, label='Speed:') gui.rubber(self.controlArea) # disable until data loaded self.set_disabled_all(True) # graph in mainArea self.scatter = Scatterplot(click_callback=self.graph_clicked, drop_callback=self.centroid_dropped, xAxis_gridLineWidth=0, yAxis_gridLineWidth=0, title_text='', tooltip_shared=False, debug=True) # TODO: set false when end of development # Just render an empty chart so it shows a nice 'No data to display' self.scatter.chart() self.mainArea.layout().addWidget(self.scatter) def concat_x_y(self): """ Function takes two selected columns from data table and merge them in new Orange.data.Table :return: table with selected columns :type: Orange.data.Table """ attr_x, attr_y = self.data.domain[self.attr_x], self.data.domain[self.attr_y] cols = [] for attr in (attr_x, attr_y): subset = self.data[:, attr] cols.append(subset.Y if subset.Y.size else subset.X) x = np.column_stack(cols) domain = Domain([attr_x, attr_y]) return Table(domain, x) def set_empty_plot(self): self.scatter.clear() def set_disabled_all(self, disabled): """ Function disable all controls """ self.optionsBox.setDisabled(disabled) self.centroidsBox.setDisabled(disabled) self.commandsBox.setDisabled(disabled) def set_data(self, data): """ Function receives data from input and init part of widget if data are ok. Otherwise set empty plot and notice user about that :param data: input data :type data: Orange.data.Table or None """ self.data = data def reset_combos(): self.cbx.clear() self.cby.clear() def init_combos(): """ function initialize the combos with attributes """ reset_combos() for var in data.domain if data is not None else []: if var.is_primitive() and var.is_continuous: self.cbx.addItem(gui.attributeIconDict[var], var.name) self.cby.addItem(gui.attributeIconDict[var], var.name) self.warning(1) # remove warning about too less continuous attributes if exists self.warning(2) # remove warning about not enough data if data is None or len(data) == 0: reset_combos() self.set_empty_plot() self.set_disabled_all(True) elif sum(True for var in data.domain.attributes if isinstance(var, ContinuousVariable)) < 2: reset_combos() self.warning(1, "Too few Continuous feature. Min 2 required") self.set_empty_plot() self.set_disabled_all(True) else: init_combos() self.set_disabled_all(False) self.attr_x = self.cbx.itemText(0) self.attr_y = self.cbx.itemText(1) if self.k_means is None: self.k_means = Kmeans(self.concat_x_y()) else: self.k_means.set_data(self.concat_x_y()) self.modify_kmeans() def restart(self): """ Function triggered on data change or restart button pressed """ self.k_means = Kmeans(self.concat_x_y()) self.modify_kmeans() def modify_kmeans(self): self.number_of_clusters_change() self.button_text_change() def step(self): """ Function called on every step """ self.k_means.step() self.replot() self.button_text_change() self.send_data() def step_back(self): """ Function called for step back """ self.k_means.step_back() self.replot() self.button_text_change() self.send_data() def button_text_change(self): """ Function changes text on ste button and chanbe the button text """ self.stepButton.setText(self.button_labels["step2"] if self.k_means.step_completed else self.button_labels["step1"]) if self.k_means.stepNo <= 0: self.stepBackButton.setDisabled(True) elif not self.autoPlay: self.stepBackButton.setDisabled(False) def auto_play(self): """ Function called when autoplay button pressed """ self.autoPlay = not self.autoPlay self.autoPlayButton.setText(self.button_labels["autoplay_stop"] if self.autoPlay else self.button_labels["autoplay_run"]) if self.autoPlay: self.optionsBox.setDisabled(True) self.centroidsBox.setDisabled(True) self.stepButton.setDisabled(True) self.stepBackButton.setDisabled(True) self.autoPlayThread = Autoplay(self) self.connect(self.autoPlayThread, SIGNAL("step()"), self.step) self.connect(self.autoPlayThread, SIGNAL("stop_auto_play()"), self.stop_auto_play) self.autoPlayThread.start() else: self.stop_auto_play() def stop_auto_play(self): """ Called when stop autoplay button pressed or in the end of autoplay """ self.optionsBox.setDisabled(False) self.stepButton.setDisabled(False) self.centroidsBox.setDisabled(False) self.stepBackButton.setDisabled(False) self.autoPlay = False self.autoPlayButton.setText(self.button_labelsp["autoplay_stop"] if self.autoPlay else self.button_labels["autoplay_run"]) def replot(self): """ Function refreshes the chart """ if self.data is None or not self.attr_x or not self.attr_y: return if self.k_means.centroids_moved: # when centroids moved during step self.scatter.update_series(0, self.k_means.centroids) if self.lines_to_centroids: for i, c in enumerate(self.k_means.centroids): self.scatter.update_series(1 + i, list(chain.from_iterable( ([p[0], p[1]], [c[0], c[1]]) for p in self.k_means.centroids_belonging_points[i]))) else: self.complete_replot() def complete_replot(self): """ This function performs complete replot of the graph without animation """ attr_x, attr_y = self.data.domain[self.attr_x], self.data.domain[self.attr_y] # plot centroids options = dict(series=[]) options['series'].append(dict(data=[{'x': p[0], 'y': p[1], 'marker':{'fillColor': self.colors[i % len(self.colors)]}} for i, p in enumerate(self.k_means.centroids)], type="scatter", draggableX=True if self.k_means.step_completed else False, draggableY=True if self.k_means.step_completed else False, showInLegend=False, zIndex=10, marker=dict(symbol='diamond', radius=10))) # plot lines between centroids and points if self.lines_to_centroids: for i, c in enumerate(self.k_means.centroids): options['series'].append(dict(data=list( chain.from_iterable(([p[0], p[1]], [c[0], c[1]]) for p in self.k_means.centroids_belonging_points[i])), type="line", showInLegend=False, lineWidth=0.2, enableMouseTracking=False, color="#ccc")) # plot data points for i, points in enumerate(self.k_means.centroids_belonging_points): options['series'].append(dict(data=points, type="scatter", showInLegend=False, color=rgb_hash_brighter(self.colors[i % len(self.colors)], 30))) # highcharts parameters kwargs = dict( xAxis_title_text=attr_x.name, yAxis_title_text=attr_y.name, tooltip_headerFormat="", tooltip_pointFormat="<strong>%s:</strong> {point.x:.2f} <br/>" "<strong>%s:</strong> {point.y:.2f}" % (self.attr_x, self.attr_y)) # plot self.scatter.chart(options, **kwargs) def replot_series(self): """ This function replot just series connected with centroids and uses animation for that """ k = self.k_means.k series = [] # plot lines between centroids and points if self.lines_to_centroids: for i, c in enumerate(self.k_means.centroids): series.append(dict( data=list(chain.from_iterable(([p[0], p[1]], [c[0], c[1]]) for p in self.k_means.centroids_belonging_points[i])), type="line", showInLegend=False, lineWidth=0.2, enableMouseTracking=False, color="#ccc")) # plot data points for i, points in enumerate(self.k_means.centroids_belonging_points): series.append(dict(data=points, type="scatter", showInLegend=False, color=rgb_hash_brighter(self.colors[i % len(self.colors)], 30))) self.scatter.add_series(series) self.scatter.remove_last_series(k * 2 if self.lines_to_centroids else k) def number_of_clusters_change(self): """ Function that change number of clusters if required """ if self.numberOfClusters > len(self.data): # if too less data for clusters number self.warning(2, "Please provide at least number of points equal to " "number of clusters selected or decrease number of clusters") self.set_empty_plot() self.commandsBox.setDisabled(True) else: self.warning(2) self.commandsBox.setDisabled(False) if self.k_means is None: # if before too less data k_means is None self.k_means = Kmeans(self.concat_x_y()) if self.k_means.k < self.numberOfClusters: self.k_means.add_centroids(self.numberOfClusters - self.k_means.k) elif not self.k_means.k == self.numberOfClusters: self.k_means.delete_centroids(self.k_means.k - self.numberOfClusters) self.replot() self.send_data() def graph_clicked(self, x, y): """ Function called when user click in graph. Centroid have to be added. """ if self.k_means is not None: self.k_means.add_centroids([x, y]) self.numberOfClusters += 1 self.replot() self.send_data() self.button_text_change() def centroid_dropped(self, _index, x, y): """ Function called when centroid with _index moved. """ self.k_means.move_centroid(_index, x, y) self.complete_replot() self.send_data() self.button_text_change() def send_data(self): """ Function sends data with clusters column and data with centroids position to the output """ if self.k_means is None or self.k_means.clusters is None: self.send("Annotated Data", None) self.send("Centroids", None) else: clust_var = DiscreteVariable( self.outputName, values=["C%d" % (x + 1) for x in range(self.k_means.k)]) attributes, classes = self.data.domain.attributes, 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.get_column_view(clust_var)[0][:] = self.k_means.clusters centroids = Table(Domain(self.k_means.data.domain.attributes), self.k_means.centroids) self.send("Annotated Data", annotated_data) self.send("Centroids", centroids)
def restart(self): """ Function triggered on data change or restart button pressed """ self.k_means = Kmeans(self.concat_x_y()) self.number_of_clusters_change()
def set_data(self, data): """ Function receives data from input and init part of widget if data are ok. Otherwise set empty plot and notice user about that Parameters ---------- data : Orange.data.Table or None input data """ self.data = data def get_valid_attributes(data): attrs = [var for var in data.domain.attributes if var.is_continuous] return [var for var in attrs if sum(~np.isnan(data[:, var])) > 0] def reset_combos(): self.cbx.clear() self.cby.clear() def init_combos(): """ function initialize the combos with attributes """ reset_combos() valid_class_vars = [var for var in data.domain.class_vars if data is not None and var.is_continuous] for var in chain(valid_attributes, valid_class_vars): self.cbx.addItem(gui.attributeIconDict[var], var.name) self.cby.addItem(gui.attributeIconDict[var], var.name) # remove warnings about too less continuous attributes and not enough data self.Warning.clear() if self.auto_play_thread: self.auto_play_thread.stop() if data is None or len(data) == 0: reset_combos() self.set_empty_plot() self.set_disabled_all(True) return valid_attributes = get_valid_attributes(data) if len(valid_attributes) < 2: reset_combos() self.Warning.num_features() self.set_empty_plot() self.set_disabled_all(True) else: init_combos() self.set_disabled_all(False) self.attr_x = self.cbx.itemText(0) self.attr_y = self.cbx.itemText(1) if self.k_means is None: self.k_means = Kmeans(self.concat_x_y()) else: self.k_means.set_data(self.concat_x_y()) self.number_of_clusters_change()
class OWKmeans(OWWidget): """ K-means widget """ name = "Interactive k-Means" description = "Widget demonstrates working of k-means algorithm." icon = "icons/InteractiveKMeans.svg" want_main_area = False # inputs and outputs class Inputs: data = Input("Data", Table) class Outputs: annotated_data = Output("Annotated Data", Table, default=True) centroids = Output("Centroids", Table) class Warning(OWWidget.Warning): num_features = Msg("Widget requires at least two numeric features with valid values") cluster_points = Msg("The number of clusters can't exceed the number of points") # settings number_of_clusters = settings.Setting(3) auto_play_enabled = False auto_play_thread = None # data data = None selected_rows = None # rows that are selected for kmeans (not nan rows) # selected attributes in chart attr_x = settings.Setting('') attr_y = settings.Setting('') # other settings k_means = None auto_play_speed = settings.Setting(1) lines_to_centroids = settings.Setting(True) graph_name = 'scatter' output_name = "cluster" STEP_BUTTONS = ["Reassign Membership", "Recompute Centroids"] AUTOPLAY_BUTTONS = ["Run", "Stop"] # colors taken from chart.options.colors in Highchart # (if more required check for more in chart.options.color) colors = ["#1F7ECA", "#D32525", "#28D825", "#D5861F", "#98257E", "#2227D5", "#D5D623", "#D31BD6", "#6A7CDB", "#78D5D4"] # signals step_trigger = pyqtSignal() stop_auto_play_trigger = pyqtSignal() def __init__(self): super().__init__() # options box self.options_box = gui.widgetBox(self.controlArea, "Data") opts = dict( widget=self.options_box, master=self, orientation=Qt.Horizontal, callback=self.restart, sendSelectedValue=True, maximumContentsLength=15) self.cbx = gui.comboBox(value='attr_x', label='X: ', **opts) self.cby = gui.comboBox(value='attr_y', label='Y: ', **opts) self.centroids_box = gui.widgetBox(self.controlArea, "Centroids") self.centroid_numbers_spinner = gui.spin( self.centroids_box, self, 'number_of_clusters', minv=1, maxv=10, step=1, label='Number of centroids:', alignment=Qt.AlignRight, callback=self.number_of_clusters_change) self.restart_button = gui.button( self.centroids_box, self, "Randomize Positions", callback=self.restart) gui.separator(self.centroids_box) self.lines_checkbox = gui.checkBox( self.centroids_box, self, 'lines_to_centroids', 'Show membership lines', callback=self.complete_replot) # control box gui.separator(self.controlArea, 20, 20) self.step_box = gui.widgetBox(self.controlArea, "Manually step through") self.step_button = gui.button( self.step_box, self, self.STEP_BUTTONS[1], callback=self.step) self.step_back_button = gui.button( self.step_box, self, "Step Back", callback=self.step_back) self.run_box = gui.widgetBox(self.controlArea, "Run") self.auto_play_speed_spinner = gui.hSlider( self.run_box, self, 'auto_play_speed', label='Speed:', minValue=0, maxValue=1.91, step=0.1, intOnly=False, createLabel=False) self.auto_play_button = gui.button( self.run_box, self, self.AUTOPLAY_BUTTONS[0], callback=self.auto_play) gui.rubber(self.controlArea) # disable until data loaded self.set_disabled_all(True) # graph in mainArea self.scatter = Scatterplot( click_callback=self.graph_clicked, drop_callback=self.centroid_dropped, xAxis_gridLineWidth=0, yAxis_gridLineWidth=0, tooltip_enabled=False, debug=False) # Just render an empty chart so it shows a nice 'No data to display' self.scatter.chart() self.mainArea.layout().addWidget(self.scatter) def concat_x_y(self): """ Function takes two selected columns from data table and merge them in new Orange.data.Table Returns ------- Orange.data.Table table with selected columns """ attr_x = self.data.domain[self.attr_x] attr_y = self.data.domain[self.attr_y] cols = [] for attr in (attr_x, attr_y): subset = self.data[:, attr] cols.append(subset.Y if subset.Y.size else subset.X) x = np.column_stack(cols) not_nan = ~np.isnan(x).any(axis=1) x = x[not_nan] # remove rows with nan self.selected_rows = np.where(not_nan) domain = Domain([attr_x, attr_y]) return Table(domain, x) def set_empty_plot(self): self.scatter.clear() def set_disabled_all(self, disabled): """ Function disable all controls """ self.options_box.setDisabled(disabled) self.centroids_box.setDisabled(disabled) self.step_box.setDisabled(disabled) self.run_box.setDisabled(disabled) @Inputs.data def set_data(self, data): """ Function receives data from input and init part of widget if data are ok. Otherwise set empty plot and notice user about that Parameters ---------- data : Orange.data.Table or None input data """ self.data = data def get_valid_attributes(data): attrs = [var for var in data.domain.attributes if var.is_continuous] return [var for var in attrs if sum(~np.isnan(data[:, var])) > 0] def reset_combos(): self.cbx.clear() self.cby.clear() def init_combos(): """ function initialize the combos with attributes """ reset_combos() valid_class_vars = [var for var in data.domain.class_vars if data is not None and var.is_continuous] for var in chain(valid_attributes, valid_class_vars): self.cbx.addItem(gui.attributeIconDict[var], var.name) self.cby.addItem(gui.attributeIconDict[var], var.name) # remove warnings about too less continuous attributes and not enough data self.Warning.clear() if self.auto_play_thread: self.auto_play_thread.stop() if data is None or len(data) == 0: reset_combos() self.set_empty_plot() self.set_disabled_all(True) return valid_attributes = get_valid_attributes(data) if len(valid_attributes) < 2: reset_combos() self.Warning.num_features() self.set_empty_plot() self.set_disabled_all(True) else: init_combos() self.set_disabled_all(False) self.attr_x = self.cbx.itemText(0) self.attr_y = self.cbx.itemText(1) if self.k_means is None: self.k_means = Kmeans(self.concat_x_y()) else: self.k_means.set_data(self.concat_x_y()) self.number_of_clusters_change() def restart(self): """ Function triggered on data change or restart button pressed """ self.k_means = Kmeans(self.concat_x_y()) self.number_of_clusters_change() def step(self): """ Function called on every step """ self.k_means.step() self.replot() self.button_text_change() self.send_data() def step_back(self): """ Function called for step back """ self.k_means.step_back() self.replot() self.button_text_change() self.send_data() self.number_of_clusters = self.k_means.k def button_text_change(self): """ Function changes text on ste button and chanbe the button text """ self.step_button.setText(self.STEP_BUTTONS[self.k_means.step_completed]) if self.k_means.step_no <= 0: self.step_back_button.setDisabled(True) elif not self.auto_play_enabled: self.step_back_button.setDisabled(False) def auto_play(self): """ Function called when autoplay button pressed """ self.auto_play_enabled = not self.auto_play_enabled self.auto_play_button.setText( self.AUTOPLAY_BUTTONS[self.auto_play_enabled]) if self.auto_play_enabled: self.options_box.setDisabled(True) self.centroids_box.setDisabled(True) self.step_box.setDisabled(True) self.auto_play_thread = Autoplay(self) self.step_trigger.connect(self.step) self.stop_auto_play_trigger.connect(self.stop_auto_play) self.auto_play_thread.start() else: self.stop_auto_play() def stop_auto_play(self): """ Called when stop autoplay button pressed or in the end of autoplay """ self.options_box.setDisabled(False) self.centroids_box.setDisabled(False) self.step_box.setDisabled(False) self.auto_play_enabled = False self.auto_play_button\ .setText(self.AUTOPLAY_BUTTONS[self.auto_play_enabled]) self.button_text_change() def replot(self): """ Function refreshes the chart """ if self.data is None or not self.attr_x or not self.attr_y: return km = self.k_means if not km.centroids_moved: self.complete_replot() return # when centroids moved during step self.scatter.update_series(0, self.k_means.centroids) if self.lines_to_centroids: for i, (c, pts) in enumerate(zip( km.centroids, km.centroids_belonging_points)): self.scatter.update_series(1 + i, list(chain.from_iterable( ([p[0], p[1]], [c[0], c[1]]) for p in pts))) def complete_replot(self): """ This function performs complete replot of the graph without animation """ try: attr_x = self.data.domain[self.attr_x] attr_y = self.data.domain[self.attr_y] except KeyError: return # plot centroids options = dict(series=[]) n_colors = len(self.colors) km = self.k_means options['series'].append( dict( data=[{'x': p[0], 'y': p[1], 'marker':{'fillColor': self.colors[i % n_colors]}} for i, p in enumerate(km.centroids)], type="scatter", draggableX=True, draggableY=True, cursor="move", zIndex=10, marker=dict(symbol='square', radius=8))) # plot lines between centroids and points if self.lines_to_centroids: for i, (c, pts) in enumerate(zip( km.centroids, km.centroids_belonging_points)): options['series'].append(dict( data=list( chain.from_iterable(([p[0], p[1]], [c[0], c[1]]) for p in pts)), type="line", lineWidth=0.2, enableMouseTracking=False, color="#ccc")) # plot data points for i, points in enumerate(km.centroids_belonging_points): options['series'].append(dict( data=points, type="scatter", color=rgb_hash_brighter( self.colors[i % len(self.colors)], 0.3))) # highcharts parameters kwargs = dict( xAxis_title_text=attr_x.name, yAxis_title_text=attr_y.name, tooltip_headerFormat="", tooltip_pointFormat="<strong>%s:</strong> {point.x:.2f} <br/>" "<strong>%s:</strong> {point.y:.2f}" % (self.attr_x, self.attr_y)) # plot self.scatter.chart(options, **kwargs) def replot_series(self): """ This function replot just series connected with centroids and uses animation for that """ km = self.k_means k = km.k series = [] # plot lines between centroids and points if self.lines_to_centroids: for i, (c, pts) in enumerate(zip( km.centroids, km.centroids_belonging_points)): series.append(dict( data=list( chain.from_iterable(([p[0], p[1]], [c[0], c[1]]) for p in pts)), type="line", showInLegend=False, lineWidth=0.2, enableMouseTracking=False, color="#ccc")) # plot data points for i, points in enumerate(km.centroids_belonging_points): series.append(dict( data=points, type="scatter", showInLegend=False, color=rgb_hash_brighter( self.colors[i % len(self.colors)], 0.5))) self.scatter.add_series(series) self.scatter.remove_last_series(k * 2 if self.lines_to_centroids else k) def number_of_clusters_change(self): """ Function that change number of clusters if required """ if self.data is None: return if self.number_of_clusters > len(self.data): # if too less data for clusters number self.Warning.cluster_points() self.set_empty_plot() self.step_box.setDisabled(True) self.run_box.setDisabled(True) else: self.Warning.cluster_points.clear() self.step_box.setDisabled(False) self.run_box.setDisabled(False) if self.k_means is None: # if before too less data k_means is None self.k_means = Kmeans(self.concat_x_y()) if self.k_means.k < self.number_of_clusters: self.k_means.add_centroids( self.number_of_clusters - self.k_means.k) elif not self.k_means.k == self.number_of_clusters: self.k_means.delete_centroids( self.k_means.k - self.number_of_clusters) self.replot() self.send_data() self.button_text_change() def graph_clicked(self, x, y): """ Function called when user click in graph. Centroid have to be added. """ if self.k_means is not None and self.data is not None: self.k_means.add_centroids([x, y]) self.number_of_clusters += 1 self.replot() self.send_data() self.button_text_change() def centroid_dropped(self, _index, x, y): """ Function called when centroid with _index moved. """ self.k_means.move_centroid(_index, x, y) self.complete_replot() self.send_data() self.button_text_change() 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) def send_report(self): if self.data is None: return caption = report.render_items_vert(( ("Number of centroids:", self.number_of_clusters), )) self.report_plot(self.scatter) self.report_caption(caption)
def restart(self): """ Function triggered on data change or restart button pressed """ self.k_means = Kmeans(self.concat_x_y()) self.modify_kmeans()
class TestKmeans(unittest.TestCase): def setUp(self): self.data = Table('iris') new_domain = Domain(self.data.domain.attributes[:2]) self.data = Table(new_domain, self.data) # self.centroids = [[5.2, 3.1], [6.5, 3], [7, 4]] self.kmeans = Kmeans(self.data) def test_k(self): centroids = [[5.2, 3.1], [6.5, 3], [7, 4]] self.kmeans.add_centroids(centroids) self.assertEqual(self.kmeans.k, 3) self.assertEqual(self.kmeans.k, len(self.kmeans.centroids)) def test_converged(self): centroids = [[5.2, 3.1], [6.5, 3], [7, 4]] self.kmeans.add_centroids(centroids) self.assertFalse(self.kmeans.converged) self.kmeans.step() self.assertFalse(self.kmeans.converged) # step not complete so false every odd state self.kmeans.step() # it is even step so maybe converged but it depends on example # unable to test self.kmeans.step() self.assertFalse(self.kmeans.converged) # check if false every not completed step for i in range(self.kmeans.max_iter // 2 + 1): self.kmeans.step() self.kmeans.step() self.assertFalse(self.kmeans.converged) # it converged because of max iter self.kmeans.step() self.assertTrue(self.kmeans.converged) def test_centroids_belonging_points(self): centroids = [[5.2, 3.6]] self.kmeans.add_centroids(centroids) # if only one cluster all points in 0th element of first dimension np.testing.assert_equal(self.kmeans.centroids_belonging_points, np.array([self.data.X])) # try with two clusters and less data self.kmeans.set_data(self.data[:3]) self.kmeans.add_centroids([[4.7, 3.0]]) desired_array = np.array([ np.array([[5.100, 3.500]]), np.array([[4.900, 3.000], [4.700, 3.200]]) ]) for i, arr in enumerate(self.kmeans.centroids_belonging_points): np.testing.assert_equal(arr, desired_array[i]) def test_step_completed(self): centroids = [[5.2, 3.1], [6.5, 3], [7, 4]] self.kmeans.add_centroids(centroids) self.assertEqual(self.kmeans.step_completed, True) self.kmeans.step() self.assertEqual(self.kmeans.step_completed, False) self.kmeans.step() self.assertEqual(self.kmeans.step_completed, True) def test_set_data(self): self.kmeans.set_data(self.data) self.assertEqual(self.kmeans.data, self.data) self.assertEqual(self.kmeans.centroids_history, []) self.assertEqual(self.kmeans.step_no, 0) self.assertEqual(self.kmeans.step_completed, True) self.assertEqual(self.kmeans.centroids_moved, False) # try with none data self.kmeans.set_data(None) self.assertEqual(self.kmeans.data, None) self.assertEqual(self.kmeans.centroids_history, []) self.assertEqual(self.kmeans.clusters, None) self.assertEqual(self.kmeans.step_no, 0) self.assertEqual(self.kmeans.step_completed, True) self.assertEqual(self.kmeans.centroids_moved, False) def test_find_clusters(self): self.kmeans.add_centroids([[5.2, 3.6]]) # if only one cluster all points in 0th element of first dimension np.testing.assert_equal( self.kmeans.find_clusters(self.kmeans.centroids), np.zeros(len(self.data))) # try with two clusters and less data self.kmeans.set_data(self.data[:3]) self.kmeans.add_centroids([[4.7, 3.0]]) np.testing.assert_equal( self.kmeans.find_clusters(self.kmeans.centroids), np.array([0, 1, 1])) def test_step(self): centroids = [[5.2, 3.1], [6.5, 3], [7, 4]] self.kmeans.add_centroids(centroids) centroids_before = np.copy(self.kmeans.centroids) clusters_before = np.copy(self.kmeans.clusters) self.kmeans.step() self.assertEqual(self.kmeans.step_completed, False) self.assertEqual(self.kmeans.centroids_moved, True) np.testing.assert_equal(centroids_before, self.kmeans.centroids_history[-2]) # clusters doesnt change in every odd step np.testing.assert_equal(clusters_before, self.kmeans.clusters) centroids_before = np.copy(self.kmeans.centroids) self.kmeans.step() self.assertEqual(self.kmeans.step_completed, True) self.assertEqual(self.kmeans.centroids_moved, False) np.testing.assert_equal(centroids_before, self.kmeans.centroids) centroids_before = np.copy(self.kmeans.centroids) self.kmeans.step() self.kmeans.step_back() np.testing.assert_equal(centroids_before, self.kmeans.centroids) def test_step_back(self): centroids = [[5.2, 3.1], [6.5, 3], [7, 4]] self.kmeans.add_centroids(centroids) # check if nothing happens when step = 0 centroids_before = np.copy(self.kmeans.centroids) clusters_before = np.copy(self.kmeans.clusters) self.kmeans.step_back() np.testing.assert_equal(centroids_before, self.kmeans.centroids) np.testing.assert_equal(clusters_before, self.kmeans.clusters) # check if centroids remain in even step self.kmeans.step() self.kmeans.step() centroids_before = self.kmeans.centroids self.kmeans.step_back() np.testing.assert_equal(centroids_before, self.kmeans.centroids) self.assertEqual(self.kmeans.step_completed, False) self.assertEqual(self.kmeans.centroids_moved, False) # check if clusters remain in even step clusters_before = self.kmeans.clusters self.kmeans.step_back() np.testing.assert_equal(clusters_before, self.kmeans.clusters) self.assertEqual(self.kmeans.step_completed, True) self.assertEqual(self.kmeans.centroids_moved, True) def test_random_positioning(self): self.assertEqual(self.kmeans.random_positioning(4).shape, (4, 2)) self.assertEqual(self.kmeans.random_positioning(1).shape, (1, 2)) self.assertEqual(self.kmeans.random_positioning(0).shape, (0, )) self.assertEqual(self.kmeans.random_positioning(-1).shape, (0, )) def test_add_centroids(self): self.kmeans.add_centroids([[5.2, 3.1]]) self.assertEqual(self.kmeans.k, 1) self.kmeans.add_centroids([[6.5, 3], [7, 4]]) self.assertEqual(self.kmeans.k, 3) self.kmeans.add_centroids(2) self.assertEqual(self.kmeans.k, 5) self.kmeans.add_centroids() self.assertEqual(self.kmeans.k, 6) step_before = self.kmeans.step_no self.assertEqual(step_before, self.kmeans.step_no) self.kmeans.step() self.kmeans.add_centroids() self.assertEqual(step_before + 2, self.kmeans.step_no) self.assertEqual(self.kmeans.centroids_moved, False) def test_delete_centroids(self): self.kmeans.add_centroids([[6.5, 3], [7, 4], [5.2, 3.1]]) self.kmeans.delete_centroids(1) self.assertEqual(self.kmeans.k, 2) self.kmeans.delete_centroids(2) self.assertEqual(self.kmeans.k, 0) self.kmeans.delete_centroids(2) self.assertEqual(self.kmeans.k, 0) def test_move_centroid(self): self.kmeans.add_centroids([[6.5, 3], [7, 4], [5.2, 3.1]]) self.kmeans.move_centroid(1, 3, 3.2) np.testing.assert_equal(self.kmeans.centroids[1], np.array([3, 3.2])) self.assertEqual(self.kmeans.k, 3) self.kmeans.step() self.kmeans.move_centroid(2, 3.2, 3.4) self.assertEqual(self.kmeans.centroids_moved, False) self.assertEqual(self.kmeans.step_no, 2) def test_set_list(self): # test adding Nones if list too short self.assertEqual(self.kmeans.set_list([], 2, 1), [None, None, 1]) # test adding Nones if list too short self.assertEqual(self.kmeans.set_list([2], 2, 1), [2, None, 1]) # adding to end self.assertEqual(self.kmeans.set_list([2, 1], 2, 1), [2, 1, 1]) # changing the element in the last place self.assertEqual(self.kmeans.set_list([2, 1], 1, 3), [2, 3]) # changing the element in the middle place self.assertEqual(self.kmeans.set_list([2, 1, 3], 1, 3), [2, 3, 3])
def setUp(self): self.data = Table('iris') new_domain = Domain(self.data.domain.attributes[:2]) self.data = Table(new_domain, self.data) # self.centroids = [[5.2, 3.1], [6.5, 3], [7, 4]] self.kmeans = Kmeans(self.data)
class TestKmeans(unittest.TestCase): def setUp(self): self.data = Table('iris') new_domain = Domain(self.data.domain.attributes[:2]) self.data = Table(new_domain, self.data) # self.centroids = [[5.2, 3.1], [6.5, 3], [7, 4]] self.kmeans = Kmeans(self.data) def test_k(self): centroids = [[5.2, 3.1], [6.5, 3], [7, 4]] self.kmeans.add_centroids(centroids) self.assertEqual(self.kmeans.k, 3) self.assertEqual(self.kmeans.k, len(self.kmeans.centroids)) def test_converged(self): centroids = [[5.2, 3.1], [6.5, 3], [7, 4]] self.kmeans.add_centroids(centroids) self.assertFalse(self.kmeans.converged) self.kmeans.step() self.assertFalse(self.kmeans.converged) # step not complete so false every odd state self.kmeans.step() # it is even step so maybe converged but it depends on example # unable to test self.kmeans.step() self.assertFalse(self.kmeans.converged) # check if false every not completed step for i in range(self.kmeans.max_iter // 2 + 1): self.kmeans.step() self.kmeans.step() self.assertFalse(self.kmeans.converged) # it converged because of max iter self.kmeans.step() self.assertTrue(self.kmeans.converged) def test_centroids_belonging_points(self): centroids = [[5.2, 3.6]] self.kmeans.add_centroids(centroids) # if only one cluster all points in 0th element of first dimension np.testing.assert_equal( self.kmeans.centroids_belonging_points, np.array([self.data.X])) # try with two clusters and less data self.kmeans.set_data(self.data[:3]) self.kmeans.add_centroids([[4.7, 3.0]]) desired_array = np.array([np.array([[5.100, 3.500]]), np.array([[4.900, 3.000], [4.700, 3.200]])]) for i, arr in enumerate(self.kmeans.centroids_belonging_points): np.testing.assert_equal(arr, desired_array[i]) def test_step_completed(self): centroids = [[5.2, 3.1], [6.5, 3], [7, 4]] self.kmeans.add_centroids(centroids) self.assertEqual(self.kmeans.step_completed, True) self.kmeans.step() self.assertEqual(self.kmeans.step_completed, False) self.kmeans.step() self.assertEqual(self.kmeans.step_completed, True) def test_set_data(self): self.kmeans.set_data(self.data) self.assertEqual(self.kmeans.data, self.data) self.assertEqual(self.kmeans.centroids_history, []) self.assertEqual(self.kmeans.step_no, 0) self.assertEqual(self.kmeans.step_completed, True) self.assertEqual(self.kmeans.centroids_moved, False) # try with none data self.kmeans.set_data(None) self.assertEqual(self.kmeans.data, None) self.assertEqual(self.kmeans.centroids_history, []) self.assertEqual(self.kmeans.clusters, None) self.assertEqual(self.kmeans.step_no, 0) self.assertEqual(self.kmeans.step_completed, True) self.assertEqual(self.kmeans.centroids_moved, False) def test_find_clusters(self): self.kmeans.add_centroids([[5.2, 3.6]]) # if only one cluster all points in 0th element of first dimension np.testing.assert_equal( self.kmeans.find_clusters(self.kmeans.centroids), np.zeros(len(self.data))) # try with two clusters and less data self.kmeans.set_data(self.data[:3]) self.kmeans.add_centroids([[4.7, 3.0]]) np.testing.assert_equal( self.kmeans.find_clusters(self.kmeans.centroids), np.array([0, 1, 1])) def test_step(self): centroids = [[5.2, 3.1], [6.5, 3], [7, 4]] self.kmeans.add_centroids(centroids) centroids_before = np.copy(self.kmeans.centroids) clusters_before = np.copy(self.kmeans.clusters) self.kmeans.step() self.assertEqual(self.kmeans.step_completed, False) self.assertEqual(self.kmeans.centroids_moved, True) np.testing.assert_equal(centroids_before, self.kmeans.centroids_history[-2]) # clusters doesnt change in every odd step np.testing.assert_equal(clusters_before, self.kmeans.clusters) centroids_before = np.copy(self.kmeans.centroids) self.kmeans.step() self.assertEqual(self.kmeans.step_completed, True) self.assertEqual(self.kmeans.centroids_moved, False) np.testing.assert_equal(centroids_before, self.kmeans.centroids) centroids_before = np.copy(self.kmeans.centroids) self.kmeans.step() self.kmeans.step_back() np.testing.assert_equal(centroids_before, self.kmeans.centroids) def test_step_back(self): centroids = [[5.2, 3.1], [6.5, 3], [7, 4]] self.kmeans.add_centroids(centroids) # check if nothing happens when step = 0 centroids_before = np.copy(self.kmeans.centroids) clusters_before = np.copy(self.kmeans.clusters) self.kmeans.step_back() np.testing.assert_equal(centroids_before, self.kmeans.centroids) np.testing.assert_equal(clusters_before, self.kmeans.clusters) # check if centroids remain in even step self.kmeans.step() self.kmeans.step() centroids_before = self.kmeans.centroids self.kmeans.step_back() np.testing.assert_equal(centroids_before, self.kmeans.centroids) self.assertEqual(self.kmeans.step_completed, False) self.assertEqual(self.kmeans.centroids_moved, False) # check if clusters remain in even step clusters_before = self.kmeans.clusters self.kmeans.step_back() np.testing.assert_equal(clusters_before, self.kmeans.clusters) self.assertEqual(self.kmeans.step_completed, True) self.assertEqual(self.kmeans.centroids_moved, True) def test_random_positioning(self): self.assertEqual(self.kmeans.random_positioning(4).shape, (4, 2)) self.assertEqual(self.kmeans.random_positioning(1).shape, (1, 2)) self.assertEqual(self.kmeans.random_positioning(0).shape, (0,)) self.assertEqual(self.kmeans.random_positioning(-1).shape, (0,)) def test_add_centroids(self): self.kmeans.add_centroids([[5.2, 3.1]]) self.assertEqual(self.kmeans.k, 1) self.kmeans.add_centroids([[6.5, 3], [7, 4]]) self.assertEqual(self.kmeans.k, 3) self.kmeans.add_centroids(2) self.assertEqual(self.kmeans.k, 5) self.kmeans.add_centroids() self.assertEqual(self.kmeans.k, 6) step_before = self.kmeans.step_no self.assertEqual(step_before, self.kmeans.step_no) self.kmeans.step() self.kmeans.add_centroids() self.assertEqual(step_before + 2, self.kmeans.step_no) self.assertEqual(self.kmeans.centroids_moved, False) def test_delete_centroids(self): self.kmeans.add_centroids([[6.5, 3], [7, 4], [5.2, 3.1]]) self.kmeans.delete_centroids(1) self.assertEqual(self.kmeans.k, 2) self.kmeans.delete_centroids(2) self.assertEqual(self.kmeans.k, 0) self.kmeans.delete_centroids(2) self.assertEqual(self.kmeans.k, 0) def test_move_centroid(self): self.kmeans.add_centroids([[6.5, 3], [7, 4], [5.2, 3.1]]) self.kmeans.move_centroid(1, 3, 3.2) np.testing.assert_equal(self.kmeans.centroids[1], np.array([3, 3.2])) self.assertEqual(self.kmeans.k, 3) self.kmeans.step() self.kmeans.move_centroid(2, 3.2, 3.4) self.assertEqual(self.kmeans.centroids_moved, False) self.assertEqual(self.kmeans.step_no, 2) def test_set_list(self): # test adding Nones if list too short self.assertEqual(self.kmeans.set_list([], 2, 1), [None, None, 1]) # test adding Nones if list too short self.assertEqual(self.kmeans.set_list([2], 2, 1), [2, None, 1]) # adding to end self.assertEqual(self.kmeans.set_list([2, 1], 2, 1), [2, 1, 1]) # changing the element in the last place self.assertEqual(self.kmeans.set_list([2, 1], 1, 3), [2, 3]) # changing the element in the middle place self.assertEqual(self.kmeans.set_list([2, 1, 3], 1, 3), [2, 3, 3])