def restart_clustering(self, w, p_a, parent_id):
""" restart network division after the state of submodule movement
and then restart the recursive clustering after
"""
QL = ql.Quality()
#print("##### start re-clustering for node id", parent_id)
node_list, module_list = self.__Tree.subtree2modulelist(parent_id)
#print("##### module list before\n",module_list)
w_part, pa_part, id_glo_loc = self.extract_partial_w_pa(
w.tocsr(), p_a, module_list)
#print("##### w_part pa_part check", w_part, pa_part, id_glo_loc)
# restart clustering from this state
restarted_cluster = cc.Cluster_Core(w_part, pa_part, node_list,
module_list)
# take new state of module list
module_list = restarted_cluster.get_modules()
restarted_cluster.set_nodes_global_id(id_glo_loc)
#print("##### module list after\n",module_list)
#modify the tree composition
self.__Tree.replace_subtree(parent_id, module_list)
ql_now = restarted_cluster.get_ql_final()
#ql_now = QL.get_hierarchical_quality_value(self.__Tree.get_tree_list(), self.glob_w, self.glob_pa)
return ql_now
def __init__(self, w, p_a):
# keep accesses to global w p_a
self.glob_w = w
self.glob_pa = p_a
# Initially clustring for two-levl
Two_level = cc.Cluster_Core(w, p_a)
# get clustring results
self.__nodes = Two_level.get_nodes()
self.__modules = Two_level.get_modules()
# get the final quality value
ql_first_division = Two_level.get_ql_final()
# advance division till no further splits are possible.
# then submodule and single node movement are done with Depth-First Searching order.
self.build_network_tree(w, p_a, self.__modules, ql_first_division)
def __init__(self, w, p_a):
# Initially clustring for two-level
Two_level = cc.Cluster_Core(w, p_a)
# get clustring results
self.__nodes = Two_level.get_nodes()
self.__modules = Two_level.get_modules()
# get the final quality value
ql_first_division = Two_level.get_ql_final()
print("ql initi val", ql_first_division)
if cf.modified_louvain == True:
print("============================================")
print("modified_louvain mode is selected.")
print("start recursive modules/submodules division.")
print("============================================")
self.build_network_tree(w, p_a, self.__modules, ql_first_division)
else:
self.ql_final = ql_first_division
def restart_clustering(self, w, p_a, parent_id):
""" restart network division after the state of submodule movement
and then restart the recursive clustering after
"""
node_list, module_list = self.__Tree.subtree2modulelist(parent_id)
w_part, pa_part, id_glo_loc = self.extract_partial_w_pa(
w.tocsr(), p_a, module_list)
# restart clustering from this state
restarted_cluster = cc.Cluster_Core(w_part, pa_part, node_list,
module_list)
# take new state of module list
module_list = restarted_cluster.get_modules()
restarted_cluster.set_nodes_global_id(id_glo_loc)
#modify the tree composition
self.__Tree.replace_subtree(parent_id, module_list)
ql_now = restarted_cluster.get_ql_final()
return ql_now
def one_level_finer(self, w, p_a, grand_parent_id, ql_init):
""" this function tries to expand each branch of the tree
by being called recursively
tree_elements, level
:
. ------------ grand parent
| \
. . -------- parent
|\ |\
. . . . ----- child
: : : :
"""
# initiation
QL = ql.Quality()
loop_count = 0
ql_best = ql_init
ql_now = None
store_tree = copy.deepcopy(self.__Tree.get_tree_list())
while loop_count < cf.num_trial:
# for fast conversion
if grand_parent_id != 0:
loop_count = cf.num_trial
queue_ids = copy.deepcopy(
self.__Tree.get_element_object(grand_parent_id).id_child)
while queue_ids:
# get the parent id of this branch
parent_id = queue_ids[0]
mod = self.__Tree.tree_ele2one_module(parent_id)
num_nodes = mod.get_num_nodes()
if num_nodes == 1: # module with only one member may not be divided anymore
pass
else:
# extract the partial w matrix and pa array
w_part, pa_part, id_glo_loc = self.extract_partial_w_pa(
w.tocsr(), p_a, mod)
sub_level = cc.Cluster_Core(w_part, pa_part)
# set global node ids
sub_level.set_nodes_global_id(id_glo_loc)
sub_modules = sub_level.get_modules()
if len(sub_modules) == 1 or len(sub_modules) == num_nodes:
pass
else:
# get quality value
ql_temp = sub_level.get_ql_final()
# append a branch to the tree
# register a new branch
self.__Tree.add_one_level(sub_modules, parent_id)
erased_id = self.one_level_finer(
w, p_a, parent_id, ql_temp)
# get quality value
#ql_temp = sub_level.get_ql_final()
#ql_temp = QL.get_hierarchical_quality_value(self.__Tree.get_tree_list(), self.glob_w, self.glob_pa)
# modify the queue list
if erased_id != None:
for i in range(len(queue_ids)):
ele_id = queue_ids[i]
if ele_id >= erased_id:
queue_ids[i] -= 1
# erase a queue already done
queue_ids.pop(0)
# reconstruct module_list from subtree
node_list, module_list = self.__Tree.subtree2modulelist(
grand_parent_id)
# restart clustering
ql_now = self.restart_clustering(w, p_a, grand_parent_id)
# if the quality of this subtree is imploved
if QL.check_network_got_better(ql_best, ql_now) == True:
ql_best = ql_now
## store and replace the state of the entire tree
store_tree = copy.deepcopy(self.__Tree.get_tree_list())
#self.final_store = copy.deepcopy(self.__Tree.get_tree_list())
else:
# go to the next loop
pass
loop_count += 1
#if grand_parent_id == 1: ######## for test
ql_global_temp = QL.get_hierarchical_quality_value(
self.__Tree.get_tree_list(), self.glob_w, self.glob_pa)
if QL.check_network_got_better(self.ql_global_best,
ql_global_temp) == True:
self.ql_global_best = ql_global_temp
self.final_store = copy.deepcopy(self.__Tree.get_tree_list())
if grand_parent_id == 0:
#print("ql_best", ql_best)
#print(store_tree)
self.__Tree.tree_draw_with_ete3(0, ql_now)
# erase "#" for indicate tree states at each step
#print( self.__Tree.print_tree())
#self.__Tree.tree_draw_with_ete3(0, ql_global_temp)
### end while loop
self.__Tree.set_tree_list(store_tree)
# reload the best state of tree
# sub module movement will be invoked
# when extention for one subtree stoped (need to )
if grand_parent_id != 0:
#print("finish all branches of this subtree finished")
#print("id", grand_parent_id, "will be erased")
self.submodule_movement_onesubtree(grand_parent_id)
erased_id = grand_parent_id
else:
#print("recursive tree branch extention finished")
self.__Tree.set_tree_list(self.final_store)
erased_id = None
#print("ql initial ---> best", ql_init, " ---> ",ql_best)
return erased_id