def template_clustering(file, map_size, radius, sync_order = 0.999, show_dyn = False, show_layer1 = False, show_layer2 = False, show_clusters = True): # Read sample sample = read_sample(file); # Create network network = syncsom(sample, map_size[0], map_size[1], radius); # Run processing (ticks, (dyn_time, dyn_phase)) = timedcall(network.process, show_dyn, sync_order); print("Sample: ", file, "\t\tExecution time: ", ticks, "\n"); # Show dynamic of the last layer. if (show_dyn == True): draw_dynamics(dyn_time, dyn_phase, x_title = "Time", y_title = "Phase", y_lim = [0, 3.14]); if (show_clusters == True): clusters = network.get_som_clusters(); visualizer = cluster_visualizer(); visualizer.append_clusters(clusters, network.som_layer.weights); visualizer.show(); # Show network stuff. if (show_layer1 == True): network.show_som_layer(); if (show_layer2 == True): network.show_sync_layer(); if (show_clusters == True): clusters = network.get_clusters(); visualizer = cluster_visualizer(); visualizer.append_clusters(clusters, sample); visualizer.show();
def show_clusters(clusters, sample, covariances, means, figure = None, display = True): """! @brief Draws clusters and in case of two-dimensional dataset draws their ellipses. @param[in] clusters (list): Clusters that were allocated by the algorithm. @param[in] sample (list): Dataset that were used for clustering. @param[in] covariances (list): Covariances of the clusters. @param[in] means (list): Means of the clusters. @param[in] figure (figure): If 'None' then new is figure is creater, otherwise specified figure is used for visualization. @param[in] display (bool): If 'True' then figure will be shown by the method, otherwise it should be shown manually using matplotlib function 'plt.show()'. @return (figure) Figure where clusters were drawn. """ visualizer = cluster_visualizer() visualizer.append_clusters(clusters, sample) if figure is None: figure = visualizer.show(display = False) else: visualizer.show(figure = figure, display = False) if len(sample[0]) == 2: ema_visualizer.__draw_ellipses(figure, visualizer, clusters, covariances, means) if display is True: plt.show() return figure
def show_clusters(sample, clusters, representatives, **kwargs): """! @brief Display BSAS clustering results. @param[in] sample (list): Dataset that was used for clustering. @param[in] clusters (array_like): Clusters that were allocated by the algorithm. @param[in] representatives (array_like): Allocated representatives correspond to clusters. @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'figure', 'display', 'offset'). <b>Keyword Args:</b><br> - figure (figure): If 'None' then new is figure is created, otherwise specified figure is used for visualization. - display (bool): If 'True' then figure will be shown by the method, otherwise it should be shown manually using matplotlib function 'plt.show()'. - offset (uint): Specify axes index on the figure where results should be drawn (only if argument 'figure' is specified). @return (figure) Figure where clusters were drawn. """ figure = kwargs.get('figure', None) display = kwargs.get('display', True) offset = kwargs.get('offset', 0) visualizer = cluster_visualizer() visualizer.append_clusters(clusters, sample, canvas=offset) for cluster_index in range(len(clusters)): visualizer.append_cluster_attribute(offset, cluster_index, [representatives[cluster_index]], '*', 10) return visualizer.show(figure=figure, display=display)
def testVisualizeHugeAmountClusters(self): visualizer = cluster_visualizer(); data_clusters = [ [ [ random.random() ] ] for _ in range(0, 100) ]; visualizer.append_clusters(data_clusters); visualizer.show();
def testVisualizeByDataOnly(self): visualizer = cluster_visualizer(); sample = read_sample(SIMPLE_SAMPLES.SAMPLE_SIMPLE1); visualizer.append_clusters([ sample ]); visualizer.show();
def template_clustering(number_clusters, path, links): sample = read_sample(path); clusters_centroid_link = None; clusters_single_link = None; clusters_complete_link = None; clusters_average_link = None; visualizer = cluster_visualizer(len(links)); index_canvas = 0; if (type_link.CENTROID_LINK in links): agglomerative_centroid_link = agglomerative(sample, number_clusters, type_link.CENTROID_LINK); (ticks, result) = timedcall(agglomerative_centroid_link.process); clusters_centroid_link = agglomerative_centroid_link.get_clusters(); visualizer.append_clusters(clusters_centroid_link, sample, index_canvas); visualizer.set_canvas_title('Link: Centroid', index_canvas); index_canvas += 1; print("Sample: ", path, "Link: Centroid", "\tExecution time: ", ticks, "\n"); if (type_link.SINGLE_LINK in links): agglomerative_simple_link = agglomerative(sample, number_clusters, type_link.SINGLE_LINK); (ticks, result) = timedcall(agglomerative_simple_link.process); clusters_single_link = agglomerative_simple_link.get_clusters(); visualizer.append_clusters(clusters_single_link, sample, index_canvas); visualizer.set_canvas_title('Link: Single', index_canvas); index_canvas += 1; print("Sample: ", path, "Link: Single", "\tExecution time: ", ticks, "\n"); if (type_link.COMPLETE_LINK in links): agglomerative_complete_link = agglomerative(sample, number_clusters, type_link.COMPLETE_LINK); (ticks, result) = timedcall(agglomerative_complete_link.process); clusters_complete_link = agglomerative_complete_link.get_clusters(); visualizer.append_clusters(clusters_complete_link, sample, index_canvas); visualizer.set_canvas_title('Link: Complete', index_canvas); index_canvas += 1; print("Sample: ", path, "Link: Complete", "\tExecution time: ", ticks, "\n"); if (type_link.AVERAGE_LINK in links): agglomerative_average_link = agglomerative(sample, number_clusters, type_link.AVERAGE_LINK); (ticks, result) = timedcall(agglomerative_average_link.process); clusters_average_link = agglomerative_average_link.get_clusters(); visualizer.append_clusters(clusters_average_link, sample, index_canvas); visualizer.set_canvas_title('Link: Average', index_canvas); index_canvas += 1; print("Sample: ", path, "Link: Average", "\tExecution time: ", ticks, "\n"); visualizer.show();
def testVisualizeOnExistedFigure(self): figure = plt.figure(); sample = read_sample(SIMPLE_SAMPLES.SAMPLE_SIMPLE1); visualizer = cluster_visualizer(); visualizer.append_clusters([ sample ]); visualizer.show(figure);
def testVisualizeRectangeRepresentation3x5(self): visualizer = cluster_visualizer(15, 5); for i in range(15): sample = read_sample(SIMPLE_SAMPLES.SAMPLE_SIMPLE1); visualizer.append_clusters([ sample ], None, i, markersize = 5); visualizer.show();
def testVisualize2DAnd3DClusters(self): sample_2d = read_sample(SIMPLE_SAMPLES.SAMPLE_SIMPLE1); sample_3d = read_sample(FCPS_SAMPLES.SAMPLE_HEPTA); visualizer = cluster_visualizer(2, 2); visualizer.append_clusters([ sample_2d ], None, 0, markersize = 5); visualizer.append_clusters([ sample_3d ], None, 1, markersize = 30); visualizer.show();
def testVisualize1DClustersTwoCanvases(self): sample_simple7 = read_sample(SIMPLE_SAMPLES.SAMPLE_SIMPLE7); sample_simple8 = read_sample(SIMPLE_SAMPLES.SAMPLE_SIMPLE8); # Two canvas visualization visualizer = cluster_visualizer(2); visualizer.append_clusters([ sample_simple7 ], None, 0, markersize = 30); visualizer.append_clusters([ sample_simple8 ], None, 1, markersize = 30); visualizer.show();
def testVisualize3DClustersTwoCanvases(self): sample_tetra = read_sample(FCPS_SAMPLES.SAMPLE_TETRA); sample_hepta = read_sample(FCPS_SAMPLES.SAMPLE_HEPTA); # Two canvas visualization visualizer = cluster_visualizer(2); visualizer.append_clusters([ sample_tetra ], None, 0, markersize = 30); visualizer.append_clusters([ sample_hepta ], None, 1, markersize = 30); visualizer.show();
def testVisualizeRectangeRepresentation2x2(self): sample_simple1 = read_sample(SIMPLE_SAMPLES.SAMPLE_SIMPLE1); sample_simple2 = read_sample(SIMPLE_SAMPLES.SAMPLE_SIMPLE2); sample_simple3 = read_sample(SIMPLE_SAMPLES.SAMPLE_SIMPLE3); visualizer = cluster_visualizer(3, 2); visualizer.append_clusters([ sample_simple1 ], None, 0, markersize = 5); visualizer.append_clusters([ sample_simple2 ], None, 1, markersize = 5); visualizer.append_clusters([ sample_simple3 ], None, 2, markersize = 5); visualizer.show();
def testVisualizeOnExistedFigureWithContentByDefault(self): figure = plt.figure(); axis = figure.add_subplot(211); axis.plot(range(0, 10, 1), range(0, 10, 1), marker = 'o', color = 'blue', ls = ''); sample = read_sample(SIMPLE_SAMPLES.SAMPLE_SIMPLE1); visualizer = cluster_visualizer(); visualizer.append_clusters([ sample ]); visualizer.show(figure);
def testVisualize2DClustersOneCanvas(self): sample = read_sample(SIMPLE_SAMPLES.SAMPLE_SIMPLE4); dbscan_instance = dbscan(sample, 0.7, 3, False); dbscan_instance.process(); clusters = dbscan_instance.get_clusters(); visualizer = cluster_visualizer(); visualizer.append_clusters(clusters, sample, markersize = 5); visualizer.show();
def testVisualize3DClustersOneCanvas(self): sample = read_sample(FCPS_SAMPLES.SAMPLE_HEPTA); dbscan_instance = dbscan(sample, 0.5, 3, False); dbscan_instance.process(); clusters = dbscan_instance.get_clusters(); visualizer = cluster_visualizer(); visualizer.append_clusters(clusters, sample, markersize = 30); visualizer.show();
def display_fcps_clustering_results(): (simple4, simple4_clusters) = template_clustering(SIMPLE_SAMPLES.SAMPLE_SIMPLE4, 1, 0.999, show_dyn = False, show_conn = False, ccore_flag = True); (simple_elongate, simple_elongate_clusters) = template_clustering(SIMPLE_SAMPLES.SAMPLE_ELONGATE, 0.5, 0.999, show_dyn = False, show_conn = False, ccore_flag = True); (lsun, lsun_clusters) = template_clustering(FCPS_SAMPLES.SAMPLE_LSUN, 0.45, 0.9995, show_dyn = False, show_conn = False, ccore_flag = True, tolerance = 0.2); visualizer = cluster_visualizer(1, 3); visualizer.append_clusters(simple4_clusters, simple4, 0); visualizer.append_clusters(simple_elongate_clusters, simple_elongate, 1); visualizer.append_clusters(lsun_clusters, lsun, 2); visualizer.show();
def template_kmeans_plusplus_initializer(path, amount, draw = True): sample = read_sample(path); centers = kmeans_plusplus_initializer(sample, amount).initialize(); if (draw is True): visualizer = cluster_visualizer(); visualizer.append_cluster(sample); visualizer.append_cluster(centers, marker = '*', markersize = 10); visualizer.show(); return (sample, centers);
def show_clusters(data, clusters, noise=None): """! @brief Display BANG clustering results. @param[in] data (list): Dataset that was used for clustering. @param[in] clusters (array_like): Clusters that were allocated by the algorithm. @param[in] noise (array_like): Noise that were allocated by the algorithm. """ visualizer = cluster_visualizer() visualizer.append_clusters(clusters, data) visualizer.append_cluster(noise or [], data, marker='x') visualizer.show()
def template_clustering(start_medoids, path, tolerance = 0.25, show = True): sample = read_sample(path); kmedoids_instance = kmedoids(sample, start_medoids, tolerance); (ticks, result) = timedcall(kmedoids_instance.process); clusters = kmedoids_instance.get_clusters(); print("Sample: ", path, "\t\tExecution time: ", ticks, "\n"); if (show is True): visualizer = cluster_visualizer(1); visualizer.append_clusters(clusters, sample, 0); visualizer.show(); return (sample, clusters);
def template_clustering(radius, neighb, path, invisible_axes = False, ccore = True): sample = read_sample(path); dbscan_instance = dbscan(sample, radius, neighb, ccore); (ticks, result) = timedcall(dbscan_instance.process); clusters = dbscan_instance.get_clusters(); noise = dbscan_instance.get_noise(); visualizer = cluster_visualizer(); visualizer.append_clusters(clusters, sample); visualizer.append_cluster(noise, sample, marker = 'x'); visualizer.show(); print("Sample: ", path, "\t\tExecution time: ", ticks, "\n");
def template_clustering(start_centers, path, tolerance=0.25, ccore=True): sample = read_sample(path) kmeans_instance = kmeans(sample, start_centers, tolerance, ccore) (ticks, result) = timedcall(kmeans_instance.process) clusters = kmeans_instance.get_clusters() centers = kmeans_instance.get_centers() print("Sample: ", path, "\t\tExecution time: ", ticks, "\n") visualizer = cluster_visualizer() visualizer.append_clusters(clusters, sample) visualizer.append_cluster(start_centers, marker="*", markersize=20) visualizer.append_cluster(centers, marker="*", markersize=20) visualizer.show()
def template_clustering(number_clusters, path, branching_factor = 5, max_node_entries = 5, initial_diameter = 0.0, type_measurement = measurement_type.AVERAGE_INTER_CLUSTER_DISTANCE, entry_size_limit = 200, diameter_multiplier = 1.5, show_result = True): sample = read_sample(path); birch_instance = birch(sample, number_clusters, branching_factor, max_node_entries, initial_diameter, type_measurement, entry_size_limit, diameter_multiplier); (ticks, result) = timedcall(birch_instance.process); print("Sample: ", path, "\t\tExecution time: ", ticks, "\n"); clusters = birch_instance.get_clusters(); if (show_result is True): visualizer = cluster_visualizer(); visualizer.append_clusters(clusters, sample); visualizer.show(); return (sample, clusters);
def xmeans_clustering( data: np.ndarray, kmin: [int, None] = 1, kmax: [int, None] = 20, tolerance: float = 0.025, criterion: enumerate = splitting_type.BAYESIAN_INFORMATION_CRITERION, ccore: bool = True, logger=Logger(name='clustering'), visualize: bool = False) -> np.ndarray: # Initial centers - KMeans algorithm kmeans = KMeans(n_clusters=kmin) kmeans.fit(data) initial_centers = kmeans.cluster_centers_ # X-Means algorithm xmeans_instance = xmeans(data=data, initial_centers=initial_centers, kmax=kmax, tolerance=tolerance, criterion=criterion, ccore=ccore) (ticks, _) = timedcall(xmeans_instance.process) clusters = xmeans_instance.get_clusters() centers = xmeans_instance.get_centers() criterion_string = "UNKNOWN" if criterion == splitting_type.BAYESIAN_INFORMATION_CRITERION: criterion_string = "BAYESIAN INFORMATION CRITERION" elif criterion == splitting_type.MINIMUM_NOISELESS_DESCRIPTION_LENGTH: criterion_string = "MINIMUM NOISELESS DESCRIPTION_LENGTH" if logger is not None: logger.debug( "Initial centers: {},\n Execution time: {},\n Number of clusters: {},\n criterion: {}" .format(initial_centers is not None, ticks, len(clusters), criterion_string)) if visualize: visualizer = cluster_visualizer() visualizer.set_canvas_title(criterion_string) visualizer.append_clusters(clusters, data) visualizer.append_cluster(centers, None, marker='*') visualizer.show() return clusters
def find_optimal_amout_clusters(sample_path, kmin, kmax, algorithm): sample = read_sample(sample_path) search_instance = silhouette_ksearch(sample, kmin, kmax, algorithm=algorithm).process() amount = search_instance.get_amount() scores = search_instance.get_scores() print("Sample: '%s', Scores: '%s'" % (sample_path, str(scores))) initial_centers = kmeans_plusplus_initializer(sample, amount).initialize() kmeans_instance = kmeans(sample, initial_centers).process() clusters = kmeans_instance.get_clusters() visualizer = cluster_visualizer() visualizer.append_clusters(clusters, sample) visualizer.show()
def show_feature_destibution(self, data=None): visualizer = cluster_visualizer() print("amount of nodes: ", self.__amount_nodes) if (data is not None): visualizer.append_cluster(data, marker='x') for level in range(0, self.height): level_nodes = self.get_level_nodes(level) centers = [node.feature.get_centroid() for node in level_nodes] visualizer.append_cluster(centers, None, markersize=(self.height - level + 1) * 5) visualizer.show()
def testVisualizeClusterWithAttributes(self): sample = read_sample(SIMPLE_SAMPLES.SAMPLE_SIMPLE1); cure_instance = cure(sample, 2, 5, 0.5, False); cure_instance.process(); clusters = cure_instance.get_clusters(); representors = cure_instance.get_representors(); means = cure_instance.get_means(); visualizer = cluster_visualizer(); visualizer.append_clusters(clusters, sample); for cluster_index in range(len(clusters)): visualizer.append_cluster_attribute(0, cluster_index, representors[cluster_index], '*', 10); visualizer.append_cluster_attribute(0, cluster_index, [ means[cluster_index] ], 'o'); visualizer.show();
def show_clusters(sample, clusters, centers, initial_centers=None, **kwargs): """! @brief Display K-Means clustering results. @details Allocated figure by this method should be closed using `close()` method of this visualizer. @param[in] sample (list): Dataset that was used for clustering. @param[in] clusters (array_like): Clusters that were allocated by the algorithm. @param[in] centers (array_like): Centers that were allocated by the algorithm. @param[in] initial_centers (array_like): Initial centers that were used by the algorithm, if 'None' then initial centers are not displyed. @param[in] **kwargs: Arbitrary keyword arguments (available arguments: 'figure', 'display', 'offset'). <b>Keyword Args:</b><br> - figure (figure): If 'None' then new is figure is created, otherwise specified figure is used for visualization. - display (bool): If 'True' then figure will be shown by the method, otherwise it should be shown manually using matplotlib function 'plt.show()'. - offset (uint): Specify axes index on the figure where results should be drawn (only if argument 'figure' is specified). @return (figure) Figure where clusters were drawn. """ visualizer = cluster_visualizer() visualizer.append_clusters(clusters, sample) offset = kwargs.get('offset', 0) figure = kwargs.get('figure', None) display = kwargs.get('display', True) if figure is None: figure = visualizer.show(display=False) else: visualizer.show(figure=figure, display=False) kmeans_visualizer.__draw_centers(figure, offset, visualizer, centers, initial_centers) kmeans_visualizer.__draw_rays(figure, offset, visualizer, sample, clusters, centers) if display is True: plt.show() return figure
def optics_temp(self, point_list): # data = np.array( point_list) sample = point_list start = time.time() optics_instance = optics(sample, 0.5, 6, ccore=True) optics_instance.process() clusters = optics_instance.get_clusters() end = time.time() print("imte", end - start) noise = optics_instance.get_noise() visualizer = cluster_visualizer() visualizer.append_clusters(clusters, sample) visualizer.append_cluster(noise, sample, marker='x') visualizer.show() ordering = optics_instance.get_ordering() analyser = ordering_analyser(ordering) ordering_visualizer.show_ordering_diagram(analyser, amount_clusters)
def template_clustering(number_clusters, path, branching_factor = 5, max_node_entries = 5, initial_diameter = 0.0, type_measurement = measurement_type.AVERAGE_INTER_CLUSTER_DISTANCE, entry_size_limit = 200, diameter_multiplier = 1.5, outlier_detector = 0, show_result = True): sample = read_sample(path); birch_instance = birch(sample, number_clusters, branching_factor, max_node_entries, initial_diameter, type_measurement, entry_size_limit, diameter_multiplier, outlier_detector); (ticks, result) = timedcall(birch_instance.process); print("Sample: ", path, "\t\tExecution time: ", ticks, "\n"); clusters = birch_instance.get_clusters(); noise = birch_instance.get_noise(); if (show_result is True): visualizer = cluster_visualizer(); visualizer.append_clusters(clusters, sample); visualizer.append_cluster(noise, sample, marker = 'x'); visualizer.show(); return (sample, clusters, noise);
def template_clustering(start_medoids, path, tolerance = 0.25, show = True): sample = read_sample(path) kmedoids_instance = kmedoids(sample, start_medoids, tolerance) (ticks, result) = timedcall(kmedoids_instance.process) clusters = kmedoids_instance.get_clusters() medoids = kmedoids_instance.get_medoids() print("Sample: ", path, "\t\tExecution time: ", ticks, "\n") if show is True: visualizer = cluster_visualizer(1) visualizer.append_clusters(clusters, sample, 0) visualizer.append_cluster([sample[index] for index in start_medoids], marker='*', markersize=15) visualizer.append_cluster(medoids, data=sample, marker='*', markersize=15) visualizer.show() return sample, clusters
def template_clustering(start_medoids, path, tolerance = 0.25, show = True): sample = read_sample(path); kmedoids_instance = kmedoids(sample, start_medoids, tolerance); (ticks, result) = timedcall(kmedoids_instance.process); clusters = kmedoids_instance.get_clusters(); medoids = kmedoids_instance.get_medoids(); print("Sample: ", path, "\t\tExecution time: ", ticks, "\n"); if (show is True): visualizer = cluster_visualizer(1); visualizer.append_clusters(clusters, sample, 0); visualizer.append_cluster([ sample[index] for index in start_medoids ], marker = '*', markersize = 15); visualizer.append_cluster(medoids, marker = '*', markersize = 15); visualizer.show(); return (sample, clusters);
def template_clustering(start_medoids, path, tolerance=0.25, show=True, **kwargs): ccore = kwargs.get('ccore', True) data_type = kwargs.get('data_type', 'points') original_data = read_sample(path) sample = original_data if data_type == 'distance_matrix': sample = calculate_distance_matrix(sample) metric = distance_metric(type_metric.EUCLIDEAN_SQUARE, data=sample) kmedoids_instance = kmedoids(sample, start_medoids, tolerance, metric=metric, ccore=ccore, data_type=data_type) (ticks, result) = timedcall(kmedoids_instance.process) clusters = kmedoids_instance.get_clusters() print("Iterations:", kmedoids_instance.get_iterations()) print([len(cluster) for cluster in clusters]) print(clusters) medoids = kmedoids_instance.get_medoids() print("Sample: ", path, "\t\tExecution time: ", ticks, "\n") if show is True: visualizer = cluster_visualizer(1) visualizer.append_clusters(clusters, original_data, 0) visualizer.append_cluster( [original_data[index] for index in start_medoids], marker='*', markersize=15) visualizer.append_cluster(medoids, data=original_data, marker='*', markersize=15) visualizer.show() return original_data, clusters
def frame_generation(index_dynamic): figure.clf() if title is not None: figure.suptitle(title, fontsize = 26, fontweight = 'bold') ax1 = figure.add_subplot(121, projection='polar') clusters = analyser.allocate_clusters(eps = tolerance, iteration = index_dynamic) dynamic = analyser.output[index_dynamic] visualizer = cluster_visualizer(size_row = 2) visualizer.append_clusters(clusters, dataset) artist1, = ax1.plot(dynamic, [1.0] * len(dynamic), marker='o', color='blue', ls='') visualizer.show(figure, display = False) artist2 = figure.gca() return [ artist1, artist2 ]
def kmeans_plusplus_initializer_collection(): (sample1, centers1) = template_kmeans_plusplus_initializer(SIMPLE_SAMPLES.SAMPLE_SIMPLE1, 2, False); (sample2, centers2) = template_kmeans_plusplus_initializer(SIMPLE_SAMPLES.SAMPLE_SIMPLE2, 3, False); (sample3, centers3) = template_kmeans_plusplus_initializer(SIMPLE_SAMPLES.SAMPLE_SIMPLE3, 4, False); (sample4, centers4) = template_kmeans_plusplus_initializer(FCPS_SAMPLES.SAMPLE_TWO_DIAMONDS, 2, False); visualizer = cluster_visualizer(4, 2); visualizer.append_cluster(sample1, canvas = 0); visualizer.append_cluster(centers1, canvas = 0, marker = '*', markersize = 10); visualizer.append_cluster(sample2, canvas = 1); visualizer.append_cluster(centers2, canvas = 1, marker = '*', markersize = 10); visualizer.append_cluster(sample3, canvas = 2); visualizer.append_cluster(centers3, canvas = 2, marker = '*', markersize = 10); visualizer.append_cluster(sample4, canvas = 3); visualizer.append_cluster(centers4, canvas = 3, marker = '*', markersize = 10); visualizer.show();
def kmeans_plusplus_initializer_collection(): (sample1, centers1) = template_kmeans_plusplus_initializer(SIMPLE_SAMPLES.SAMPLE_SIMPLE1, 2, False) (sample2, centers2) = template_kmeans_plusplus_initializer(SIMPLE_SAMPLES.SAMPLE_SIMPLE2, 3, False) (sample3, centers3) = template_kmeans_plusplus_initializer(SIMPLE_SAMPLES.SAMPLE_SIMPLE3, 4, False) (sample4, centers4) = template_kmeans_plusplus_initializer(FCPS_SAMPLES.SAMPLE_TWO_DIAMONDS, 2, False) visualizer = cluster_visualizer(4, 2) visualizer.append_cluster(sample1, canvas=0) visualizer.append_cluster(centers1, canvas=0, marker='*', markersize=10) visualizer.append_cluster(sample2, canvas=1) visualizer.append_cluster(centers2, canvas=1, marker='*', markersize=10) visualizer.append_cluster(sample3, canvas=2) visualizer.append_cluster(centers3, canvas=2, marker='*', markersize=10) visualizer.append_cluster(sample4, canvas=3) visualizer.append_cluster(centers4, canvas=3, marker='*', markersize=10) visualizer.show()
def template_clustering(radius, neighb, path, invisible_axes=False, ccore=True): sample = read_sample(path) dbscan_instance = dbscan(sample, radius, neighb, ccore) (ticks, result) = timedcall(dbscan_instance.process) clusters = dbscan_instance.get_clusters() noise = dbscan_instance.get_noise() visualizer = cluster_visualizer() visualizer.append_clusters(clusters, sample) visualizer.append_cluster(noise, sample, marker='x') visualizer.show() print("Sample: ", path, "\t\tExecution time: ", ticks, "\n")
def display_simple_dbscan_results(): (simple1, simple1_clusters, _) = template_clustering(0.4, 2, SIMPLE_SAMPLES.SAMPLE_SIMPLE1) (simple2, simple2_clusters, _) = template_clustering(1, 2, SIMPLE_SAMPLES.SAMPLE_SIMPLE2) (simple3, simple3_clusters, _) = template_clustering(0.7, 3, SIMPLE_SAMPLES.SAMPLE_SIMPLE3) (simple4, simple4_clusters, _) = template_clustering(0.7, 3, SIMPLE_SAMPLES.SAMPLE_SIMPLE4) (simple5, simple5_clusters, _) = template_clustering(0.7, 3, SIMPLE_SAMPLES.SAMPLE_SIMPLE5) (simple6, simple6_clusters, _) = template_clustering(1, 2, SIMPLE_SAMPLES.SAMPLE_SIMPLE6) (simple7, simple7_clusters, _) = template_clustering(1.0, 3, SIMPLE_SAMPLES.SAMPLE_SIMPLE7) (simple8, simple8_clusters, _) = template_clustering(1.0, 3, SIMPLE_SAMPLES.SAMPLE_SIMPLE8) visualizer = cluster_visualizer(8, 4) visualizer.append_clusters(simple1_clusters, simple1, 0) visualizer.append_clusters(simple2_clusters, simple2, 1) visualizer.append_clusters(simple3_clusters, simple3, 2) visualizer.append_clusters(simple4_clusters, simple4, 3) visualizer.append_clusters(simple5_clusters, simple5, 4) visualizer.append_clusters(simple6_clusters, simple6, 5) visualizer.append_clusters(simple7_clusters, simple7, 6) visualizer.append_clusters(simple8_clusters, simple8, 7) visualizer.show()
def template_clustering(start_centers, path, tolerance = 0.025, criterion = splitting_type.BAYESIAN_INFORMATION_CRITERION, ccore = False): sample = read_sample(path) xmeans_instance = xmeans(sample, start_centers, 20, tolerance, criterion, ccore) (ticks, _) = timedcall(xmeans_instance.process) clusters = xmeans_instance.get_clusters() centers = xmeans_instance.get_centers() criterion_string = "UNKNOWN" if (criterion == splitting_type.BAYESIAN_INFORMATION_CRITERION): criterion_string = "BAYESIAN INFORMATION CRITERION"; elif (criterion == splitting_type.MINIMUM_NOISELESS_DESCRIPTION_LENGTH): criterion_string = "MINIMUM NOISELESS DESCRIPTION_LENGTH"; print("Sample: ", ntpath.basename(path), "\nInitial centers: '", (start_centers is not None), "', Execution time: '", ticks, "', Number of clusters:", len(clusters), ",", criterion_string, "\n") visualizer = cluster_visualizer() visualizer.set_canvas_title(criterion_string) visualizer.append_clusters(clusters, sample) visualizer.append_cluster(centers, None, marker = '*') visualizer.show()
def display_fcps_clustering_results(): (lsun, lsun_clusters) = template_clustering([10, 275, 385], FCPS_SAMPLES.SAMPLE_LSUN, 0.1, False); (target, target_clusters) = template_clustering([10, 160, 310, 460, 560, 700], FCPS_SAMPLES.SAMPLE_TARGET, 0.1, False); (two_diamonds, two_diamonds_clusters) = template_clustering([10, 650], FCPS_SAMPLES.SAMPLE_TWO_DIAMONDS, 0.1, False); (wing_nut, wing_nut_clusters) = template_clustering([19, 823], FCPS_SAMPLES.SAMPLE_WING_NUT, 0.1, False); (chainlink, chainlink_clusters) = template_clustering([30, 900], FCPS_SAMPLES.SAMPLE_CHAINLINK, 0.1, False); (hepta, hepta_clusters) = template_clustering([0, 35, 86, 93, 125, 171, 194], FCPS_SAMPLES.SAMPLE_HEPTA, 0.1, False); (tetra, tetra_clusters) = template_clustering([0, 131, 214, 265], FCPS_SAMPLES.SAMPLE_TETRA, 0.1, False); (atom, atom_clusters) = template_clustering([0, 650], FCPS_SAMPLES.SAMPLE_ATOM, 0.1, False); visualizer = cluster_visualizer(8, 4); visualizer.append_clusters(lsun_clusters, lsun, 0); visualizer.append_clusters(target_clusters, target, 1); visualizer.append_clusters(two_diamonds_clusters, two_diamonds, 2); visualizer.append_clusters(wing_nut_clusters, wing_nut, 3); visualizer.append_clusters(chainlink_clusters, chainlink, 4); visualizer.append_clusters(hepta_clusters, hepta, 5); visualizer.append_clusters(tetra_clusters, tetra, 6); visualizer.append_clusters(atom_clusters, atom, 7); visualizer.show();
def display_fcps_clarans_results(): (lsun, lsun_clusters) = template_clustering(3, FCPS_SAMPLES.SAMPLE_LSUN, 10, 5); (target, target_clusters) = template_clustering(6, FCPS_SAMPLES.SAMPLE_TARGET, 10, 5); (two_diamonds, two_diamonds_clusters) = template_clustering(2, FCPS_SAMPLES.SAMPLE_TWO_DIAMONDS, 2, 2); (wing_nut, wing_nut_clusters) = template_clustering(2, FCPS_SAMPLES.SAMPLE_WING_NUT, 2, 2); (chainlink, chainlink_clusters) = template_clustering(2, FCPS_SAMPLES.SAMPLE_CHAINLINK, 2, 2); (hepta, hepta_clusters) = template_clustering(7, FCPS_SAMPLES.SAMPLE_HEPTA, 2, 2); (tetra, tetra_clusters) = template_clustering(4, FCPS_SAMPLES.SAMPLE_TETRA, 2, 2); (atom, atom_clusters) = template_clustering(2, FCPS_SAMPLES.SAMPLE_ATOM, 2, 2); visualizer = cluster_visualizer(8, 4) visualizer.append_clusters(lsun_clusters, lsun, 0) visualizer.append_clusters(target_clusters, target, 1) visualizer.append_clusters(two_diamonds_clusters, two_diamonds, 2) visualizer.append_clusters(wing_nut_clusters, wing_nut, 3) visualizer.append_clusters(chainlink_clusters, chainlink, 4) visualizer.append_clusters(hepta_clusters, hepta, 5) visualizer.append_clusters(tetra_clusters, tetra, 6) visualizer.append_clusters(atom_clusters, atom, 7) visualizer.show()
def display_fcps_clustering_results(): (lsun, lsun_clusters, _) = template_clustering(3, FCPS_SAMPLES.SAMPLE_LSUN, show_result = False); (target, target_clusters, _) = template_clustering(6, FCPS_SAMPLES.SAMPLE_TARGET, show_result = False); (two_diamonds, two_diamonds_clusters, _) = template_clustering(2, FCPS_SAMPLES.SAMPLE_TWO_DIAMONDS, show_result = False); (wing_nut, wing_nut_clusters, _) = template_clustering(2, FCPS_SAMPLES.SAMPLE_WING_NUT, show_result = False); (chainlink, chainlink_clusters, _) = template_clustering(2, FCPS_SAMPLES.SAMPLE_CHAINLINK, show_result = False); (hepta, hepta_clusters, _) = template_clustering(7, FCPS_SAMPLES.SAMPLE_HEPTA, show_result = False); (tetra, tetra_clusters, _) = template_clustering(4, FCPS_SAMPLES.SAMPLE_TETRA, show_result = False); (atom, atom_clusters, _) = template_clustering(2, FCPS_SAMPLES.SAMPLE_ATOM, show_result = False); visualizer = cluster_visualizer(8, 4); visualizer.append_clusters(lsun_clusters, lsun, 0); visualizer.append_clusters(target_clusters, target, 1); visualizer.append_clusters(two_diamonds_clusters, two_diamonds, 2); visualizer.append_clusters(wing_nut_clusters, wing_nut, 3); visualizer.append_clusters(chainlink_clusters, chainlink, 4); visualizer.append_clusters(hepta_clusters, hepta, 5); visualizer.append_clusters(tetra_clusters, tetra, 6); visualizer.append_clusters(atom_clusters, atom, 7); visualizer.show();
def frame_generation(index_iteration): figure.clf() figure.suptitle("Clustering genetic algorithm (iteration: " + str(index_iteration) + ")", fontsize=18, fontweight='bold') visualizer = cluster_visualizer(4, 2, ["The best pop. on step #" + str(index_iteration), "The best population"]) local_minimum_clusters = ga_math.get_clusters_representation(observer.get_population_best()['chromosome'][index_iteration]) visualizer.append_clusters(local_minimum_clusters, data, 0) global_minimum_clusters = ga_math.get_clusters_representation(observer.get_global_best()['chromosome'][index_iteration]) visualizer.append_clusters(global_minimum_clusters, data, 1) ax1 = plt.subplot2grid((2, 2), (1, 0), colspan=2) ga_visualizer.show_evolution(observer, 0, index_iteration + 1, ax1, False) visualizer.show(figure, shift=0, display=False) figure.subplots_adjust(top=0.85) return [figure.gca()]
def display_fcps_clustering_results(): (lsun, lsun_clusters, _) = template_clustering(0.5, 3, FCPS_SAMPLES.SAMPLE_LSUN, False, True, False) (target, target_clusters, _) = template_clustering(0.5, 2, FCPS_SAMPLES.SAMPLE_TARGET, False, True, False) (two_diamonds, two_diamonds_clusters, _) = template_clustering(0.15, 7, FCPS_SAMPLES.SAMPLE_TWO_DIAMONDS, False, True, False) (wing_nut, wing_nut_clusters, _) = template_clustering(0.25, 2, FCPS_SAMPLES.SAMPLE_WING_NUT, False, True, False) (chainlink, chainlink_clusters, _) = template_clustering(0.5, 3, FCPS_SAMPLES.SAMPLE_CHAINLINK, False, True, False) (hepta, hepta_clusters, _) = template_clustering(1, 3, FCPS_SAMPLES.SAMPLE_HEPTA, False, True, False) (tetra, tetra_clusters, _) = template_clustering(0.4, 3, FCPS_SAMPLES.SAMPLE_TETRA, False, True, False) (atom, atom_clusters, _) = template_clustering(15, 3, FCPS_SAMPLES.SAMPLE_ATOM, False, True, False) visualizer = cluster_visualizer(8, 4) visualizer.append_clusters(lsun_clusters, lsun, 0) visualizer.append_clusters(target_clusters, target, 1) visualizer.append_clusters(two_diamonds_clusters, two_diamonds, 2) visualizer.append_clusters(wing_nut_clusters, wing_nut, 3) visualizer.append_clusters(chainlink_clusters, chainlink, 4) visualizer.append_clusters(hepta_clusters, hepta, 5) visualizer.append_clusters(tetra_clusters, tetra, 6) visualizer.append_clusters(atom_clusters, atom, 7) visualizer.show()
def template_clustering(data_path, intervals, density_threshold, **kwargs): print("Sample: '%s'." % os.path.basename(data_path)) data = read_sample(data_path) clique_instance = clique(data, intervals, density_threshold) clique_instance.process() clusters = clique_instance.get_clusters() noise = clique_instance.get_noise() cells = clique_instance.get_cells() print([len(cluster) for cluster in clusters]) clique_visualizer.show_grid(cells, data) visualizer = cluster_visualizer() visualizer.append_clusters(clusters, data) visualizer.append_cluster(noise, data, marker='x') visualizer.show()
def template_clustering(radius, neighb, path, invisible_axes = False, ccore = True, show = True): sample = read_sample(path); dbscan_instance = dbscan(sample, radius, neighb, ccore); (ticks, _) = timedcall(dbscan_instance.process); clusters = dbscan_instance.get_clusters(); noise = dbscan_instance.get_noise(); print([len(cluster) for cluster in clusters]); if (False): visualizer = cluster_visualizer(); visualizer.append_clusters(clusters, sample); visualizer.append_cluster(noise, sample, marker = 'x'); visualizer.show(); print("Sample: ", path, "\t\tExecution time: ", ticks, "\n"); return (sample, clusters, noise);
def template_clustering(radius, neighb, path, invisible_axes = False, ccore = True, show = True): sample = read_sample(path) dbscan_instance = dbscan(sample, radius, neighb, ccore) (ticks, _) = timedcall(dbscan_instance.process) clusters = dbscan_instance.get_clusters() noise = dbscan_instance.get_noise() print([len(cluster) for cluster in clusters]) if show: visualizer = cluster_visualizer() visualizer.append_clusters(clusters, sample) visualizer.append_cluster(noise, sample, marker = 'x') visualizer.show() print("Sample: ", path, "\t\tExecution time: ", ticks, "\n") return sample, clusters, noise
def display_fcps_clustering_results(): (lsun, lsun_clusters) = template_clustering([10, 275, 385], FCPS_SAMPLES.SAMPLE_LSUN, 0.1, False) (target, target_clusters) = template_clustering([10, 160, 310, 460, 560, 700], FCPS_SAMPLES.SAMPLE_TARGET, 0.1, False) (two_diamonds, two_diamonds_clusters) = template_clustering([10, 650], FCPS_SAMPLES.SAMPLE_TWO_DIAMONDS, 0.1, False) (wing_nut, wing_nut_clusters) = template_clustering([19, 823], FCPS_SAMPLES.SAMPLE_WING_NUT, 0.1, False) (chainlink, chainlink_clusters) = template_clustering([30, 900], FCPS_SAMPLES.SAMPLE_CHAINLINK, 0.1, False) (hepta, hepta_clusters) = template_clustering([0, 35, 86, 93, 125, 171, 194], FCPS_SAMPLES.SAMPLE_HEPTA, 0.1, False) (tetra, tetra_clusters) = template_clustering([0, 131, 214, 265], FCPS_SAMPLES.SAMPLE_TETRA, 0.1, False) (atom, atom_clusters) = template_clustering([0, 650], FCPS_SAMPLES.SAMPLE_ATOM, 0.1, False) visualizer = cluster_visualizer(8, 4) visualizer.append_clusters(lsun_clusters, lsun, 0) visualizer.append_clusters(target_clusters, target, 1) visualizer.append_clusters(two_diamonds_clusters, two_diamonds, 2) visualizer.append_clusters(wing_nut_clusters, wing_nut, 3) visualizer.append_clusters(chainlink_clusters, chainlink, 4) visualizer.append_clusters(hepta_clusters, hepta, 5) visualizer.append_clusters(tetra_clusters, tetra, 6) visualizer.append_clusters(atom_clusters, atom, 7) visualizer.show()
def initialize_kmedoids_model( path_to_points="./lib/us_metros_scraped_geocoords.tsv"): import numpy as np from sklearn.cluster import KMeans coords = [] labels = [] if isinstance(path_to_points, str): for row in load_csv(path_to_points, delimiter="\t"): try: coords.append( list(deg2dec((row["latitude"], row["longitude"])))) labels.append(row["parent"]) except Exception as e: print(e) else: coords = path_to_points arr = np.array([c for c in coords if c and len(c) == 2]) print(f"Points: {len(arr)}") k = 32 from pyclustering.cluster.kmedoids import kmedoids # Load list of points for cluster analysis. # Set random initial medoids. initial_medoids = random.sample(range(0, len(arr)), k=k) # Create instance of K-Medoids algorithm. kmedoids_instance = kmedoids(arr, initial_medoids) # Run cluster analysis and obtain results. kmedoids_instance.process() clusters = kmedoids_instance.get_clusters() # Show allocated clusters. print(clusters) # return kmedoids_instance # Display clusters. from pyclustering.cluster import cluster_visualizer visualizer = cluster_visualizer() visualizer.append_clusters(clusters, arr) visualizer.show()
def display_fcps_dependence_clustering_results(): (two_diamonds, two_diamonds_clusters_1, _) = template_clustering(0.15, 4, FCPS_SAMPLES.SAMPLE_TWO_DIAMONDS, False, True, False); (two_diamonds, two_diamonds_clusters_2, _) = template_clustering(0.15, 5, FCPS_SAMPLES.SAMPLE_TWO_DIAMONDS, False, True, False); (two_diamonds, two_diamonds_clusters_3, _) = template_clustering(0.15, 6, FCPS_SAMPLES.SAMPLE_TWO_DIAMONDS, False, True, False); (two_diamonds, two_diamonds_clusters_4, _) = template_clustering(0.15, 7, FCPS_SAMPLES.SAMPLE_TWO_DIAMONDS, False, True, False); (two_diamonds, two_diamonds_clusters_5, _) = template_clustering(0.10, 6, FCPS_SAMPLES.SAMPLE_TWO_DIAMONDS, False, True, False); (two_diamonds, two_diamonds_clusters_6, _) = template_clustering(0.12, 6, FCPS_SAMPLES.SAMPLE_TWO_DIAMONDS, False, True, False); (two_diamonds, two_diamonds_clusters_7, _) = template_clustering(0.15, 6, FCPS_SAMPLES.SAMPLE_TWO_DIAMONDS, False, True, False); (two_diamonds, two_diamonds_clusters_8, _) = template_clustering(0.17, 6, FCPS_SAMPLES.SAMPLE_TWO_DIAMONDS, False, True, False); visualizer = cluster_visualizer(8, 4); visualizer.append_clusters(two_diamonds_clusters_1, two_diamonds, 0); visualizer.append_clusters(two_diamonds_clusters_2, two_diamonds, 1); visualizer.append_clusters(two_diamonds_clusters_3, two_diamonds, 2); visualizer.append_clusters(two_diamonds_clusters_4, two_diamonds, 3); visualizer.append_clusters(two_diamonds_clusters_5, two_diamonds, 4); visualizer.append_clusters(two_diamonds_clusters_6, two_diamonds, 5); visualizer.append_clusters(two_diamonds_clusters_7, two_diamonds, 6); visualizer.append_clusters(two_diamonds_clusters_8, two_diamonds, 7); visualizer.show();
def testVisualizeClusterWithAttributesNumpy(self): sample = read_sample(SIMPLE_SAMPLES.SAMPLE_SIMPLE1, return_type='numpy') cure_instance = cure(sample, 2, 5, 0.5, False) cure_instance.process() clusters = cure_instance.get_clusters() representors = cure_instance.get_representors() means = cure_instance.get_means() visualizer = cluster_visualizer() visualizer.append_clusters(clusters, sample) for cluster_index in range(len(clusters)): visualizer.append_cluster_attribute( 0, cluster_index, numpy.array(representors[cluster_index]), '*', 10) visualizer.append_cluster_attribute( 0, cluster_index, numpy.array([means[cluster_index]]), 'o') visualizer.show()
def display_simple_clarans_results(): (simple1, simple1_clusters) = template_clustering(2, SIMPLE_SAMPLES.SAMPLE_SIMPLE1, 10, 3); (simple2, simple2_clusters) = template_clustering(3, SIMPLE_SAMPLES.SAMPLE_SIMPLE2, 10, 3); (simple3, simple3_clusters) = template_clustering(4, SIMPLE_SAMPLES.SAMPLE_SIMPLE3, 10, 3); (simple4, simple4_clusters) = template_clustering(5, SIMPLE_SAMPLES.SAMPLE_SIMPLE4, 10, 4); (simple5, simple5_clusters) = template_clustering(4, SIMPLE_SAMPLES.SAMPLE_SIMPLE5, 10, 5); (simple6, simple6_clusters) = template_clustering(2, SIMPLE_SAMPLES.SAMPLE_SIMPLE6, 10, 3); (simple7, simple7_clusters) = template_clustering(2, SIMPLE_SAMPLES.SAMPLE_SIMPLE7, 10, 3); (simple8, simple8_clusters) = template_clustering(4, SIMPLE_SAMPLES.SAMPLE_SIMPLE8, 15, 5); visualizer = cluster_visualizer(8, 4) visualizer.append_clusters(simple1_clusters, simple1, 0) visualizer.append_clusters(simple2_clusters, simple2, 1) visualizer.append_clusters(simple3_clusters, simple3, 2) visualizer.append_clusters(simple4_clusters, simple4, 3) visualizer.append_clusters(simple5_clusters, simple5, 4) visualizer.append_clusters(simple6_clusters, simple6, 5) visualizer.append_clusters(simple7_clusters, simple7, 6) visualizer.append_clusters(simple8_clusters, simple8, 7) visualizer.show()
def template_clustering(path_sample, eps, minpts, amount_clusters = None, visualize = True): sample = read_sample(path_sample); optics_instance = optics(sample, eps, minpts, amount_clusters); (ticks, _) = timedcall(optics_instance.process); print("Sample: ", path_sample, "\t\tExecution time: ", ticks, "\n"); if (visualize is True): clusters = optics_instance.get_clusters(); noise = optics_instance.get_noise(); visualizer = cluster_visualizer(); visualizer.append_clusters(clusters, sample); visualizer.append_cluster(noise, sample, marker = 'x'); visualizer.show(); ordering = optics_instance.get_ordering(); analyser = ordering_analyser(ordering); ordering_visualizer.show_ordering_diagram(analyser, amount_clusters);
def display_simple_clustering_results(): (simple1, simple1_clusters) = template_clustering(SIMPLE_SAMPLES.SAMPLE_SIMPLE1, visualize=False) (simple2, simple2_clusters) = template_clustering(SIMPLE_SAMPLES.SAMPLE_SIMPLE2, visualize=False) (simple3, simple3_clusters) = template_clustering(SIMPLE_SAMPLES.SAMPLE_SIMPLE3, visualize=False) (simple4, simple4_clusters) = template_clustering(SIMPLE_SAMPLES.SAMPLE_SIMPLE4, visualize=False) (simple5, simple5_clusters) = template_clustering(SIMPLE_SAMPLES.SAMPLE_SIMPLE5, visualize=False) (simple6, simple6_clusters) = template_clustering(SIMPLE_SAMPLES.SAMPLE_SIMPLE6, visualize=False) (simple7, simple7_clusters) = template_clustering(SIMPLE_SAMPLES.SAMPLE_SIMPLE7, visualize=False) (simple8, simple8_clusters) = template_clustering(SIMPLE_SAMPLES.SAMPLE_SIMPLE8, visualize=False) (simple9, simple9_clusters) = template_clustering(SIMPLE_SAMPLES.SAMPLE_SIMPLE9, visualize=False) visualizer = cluster_visualizer(9, 3) visualizer.append_clusters(simple1_clusters, simple1, 0, markersize=3) visualizer.append_clusters(simple2_clusters, simple2, 1, markersize=3) visualizer.append_clusters(simple3_clusters, simple3, 2, markersize=3) visualizer.append_clusters(simple4_clusters, simple4, 3, markersize=3) visualizer.append_clusters(simple5_clusters, simple5, 4, markersize=3) visualizer.append_clusters(simple6_clusters, simple6, 5, markersize=6) visualizer.append_clusters(simple7_clusters, simple7, 6, markersize=6) visualizer.append_clusters(simple8_clusters, simple8, 7, markersize=6) visualizer.append_clusters(simple9_clusters, simple9, 8, markersize=6) visualizer.show()
def template_clustering(radius, neighb, path, invisible_axes = False, ccore = False, show = True, tempos = tempos_dbscan): sample = read_sample(path) dbscan_instance = dbscan(sample, radius, neighb, ccore) (ticks, _) = timedcall(dbscan_instance.process) clusters = dbscan_instance.get_clusters() noise = dbscan_instance.get_noise() print([len(cluster) for cluster in clusters]) if show: visualizer = cluster_visualizer() visualizer.append_clusters(clusters, sample) visualizer.append_cluster(noise, sample, marker = 'x') visualizer.show() print("Sample: ", path, "\t\tExecution time: ", ticks, "\n") tempos_dbscan.append(ticks) return sample, clusters, noise
def testVisualize2DClustersThreeCanvases(self): sample_simple1 = read_sample(SIMPLE_SAMPLES.SAMPLE_SIMPLE1); sample_simple2 = read_sample(SIMPLE_SAMPLES.SAMPLE_SIMPLE2); sample_simple3 = read_sample(SIMPLE_SAMPLES.SAMPLE_SIMPLE3); dbscan_instance = dbscan(sample_simple1, 0.4, 2, False); dbscan_instance.process(); clusters_sample1 = dbscan_instance.get_clusters(); dbscan_instance = dbscan(sample_simple2, 1, 2, False); dbscan_instance.process(); clusters_sample2 = dbscan_instance.get_clusters(); dbscan_instance = dbscan(sample_simple3, 0.7, 3, False); dbscan_instance.process(); clusters_sample3 = dbscan_instance.get_clusters(); visualizer = cluster_visualizer(3); visualizer.append_clusters(clusters_sample1, sample_simple1, 0, markersize = 5); visualizer.append_clusters(clusters_sample2, sample_simple2, 1, markersize = 5); visualizer.append_clusters(clusters_sample3, sample_simple3, 2, markersize = 5); visualizer.show();
def template_clustering(start_medoids, sample, tolerance=0.25, show=True): kmedoids_instance = kmedoids(sample, start_medoids, tolerance) (ticks, result) = timedcall(kmedoids_instance.process) clusters = kmedoids_instance.get_clusters() medoids = kmedoids_instance.get_medoids() print("Execution time: ", ticks, "\n") if (show is True): visualizer = cluster_visualizer(1) visualizer.append_clusters(clusters, sample, 0) visualizer.append_cluster( [sample[index] for index in start_medoids], marker='+', markersize=15) visualizer.append_cluster(medoids, marker='*', markersize=5) visualizer.show() return medoids
def show_feature_destibution(self, data = None): """! @brief Shows feature distribution. @details Only features in 1D, 2D, 3D space can be visualized. @param[in] data (list): List of points that will be used for visualization, if it not specified than feature will be displayed only. """ visualizer = cluster_visualizer(); print("amount of nodes: ", self.__amount_nodes); if (data is not None): visualizer.append_cluster(data, marker = 'x'); for level in range(0, self.height): level_nodes = self.get_level_nodes(level); centers = [ node.feature.get_centroid() for node in level_nodes ]; visualizer.append_cluster(centers, None, markersize = (self.height - level + 1) * 5); visualizer.show();