def get_information(file_path): # using target_MDG and a benchmark, create result
"""
Execute Each algorithm for given file and return TurboMQ, cohesion, and coupling
:param file_path: A path of dot file
:return: Clustering result - value of TurboMQ, A list of [Cohesion, Coupling], A list of result clusters
"""
targetMDG = make_target_MDG(file_path)
methods = ['WCA', 'HC', 'WCA_HC', 'SA', 'WCA_SA', 'PSO', 'WCA_PSO']
clusters_set = []
TMQ = []
cohe_coup = []
print("====WCA start====\n")
clusters_set.append(WCA(targetMDG))
print("====WCA end====\n\n")
print("====HC start====\n")
clusters_set.append(HC.HC(targetMDG))
print("====HC end====\n\n")
print("====WCA_HC start====\n")
clusters_set.append(HC.WCA_HC(targetMDG, WCA(targetMDG)))
print("====WCA_HC end====\n\n")
print("====SA start====\n")
clusters_set.append(SA.SA(targetMDG))
print("====SA end====\n\n")
print("====WCA_SA start====\n")
clusters_set.append(SA.WCA_SA(targetMDG, WCA(targetMDG)))
print("====WCA_SA end====\n\n")
print("====PSO start====\n\n")
clusters_set.append(PSO.PSO(targetMDG))
print("====PSO end====\n\n")
print("====WCA_PSO start====\n\n")
clusters_set.append(PSO.WCA_PSO(targetMDG, WCA(targetMDG)))
print("====WCA_PSO end====\n\n")
# get TMQ data
for clusters in clusters_set:
TMQ.append(TurboMQ.calculate_fitness(clusters, targetMDG))
cohe_coup.append(TurboMQ.get_cohesion_coupling(clusters, targetMDG))
# write result files
for i in range(len(methods)):
DotParser.write_file(file_path, methods[i], clusters_set[i], targetMDG)
return TMQ, cohe_coup, clusters_set
def __init__(self, targetMDG, Num_Cluster=-1, WCAresult=None):
self.graph = targetMDG
self.result = []
if WCAresult is None: # initialize clusters by random
if Num_Cluster == -1 or Num_Cluster > len(targetMDG.nodes):
for i in range(len(targetMDG.nodes)):
self.result.append(Cluster.Cluster())
for i in range(len(targetMDG.nodes)):
idx = random.randrange(0, len(self.result))
self.result[idx].add_node(targetMDG.nodes[i])
for cluster in self.result[:]:
if len(cluster.get_nodes()) == 0:
self.result.remove(cluster)
else:
for i in range(Num_Cluster):
self.result.append(Cluster.Cluster())
suffled_node = targetMDG.nodes[:]
random.shuffle(suffled_node)
list = range(0, len(targetMDG.nodes))
out = random.sample(list, Num_Cluster - 1)
out.sort()
cut = 0
for i in range(len(suffled_node)):
if cut < Num_Cluster - 1 and i >= out[cut]:
cut += 1
self.result[cut].add_node(suffled_node[i])
else: # based on WCA
self.result = WCAresult
self.score = TurboMQ.calculate_fitness(self.result, self.graph)
self.position = self.cluster_to_position_matrix()
self.velocity = [[0] * len(self.result)] * len(self.position)
self.lbest = self.result[:]
self.gbest = self.result[:]
def try_replace_node(self, node, from_idx, to_idx):
"""
Try to replace node between two clusters and give fitness score of result
:param node: Given node that wanted to remove to given cluster.
:param from_idx: An index of cluster based on self.result
:param to_idx: An index of cluster based on self.result
:return: Fitness score after replace node
"""
result = self.result[:]
target_cluster = result[from_idx]
target_cluster.remove_node(node)
if to_idx == len(result):
target_cluster = Cluster.Cluster()
result.append(target_cluster)
else:
target_cluster = result[to_idx]
target_cluster.add_node(node)
tried_score = TurboMQ.calculate_fitness(result, self.graph)
target_cluster = result[to_idx]
target_cluster.remove_node(node)
target_cluster = result[from_idx]
target_cluster.add_node(node)
return tried_score
def applyWCA(clusters, targetMDG):
"""
Apply WCA algorithm
:param clusters: A list of clusters that initialized
:param targetMDG: Dependency graph
:return: Maximum TurboMQ value and
"""
max_TurboMQ = 0
max_clusters = []
numofnodes = len(targetMDG.nodes)
count = 0
for i in range(numofnodes - 1): # clustering
c1, c2 = compare_similarity(clusters, targetMDG.nodes)
# print (c1.nodes)
# print (c2.nodes)
clusters = merge_cluster(
c1, c2, clusters,
targetMDG.nodes) # c1,c2�� merge�� clusters�� return
TMQ = TurboMQ.calculate_fitness(
clusters, targetMDG) # calculate TurboMQ of these clusters
if TMQ >= max_TurboMQ and TMQ != 1:
max_TurboMQ = TMQ
max_clusters = clusters[:]
count = 0
else:
count += 1
if count == 30:
print("TurboMQ = ", TurboMQ)
break
print("Interation " + str(i) + " : " + str(max_TurboMQ))
return max_TurboMQ, max_clusters
def update_lbest(self):
"""
Update local best particle of all iteration.
:return: None
"""
lbest_score = TurboMQ.calculate_fitness(self.lbest, self.graph)
if lbest_score < self.get_score():
self.lbest = self.result[:]
def replace_node(self, node, from_idx, to_idx):
"""
Replace given node between two clusters
:param node: Given node that wanted to remove to given cluster.
:param from_idx: An index of cluster based on self.result
:param to_idx: An index of cluster based on self.result
:return: None
"""
self.remove_node_to_cluster(from_idx, node)
self.add_node_to_cluster(to_idx, node)
self.score = TurboMQ.calculate_fitness(self.result, self.graph)
def update_gbest(self, others, k):
"""
Update global best particle of all iteration with k neighborhoods.
:param : others: list of all particles included self
:param : k: int, number of neighbors to be considered
:return: None
"""
neighborhoods = self.k_neighberhood(others, k)
gbest_score = TurboMQ.calculate_fitness(self.gbest, self.graph)
for position in neighborhoods:
if gbest_score < position.get_score():
self.gbest = position.result[:]
def __init__(self, targetMDG, WCAresult=None):
self.graph = targetMDG
self.result = []
if WCAresult is None: # initialize clusters by random
for i in range(len(targetMDG.nodes)):
self.result.append(Cluster.Cluster())
for node in targetMDG.nodes:
idx = random.randrange(0, len(self.result))
self.result[idx].add_node(node)
for cluster in self.result[:]:
if len(cluster.get_nodes()) == 0:
self.result.remove(cluster)
else: # based on WCA
self.result = WCAresult
self.score = TurboMQ.calculate_fitness(self.result, self.graph)
def update_score(self):
"""
Update score with fitness function(TurboMQ).
:return: None
"""
self.score = TurboMQ.calculate_fitness(self.result, self.graph)