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)
