def test_cuttree0(self): G = graph() nations_of_the_world(G) ct = cut_tree( G ) import pdb pdb.set_trace()
def test_cut_tree(self): #set up the graph (see example on wikipedia page for Gomory-Hu tree) gr = graph() gr.add_nodes([0,1,2,3,4,5]) gr.add_edge((0,1), wt=1) gr.add_edge((0,2), wt=7) gr.add_edge((1,3), wt=3) gr.add_edge((1,2), wt=1) gr.add_edge((1,4), wt=2) gr.add_edge((2,4), wt=4) gr.add_edge((3,4), wt=1) gr.add_edge((3,5), wt=6) gr.add_edge((4,5), wt=2) ct = cut_tree(gr) #check ct assert ct[(2,0)] == 8 assert ct[(4,2)] == 6 assert ct[(1,4)] == 7 assert ct[(3,1)] == 6 assert ct[(5,3)] == 8
def test_cut_tree(self): #set up the graph (see example on wikipedia page for Gomory-Hu tree) gr = graph() gr.add_nodes([0, 1, 2, 3, 4, 5]) gr.add_edge((0, 1), wt=1) gr.add_edge((0, 2), wt=7) gr.add_edge((1, 3), wt=3) gr.add_edge((1, 2), wt=1) gr.add_edge((1, 4), wt=2) gr.add_edge((2, 4), wt=4) gr.add_edge((3, 4), wt=1) gr.add_edge((3, 5), wt=6) gr.add_edge((4, 5), wt=2) ct = cut_tree(gr) #check ct assert ct[(2, 0)] == 8 assert ct[(4, 2)] == 6 assert ct[(1, 4)] == 7 assert ct[(3, 1)] == 6 assert ct[(5, 3)] == 8
def test_cut_tree_with_random_graph(self): gr = testlib.new_graph() ct = cut_tree(gr)
def test_cut_tree_with_empty_graph(self): gr = graph() ct = cut_tree(gr) assert ct == {}
def graph_features(self): """Generating topological features including vertice orders for future use.""" gr_nodes = self.gr.nodes() gr_edges = self.gr.edges() node_count = len(gr_nodes) edge_count = len(gr_edges) / 2.0 average_order = 0.0 clustering_coefficient = 0.0 max_order = 0 for each_node in gr_nodes: #for orders current_node_order = self.gr.node_order(each_node) average_order += current_node_order max_order = max(max_order, current_node_order) #now for clustering coefficient direct_neighbors = self.gr.neighbors(each_node) tmp_v_edge_count = 0.0 tmp_r_edge_count = 0.0 for virtual_edge in itertools.product(direct_neighbors, direct_neighbors): if virtual_edge[0] != virtual_edge[1]: tmp_v_edge_count += 1.0 if self.gr.has_edge(tuple(virtual_edge)): tmp_r_edge_count += 1.0 if tmp_v_edge_count == 0: clustering_coefficient += 0.0 else: clustering_coefficient += (tmp_r_edge_count / tmp_v_edge_count) clustering_coefficient /= float(node_count) average_order /= float(node_count) #for kernel order cut_dict = cut_tree(self.gr) cut_places = set(cut_dict.values()) how_many_kernel_orders = list(range(5)) kernel_orders = [] bloods = 0.0 for kernel_tick in how_many_kernel_orders: if kernel_tick in cut_places: bloods += 1.0 kernel_orders.append(bloods) #for redundant edges and missing edges redundant_edges = 0.0 missing_edges = 0.0 for each_edge in gr_edges: node0 = each_edge[0] node1 = each_edge[1] #find common set of nodes' neighbors common_set = set(self.gr.neighbors(node0)).intersection( set(self.gr.neighbors(node1))) if len(common_set) == 0: missing_edges += 1.0 elif len(common_set) > 1: in_cell_edges = list( itertools.combinations(list(common_set), 2)) cell_judge = True for cell_edge in in_cell_edges: if self.gr.has_edge(cell_edge): cell_judge = False if cell_judge == False: redundant_edges += 1.0 if edge_count != 0.0: redundant_edges /= float(edge_count) missing_edges /= float(edge_count) #average edge lenghth total_length = 0.0 for each_edge in gr_edges: node0 = each_edge[0] node1 = each_edge[1] total_length += sqrt( sum((self.nodes[node0] - self.nodes[node1])**2)) if len(gr_edges) == 0: average_length = 0.0 else: average_length = total_length / float(len(gr_edges)) return [ average_length, node_count, edge_count, average_order, max_order, redundant_edges, missing_edges ] + kernel_orders
def group(setN, gr, write_mark, minimum_cluster, alpha): ## print gr ## print write_mark N = len(setN) ## print N density = zeros(N) for i in range(N): distances = 0.0 neighbor_set = gr.neighbors(i) for each_node in neighbor_set: tmp_d = setN[i] - setN[each_node] distances += sqrt(inner(tmp_d, tmp_d)) if distances == 0.0 or len(neighbor_set) == 0: ## print i,N,'in the pool' ## raw_input('ISB..') distances = 0.0 else: ## print distances,float(len(neighbor_set)) distances = distances / float(len(neighbor_set)) density[i] = 1.0 / pow(1 + distances, 2.0) density_copy = deepcopy(density) ## print density #* 1 * remain_set = set(range(N)) clusters = {} for i in range(N): if is_max(i, gr, density): clusters[i] = i remain_set.remove(i) density_copy[i] = -1 ## print 'remaining set',len(remain_set) #* 2 * while len(remain_set) > 0: unlabeled_max = argmax(density_copy) density_copy[unlabeled_max] = -1 #* 3 * neighbor_set = gr.neighbors(unlabeled_max) tmp_density = density[neighbor_set] label_index = neighbor_set[argmax(tmp_density)] clusters[unlabeled_max] = clusters[label_index] remain_set.remove(unlabeled_max) #algorithm 2 #find boundary edges cluster_centers = clusters.values() ## print len(cluster_centers),cluster_centers borders = [] for each_edge in gr.edges(): if clusters[each_edge[0]] != clusters[each_edge[1]]: if each_edge[0] < each_edge[1]: borders.append(each_edge) #find big clusters connected_groups = connected_components(gr) group_count = len(set(connected_groups.values())) big_cluster_head = [] tmp_set_appeared = set([]) for head, group_index in connected_groups.items(): if group_index not in tmp_set_appeared: big_cluster_head.append(head) tmp_set_appeared.add(group_index) #construct edge set heads_tails = accessibility(gr) head_and_tail = {} for head, tail in heads_tails.items(): if head in big_cluster_head: head_and_tail[connected_groups[head]] = tail #tresholds of the super clusters Gc = {} for head, tail in head_and_tail.items(): tmp_tresh = 0.0 count = 0.0 for each_edge in itertools.combinations(tail, 2): if gr.has_edge(each_edge): count += 1.0 tmp_tresh += abs(density[each_edge[0]] - density[each_edge[1]]) if count == 0.0: ## print('sigularity') Gc[head] = 0.0 else: Gc[head] = alpha * tmp_tresh / count #* 2 * ## print 'group,tresh',borders,Gc while len(borders) > 0: ## print borders,'borders' current_border = borders.pop() Dab = max(density[current_border[0]], density[current_border[1]]) Dca = density[clusters[current_border[0]]] Dcb = density[clusters[current_border[1]]] Gtresh = Gc[connected_groups[current_border[0]]] ## print Dca - Dab,Dcb - Dab,Gtresh,'x' if connected_groups[current_border[0]] != connected_groups[ current_border[1]]: raw_input('there be a problem') if ((Dca - Dab < Gtresh) | (Dcb - Dab < Gtresh)) == False: clusterA = clusters[current_border[0]] clusterB = clusters[current_border[1]] ## print gr,'sb' gr.del_edge(current_border) tmp_borders = deepcopy(borders) for each_edge in tmp_borders: if (clusters[each_edge[0]] == clusterA and clusters[each_edge[1]] == clusterB) or ( clusters[each_edge[1]] == clusterA and clusters[each_edge[0]] == clusterB): ## raw_input('del') gr.del_edge(each_edge) borders.remove(each_edge) ## out_cast = [] ## for i in range(len(setN)): ## if gr.neighbors(i) == 0: ## out_cast.append(i) ## for isolation in out_cast: ## gr.del_node(isolation) ## setN.remove(isolation) ## print len(setN) ## print write_mark if write_mark: connected_groups = connected_components(gr) group_count = len(set(connected_groups.values())) if minimum_cluster > group_count: grade = minimum_cluster - group_count from pygraph.algorithms.minmax import cut_tree yourcut = cut_tree(gr) ## print 'cut tree',yourcut.values(),grade yourset = yourcut.values() for i in range(grade): print min(yourset) yourset.remove(min(yourset)) max_degree = min(yourset) ## print max_degree,yourset for edge_name, cut_degree in yourcut.items(): if (cut_degree < max_degree + 1) and (gr.has_edge(edge_name)): ## print edge_name gr.del_edge(edge_name) print 'cluster break x 1', edge_name
def test_cut_tree_with_random_graph(self): gr = testlib.new_graph() ct = cut_tree(gr)
def test_cut_tree_with_empty_graph(self): gr = graph() ct = cut_tree(gr) assert ct == {}