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 = ccore_library.get();
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_create(rows, cols, conn_type, parameters):
"""!
@brief Create of self-organized map using C++ 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 = ccore_library.get()
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
c_params.random_state = parameters.random_state or -1
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 som_load(som_pointer, weights, award, capture_objects):
"""!
@brief Load dump of the network to SOM.
@details Initialize SOM using existed weights, amount of captured objects by each neuron, captured
objects by each neuron. Initialization is not performed if weights are empty.
@param[in] som_pointer (POINTER): pointer to object of self-organized map.
@param[in] weights (list): weights that should assigned to neurons.
@param[in] awards (list): amount of captured objects by each neuron.
@param[in] capture_objects (list): captured objects by each neuron.
"""
if len(weights) == 0:
return
ccore = ccore_library.get()
package_weights = package_builder(weights, c_double).create()
package_award = package_builder(award, c_size_t).create()
package_capture_objects = package_builder(capture_objects,
c_size_t).create()
ccore.som_load(som_pointer, package_weights, package_award,
package_capture_objects)
def elbow(sample, kmin, kmax, kstep, initializer, random_state):
random_state = random_state or -1
pointer_data = package_builder(sample, c_double).create()
ccore = ccore_library.get()
if initializer == elbow_center_initializer.KMEANS_PLUS_PLUS:
ccore.elbow_method_ikpp.restype = POINTER(pyclustering_package)
package = ccore.elbow_method_ikpp(pointer_data, c_size_t(kmin),
c_size_t(kmax), c_size_t(kstep),
c_longlong(random_state))
elif initializer == elbow_center_initializer.RANDOM:
ccore.elbow_method_irnd.restype = POINTER(pyclustering_package)
package = ccore.elbow_method_irnd(pointer_data, c_size_t(kmin),
c_size_t(kmax), c_size_t(kstep),
c_longlong(random_state))
else:
raise ValueError("Not supported type of center initializer '" +
str(initializer) + "'.")
results = package_extractor(package).extract()
ccore.free_pyclustering_package(package)
if isinstance(results, bytes):
raise RuntimeError(results.decode('utf-8'))
return (results[elbow_package_indexer.ELBOW_PACKAGE_INDEX_AMOUNT][0],
results[elbow_package_indexer.ELBOW_PACKAGE_INDEX_WCE])
def optics(sample, radius, minimum_neighbors, amount_clusters, data_type):
amount = amount_clusters
if amount is None:
amount = 0
pointer_data = package_builder(sample, c_double).create()
c_data_type = convert_data_type(data_type)
ccore = ccore_library.get()
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), c_data_type)
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],
results[optics_package_indexer.
OPTICS_PACKAGE_INDEX_OPTICS_OBJECTS_INDEX],
results[optics_package_indexer.
OPTICS_PACKAGE_INDEX_OPTICS_OBJECTS_CORE_DISTANCE],
results[optics_package_indexer.
OPTICS_PACKAGE_INDEX_OPTICS_OBJECTS_REACHABILITY_DISTANCE])
def __call__(self, point1, point2):
point_package1 = package_builder(point1, c_double).create();
point_package2 = package_builder(point2, c_double).create();
ccore = ccore_library.get();
ccore.metric_calculate.restype = c_double;
return ccore.metric_calculate(self.__pointer, point_package1, point_package2);
def cure_algorithm(sample, number_clusters, number_represent_points, compression):
pointer_data = package_builder(sample, c_double).create();
ccore = ccore_library.get();
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 som_destroy(som_pointer):
"""!
@brief Destroys self-organized map.
@param[in] som_pointer (POINTER): pointer to object of self-organized map.
"""
ccore = ccore_library.get()
ccore.som_destroy(som_pointer)
def cure_get_means(cure_data_pointer):
ccore = ccore_library.get();
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 cure_get_representors(cure_data_pointer):
ccore = ccore_library.get()
ccore.cure_get_representors.restype = POINTER(pyclustering_package)
package = ccore.cure_get_representors(cure_data_pointer)
result = package_extractor(package).extract()
ccore.free_pyclustering_package(package)
return result
def __init__(self, type_metric, arguments, func):
self.__func = lambda p1, p2: func(package_extractor(p1).extract(), package_extractor(p2).extract());
package_arguments = package_builder(arguments, c_double).create();
ccore = ccore_library.get();
ccore.metric_create.restype = POINTER(c_void_p);
self.__pointer = ccore.metric_create(c_size_t(type_metric), package_arguments, metric_callback(self.__func));
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 = ccore_library.get()
ccore.som_get_winner_number.restype = c_size_t
return ccore.som_get_winner_number(som_pointer)
def agglomerative_algorithm(data, number_clusters, link):
pointer_data = package_builder(data, c_double).create();
ccore = ccore_library.get();
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 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 = ccore_library.get()
ccore.som_get_size.restype = c_size_t
return ccore.som_get_size(som_pointer)
def ttsas(sample, threshold1, threshold2, metric_pointer):
pointer_data = package_builder(sample, c_double).create();
ccore = ccore_library.get();
ccore.ttsas_algorithm.restype = POINTER(pyclustering_package);
package = ccore.ttsas_algorithm(pointer_data, c_double(threshold1), c_double(threshold2), metric_pointer);
result = package_extractor(package).extract();
ccore.free_pyclustering_package(package);
return result[0], result[1];
def bsas(sample, amount, threshold, metric_pointer):
pointer_data = package_builder(sample, c_double).create()
ccore = ccore_library.get()
ccore.bsas_algorithm.restype = POINTER(pyclustering_package)
package = ccore.bsas_algorithm(pointer_data, c_size_t(amount), c_double(threshold), metric_pointer)
result = package_extractor(package).extract()
ccore.free_pyclustering_package(package)
return result[0], result[1]
def silhoeutte(sample, clusters, pointer_metric):
pointer_data = package_builder(sample, c_double).create()
pointer_clusters = package_builder(clusters, c_size_t).create()
ccore = ccore_library.get()
ccore.silhouette_algorithm.restype = POINTER(pyclustering_package)
package = ccore.silhouette_algorithm(pointer_data, pointer_clusters, pointer_metric)
result = package_extractor(package).extract()
ccore.free_pyclustering_package(package)
return result
def kmeans(sample, centers, tolerance, observe):
pointer_data = package_builder(sample, c_double).create();
pointer_centers = package_builder(centers, c_double).create();
ccore = ccore_library.get();
ccore.kmeans_algorithm.restype = POINTER(pyclustering_package);
package = ccore.kmeans_algorithm(pointer_data, pointer_centers, c_double(tolerance), c_bool(observe));
result = package_extractor(package).extract();
ccore.free_pyclustering_package(package);
return result;
def fcm_algorithm(sample, centers, m, tolerance, itermax):
pointer_data = package_builder(sample, c_double).create()
pointer_centers = package_builder(centers, c_double).create()
ccore = ccore_library.get()
ccore.fcm_algorithm.restype = POINTER(pyclustering_package)
package = ccore.fcm_algorithm(pointer_data, pointer_centers, c_double(m), c_double(tolerance), c_size_t(itermax))
result = package_extractor(package).extract()
ccore.free_pyclustering_package(package)
return result
def silhoeutte_ksearch(sample, kmin, kmax, allocator):
pointer_data = package_builder(sample, c_double).create()
ccore = ccore_library.get()
ccore.silhouette_ksearch_algorithm.restype = POINTER(pyclustering_package)
package = ccore.silhouette_ksearch_algorithm(pointer_data, c_size_t(kmin), c_size_t(kmax), c_size_t(allocator))
results = package_extractor(package).extract()
ccore.free_pyclustering_package(package)
return (results[silhouette_ksearch_package_indexer.SILHOUETTE_KSEARCH_PACKAGE_INDEX_AMOUNT][0],
results[silhouette_ksearch_package_indexer.SILHOUETTE_KSEARCH_PACKAGE_INDEX_SCORE][0],
results[silhouette_ksearch_package_indexer.SILHOUETTE_KSEARCH_PACKAGE_INDEX_SCORES])
def silhoeutte_ksearch(sample, kmin, kmax, allocator):
pointer_data = package_builder(sample, c_double).create()
ccore = ccore_library.get()
ccore.silhouette_ksearch_algorithm.restype = POINTER(pyclustering_package)
package = ccore.silhouette_ksearch_algorithm(pointer_data, c_size_t(kmin), c_size_t(kmax), c_size_t(allocator))
results = package_extractor(package).extract()
ccore.free_pyclustering_package(package)
return (results[silhouette_ksearch_package_indexer.SILHOUETTE_KSEARCH_PACKAGE_INDEX_AMOUNT][0],
results[silhouette_ksearch_package_indexer.SILHOUETTE_KSEARCH_PACKAGE_INDEX_SCORE][0],
results[silhouette_ksearch_package_indexer.SILHOUETTE_KSEARCH_PACKAGE_INDEX_SCORES])
def gmeans(sample, amount, tolerance, repeat):
pointer_data = package_builder(sample, c_double).create()
ccore = ccore_library.get()
ccore.gmeans_algorithm.restype = POINTER(pyclustering_package)
package = ccore.gmeans_algorithm(pointer_data, c_size_t(amount),
c_double(tolerance), c_size_t(repeat))
result = package_extractor(package).extract()
ccore.free_pyclustering_package(package)
return result[0], result[1], result[2][0]
def xmeans(sample, centers, kmax, tolerance, criterion):
pointer_data = package_builder(sample, c_double).create();
pointer_centers = package_builder(centers, c_double).create();
ccore = ccore_library.get();
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 silhoeutte(sample, clusters, pointer_metric):
pointer_data = package_builder(sample, c_double).create()
pointer_clusters = package_builder(clusters, c_size_t).create()
ccore = ccore_library.get()
ccore.silhouette_algorithm.restype = POINTER(pyclustering_package)
package = ccore.silhouette_algorithm(pointer_data, pointer_clusters,
pointer_metric)
result = package_extractor(package).extract()
ccore.free_pyclustering_package(package)
return result
def kmedians(sample, centers, tolerance, metric_pointer):
pointer_data = package_builder(sample, c_double).create()
pointer_centers = package_builder(centers, c_double).create()
ccore = ccore_library.get()
ccore.kmedians_algorithm.restype = POINTER(pyclustering_package)
package = ccore.kmedians_algorithm(pointer_data, pointer_centers, c_double(tolerance), metric_pointer)
result = package_extractor(package).extract()
ccore.free_pyclustering_package(package)
return result
def xmeans(sample, centers, kmax, tolerance, criterion):
pointer_data = package_builder(sample, c_double).create();
pointer_centers = package_builder(centers, c_double).create();
ccore = ccore_library.get();
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 kmedians(sample, centers, tolerance, itermax, metric_pointer):
pointer_data = package_builder(sample, c_double).create()
pointer_centers = package_builder(centers, c_double).create()
ccore = ccore_library.get()
ccore.kmedians_algorithm.restype = POINTER(pyclustering_package)
package = ccore.kmedians_algorithm(pointer_data, pointer_centers, c_double(tolerance), c_size_t(itermax), metric_pointer)
result = package_extractor(package).extract()
ccore.free_pyclustering_package(package)
return result[0], result[1]
def kmedoids(sample, medoids, tolerance, itermax, metric_pointer, data_type):
pointer_data = package_builder(sample, c_double).create()
medoids_package = package_builder(medoids, c_size_t).create()
c_data_type = convert_data_type(data_type)
ccore = ccore_library.get()
ccore.kmedoids_algorithm.restype = POINTER(pyclustering_package)
package = ccore.kmedoids_algorithm(pointer_data, medoids_package, c_double(tolerance), c_size_t(itermax), metric_pointer, c_data_type)
result = package_extractor(package).extract()
ccore.free_pyclustering_package(package)
return result[0], result[1]
def fcm_algorithm(sample, centers, m, tolerance, itermax):
pointer_data = package_builder(sample, c_double).create()
pointer_centers = package_builder(centers, c_double).create()
ccore = ccore_library.get()
ccore.fcm_algorithm.restype = POINTER(pyclustering_package)
package = ccore.fcm_algorithm(pointer_data, pointer_centers, c_double(m),
c_double(tolerance), c_size_t(itermax))
result = package_extractor(package).extract()
ccore.free_pyclustering_package(package)
return result
def kmedoids(sample, medoids, tolerance):
pointer_data = package_builder(sample, c_double).create()
medoids_package = package_builder(medoids, c_size_t).create()
ccore = ccore_library.get()
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 kmedoids(sample, medoids, tolerance, itermax, metric_pointer, data_type):
pointer_data = package_builder(sample, c_double).create()
medoids_package = package_builder(medoids, c_size_t).create()
c_data_type = convert_data_type(data_type)
ccore = ccore_library.get()
ccore.kmedoids_algorithm.restype = POINTER(pyclustering_package)
package = ccore.kmedoids_algorithm(pointer_data, medoids_package, c_double(tolerance), c_size_t(itermax), metric_pointer, c_data_type)
result = package_extractor(package).extract()
ccore.free_pyclustering_package(package)
return result[0], result[1], result[2][0], result[3][0]
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 = ccore_library.get()
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 = ccore_library.get()
ccore.som_get_awards.restype = POINTER(pyclustering_package)
package = ccore.som_get_awards(som_pointer)
result = package_extractor(package).extract()
return result
def dbscan(sample, eps, min_neighbors, data_type):
pointer_data = package_builder(sample, c_double).create()
c_data_type = convert_data_type(data_type)
ccore = ccore_library.get()
ccore.dbscan_algorithm.restype = POINTER(pyclustering_package)
package = ccore.dbscan_algorithm(pointer_data, c_double(eps), c_size_t(min_neighbors), c_data_type)
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 pam_build(sample, amount, pointer_metric, data_type):
pointer_data = package_builder(sample, c_double).create()
c_data_type = convert_data_type(data_type)
ccore = ccore_library.get()
ccore.pam_build_algorithm.restype = POINTER(pyclustering_package)
package = ccore.pam_build_algorithm(pointer_data, c_size_t(amount),
pointer_metric, c_data_type)
results = package_extractor(package).extract()
ccore.free_pyclustering_package(package)
if isinstance(results, bytes):
raise RuntimeError(results.decode('utf-8'))
return results[0]
def dbscan(sample, eps, min_neighbors, data_type):
pointer_data = package_builder(sample, c_double).create()
c_data_type = convert_data_type(data_type)
ccore = ccore_library.get()
ccore.dbscan_algorithm.restype = POINTER(pyclustering_package)
package = ccore.dbscan_algorithm(pointer_data, c_double(eps), c_size_t(min_neighbors), c_data_type)
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 gmeans(sample, kinit, tolerance, repeat, kmax, random_state):
random_state = random_state or -1
pointer_data = package_builder(sample, c_double).create()
ccore = ccore_library.get()
ccore.gmeans_algorithm.restype = POINTER(pyclustering_package)
package = ccore.gmeans_algorithm(pointer_data, c_size_t(kinit),
c_double(tolerance), c_size_t(repeat),
c_longlong(kmax),
c_longlong(random_state))
result = package_extractor(package).extract()
ccore.free_pyclustering_package(package)
return result[0], result[1], result[2][0]
def clique(sample, intervals, threshold):
pointer_data = package_builder(sample, c_double).create()
ccore = ccore_library.get()
ccore.clique_algorithm.restype = POINTER(pyclustering_package)
package = ccore.clique_algorithm(pointer_data, c_size_t(intervals), c_size_t(threshold))
results = package_extractor(package).extract()
ccore.free_pyclustering_package(package)
return (results[clique_package_indexer.CLIQUE_PACKAGE_INDEX_CLUSTERS],
results[clique_package_indexer.CLIQUE_PACKAGE_INDEX_NOISE],
results[clique_package_indexer.CLIQUE_PACKAGE_INDEX_LOGICAL_LOCATION],
results[clique_package_indexer.CLIQUE_PACKAGE_INDEX_MAX_CORNER],
results[clique_package_indexer.CLIQUE_PACKAGE_INDEX_MIN_CORNER],
results[clique_package_indexer.CLIQUE_PACKAGE_INDEX_BLOCK_POINTS])
def optics(sample, radius, minimum_neighbors, amount_clusters, data_type):
amount = amount_clusters
if amount is None:
amount = 0
pointer_data = package_builder(sample, c_double).create()
c_data_type = convert_data_type(data_type)
ccore = ccore_library.get()
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), c_data_type)
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],
results[optics_package_indexer.OPTICS_PACKAGE_INDEX_OPTICS_OBJECTS_INDEX],
results[optics_package_indexer.OPTICS_PACKAGE_INDEX_OPTICS_OBJECTS_CORE_DISTANCE],
results[optics_package_indexer.OPTICS_PACKAGE_INDEX_OPTICS_OBJECTS_REACHABILITY_DISTANCE])
def cure_data_destroy(cure_data_pointer):
ccore = ccore_library.get();
ccore.cure_data_destroy(cure_data_pointer);
