def som_create(rows, cols, conn_type, parameters): """! @brief Create of self-organized map using CCORE pyclustering library. @param[in] rows (uint): Number of neurons in the column (number of rows). @param[in] cols (uint): Number of neurons in the row (number of columns). @param[in] conn_type (type_conn): Type of connection between oscillators in the network (grid four, grid eight, honeycomb, function neighbour). @param[in] parameters (som_parameters): Other specific parameters. @return (POINTER) C-pointer to object of self-organized feature in memory. """ ccore = load_core() c_params = c_som_parameters() c_params.init_type = parameters.init_type c_params.init_radius = parameters.init_radius c_params.init_learn_rate = parameters.init_learn_rate c_params.adaptation_threshold = parameters.adaptation_threshold ccore.som_create.restype = POINTER(c_void_p) som_pointer = ccore.som_create(c_uint(rows), c_uint(cols), c_uint(conn_type), pointer(c_params)) return som_pointer
def rock(sample, eps, number_clusters, threshold): """ @brief Clustering algorithm ROCK returns allocated clusters and noise that are consisted from input data. @details Calculation is performed via CCORE (C/C++ part of the pyclustering)." @param[in] sample: input data - list of points where each point is represented by list of coordinates. @param[in] eps: connectivity radius (similarity threshold), points are neighbors if distance between them is less than connectivity radius. @param[in] number_clusters: defines number of clusters that should be allocated from the input data set. @param[in] threshold: value that defines degree of normalization that influences on choice of clusters for merging during processing. @return List of allocated clusters, each cluster contains indexes of objects in list of data. """ pointer_data = package_builder(sample, c_double).create() ccore = load_core() ccore.rock_algorithm.restype = POINTER(pyclustering_package) package = ccore.rock_algorithm(pointer_data, c_double(eps), c_size_t(number_clusters), c_double(threshold)) list_of_clusters = package_extractor(package).extract() ccore.free_pyclustering_package(package) return list_of_clusters
def som_destroy(som_pointer): """! @brief Destroys self-organized map. @param[in] som_pointer (POINTER): pointer to object of self-organized map. """ ccore = load_core() ccore.som_destroy(som_pointer)
def cure_get_means(cure_data_pointer): ccore = load_core() ccore.cure_get_means.restype = POINTER(pyclustering_package) package = ccore.cure_get_means(cure_data_pointer) result = package_extractor(package).extract() ccore.free_pyclustering_package(package) return result
def som_get_winner_number(som_pointer): """! @brief Returns of number of winner at the last step of learning process. @param[in] som_pointer (c_pointer): pointer to object of self-organized map. """ ccore = load_core() ccore.som_get_winner_number.restype = c_size_t return ccore.som_get_winner_number(som_pointer)
def som_get_size(som_pointer): """! @brief Returns size of self-organized map (number of neurons). @param[in] som_pointer (c_pointer): pointer to object of self-organized map. """ ccore = load_core() ccore.som_get_size.restype = c_size_t return ccore.som_get_size(som_pointer)
def cure_algorithm(sample, number_clusters, number_represent_points, compression): pointer_data = package_builder(sample, c_double).create() ccore = load_core() ccore.cure_algorithm.restype = POINTER(c_void_p) cure_data_pointer = ccore.cure_algorithm(pointer_data, c_size_t(number_clusters), c_size_t(number_represent_points), c_double(compression)) return cure_data_pointer
def kmedoids(sample, medoids, tolerance): pointer_data = package_builder(sample, c_double).create(); medoids_package = package_builder(medoids, c_size_t).create(); ccore = load_core(); ccore.kmedoids_algorithm.restype = POINTER(pyclustering_package); package = ccore.kmedoids_algorithm(pointer_data, medoids_package, c_double(tolerance)); result = package_extractor(package).extract(); ccore.free_pyclustering_package(package); return result;
def agglomerative_algorithm(data, number_clusters, link): pointer_data = package_builder(data, c_double).create() ccore = load_core() ccore.agglomerative_algorithm.restype = POINTER(pyclustering_package) package = ccore.agglomerative_algorithm(pointer_data, c_size_t(number_clusters), c_size_t(link)) result = package_extractor(package).extract() ccore.free_pyclustering_package(package) return result
def kmeans(sample, centers, tolerance): pointer_data = package_builder(sample, c_double).create() pointer_centers = package_builder(centers, c_double).create() ccore = load_core() ccore.kmeans_algorithm.restype = POINTER(pyclustering_package) package = ccore.kmeans_algorithm(pointer_data, pointer_centers, c_double(tolerance)) result = package_extractor(package).extract() ccore.free_pyclustering_package(package) return result
def dbscan(sample, eps, min_neighbors, return_noise = False): pointer_data = package_builder(sample, c_double).create(); ccore = load_core(); ccore.dbscan_algorithm.restype = POINTER(pyclustering_package); package = ccore.dbscan_algorithm(pointer_data, c_double(eps), c_size_t(min_neighbors)); list_of_clusters = package_extractor(package).extract(); ccore.free_pyclustering_package(package); noise = list_of_clusters[len(list_of_clusters) - 1]; list_of_clusters.remove(noise); return (list_of_clusters, noise);
def xmeans(sample, centers, kmax, tolerance, criterion): pointer_data = package_builder(sample, c_double).create() pointer_centers = package_builder(centers, c_double).create() ccore = load_core() ccore.xmeans_algorithm.restype = POINTER(pyclustering_package) package = ccore.xmeans_algorithm(pointer_data, pointer_centers, c_size_t(kmax), c_double(tolerance), c_uint(criterion)) result = package_extractor(package).extract() ccore.free_pyclustering_package(package) return result[0], result[1]
def som_get_neighbors(som_pointer): """! @brief Returns list of indexes of neighbors of each neuron. @param[in] som_pointer (c_pointer): pointer to object of self-organized map. """ ccore = load_core() ccore.som_get_neighbors.restype = POINTER(pyclustering_package) package = ccore.som_get_neighbors(som_pointer) result = package_extractor(package).extract() return result
def som_get_awards(som_pointer): """! @brief Returns list of amount of captured objects by each neuron. @param[in] som_pointer (c_pointer): pointer to object of self-organized map. """ ccore = load_core() ccore.som_get_awards.restype = POINTER(pyclustering_package) package = ccore.som_get_awards(som_pointer) result = package_extractor(package).extract() return result
def som_train(som_pointer, data, epochs, autostop): """! @brief Trains self-organized feature map (SOM) using CCORE pyclustering library. @param[in] data (list): Input data - list of points where each point is represented by list of features, for example coordinates. @param[in] epochs (uint): Number of epochs for training. @param[in] autostop (bool): Automatic termination of learining process when adaptation is not occurred. @return (uint) Number of learining iterations. """ pointer_data = package_builder(data, c_double).create() ccore = load_core() ccore.som_train.restype = c_size_t return ccore.som_train(som_pointer, pointer_data, c_uint(epochs), autostop)
def som_simulate(som_pointer, pattern): """! @brief Processes input pattern (no learining) and returns index of neuron-winner. @details Using index of neuron winner catched object can be obtained using property capture_objects. @param[in] som_pointer (c_pointer): pointer to object of self-organized map. @param[in] pattern (list): input pattern. @return Returns index of neuron-winner. """ pointer_data = package_builder(pattern, c_double).create() ccore = load_core() ccore.som_simulate.restype = c_size_t return ccore.som_simulate(som_pointer, pointer_data)
def optics(sample, radius, minimum_neighbors, amount_clusters): amount = amount_clusters; if (amount is None): amount = 0; pointer_data = package_builder(sample, c_double).create(); ccore = load_core(); ccore.optics_algorithm.restype = POINTER(pyclustering_package); package = ccore.optics_algorithm(pointer_data, c_double(radius), c_size_t(minimum_neighbors), c_size_t(amount)); results = package_extractor(package).extract(); ccore.free_pyclustering_package(package); return (results[optics_package_indexer.OPTICS_PACKAGE_INDEX_CLUSTERS], results[optics_package_indexer.OPTICS_PACKAGE_INDEX_NOISE], results[optics_package_indexer.OPTICS_PACKAGE_INDEX_ORDERING], results[optics_package_indexer.OPTICS_PACKAGE_INDEX_RADIUS][0]);
def cure_data_destroy(cure_data_pointer): ccore = load_core() ccore.cure_data_destroy(cure_data_pointer)