def testEuclideanDistance(self):
point1 = [1, 2];
point2 = [1, 3];
point3 = [4, 6];
# Tests for euclidean_distance
assert euclidean_distance(point1, point2) == 1;
assert euclidean_distance(point1, point1) == 0;
assert euclidean_distance(point1, point3) == 5;
def testEuclideanDistance(self):
point1 = [1, 2]
point2 = [1, 3]
point3 = [4, 6]
# Tests for euclidean_distance
assert euclidean_distance(point1, point2) == 1
assert euclidean_distance(point1, point1) == 0
assert euclidean_distance(point1, point3) == 5
def __merge_clusters(self, cluster1, cluster2):
"""!
@brief Merges two clusters and returns new merged cluster. Representation points and mean points are calculated for the new cluster.
@param[in] cluster1 (cure_cluster): Cluster that should be merged.
@param[in] cluster2 (cure_cluster): Cluster that should be merged.
@return (cure_cluster) New merged CURE cluster.
"""
merged_cluster = cure_cluster(None, None);
merged_cluster.points = cluster1.points + cluster2.points;
merged_cluster.indexes = cluster1.indexes + cluster2.indexes;
# merged_cluster.mean = ( len(cluster1.points) * cluster1.mean + len(cluster2.points) * cluster2.mean ) / ( len(cluster1.points) + len(cluster2.points) );
dimension = len(cluster1.mean);
merged_cluster.mean = [0] * dimension;
if merged_cluster.points[1:] == merged_cluster.points[:-1]:
merged_cluster.mean = merged_cluster.points[0]
else:
for index in range(dimension):
merged_cluster.mean[index] = ( len(cluster1.points) * cluster1.mean[index] + len(cluster2.points) * cluster2.mean[index] ) / ( len(cluster1.points) + len(cluster2.points) );
temporary = list();
for index in range(self.__number_represent_points):
maximal_distance = 0;
maximal_point = None;
for point in merged_cluster.points:
minimal_distance = 0;
if (index == 0):
minimal_distance = euclidean_distance(point, merged_cluster.mean);
#minimal_distance = euclidean_distance_sqrt(point, merged_cluster.mean);
else:
minimal_distance = min([euclidean_distance(point, p) for p in temporary]);
#minimal_distance = cluster_distance(cure_cluster(point), cure_cluster(temporary[0]));
if (minimal_distance >= maximal_distance):
maximal_distance = minimal_distance;
maximal_point = point;
if (maximal_point not in temporary):
temporary.append(maximal_point);
for point in temporary:
representative_point = [0] * dimension;
for index in range(dimension):
representative_point[index] = point[index] + self.__compression * (merged_cluster.mean[index] - point[index]);
merged_cluster.rep.append(representative_point);
return merged_cluster;
def __merge_clusters(self, cluster1, cluster2):
"""!
@brief Merges two clusters and returns new merged cluster. Representation points and mean points are calculated for the new cluster.
@param[in] cluster1 (cure_cluster): Cluster that should be merged.
@param[in] cluster2 (cure_cluster): Cluster that should be merged.
@return (cure_cluster) New merged CURE cluster.
"""
merged_cluster = cure_cluster();
merged_cluster.points = cluster1.points + cluster2.points;
# merged_cluster.mean = ( len(cluster1.points) * cluster1.mean + len(cluster2.points) * cluster2.mean ) / ( len(cluster1.points) + len(cluster2.points) );
dimension = len(cluster1.mean);
merged_cluster.mean = [0] * dimension;
if merged_cluster.points[1:] == merged_cluster.points[:-1]:
merged_cluster.mean = merged_cluster.points[0]
else:
for index in range(dimension):
merged_cluster.mean[index] = ( len(cluster1.points) * cluster1.mean[index] + len(cluster2.points) * cluster2.mean[index] ) / ( len(cluster1.points) + len(cluster2.points) );
temporary = list(); # TODO: Set should be used in line with specification (article), but list is not hashable object therefore it's impossible to use list in this f*****g set!
for index in range(self.__number_represent_points):
maximal_distance = 0;
maximal_point = None;
for point in merged_cluster.points:
minimal_distance = 0;
if (index == 0):
minimal_distance = euclidean_distance(point, merged_cluster.mean);
#minimal_distance = euclidean_distance_sqrt(point, merged_cluster.mean);
else:
minimal_distance = euclidean_distance(point, temporary[0]);
#minimal_distance = cluster_distance(cure_cluster(point), cure_cluster(temporary[0]));
if (minimal_distance >= maximal_distance):
maximal_distance = minimal_distance;
maximal_point = point;
if (maximal_point not in temporary):
temporary.append(maximal_point);
for point in temporary:
representative_point = [0] * dimension;
for index in range(dimension):
representative_point[index] = point[index] + self.__compression * (merged_cluster.mean[index] - point[index]);
merged_cluster.rep.append(representative_point);
return merged_cluster;
def __merge_clusters(self, cluster1, cluster2):
"""!
@brief Merges two clusters and returns new merged cluster. Representation points and mean points are calculated for the new cluster.
@param[in] cluster1 (cure_cluster): Cluster that should be merged.
@param[in] cluster2 (cure_cluster): Cluster that should be merged.
@return (cure_cluster) New merged CURE cluster.
"""
merged_cluster = cure_cluster();
merged_cluster.points = cluster1.points + cluster2.points;
# merged_cluster.mean = ( len(cluster1.points) * cluster1.mean + len(cluster2.points) * cluster2.mean ) / ( len(cluster1.points) + len(cluster2.points) );
dimension = len(cluster1.mean);
merged_cluster.mean = [0] * dimension;
if merged_cluster.points[1:] == merged_cluster.points[:-1]:
merged_cluster.mean = merged_cluster.points[0]
else:
for index in range(dimension):
merged_cluster.mean[index] = ( len(cluster1.points) * cluster1.mean[index] + len(cluster2.points) * cluster2.mean[index] ) / ( len(cluster1.points) + len(cluster2.points) );
temporary = list(); # TODO: Set should be used in line with specification (article), but list is not hashable object therefore it's impossible to use list in this f*****g set!
for index in range(self.__number_represent_points):
maximal_distance = 0;
maximal_point = None;
for point in merged_cluster.points:
minimal_distance = 0;
if (index == 0):
minimal_distance = euclidean_distance(point, merged_cluster.mean);
#minimal_distance = euclidean_distance_sqrt(point, merged_cluster.mean);
else:
minimal_distance = euclidean_distance(point, temporary[0]);
#minimal_distance = cluster_distance(cure_cluster(point), cure_cluster(temporary[0]));
if (minimal_distance >= maximal_distance):
maximal_distance = minimal_distance;
maximal_point = point;
if (maximal_point not in temporary):
temporary.append(maximal_point);
for point in temporary:
representative_point = [0] * dimension;
for index in range(dimension):
representative_point[index] = point[index] + self.__compression * (merged_cluster.mean[index] - point[index]);
merged_cluster.rep.append(representative_point);
return merged_cluster;
def __calc_distance_to_nearest_center(self, data, centers):
"""!
@brief Calculates distance from each data point to nearest center.
@param[in] data (list): List of points where each point is represented by list of coordinates.
@param[in] centers (list): List of points that represents centers and where each center is represented by list of coordinates.
@return (list) List of distances to closest center for each data point.
"""
# Initialize
distance_data = [];
# For each data point x, compute D(x), the distance between x and the nearest center
for _point in data:
# Min dist to nearest center
min_dist = float('inf');
# For each center
for _center in centers:
min_dist = min(min_dist, euclidean_distance(_center, _point));
# Add distance to nearest center into result list
distance_data.append(min_dist);
return distance_data;
def __minimum_noiseless_description_length(self, clusters, centers):
"""!
@brief Calculates splitting criterion for input clusters using minimum noiseless description length criterion.
@param[in] clusters (list): Clusters for which splitting criterion should be calculated.
@param[in] centers (list): Centers of the clusters.
@return (double) Returns splitting criterion in line with bayesian information criterion.
Low value of splitting cretion means that current structure is much better.
@see __bayesian_information_criterion(clusters, centers)
"""
scores = float('inf')
W = 0.0
K = len(clusters)
N = 0.0
sigma_sqrt = 0.0
alpha = 0.9
betta = 0.9
for index_cluster in range(0, len(clusters), 1):
Ni = len(clusters[index_cluster])
if (Ni == 0):
return float('inf')
Wi = 0.0
for index_object in clusters[index_cluster]:
# euclidean_distance_sqrt should be used in line with paper, but in this case results are
# very poor, therefore square root is used to improved.
Wi += euclidean_distance(self.__pointer_data[index_object],
centers[index_cluster])
sigma_sqrt += Wi
W += Wi / Ni
N += Ni
if (N - K > 0):
sigma_sqrt /= (N - K)
sigma = sigma_sqrt**0.5
Kw = (1.0 - K / N) * sigma_sqrt
Ks = (2.0 * alpha * sigma / (N**0.5)) * (
(alpha**2.0) * sigma_sqrt / N + W - Kw / 2.0)**0.5
scores = sigma_sqrt * (2 * K)**0.5 * (
(2 * K)**0.5 + betta
) / N + W - sigma_sqrt + Ks + 2 * alpha**0.5 * sigma_sqrt / N
return scores
def __create_adjacency_matrix(self):
size_data = len(self.__pointer_data)
self.__adjacency_matrix = [[0 for i in range(size_data)]
for j in range(size_data)]
for i in range(0, size_data):
for j in range(i + 1, size_data):
distance = euclidean_distance(self.__pointer_data[i],
self.__pointer_data[j])
if (distance <= self.__eps):
self.__adjacency_matrix[i][j] = 1
self.__adjacency_matrix[j][i] = 1
def cluster_distances(path_sample, amount_clusters):
distances = [
'euclidian', 'manhattan', 'avr-inter', 'avr-intra', 'variance'
]
sample = utils.read_sample(path_sample)
agglomerative_instance = agglomerative(sample, amount_clusters)
agglomerative_instance.process()
obtained_clusters = agglomerative_instance.get_clusters()
print("Measurements for:", path_sample)
for index_cluster in range(len(obtained_clusters)):
for index_neighbor in range(index_cluster + 1, len(obtained_clusters),
1):
cluster1 = obtained_clusters[index_cluster]
cluster2 = obtained_clusters[index_neighbor]
center_cluster1 = utils.centroid(sample, cluster1)
center_cluster2 = utils.centroid(sample, cluster2)
for index_distance_type in range(len(distances)):
distance = None
distance_type = distances[index_distance_type]
if (distance_type == 'euclidian'):
distance = utils.euclidean_distance(
center_cluster1, center_cluster2)
elif (distance_type == 'manhattan'):
distance = utils.manhattan_distance(
center_cluster1, center_cluster2)
elif (distance_type == 'avr-inter'):
distance = utils.average_inter_cluster_distance(
cluster1, cluster2, sample)
elif (distance_type == 'avr-intra'):
distance = utils.average_intra_cluster_distance(
cluster1, cluster2, sample)
elif (distance_type == 'variance'):
distance = utils.variance_increase_distance(
cluster1, cluster2, sample)
print("\tDistance", distance_type, "from", index_cluster, "to",
index_neighbor, "is:", distance)
def __create_adjacency_matrix(self):
"""!
@brief Creates 2D adjacency matrix (list of lists) where each element described existence of link between points (means that points are neighbors).
"""
size_data = len(self.__pointer_data);
self.__adjacency_matrix = [ [ 0 for i in range(size_data) ] for j in range(size_data) ];
for i in range(0, size_data):
for j in range(i + 1, size_data):
distance = euclidean_distance(self.__pointer_data[i], self.__pointer_data[j]);
if (distance <= self.__eps):
self.__adjacency_matrix[i][j] = 1;
self.__adjacency_matrix[j][i] = 1;
def __create_adjacency_matrix(self):
"""!
@brief Creates 2D adjacency matrix (list of lists) where each element described existence of link between points (means that points are neighbors).
"""
size_data = len(self.__pointer_data)
self.__adjacency_matrix = [[0 for i in range(size_data)] for j in range(size_data)]
for i in range(0, size_data):
for j in range(i + 1, size_data):
distance = euclidean_distance(self.__pointer_data[i], self.__pointer_data[j])
if (distance <= self.__eps):
self.__adjacency_matrix[i][j] = 1
self.__adjacency_matrix[j][i] = 1
def _create_connections(self, radius):
"""!
@brief Create connections between oscillators in line with input radius of connectivity.
@param[in] radius (double): Connectivity radius between oscillators.
"""
if (self._ena_conn_weight is True):
self._conn_weight = [[0] * self._num_osc for index in range(0, self._num_osc, 1)];
maximum_distance = 0;
minimum_distance = float('inf');
# Create connections
for i in range(0, self._num_osc, 1):
for j in range(i + 1, self._num_osc, 1):
dist = euclidean_distance(self._osc_loc[i], self._osc_loc[j]);
if (self._ena_conn_weight is True):
self._conn_weight[i][j] = dist;
self._conn_weight[j][i] = dist;
if (dist > maximum_distance): maximum_distance = dist;
if (dist < minimum_distance): minimum_distance = dist;
if (dist <= radius):
if (self._conn_represent == conn_represent.LIST):
self._osc_conn[i].append(j);
self._osc_conn[j].append(i);
else:
self._osc_conn[i][j] = True;
self._osc_conn[j][i] = True;
if (self._ena_conn_weight is True):
multiplier = 1;
subtractor = 0;
if (maximum_distance != minimum_distance):
multiplier = (maximum_distance - minimum_distance);
subtractor = minimum_distance;
for i in range(0, self._num_osc, 1):
for j in range(i + 1, self._num_osc, 1):
value_conn_weight = (self._conn_weight[i][j] - subtractor) / multiplier;
self._conn_weight[i][j] = value_conn_weight;
self._conn_weight[j][i] = value_conn_weight;
def getCityDistance(self, result, object_locations, citiesDistRepresent):
visited_objects = [False] * len(result.object_sequence);
current_distance = 0.0;
for i in range(len(result.object_sequence)):
assert visited_objects[i] == False;
index1 = result.object_sequence[i];
index2 = result.object_sequence[(i + 1) % len(result.object_sequence)];
if citiesDistRepresent == wrapper.CITIES_DISTANCE_SET_BY_MATRIX:
current_distance += object_locations[index1][index2];
else:
current_distance += euclidean_distance(object_locations[index1], object_locations[index2]);
return current_distance
def _create_connections(self, radius):
"""!
@brief Create connections between oscillators in line with input radius of connectivity.
@param[in] radius (double): Connectivity radius between oscillators.
"""
if self._ena_conn_weight is True:
self._conn_weight = [[0] * self._num_osc
for _ in range(0, self._num_osc, 1)]
maximum_distance = 0
minimum_distance = float('inf')
# Create connections
for i in range(0, self._num_osc, 1):
for j in range(i + 1, self._num_osc, 1):
dist = euclidean_distance(self._osc_loc[i], self._osc_loc[j])
if self._ena_conn_weight is True:
self._conn_weight[i][j] = dist
self._conn_weight[j][i] = dist
if (dist > maximum_distance): maximum_distance = dist
if (dist < minimum_distance): minimum_distance = dist
if dist <= radius:
self.set_connection(i, j)
if self._ena_conn_weight is True:
multiplier = 1
subtractor = 0
if maximum_distance != minimum_distance:
multiplier = (maximum_distance - minimum_distance)
subtractor = minimum_distance
for i in range(0, self._num_osc, 1):
for j in range(i + 1, self._num_osc, 1):
value_conn_weight = (self._conn_weight[i][j] -
subtractor) / multiplier
self._conn_weight[i][j] = value_conn_weight
self._conn_weight[j][i] = value_conn_weight
def getCityDistance(self, result, object_locations, citiesDistRepresent):
visited_objects = [False] * len(result.object_sequence)
current_distance = 0.0
for i in range(len(result.object_sequence)):
assert not visited_objects[i]
index1 = result.object_sequence[i]
index2 = result.object_sequence[(i + 1) %
len(result.object_sequence)]
if citiesDistRepresent == wrapper.CITIES_DISTANCE_SET_BY_MATRIX:
current_distance += object_locations[index1][index2]
else:
current_distance += euclidean_distance(
object_locations[index1], object_locations[index2])
return current_distance
def __bayesian_information_criterion(self, clusters, centers):
"""!
@brief Calculates splitting criterion for input clusters using bayesian information criterion.
@param[in] clusters (list): Clusters for which splitting criterion should be calculated.
@param[in] centers (list): Centers of the clusters.
@return (double) Splitting criterion in line with bayesian information criterion.
High value of splitting cretion means that current structure is much better.
@see __minimum_noiseless_description_length(clusters, centers)
"""
scores = [0.0] * len(clusters) # splitting criterion
dimension = len(self.__pointer_data[0])
# estimation of the noise variance in the data set
sigma = 0.0
K = len(clusters)
N = 0.0
for index_cluster in range(0, len(clusters), 1):
for index_object in clusters[index_cluster]:
sigma += (euclidean_distance(self.__pointer_data[index_object],
centers[index_cluster]))
# It works
N += len(clusters[index_cluster])
if (N - K != 0):
sigma /= (N - K)
# splitting criterion
for index_cluster in range(0, len(clusters), 1):
n = len(clusters[index_cluster])
if (sigma > 0.0):
scores[index_cluster] = n * math.log(n) - n * math.log(
N) - n * math.log(
2.0 * numpy.pi) / 2.0 - n * dimension * math.log(
sigma) / 2.0 - (n - K) / 2.0
return sum(scores)
def __cluster_distance(self, cluster1, cluster2):
"""!
@brief Calculate minimal distance between clusters using representative points.
@param[in] cluster1 (cure_cluster): The first cluster.
@param[in] cluster2 (cure_cluster): The second cluster.
@return (double) Euclidean distance between two clusters that is defined by minimum distance between representation points of two clusters.
"""
distance = float('inf');
for i in range(0, len(cluster1.rep)):
for k in range(0, len(cluster2.rep)):
#dist = euclidean_distance_sqrt(cluster1.rep[i], cluster2.rep[k]); # Fast mode
dist = euclidean_distance(cluster1.rep[i], cluster2.rep[k]); # Slow mode
if (dist < distance):
distance = dist;
return distance;
def __cluster_distance(self, cluster1, cluster2):
"""!
@brief Calculate minimal distance between clusters using representative points.
@param[in] cluster1 (cure_cluster): The first cluster.
@param[in] cluster2 (cure_cluster): The second cluster.
@return (double) Euclidean distance between two clusters that is defined by minimum distance between representation points of two clusters.
"""
distance = float('inf');
for i in range(0, len(cluster1.rep)):
for k in range(0, len(cluster2.rep)):
#dist = euclidean_distance_sqrt(cluster1.rep[i], cluster2.rep[k]); # Fast mode
dist = euclidean_distance(cluster1.rep[i], cluster2.rep[k]); # Slow mode
if (dist < distance):
distance = dist;
return distance;
def __neighbor_indexes(self, optic_object):
"""!
@brief Return list of indexes of neighbors of specified point for the data.
@param[in] optic_object (optics_descriptor): Object for which neighbors should be returned in line with connectivity radius.
@return (list) List of indexes of neighbors in line the connectivity radius.
"""
neighbor_description = [];
for index in range(0, len(self.__sample_pointer), 1):
if (index == optic_object.index_object):
continue;
distance = euclidean_distance(self.__sample_pointer[optic_object.index_object], self.__sample_pointer[index]);
if (distance <= self.__eps):
neighbor_description.append( [index, distance] );
return neighbor_description;
def __neighbor_indexes(self, optic_object):
"""!
@brief Return list of indexes of neighbors of specified point for the data.
@param[in] optic_object (optics_descriptor): Object for which neighbors should be returned in line with connectivity radius.
@return (list) List of indexes of neighbors in line the connectivity radius.
"""
neighbor_description = [];
for index in range(0, len(self.__sample_pointer), 1):
if (index == optic_object.index_object):
continue;
distance = euclidean_distance(self.__sample_pointer[optic_object.index_object], self.__sample_pointer[index]);
if (distance <= self.__eps):
neighbor_description.append( [index, distance] );
return neighbor_description;
def cluster_distances(path_sample, amount_clusters):
distances = ['euclidian', 'manhattan', 'avr-inter', 'avr-intra', 'variance'];
sample = utils.read_sample(path_sample);
agglomerative_instance = agglomerative(sample, amount_clusters);
agglomerative_instance.process();
obtained_clusters = agglomerative_instance.get_clusters();
print("Measurements for:", path_sample);
for index_cluster in range(len(obtained_clusters)):
for index_neighbor in range(index_cluster + 1, len(obtained_clusters), 1):
cluster1 = obtained_clusters[index_cluster];
cluster2 = obtained_clusters[index_neighbor];
center_cluster1 = utils.centroid(sample, cluster1);
center_cluster2 = utils.centroid(sample, cluster2);
for index_distance_type in range(len(distances)):
distance = None;
distance_type = distances[index_distance_type];
if (distance_type == 'euclidian'):
distance = utils.euclidean_distance(center_cluster1, center_cluster2);
elif (distance_type == 'manhattan'):
distance = utils.manhattan_distance(center_cluster1, center_cluster2);
elif (distance_type == 'avr-inter'):
distance = utils.average_inter_cluster_distance(cluster1, cluster2, sample);
elif (distance_type == 'avr-intra'):
distance = utils.average_intra_cluster_distance(cluster1, cluster2, sample);
elif (distance_type == 'variance'):
distance = utils.variance_increase_distance(cluster1, cluster2, sample);
print("\tDistance", distance_type, "from", index_cluster, "to", index_neighbor, "is:", distance);
def __bayesian_information_criterion(self, clusters, centers):
"""!
@brief Calculates splitting criterion for input clusters using bayesian information criterion.
@param[in] clusters (list): Clusters for which splitting criterion should be calculated.
@param[in] centers (list): Centers of the clusters.
@return (double) Splitting criterion in line with bayesian information criterion.
High value of splitting cretion means that current structure is much better.
@see __minimum_noiseless_description_length(clusters, centers)
"""
scores = [0.0] * len(clusters) # splitting criterion
dimension = len(self.__pointer_data[0]);
# estimation of the noise variance in the data set
sigma = 0.0;
K = len(clusters);
N = 0.0;
for index_cluster in range(0, len(clusters), 1):
for index_object in clusters[index_cluster]:
sigma += (euclidean_distance(self.__pointer_data[index_object], centers[index_cluster])); # It works
N += len(clusters[index_cluster]);
if (N - K != 0):
sigma /= (N - K);
# splitting criterion
for index_cluster in range(0, len(clusters), 1):
n = len(clusters[index_cluster]);
if (sigma > 0.0):
scores[index_cluster] = n * math.log(n) - n * math.log(N) - n * math.log(2.0 * numpy.pi) / 2.0 - n * dimension * math.log(sigma) / 2.0 - (n - K) / 2.0;
return sum(scores);
def testFloatEuclideanDistance(self):
assert euclidean_distance(0.5, 1.5) == 1
assert self.float_comparasion(euclidean_distance(1.6, 1.4), 0.2)
assert self.float_comparasion(euclidean_distance(4.23, 2.14), 2.09)
def testFloatEuclideanDistance(self):
assert euclidean_distance(0.5, 1.5) == 1;
assert self.float_comparasion(euclidean_distance(1.6, 1.4), 0.2);
assert self.float_comparasion(euclidean_distance(4.23, 2.14), 2.09);
def display_two_dimensional_cluster_distances(path_sample, amount_clusters):
distances = [
'euclidian', 'manhattan', 'avr-inter', 'avr-intra', 'variance'
]
ajacency = [[0] * amount_clusters for i in range(amount_clusters)]
sample = utils.read_sample(path_sample)
agglomerative_instance = agglomerative(sample, amount_clusters)
agglomerative_instance.process()
obtained_clusters = agglomerative_instance.get_clusters()
stage = utils.draw_clusters(sample,
obtained_clusters,
display_result=False)
for index_cluster in range(len(ajacency)):
for index_neighbor_cluster in range(index_cluster + 1, len(ajacency)):
if ((index_cluster == index_neighbor_cluster) or
(ajacency[index_cluster][index_neighbor_cluster] is True)):
continue
ajacency[index_cluster][index_neighbor_cluster] = True
ajacency[index_neighbor_cluster][index_cluster] = True
cluster1 = obtained_clusters[index_cluster]
cluster2 = obtained_clusters[index_neighbor_cluster]
center_cluster1 = utils.centroid(sample, cluster1)
center_cluster2 = utils.centroid(sample, cluster2)
x_maximum, x_minimum, y_maximum, y_minimum = None, None, None, None
x_index_maximum, y_index_maximum = 1, 1
if (center_cluster2[0] > center_cluster1[0]):
x_maximum = center_cluster2[0]
x_minimum = center_cluster1[0]
x_index_maximum = 1
else:
x_maximum = center_cluster1[0]
x_minimum = center_cluster2[0]
x_index_maximum = -1
if (center_cluster2[1] > center_cluster1[1]):
y_maximum = center_cluster2[1]
y_minimum = center_cluster1[1]
y_index_maximum = 1
else:
y_maximum = center_cluster1[1]
y_minimum = center_cluster2[1]
y_index_maximum = -1
print("Cluster 1:", cluster1, ", center:", center_cluster1)
print("Cluster 2:", cluster2, ", center:", center_cluster2)
stage.annotate(s='',
xy=(center_cluster1[0], center_cluster1[1]),
xytext=(center_cluster2[0], center_cluster2[1]),
arrowprops=dict(arrowstyle='<->'))
for index_distance_type in range(len(distances)):
distance = None
distance_type = distances[index_distance_type]
if (distance_type == 'euclidian'):
distance = utils.euclidean_distance(
center_cluster1, center_cluster2)
elif (distance_type == 'manhattan'):
distance = utils.manhattan_distance(
center_cluster1, center_cluster2)
elif (distance_type == 'avr-inter'):
distance = utils.average_inter_cluster_distance(
cluster1, cluster2, sample)
elif (distance_type == 'avr-intra'):
distance = utils.average_intra_cluster_distance(
cluster1, cluster2, sample)
elif (distance_type == 'variance'):
distance = utils.variance_increase_distance(
cluster1, cluster2, sample)
print("\tCluster distance -", distance_type, ":", distance)
x_multiplier = index_distance_type + 3
if (x_index_maximum < 0):
x_multiplier = len(distances) - index_distance_type + 3
y_multiplier = index_distance_type + 3
if (y_index_maximum < 0):
y_multiplier = len(distances) - index_distance_type + 3
x_text = x_multiplier * (x_maximum - x_minimum) / (
len(distances) + 6) + x_minimum
y_text = y_multiplier * (y_maximum - y_minimum) / (
len(distances) + 6) + y_minimum
#print(x_text, y_text, "\n");
stage.text(x_text,
y_text,
distance_type + " {:.3f}".format(distance),
fontsize=9,
color='blue')
plt.show()
def display_two_dimensional_cluster_distances(path_sample, amount_clusters):
distances = ['euclidian', 'manhattan', 'avr-inter', 'avr-intra', 'variance'];
ajacency = [ [0] * amount_clusters for i in range(amount_clusters) ];
sample = utils.read_sample(path_sample);
agglomerative_instance = agglomerative(sample, amount_clusters);
agglomerative_instance.process();
obtained_clusters = agglomerative_instance.get_clusters();
stage = utils.draw_clusters(sample, obtained_clusters, display_result = False);
for index_cluster in range(len(ajacency)):
for index_neighbor_cluster in range(index_cluster + 1, len(ajacency)):
if ( (index_cluster == index_neighbor_cluster) or (ajacency[index_cluster][index_neighbor_cluster] is True) ):
continue;
ajacency[index_cluster][index_neighbor_cluster] = True;
ajacency[index_neighbor_cluster][index_cluster] = True;
cluster1 = obtained_clusters[index_cluster];
cluster2 = obtained_clusters[index_neighbor_cluster];
center_cluster1 = utils.centroid(sample, cluster1);
center_cluster2 = utils.centroid(sample, cluster2);
x_maximum, x_minimum, y_maximum, y_minimum = None, None, None, None;
x_index_maximum, y_index_maximum = 1, 1;
if (center_cluster2[0] > center_cluster1[0]):
x_maximum = center_cluster2[0];
x_minimum = center_cluster1[0];
x_index_maximum = 1;
else:
x_maximum = center_cluster1[0];
x_minimum = center_cluster2[0];
x_index_maximum = -1;
if (center_cluster2[1] > center_cluster1[1]):
y_maximum = center_cluster2[1];
y_minimum = center_cluster1[1];
y_index_maximum = 1;
else:
y_maximum = center_cluster1[1];
y_minimum = center_cluster2[1];
y_index_maximum = -1;
print("Cluster 1:", cluster1, ", center:", center_cluster1);
print("Cluster 2:", cluster2, ", center:", center_cluster2);
stage.annotate(s = '', xy = (center_cluster1[0], center_cluster1[1]), xytext = (center_cluster2[0], center_cluster2[1]), arrowprops = dict(arrowstyle = '<->'));
for index_distance_type in range(len(distances)):
distance = None;
distance_type = distances[index_distance_type];
if (distance_type == 'euclidian'):
distance = utils.euclidean_distance(center_cluster1, center_cluster2);
elif (distance_type == 'manhattan'):
distance = utils.manhattan_distance(center_cluster1, center_cluster2);
elif (distance_type == 'avr-inter'):
distance = utils.average_inter_cluster_distance(cluster1, cluster2, sample);
elif (distance_type == 'avr-intra'):
distance = utils.average_intra_cluster_distance(cluster1, cluster2, sample);
elif (distance_type == 'variance'):
distance = utils.variance_increase_distance(cluster1, cluster2, sample);
print("\tCluster distance -", distance_type, ":", distance);
x_multiplier = index_distance_type + 3;
if (x_index_maximum < 0):
x_multiplier = len(distances) - index_distance_type + 3;
y_multiplier = index_distance_type + 3;
if (y_index_maximum < 0):
y_multiplier = len(distances) - index_distance_type + 3;
x_text = x_multiplier * (x_maximum - x_minimum) / (len(distances) + 6) + x_minimum;
y_text = y_multiplier * (y_maximum - y_minimum) / (len(distances) + 6) + y_minimum;
#print(x_text, y_text, "\n");
stage.text(x_text, y_text, distance_type + " {:.3f}".format(distance), fontsize = 9, color='blue');
plt.show();
