def get_resource_allocation_matrix(graph): ''' Gets the resource allocation matrix W_ij, which represents the the fraction of resoure the jth X node transfers to the ith. w_ij = (1 / k(x_j)) * sum_l((a_il * a_jl) / k(y_l) where the indices, l, represent the nodes for each track. ''' degree_dict = nx.degree(graph) track_nodes, _ = bipartite.sets(graph) matrix = {} number_of_permutations = int(perm(len(track_nodes), 2)) for i, (track_i, track_j) in enumerate(itertools.permutations(track_nodes, 2)): if i % 1e6 == 0: print 'working on user perumation {} of {}'.format( i + 1, number_of_permutations) summation_term = 0. user_nodes = set(graph.neighbors(track_i)) | set( graph.neighbors(track_j)) for user_l in user_nodes: summation_term += (float(graph.has_edge(track_i, user_l)) * graph.has_edge(track_j, user_l) / degree_dict[user_l]) matrix[track_i, track_j] = summation_term / degree_dict[track_j] return matrix
def gen_setcover_inst(G): constant_add = len(G) print(" const add ", constant_add) node_list_A = list(set(G.nodes())) node_list_B = [x + constant_add for x in list(set(G.nodes()))] g = nx.Graph() g.add_nodes_from(node_list_A, bipartite=0) g.add_nodes_from(node_list_B, bipartite=1) # for i in range(total_nodes): for (v1, v2) in G.edges(): if (v1 == v2): continue g.add_edge(v1, v2 + constant_add) g.add_edge(v1 + constant_add, v2) # g.remove_nodes_from(list(nx.isolates(g))) set_nodes, element_nodes = bipartite.sets(g) set_nodes = list(set_nodes) element_nodes = list(element_nodes) print(len(set_nodes), len(element_nodes)) return g
def graph_att_head(M, N, weight, ax, title): "credit: Jinjing zhou" in_nodes = len(M) out_nodes = len(N) g = nx.bipartite.generators.complete_bipartite_graph(in_nodes, out_nodes) X, Y = bipartite.sets(g) height_in = 10 height_out = height_in height_in_y = np.linspace(0, height_in, in_nodes) height_out_y = np.linspace((height_in - height_out) / 2, height_out, out_nodes) pos = dict() pos.update((n, (1, i)) for i, n in zip(height_in_y, X)) # put nodes from X at x=1 pos.update((n, (3, i)) for i, n in zip(height_out_y, Y)) # put nodes from Y at x=2 ax.axis('off') ax.set_xlim(-1, 4) ax.set_title(title) nx.draw_networkx_nodes(g, pos, nodelist=range(in_nodes), node_color='r', node_size=50, ax=ax) nx.draw_networkx_nodes(g, pos, nodelist=range(in_nodes, in_nodes + out_nodes), node_color='b', node_size=50, ax=ax) for edge in g.edges(): nx.draw_networkx_edges(g, pos, edgelist=[edge], width=weight[edge[0], edge[1] - in_nodes] * 1.5, ax=ax) nx.draw_networkx_labels(g, pos, {i: label + ' ' for i, label in enumerate(M)}, horizontalalignment='right', font_size=8, ax=ax) nx.draw_networkx_labels(g, pos, {i + in_nodes: ' ' + label for i, label in enumerate(N)}, horizontalalignment='left', font_size=8, ax=ax)
def is_planar(G): """ function checks if graph G has K(5) or K(3,3) as minors, returns True /False on planarity and nodes of "bad_minor" """ result = True bad_minor = [] n = len(G.nodes()) if n > 5: for subnodes in it.combinations(G.nodes(), 6): subG = G.subgraph(subnodes) if bipartite.is_bipartite( G): # check if the graph G has a subgraph K(3,3) X, Y = bipartite.sets(G) if len(X) == 3: result = False bad_minor = subnodes if n > 4 and result: for subnodes in it.combinations(G.nodes(), 5): subG = G.subgraph(subnodes) if len(subG.edges() ) == 10: # check if the graph G has a subgraph K(5) result = False bad_minor = subnodes return result, bad_minor
def create_3comms_bipartite(n,m,p,No_isolates=True): import community as comm from networkx.algorithms import bipartite as bip u=0 while True: G=nx.bipartite_random_graph(n,m,p) list_of_isolates=nx.isolates(G) if No_isolates: G.remove_nodes_from(nx.isolates(G)) partition=comm.best_partition(G) sel=max(partition.values()) if sel==2 and nx.is_connected(G): break u+=1 print u,sel ndlss=bip.sets(G) ndls=[list(i) for i in ndlss] slayer1=ndls[0] slayer2=ndls[1] layer1=[i for i,v in partition.items() if v==0] layer2=[i for i,v in partition.items() if v==1] layer3=[i for i,v in partition.items() if v==2] edgeList=[] for e in G.edges(): if (e[0] in slayer1 and e[1] in slayer2) or (e[0] in slayer2 and e[1] in slayer1): edgeList.append(e) return G,layer1,layer2,layer3,slayer1,slayer2,edgeList,partition
def clusterConstrained(dupes, threshold=0.6): dupe_graph = networkx.Graph() dupe_graph.add_weighted_edges_from(((x[0], x[1], y) for (x, y) in dupes), bipartite=1) dupe_sub_graphs = connected_component_subgraphs(dupe_graph) clusters = [] for sub_graph in dupe_sub_graphs: if len(sub_graph) > 2: row_order, col_order = bipartite.sets(sub_graph) row_order, col_order = list(row_order), list(col_order) scored_pairs = numpy.asarray(biadjacency_matrix(sub_graph, row_order, col_order)) scored_pairs[scored_pairs < threshold] = 0 scored_pairs = 1 - scored_pairs m = _Hungarian() clustering = m.compute(scored_pairs) cluster = [set([row_order[l[0]], col_order[l[1]]]) for l in clustering if len(l) > 1] clusters = clusters + cluster else: clusters.append(set(sub_graph.edges()[0])) return clusters
def plot_helper(inst, repos, countries): df = pd.read_csv(diffusion_graph_dir+'epoch_0.tsv', sep='\t').dropna() tweets = df.copy().drop('target_url', axis=1).drop_duplicates('source_url') #beutify country names tweets = tweets.merge(pd.read_csv(countriesFile).rename(columns={'Name':'Country'}), left_on='user_country', right_on='Code').drop(['user_country', 'Code'], axis=1).set_index('source_url') tweets.loc[tweets['Country'] == 'United States', 'Country'] = 'USA' print('Initial Tweets:', len(tweets)) #Popularity inst.groupby('Institution').mean()['popularity'].sort_values(ascending=False)[:20] repos.groupby('Field').size().sort_values(ascending=False) inst.groupby('Institution').mean().plot.scatter(x='Score', y='popularity') corr = inst.groupby('Institution').mean()[['popularity', 'World Rank', 'National Rank', 'Alumni Employment', 'Publications', 'Influence', 'Citations', 'Broad Impact', 'Patents', 'Score']].corr() #sns.heatmap(corr, xticklabels=corr.columns.values, yticklabels=corr.columns.values) corr.iloc[0] #bipartite graph countries['Name'] = countries['Name'].map(lambda n: n+'_user') countries['Location'] = countries['Location'].map(lambda n: n+'_inst') B = nx.Graph() B.add_edges_from([(row['Name'], row['Location']) for _, row in countries.iterrows()]) plt.figure(figsize=(10,10)) X, Y = bipartite.sets(B) pos = dict() pos.update( (n, (1, i)) for i, n in enumerate(X) ) # put nodes from X at x=1 pos.update( (n, (2, i*4)) for i, n in enumerate(Y) ) # put nodes from Y at x=2 nx.draw(B, pos=pos, with_labels = True)
def main(): homens = dict() arquivoMen = open('men.txt', 'r') for linha in arquivoMen: h = linha.split(sep=':')[0] m = linha.split(sep=':')[1:][0] m = m.split(sep=',') for i in range(len(m)): m[i] = m[i].replace('\n', '').replace(',', '').strip() homens[h] = dict((k, 0) for k in m) arquivoMen.close() mulheres = dict() arquivoWomen = open('women.txt', 'r') for linha in arquivoWomen: m = linha.split(sep=':')[0] h = linha.split(sep=':')[1:][0] h = h.split(sep=',') for i in range(len(h)): h[i] = h[i].replace('\n', '').replace(',', '').strip() mulheres[m] = h arquivoWomen.close() edges = GaleShappley(homens, mulheres) print(edges) G = nx.Graph() node_color_map = list() for homem in homens: for mulher in homens[homem]: G.add_node(homem, bipartite=0, color='blue') G.add_node(mulher, bipartite=1, color='red') G.add_edge(homem, mulher, color='black') for edge in edges: G.nodes[edge]['color'] = 'red' G.nodes[edges[edge]]['color'] = 'blue' G.add_edge(edge, edges[edge], color='red') edges_color = [G[u][v]['color'] for u, v in G.edges()] node_color_map = [u[1]['color'] for u in G.nodes(data=True)] X, Y = bipartite.sets(G) pos = dict() pos.update((n, (1, i)) for i, n in enumerate(X)) # put nodes from X at x=1 pos.update((n, (2, i)) for i, n in enumerate(Y)) # put nodes from Y at x=2 nx.draw(G, with_labels=True, node_color=node_color_map, edge_color=edges_color, pos=pos) plt.savefig('grafo_gale.png')
def plot_initial_bgraph(G, subp=121): fig = plt.figure(num=1, figsize=(16, 12)) fig.add_subplot(subp) sets = bipartite.sets(G) pos = {} for i, v in enumerate(sets[0]): pos[v] = (0., i) for i, v in enumerate(sets[1]): pos[v] = (1, i) rr = nx.attribute_assortativity_coefficient(G, 'bipartite') s_title = 'Bipartite Graph\nAssortativity_coef(bipartition) = %.2f' % rr plt.title(s_title) #,{'size': '20'}) nx.draw_networkx_nodes(G, pos=pos, nodelist=list(sets[0]), node_color='grey', alpha=0.3) nx.draw_networkx_nodes(G, pos=pos, nodelist=list(sets[1]), node_color='gold') nx.draw_networkx_labels(G, pos=pos) nx.draw_networkx_edges(G, pos=pos, alpha=0.2) plt.axis("off") # plt.show() return pos, fig
def draw_bi(B, X=[], Y=[], color_map=None): #draw bipartite graph (if the is disconnected then nodes lists have to be provided) if nx.is_connected(B): X, Y = bipartite.sets(B) X = sorted(list(X)) Y = sorted(list(Y)) pos = dict() pos.update( (n, (1, i)) for i, n in enumerate(X)) # put nodes from X at x=1 pos.update( (n, (2, i)) for i, n in enumerate(Y)) # put nodes from Y at x=2 if color_map == None: nx.draw(B, pos=pos, with_labels=True) else: nx.draw(B, pos=pos, with_labels=True, color=color_map) plt.show() else: if len(X) == 0 or len(Y) == 0: return ("Graph is disconnected, please specify nodes sets") else: X = sorted(list(X)) Y = sorted(list(Y)) pos = dict() pos.update((n, (1, i)) for i, n in enumerate(X)) # put nodes from X at x=1 pos.update((n, (2, i)) for i, n in enumerate(Y)) # put nodes from Y at x=2 if color_map == None: nx.draw(B, pos=pos, with_labels=True) else: nx.draw(B, pos=pos, with_labels=True, color=color_map) plt.show()
def clusterConstrained(dupes, threshold=.6): dupe_graph = networkx.Graph() dupe_graph.add_weighted_edges_from(((x[0], x[1], y) for (x, y) in dupes), bipartite=1) dupe_sub_graphs = connected_component_subgraphs(dupe_graph) clusters = [] for sub_graph in dupe_sub_graphs: if len(sub_graph) > 2: row_order, col_order = bipartite.sets(sub_graph) row_order, col_order = list(row_order), list(col_order) scored_pairs = numpy.asarray( biadjacency_matrix(sub_graph, row_order, col_order)) scored_pairs[scored_pairs < threshold] = 0 scored_pairs = 1 - scored_pairs m = _Hungarian() clustering = m.compute(scored_pairs) cluster = [ set([row_order[l[0]], col_order[l[1]]]) for l in clustering if len(l) > 1 ] clusters = clusters + cluster else: clusters.append(set(sub_graph.edges()[0])) return clusters
def buildAffGraph(matrix, k): if not os.path.exists('graphs/'): os.makedirs('graphs/') num = len(matrix) B = nx.Graph() # Add nodes with the node attribute "bipartite" B.add_nodes_from(np.arange(1, num+1), bipartite=0) B.add_nodes_from(np.arange(num+1,num*2+1), bipartite=1) # Add edges only between nodes of opposite node sets for i in range(num): for j in range(num): B.add_edges_from([(i+1, num+j+1, {'weight': matrix[i,j]})]) color_map = [] for node in B: if node < num+1: color_map.append('blue') else: color_map.append('red') X, Y = bipartite.sets(B) pos = dict() pos.update( (n, (1, i)) for i, n in enumerate(X) ) # put nodes from X at x=1 pos.update( (n, (2, i)) for i, n in enumerate(Y) ) # put nodes from Y at x=2 nx.draw(B, pos, node_color=color_map, with_labels=True, font_weight='bold') labels = nx.get_edge_attributes(B,'weight') nx.draw_networkx_edge_labels(B, pos, edge_labels=labels) plt.savefig("graphs/aff{}.png".format(k+1)) plt.close() E = nx.algorithms.bipartite.matrix.biadjacency_matrix(B,np.arange(1, num+1)).todense()
def is_planar(G): """ function checks if graph G has K(5) or K(3,3) as minors, returns True /False on planarity and nodes of "bad_minor" """ result = True bad_minor = [] n = len(G.nodes()) iterazione = 0 if n > 5: print "N >5" for subnodes in it.combinations(G.nodes(), 6): iterazione += 1 print "iterazione %d" % iterazione subG = G.subgraph(subnodes) if bipartite.is_bipartite(G): # check if the graph G has a subgraph K(3,3) X, Y = bipartite.sets(G) if len(X) == 3: result = False bad_minor = subnodes return result, bad_minor iterazione = 0 if n > 4 and result: print "N >4" for subnodes in it.combinations(G.nodes(), 5): print "iterazione %d" % iterazione subG = G.subgraph(subnodes) if len(subG.edges()) == 10: # check if the graph G has a subgraph K(5) result = False bad_minor = subnodes return result, bad_minor return result, bad_minor
def _show_bipartite_circuit_graph(filename, graph, dir_path): no_of_subgraph = 0 for subgraph in nx.connected_component_subgraphs(graph): no_of_subgraph += 1 color_map = [] x_pos, y_pos = bipartite.sets(subgraph) pos = dict() pos.update((n, (1, i)) for i, n in enumerate(x_pos)) # put nodes from X at x=1 pos.update((n, (2, i)) for i, n in enumerate(y_pos)) # put nodes from Y at x=2 #nx.draw(B, pos=pos) #plt.show() plt.figure(figsize=(6, 8)) for dummy, attr in subgraph.nodes(data=True): if "inst_type" in attr: if attr["inst_type"] == 'pmos': color_map.append('red') elif attr["inst_type"] == 'nmos': color_map.append('cyan') elif attr["inst_type"] == 'cap': color_map.append('orange') elif attr["inst_type"] == 'net': color_map.append('pink') else: color_map.append('green') nx.draw(subgraph, node_color=color_map, with_labels=True, pos=pos) plt.title(filename, fontsize=20) if not os.path.exists(dir_path): os.mkdir(dir_path) plt.savefig(dir_path + '/' + filename + "_" + str(no_of_subgraph) + '.png') plt.close()
def generateDailyGraph(dateLi): myUsrDict = deepcopy(ReadData.usrDict); myMovDict = deepcopy(ReadData.movDict); gx = nx.Graph() users = [] movies = [] edges = [] for (uid, mid) in dateLi: # add vertex for user if it does not already exist if myUsrDict[uid][1] == 0: myUsrDict[uid][1] = 1; users.append(uid) # add vertex for movie if it does not already exist if myMovDict[mid][1] == 0: myMovDict[mid][1] = 1; movies.append(mid) edges.append((uid, mid)) gx.add_nodes_from(users, bipartite=0) gx.add_nodes_from(movies, bipartite=1) gx.add_edges_from(edges) nx.is_connected(gx) bottom_nodes, top_nodes = bipartite.sets(gx) return gx, bottom_nodes, top_nodes
def is_planar(G): """ function checks if graph G has K(5) or K(3,3) as minors, returns True /False on planarity and nodes of "bad_minor" """ result = True bad_minor = [] n = len(G.nodes()) if n > 5: for subnodes in it.combinations(G.nodes(), 6): subG = G.subgraph(subnodes) if subG.number_of_edges() >= 9: print "OI" if bipartite.is_bipartite( subG): # check if the graph G has a subgraph K(3,3) X, Y = bipartite.sets(subG) if len(X) == 3: result = False bad_minor = (X.pop(), X.pop(), X.pop(), Y.pop(), Y.pop(), Y.pop()) print[(names[i], names[j]) for i, j in subG.edges()] return result, bad_minor if n > 4 and result: for subnodes in it.combinations(G.nodes(), 5): subG = G.subgraph(subnodes) if len(subG.edges() ) == 10: # check if the graph G has a subgraph K(5) result = False bad_minor = subnodes return result, bad_minor return result, bad_minor
def complete_bipartite_graph_generation_and_dump_in_json(): nb_sommets = 15 seed = 29 n1 = random.randint(1, nb_sommets - 1) n2 = nb_sommets - n1 p = 0.5 g = bipartite.complete_bipartite_graph(n1, n2) V1, V2 = bipartite.sets(g) graph_for_json = dict() graph_for_json = { "seed": seed, "graph_type": "bipartite", "total_node_count": len(g.nodes), "V1_node_count": len(V1), "V2_node_count": len(V2), "edge_count": len(list(g.edges)), "nodes": sorted(g.nodes), "edges": list(g.edges) } with open('test_dumps/complete_bipartite_1.json', 'w', encoding='utf8') as json_file: json.dump(graph_for_json, json_file, indent=4) # Ugly indents with open('test_dumps/complete_bipartite_2.json', 'w', encoding='utf8') as json_file: json_file.write(data_to_json(graph_for_json)) # Nice indents
def weighted_projected_graph(self): # create a projection on one of the nodes E = bipartite.sets(self.B)[0] print('EEEEEEEEEEEEEEEEEEE') print(E) P = bipartite.weighted_projected_graph(self.B, E, ratio=True) # self.plot_graph(P,'weighted_projected') self.plot_graph_2(P, 'weighted_projected') print('weighted_projected:number of edges:', P.number_of_edges()) print(P.edges()) print(list(P.edges(data=True))) weights = [] for i in list(P.edges(data=True)): weights.append(i[2]['weight']) print(weights) P = bipartite.weighted_projected_graph(self.B, E, ratio=False) self.plot_graph_2(P, 'weighted_projected_not_ratio') print('RRRRRRRRRRRRRRRRRRRRRRRR') print(P.edges()) weights = [] for i in list(P.edges(data=True)): weights.append(i[2]['weight']) print(weights)
def get_valid_fragments(G, stoich_rank): #reactions, complexes = bipartite.sets(G) complexes, reactions = bipartite.sets(G) complexes = list(complexes) reactions = list(reactions) if 'w1' not in complexes and 'w1' not in reactions: raise Exception('my hack to resolve this unexpected behavior shown by bipartite.sets assumes that reaction nodes are named \'w1\', \'w2\', ...') if 'w1' in complexes: complexes, reactions = reactions, complexes if not ('w1' in reactions and 's1' in complexes): raise Exception('Something went wrong generating the lists of complexes of reactions.') complex_perms = list(it.combinations(complexes,stoich_rank)) reaction_perms = list(it.combinations_with_replacement(reactions,stoich_rank)) fragments = list(it.product(complex_perms, reaction_perms)) valid_fragments = [] pool = Pool() chunksize = 100 myval = functools.partial(validate_fragments, G, stoich_rank) fragment_list = pool.imap(myval, fragments, chunksize) valid_fragments = [f for f in fragment_list if f is not None] return get_unique_fragments(valid_fragments)
def test_tate_foundation_str_id(self, history_client): """Test basic query of Tate_Foundation board members.""" charity_network = get_charity_network("1085314", client=history_client) assert len(charity_network) == 15 assert is_connected(charity_network) tate_foundation, board_members = bipartite.sets(charity_network) assert len(board_members) == 14 assert type(list(tate_foundation)[0]) is int
def test_bipartite_density(self): G=nx.path_graph(5) X,Y=bipartite.sets(G) density=float(len(G.edges()))/(len(X)*len(Y)) assert_equal(bipartite.density(G,X),density) D = nx.DiGraph(G.edges()) assert_equal(bipartite.density(D,X),density/2.0) assert_equal(bipartite.density(nx.Graph(),{}),0.0)
def test_bipartite_density(self): G = nx.path_graph(5) X, Y = bipartite.sets(G) density = float(len(list(G.edges()))) / (len(X) * len(Y)) assert_equal(bipartite.density(G, X), density) D = nx.DiGraph(G.edges()) assert_equal(bipartite.density(D, X), density / 2.0) assert_equal(bipartite.density(nx.Graph(), {}), 0.0)
def generic_weighted_projected_graph(self): E = bipartite.sets(self.B)[0] P = bipartite.generic_weighted_projected_graph(self.B, E) self.plot_graph_2(P, 'generic_weighted_projected_graph') print('generic_weighted_projected_graph:number of edges:', P.number_of_edges()) print(P.edges()) print(list(P.edges(data=True)))
def test_1hop_tate(self, history_client): """Test 1 hop query of Tate_Foundation board members.""" charity_network = get_charity_network(1085314, branches=1, client=history_client) assert len(charity_network) == 73 assert is_connected(charity_network) tate_foundation, board_members = bipartite.sets(charity_network) assert len(board_members) == 64
def save_graph(c2map, filepath): graph = c2map['graph'] X, Y = bipartite.sets(graph) pos = dict() pos.update( (n, (1, i)) for i, n in enumerate(X) ) # put nodes from X at x=1 pos.update( (n, (2, i)) for i, n in enumerate(Y) ) # put nodes from Y at x=2 nx.draw(graph, pos=pos,with_labels=True) plt.savefig(filepath)
def main(): fname = os.path.join(dir.graphs_dir, "long-all-bipartite.edges") full_g = nx.read_edgelist(fname, delimiter=",", nodetype=str) if nx.is_bipartite(full_g): nois, followers = bipartite.sets(full_g) # bipartite graph projection g = projection.overlap_weighted_projected_graph(full_g, nodes=nois, jaccard=False) fname = os.path.join(dir.graphs_dir, "projection-full-graph.edgelist") nx.write_edgelist(g, fname, delimiter=',', data='weight')
def desenhar_bipartido(G, M = []): X, Y = bipartite.sets(G) pos = dict() pos.update((n, (1, i)) for i, n in enumerate(X)) pos.update((n, (2, i)) for i, n in enumerate(Y)) cores = pintar_arestas(G, M) nx.draw(G, with_labels = True, edge_color = cores, pos=pos) plt.show()
def save_graph(c2map, filepath): graph = c2map['graph'] X, Y = bipartite.sets(graph) pos = dict() pos.update((n, (1, i)) for i, n in enumerate(X)) # put nodes from X at x=1 pos.update((n, (2, i)) for i, n in enumerate(Y)) # put nodes from Y at x=2 nx.draw(graph, pos=pos, with_labels=True) plt.savefig(filepath)
def __init__(self, graph): self.graph = graph parameters = pywrapcp.Solver.DefaultSolverParameters() solver = pywrapcp.Solver("SetCover_CP", parameters) self.solver = solver self.sets, self.items = bipartite.sets(self.graph) self.set_variables = self.generate_set_variables() self.add_ge_sum_constraints()
def generic_recommendation(raw_graph, num_of_articles): articles_by_degree = [] for connected_component in nx.connected_components(raw_graph): connected_component = nx.subgraph(raw_graph, connected_component) users, articles = bipartite.sets(connected_component) articles_degree = filter(lambda node: node[0] in articles, connected_component.degree) articles_by_degree.extend( sorted(articles_degree, key=itemgetter(1), reverse=True)) articles, _ = zip(*articles_by_degree) return articles[:num_of_articles]
def projected_graph(self): if not self.B: self.create_bipartite_graph() bottom = bipartite.sets(self.B)[0] G = bipartite.generic_weighted_projected_graph( self.B, bottom, weight_function=self.projection_weight) return G
def __init__(self, sigma: Tuple[Tuple[int]], alpha: Tuple[Tuple[int]]): super().__init__() self.sigma = sigma # should include singletons corresponding to fixed points self.alpha = alpha # should include singletons corresponding to fixed points f = self.compute_phi() self.phi = self.permlist_to_tuple(f) self.build_node_info() # print dictionary for [sigma, alpha, phi] self.node_dict = self.sigma_dict, self.alpha_dict, self.phi_dict self.node_info = [ "sigma:", self.sigma_dict, "alpha:", self.alpha_dict, "phi:", self.phi_dict ] self.code_graph = nx.MultiGraph() # Create black nodes for each cycle in sigma along with white nodes # representing "half edges" around the black nodes for cycle in self.sigma: self.code_graph.add_node(cycle, bipartite=1) for node in cycle: self.code_graph.add_node(node, bipartite=0) self.code_graph.add_edge(cycle, node) # Create black nodes for each cycle in phi along with white nodes # representing "half edges" around the black nodes for cycle in self.phi: self.code_graph.add_node(cycle, bipartite=1) for node in cycle: self.code_graph.add_edge(cycle, node) # Create nodes for each cycle in alpha then # glue the nodes corresponding to a the pairs for pair in self.alpha: self.code_graph.add_node(pair) self.code_graph = nx.contracted_nodes(self.code_graph, pair[0], pair[1], self_loops=True) # Now contract pair with pair[0] to make sure edges (white nodes) are labeled # by the pairs in alpha to keep track of the gluing from the previous step self.code_graph = nx.contracted_nodes(self.code_graph, pair, pair[0], self_loops=True) # Define the white and black nodes. White correspond to edges labeled by # cycles in alpha. Black correspond to nodes labeled by cycles in sigma # (vertices) and phi (faces) self.black_nodes, self.white_nodes = bipartite.sets(self.code_graph) self.vertex_basis() self.edge_basis() self.face_basis() self.d_2() self.d_1()
def draw_bipartite_graph(G): X, Y = bipartite.sets(G) pos = dict() pos.update( (n, (1, i)) for i, n in enumerate(X) ) # put nodes from X at x=1 pos.update( (n, (2, i)) for i, n in enumerate(Y) ) # put nodes from Y at x=2 nx.draw(G, pos=pos, with_labels=True, font_size=8, node_size=1000) fig = plt.gcf() plt.tight_layout() fig.set_size_inches(148, 84) plt.savefig('bipartite-graph.png')
def plot_initial_graph(G): fig=plt.figure(num=1,figsize=(16,12)) sets=bipartite.sets(G) pos=nx.spring_layout(G) nx.draw_networkx_nodes(G,pos=pos,nodelist=list(sets[0]),node_color='grey',alpha=0.3) nx.draw_networkx_nodes(G,pos=pos,nodelist=list(sets[1]),node_color='gold') nx.draw_networkx_labels(G,pos=pos) nx.draw_networkx_edges(G,pos=pos,alpha=0.2) plt.axis("off") plt.show()
def answer_two(): B = answer_one() employee_nodes, movie_nodes = bipartite.sets(B) for node in employee_nodes: B.add_node( node, type = "employee") for node in movie_nodes: B.add_node(node , type = "movie") return B
def collaboration_weighted_projected_graph(self): E = bipartite.sets(self.B)[0] P = bipartite.collaboration_weighted_projected_graph(self.B, E) self.plot_graph_2(P, 'collaboration_weighted_projected') print('collaboration_weighted_projected:number of edges:', P.number_of_edges()) print(P.edges()) print(list(P.edges(data=True))) weights = [] for i in list(P.edges(data=True)): weights.append(i[2]['weight']) print(weights)
def splitBipartiteGexf(inputGexf, outputGexfPath): outputGexfPath = outputGexfPath + os.sep jr["input_gexf"] = inputGexf jr["outputGexfPath"] = outputGexfPath # otuput files xgexf = os.path.join(dirname(outputGexfPath), basename(splitext(inputGexf)[0])) + ".x.gexf" ygexf = os.path.join(dirname(outputGexfPath), basename(splitext(inputGexf)[0])) + ".y.gexf" try: graph = nx.readwrite.gexf.read_gexf(inputGexf) except: throwError("unable to read gexf file") return # bug in networkx, we need to make the directed graph as undirected graph = graph.to_undirected() jr["numOfNodes"] = len(graph.nodes()) jr["numOfEdges"] = len(graph.edges()) X, Y = bipartite.sets(graph) print "biparte.sets..." print X print Y #xgr=project_bipartite_graph(graph,X,"weight") xgr = bipartite.generic_weighted_projected_graph(graph, X) print "biparte.xgr..." print len(xgr.nodes()) print len(xgr.edges()) try: nx.readwrite.gexf.write_gexf(xgr, xgexf) except: throwError("unable to write file, path:'" + xgexf + "'") return #ygr=project_bipartite_graph(graph,Y,"weight") ygr = bipartite.generic_weighted_projected_graph(graph, Y) print "biparte.ygr..." print len(ygr.nodes()) print len(ygr.edges()) try: nx.readwrite.gexf.write_gexf(ygr, ygexf) except: throwError("unable to write file, path:'" + ygexf + "'") #print sys.exc_info() jr['output_gexf'] = [xgexf, ygexf] print "nodes in X", xgr.nodes() print "edges in X", list(xgr.edges()) print "nodes in Y", ygr.nodes()
def main(): G = initialize() user, business = node_initialize(G) user = list(set(user) & set(G.nodes())) business = list(set(business) & set(G.nodes())) G = make_bipartite(G, user, business) print nx.is_bipartite(G) G = list(nx.connected_component_subgraphs(G))[0] user, business = bipartite.sets(G) print "nodes separated" Gu = bipartite.projected_graph(G, user) print Gu.number_of_nodes()
def _getBipartition(G): topSet, botSet = bipartite.sets(G) topSet, botSet = list(topSet), list(botSet) topIndices, botIndices = [], [] V = G.nodes() for i in range(G.order()): if V[i] in topSet: topIndices.append(i) else: botIndices.append(i) #print "Computed bipartition." return topIndices, botIndices
def plot_graph(G): X,Y=bipartite.sets(G) pos = dict() pos.update( (n, (1, i)) for i, n in enumerate(X) ) # put nodes from X at x=1 pos.update( (n, (2, i)) for i, n in enumerate(Y) ) # put nodes from Y at x=2 networkx.draw(G, pos=pos, with_labels=False) labels = {} for node in G.nodes(): labels[node] = node networkx.draw_networkx_labels(G, pos, labels) plt.show()
def splitBipartiteGexf( inputGexf, outputGexfPath ): outputGexfPath = outputGexfPath + os.sep jr["input_gexf"] = inputGexf jr["outputGexfPath"] = outputGexfPath # otuput files xgexf = os.path.join( dirname( outputGexfPath ), basename( splitext( inputGexf )[0] ) )+".x.gexf" ygexf = os.path.join( dirname( outputGexfPath ), basename( splitext( inputGexf )[0] ) )+".y.gexf" try: graph = nx.readwrite.gexf.read_gexf( inputGexf ); except: throwError( "unable to read gexf file" ) return # bug in networkx, we need to make the directed graph as undirected graph=graph.to_undirected() jr["numOfNodes"] = len( graph.nodes() ) jr["numOfEdges"] = len( graph.edges() ) X,Y=bipartite.sets(graph) print "biparte.sets..." print X print Y #xgr=project_bipartite_graph(graph,X,"weight") xgr=bipartite.generic_weighted_projected_graph(graph,X) print "biparte.xgr..." print len(xgr.nodes()) print len(xgr.edges()) try: nx.readwrite.gexf.write_gexf(xgr, xgexf ) except: throwError( "unable to write file, path:'" + xgexf + "'" ) return #ygr=project_bipartite_graph(graph,Y,"weight") ygr=bipartite.generic_weighted_projected_graph(graph,Y) print "biparte.ygr..." print len(ygr.nodes()) print len(ygr.edges()) try: nx.readwrite.gexf.write_gexf(ygr, ygexf ) except: throwError( "unable to write file, path:'" + ygexf + "'" ) #print sys.exc_info() jr['output_gexf'] = [ xgexf, ygexf ] print "nodes in X", xgr.nodes() print "edges in X", list( xgr.edges() ) print "nodes in Y", ygr.nodes()
def get_bipartite_sets(G): complexes, reactions = bipartite.sets(G) # some unexpected behaviour that networkx shows: # sometimes 'complexes' and 'reactions' get swapped around by bipartite.sets # this seems to happen for larger reaction networks if 'w1' not in complexes and 'w1' not in reactions: raise Exception('my hack to resolve this unexpected behavior shown by bipartite.sets assumes that reaction nodes are named \'w1\', \'w2\', ...') if 'w1' in complexes: return reactions, complexes else: return complexes, reactions
def get_check_nodes(self,encoded_Graph): cur_src_node_set, cur_encoded_node_set = bipartite.sets(encoded_Graph) cur_encoded_node_list = list(cur_encoded_node_set) num_recovered_packets = self.total_src_packets - len(cur_src_node_set) #find check nodes in the graph check_node_list =[] for j in cur_encoded_node_list: if encoded_Graph.degree(j) == 1 : check_node_list.append(j) #print j return check_node_list, num_recovered_packets
def draw_graph(G): pos=nx.spring_layout(G) # positions for all nodes cnodes,unodes = bipartite.sets(G) nx.draw_networkx_nodes(G,pos,nodelist=cnodes,node_color='r') nx.draw_networkx_nodes(G,pos,nodelist=unodes,node_color='w') # nx.draw_networkx_edges(G,pos) pos2 = copy.deepcopy(pos) for d in pos: pos2[d][1] = pos[d][1] - 0.02 nx.draw_networkx_labels(G,pos2) plt.axis('off') plt.show()
def getDivFieldEdgeWeight_list(): df_biparG = nx.Graph() df_biparG.add_nodes_from([x['div_id'] for x in _league_div], bipartite=0) # even through we are using a bipartite graph structure, node names between # the column nodes need to be distinct, or else edge (1,2) and (2,1) are not distinguished. # instead use edge (1, f2), (2, f1) - use 'f' prefix for field nodes df_biparG.add_edges_from([(x['div_id'],'f'+str(y)) for x in _league_div for y in x['divfield_list']]) div_nodes, field_nodes = bipartite.sets(df_biparG) deg_fnodes = {f:df_biparG.degree(f) for f in field_nodes} # effective edge sum lists for each division, the sum of the weights of the connected fields; # the weights of the associated fields, which are represented as field nodes, # are in turn determined by it's degree. The inverse of the degree for the connected division is # taken, which becomes the weight of the particular field associated with the division. The weights # of each field are summed for each division. The weights also represent the 'total fairness share' # of fields associated with a division. # Bipartite graph representations, with divisions as one set of nodes, and fields as the other set # are used. Thus a neighbor of a division is always a field. edgesum_list = [{'div_id':d, 'edgesum': sum([1.0/deg_fnodes[f] for f in df_biparG.neighbors(d)])} for d in div_nodes] sorted_edgesum_list = sorted(edgesum_list, key=itemgetter('div_id')) logging.debug("div fields bipartite graph %s %s effective edge sum for each node %s", df_biparG.nodes(), df_biparG.edges(), sorted_edgesum_list) # depending on the number of teams in each division, the 'fairness share' for each division is adjusted; # i.e. a division with more teams is expected to contribute a larger amount to field sharing obligations, # such as the number of expected early/late start times for a particular division. (If one div has 20 teams # and the other connected div has only 10 teams, the 20-team division should have a larger share of filling # early and late start time games. div_indexer = dict((p['div_id'],i) for i,p in enumerate(_league_div)) # ratio is represented as factor that is multiplied against the 'expected' fair share, which is the 1-inverse # of the number of divisions in the connected group - (dividing by the 1-inverse is equiv to multiple by the # number of teams - len(connected_list) as shown below) divratio_list = [{'div_id':x, 'ratio': len(connected_list)*float(_league_div[div_indexer.get(x)]['totalteams'])/ sum(_league_div[div_indexer.get(y)]['totalteams'] for y in connected_list)} for connected_list in getConnectedDivisions() for x in connected_list] sorted_divratio_list = sorted(divratio_list, key=itemgetter('div_id')) # multiply sorted edgesum list elements w. sorted divratio list elements # because of the sort all dictionary elements in the list should be sorted according to div_id and obviating # need to create an indexerGet function # x['div_id'] could have been y['div_id'] in the list comprehension below prod_list = [{'div_id': x['div_id'], 'prodratio': x['edgesum']*y['ratio']} for (x,y) in zip(sorted_edgesum_list, sorted_divratio_list)] logging.debug("getDivFieldEdgeWeight: sorted_edge=%s, sorted_ratio=%s, prod=%s", sorted_edgesum_list, sorted_divratio_list, prod_list) # define indexer function object prod_indexerGet = lambda x: dict((p['div_id'],i) for i,p in enumerate(prod_list)).get(x) List_Indexer = namedtuple('List_Indexer', 'dict_list indexerGet') return List_Indexer(prod_list, prod_indexerGet)
def __init__(self, b, num_clusters = 6): self.b = b self.num_clusters = num_clusters # split the graph into it's two partitions self.nodes = list(bipartite.sets(b)) self.mappings = {} # NOTE: self.copora[0] consideres each node in self.nodes[0] and makes a bag of songs representation for it's neighbors. # i.e self.corpora[0] is what we pass into lda when we want to model the nodes in self.nodes[0] as documents and the nodes in self.nodes[1] as "words" self.corpora, self.dicts = self._get_graph_corpora() # lda_models[0] would be the lda model where the "documents" are sets of nodes in self.nodes[1] self.lda_models = self._train_lda_models() # per_cluster_node_distributions[0] is an array of dicts, each dict mapping id->probability for that cluster index self.per_cluster_node_distributions = self._find_per_cluster_node_distributions() self.per_dnode_cluster_distributions = self._find_per_dnode_cluster_distributions()
def test_convert_graph_to_factor_garph(self): variable_nodes = ['x1', 'x2', 'x3', 'x4'] factor_nodes = ['fa', 'fb', 'fc'] g = nx.Graph() g.add_nodes_from(variable_nodes, bipartite=0) g.add_nodes_from(factor_nodes, bipartite=1) g.add_edges_from([('x1', 'fa'), ('fa', 'x2'), ('x2', 'fb'), ('fb', 'x3'), ('x2', 'fc'), ('fc', 'x4')]) bottom_nodes, top_nodes = bipartite.sets(g, variable_nodes) fg = graphs.convert_graph_to_factor_graph(g, nodes.VNode, nodes.FNode, rv.Discrete) vn = {str(n) for n in fg.get_vnodes()} fn = {str(n) for n in fg.get_fnodes()} self.assertSetEqual(bottom_nodes, vn) self.assertSetEqual(top_nodes, fn)
def params_bd(H): V, B = bipartite.sets(H) k = H.degree(list(B)[0]) r = H.degree(list(V)[0]) l = len(set(H.neighbors(list(V)[0])).intersection(set(H.neighbors(list(V)[1])))) dl = len(set(H.neighbors(list(B)[0])).intersection(set(H.neighbors(list(B)[1])))) for b in B: if k != H.degree(b): raise Exception("Failed: REGULARITY") for v in V: if r != H.degree(v): raise Exception("Failed: 1-BALANCE") rtv = set([l]) cnt = 0 for i, v1 in enumerate(V): for j, v2 in enumerate(V): if i < j: common_neighbors = set(H.neighbors(v1)).intersection(set(H.neighbors(v2))) la = len(common_neighbors) print(v1,v2) print(common_neighbors) print(la) if l != la: print("Failed: 2-BALANCE") cnt += 1 rtv.add(la) print("") print(rtv) print(cnt) for i, b1 in enumerate(B): for j, b2 in enumerate(B): if i < j: inter_block = set(H.neighbors(b1)).intersection(set(H.neighbors(b2))) dla = len(inter_block) if dl != dla: raise Exception("Failed: DUAL 2-BALANCE") return k, r, l, dl
def plot_initial_bgraph(G,subp=121): fig=plt.figure(num=1,figsize=(16,12)) fig.add_subplot(subp) sets=bipartite.sets(G) pos={} for i,v in enumerate(sets[0]): pos[v]= (0.,i) for i,v in enumerate(sets[1]): pos[v]= (1, i) rr=nx.attribute_assortativity_coefficient(G,'bipartite') s_title='Bipartite Graph\nAssortativity_coef(bipartition) = %.2f' %rr plt.title(s_title)#,{'size': '20'}) nx.draw_networkx_nodes(G,pos=pos,nodelist=list(sets[0]),node_color='grey',alpha=0.3) nx.draw_networkx_nodes(G,pos=pos,nodelist=list(sets[1]),node_color='gold') nx.draw_networkx_labels(G,pos=pos) nx.draw_networkx_edges(G,pos=pos,alpha=0.2) plt.axis("off") # plt.show() return pos,fig
def getRandomBPG(l, m, prob=0.03): g = nx.bipartite_random_graph(l, m, prob) orig = g.copy() print "%d %d %f" % (l, m, prob) # print "before: edges:%d" % len(g.edges()) count = 0 maxcount = CustomData.numAnomEdges(l + m) l, r = bipartite.sets(g) anom = l.pop() # print "adding %d anom edges" % maxcount for i in r: if not g.has_edge(anom, i) and count < maxcount: g.add_edge(anom, i) count += 1 # print "after: edges:%d" % len(g.edges()) return orig, g
def splitBipartiteGexf( inputGexf, outputGexfPath ): outputGexfPath = outputGexfPath + os.sep jr["input_gexf"] = inputGexf jr["outputGexfPath"] = outputGexfPath # otuput files xgexf = os.path.join( dirname( outputGexfPath ), basename( splitext( inputGexf )[0] ) )+".x.gexf" ygexf = os.path.join( dirname( outputGexfPath ), basename( splitext( inputGexf )[0] ) )+".y.gexf" try: graph = nx.readwrite.gexf.read_gexf( inputGexf ); except: throwError( "unable to read gexf file" ) return jr["numOfNodes"] = len( graph.nodes() ) jr["numOfEdges"] = len( graph.edges() ) X,Y=bipartite.sets(graph) # print "biparte.sets..."; # print X # print Y xgr=project_bipartite_graph(graph,X,"weight") # print "biparte.xgr..."; try: nx.readwrite.gexf.write_gexf(xgr, xgexf ) except: throwError( "unable to write file, path:'" + xgexf + "'" ) return ygr=project_bipartite_graph(graph,Y,"weight") try: nx.readwrite.gexf.write_gexf(ygr, ygexf ) except: throwError( "unable to write file, path:'" + ygexf + "'" ) #print sys.exc_info() jr['output_gexf'] = [ xgexf, ygexf ]
def plotBipartiteGraph(graph, color1="r", color2="b", figsize=(12, 8), layout="neato"): labels = {n:n for n in graph.nodes()} d = nx.degree_centrality(graph) # layout=nx.spring_layout # pos=layout(graph) pos = nx.drawing.nx_agraph.graphviz_layout(graph,prog=layout) bot_nodes, top_nodes = bipartite.sets(graph) plt.figure(figsize=figsize) plt.subplots_adjust(left=0,right=1,bottom=0,top=0.95,wspace=0.01,hspace=0.01) # nodes nx.draw_networkx_nodes(graph,pos, nodelist=bot_nodes, node_color=color1, node_size=[v * 350 for v in d.values()], alpha=0.8) nx.draw_networkx_nodes(graph,pos, nodelist=top_nodes, node_color=color2, node_size=[v * 350 for v in d.values()], alpha=0.8) nx.draw_networkx_edges(graph,pos, with_labels=True, edge_color=color1, width=1.0 ) if graph.order() < 1000: nx.draw_networkx_labels(graph,pos, labels) return plt
def test_bipartite_density(self): G=nx.path_graph(5) X,Y=bipartite.sets(G) density=float(len(G.edges()))/(len(X)*len(Y)) assert_equal(bipartite.density(G,X),density)
G=nx.Graph() #Two-Level Graph for node in J.nodes(): G.add_node(node,bipartite=0) for edge in J.edges(): G.add_edge(edge[0],edge[1]) for edge in F.edges(): G.add_edge(edge[0]+5,edge[1]+5) for node in F.nodes(): G.add_node(node+5,bipartite=1) for edge in H.edges(data=True): G.add_edge(edge[0],edge[1]) posJ=nx.spring_layout(J) posF=nx.spring_layout(F) posH={0:(0,0),1:(0,2),2:(0,4),3:(0,6),4:(0,8),5:(1,-2),6:(1,0),7:(1,2),8:(1,4),9:(1,6),10:(1,8)} mode1, mode2 = bipartite.sets(H) pos=nx.spring_layout(G) top_set=set() botom_set=set() for i in pos: npos=pos[i] if G.node[i]['bipartite']==0: pos[i]=[npos[0],npos[1]+2] top_set.add(i) elif G.node[i]['bipartite']==1: pos[i]=[npos[0],npos[1]-2] botom_set.add(i) ''' plt.figure() nx.draw(J,pos=posJ,node_color='r',node_size=700,font_size=20,font_color='#FFFFFF',with_labels=False) nx.draw_networkx_labels(J,posJ,directors,font_size=20,font_color='#FFFFFF')
def test_bipartite_sets(self): G=nx.path_graph(4) X,Y=bipartite.sets(G) assert_equal(X,set([0,2])) assert_equal(Y,set([1,3]))
remove = [node for node,degree in B.degree().items() if degree == 0] B.remove_nodes_from(remove) #print remove for node,degree in (B.degree().items()): if (degree == 0): #print node B.remove_node(node) #print(bipartite.is_bipartite(B)) Sif(B,"Bipartita_MEF2e") bottom_nodes, top_nodes = bipartite.sets(B) pos=nx.spring_layout(B) #pos=nx.shell_layout(B) #pos=nx.spectral_layout(B) #pos=nx.random_layout(B) nx.draw_networkx_nodes(B,pos,nodelist=bottom_nodes,node_shape='o',node_color='r', node_size=100) #proces nx.draw_networkx_nodes(B,pos,nodelist=top_nodes,node_shape='p',node_color='y', node_size=450) #coms nx.draw_networkx_edges(B,pos, edge_color='gray') nx.draw_networkx_labels(B, pos,font_size=7, font_color='k') plt.show()
def getPartitionings(self): partitionings = [list(bipartite.sets(subG))\ for subG in nx.connected_component_subgraphs(self.g)] return partitionings
color[n]=get_rgb_from_hue_spectrum(a[n]/a[max(a)], 0.3, 0.0) pc.append(a[n]/a[max(a)]) nx.set_node_attributes(G, 'color', color) plt.clf() fig = plt.Figure() fig.set_canvas(plt.gcf().canvas) pos = nx.spring_layout(g) nx.draw_networkx_nodes(G, pos, node_size=600,node_color=pc ,cmap=plt.get_cmap('jet'),labels=G.nodes())#,, nx.draw_networkx_labels(G,pos,font_size=14) nx.draw_networkx_edges(G, pos, edge_color='b', arrows=True) nx.draw_networkx_edges(G,pos,font_size=14) plt.savefig('directed_Network_2.pdf',bbox_inches="tight") banks , sov = bipartite.sets(B) pos = dict() pos.update( (n, (1, i)) for i, n in enumerate(banks) ) # put nodes from X at x=1 pos.update( (n, (2, i)) for i, n in enumerate(sov) ) # put nodes from Y at x=2 col= [] for n, d in B.nodes_iter(data=True): col.append(d['bipartite']) col[col==1]=='b' col[col==0]=='g' fig = plt.Figure() fig.set_canvas(plt.gcf().canvas) nx.draw_networkx_nodes(B, pos, node_size=200,node_color=col ,cmap=plt.get_cmap('jet'),labels=B.nodes())#,, nx.draw_networkx_labels(B,pos,font_size=10)
def _get_cosine_network_graph(self, ions_of_interest, clustering, peak_names): ions_of_interest_clustering = [] for item in ions_of_interest: pos = peak_names.index(item) cl = clustering[pos] ions_of_interest_clustering.append(cl) ions_of_interest_clustering = np.array(ions_of_interest_clustering) # Create the networkx graph object. # Clusters with fewer than min_size_to_plot members are not plotted min_size_to_plot = 4 node_no = 0 G = nx.Graph() uc = np.unique(clustering) cluster_nodes = {} singleton_clusters = [] cluster_interests = {} for cluster in uc: # check cluster size members = np.where(clustering == cluster)[0] if len(members) < min_size_to_plot: # print "Not plotting cluster %d with %d members." % (cluster, len(members)) singleton_clusters.append(cluster) continue # append to graph cluster_nodes[cluster] = node_no G.add_node(node_no, bipartite=0, name=cluster) node_no += 1 # also print out the ions of interest in this cluster interest_members = np.where(ions_of_interest_clustering == cluster)[0] if len(interest_members) > 0: cluster_interests[cluster] = [] for idx in interest_members: tokens = ions_of_interest[idx].split('_') pid = int(tokens[2]) cluster_interests[cluster].append(pid) peak_nodes = {} for i,name in enumerate(peak_names): this_cluster = clustering[i] if this_cluster in cluster_nodes: peak_nodes[name] = node_no G.add_node(node_no,bipartite=1, name=name) G.add_edge(node_no,cluster_nodes[clustering[i]]) node_no += 1 # Position the clusters in a grid, and their members in circle coming out from the cluster. # cstep determines the distance between grid points. # If you want cluster members closer to the cluster centers, change the 0.75 in # the x_pos and y_pos lines C,P = bipartite.sets(G) n_clusters = len(C) n_rows = np.ceil(np.sqrt(n_clusters)) pos = {} current_row = 0 current_col = 0 cstep = 2.0 for c in C: n_list = G.neighbors(c) pos[c] = [cstep*current_row,cstep*current_col] # find neighbours step = 2*np.pi/len(n_list) angle = 0.0 for n in n_list: x_pos = 0.75*np.sin(angle) y_pos = 0.75*np.cos(angle) pos[n] = [pos[c][0]+x_pos,pos[c][1]+y_pos] angle += step current_col += 1 if current_col >= n_rows: current_col = 0 current_row += 1 return C, P, G, pos, peak_nodes, cluster_interests
numEdges = int(nodesAndEdges[1]) # adds nodes for i in range(1, numNodes + 1): G.add_node(str(i)) # adds edges for i in range(0, numEdges): temp = inputFile.readline().strip().split(" ") node1 = temp[0] node2 = temp[1] G.add_edge(node1, node2) # if the graph is bipartite, we can easily find the optimal soltuion if nx.is_bipartite(G): top_nodes, bottom_nodes = bipartite.sets(G) partition1 = list(top_nodes) partition2 = list(bottom_nodes) maxEdgeCount = 0 for i in range(0, len(partition1)): maxEdgeCount += len(G.neighbors(partition1[i])) # If it's not bipartite, we must start attempting to find the optimal solution else: graph_dict = dict() sorted_graph_dict = dict() for i in G.nodes(): graph_dict[i] = G.neighbors(str(i)) sorted_graph_dict[i] = G.neighbors(str(i)) maxEdgeCount = 0