def test_bipartite_weighted_degrees(self): G = nx.path_graph(5) G.add_edge(0, 1, weight=0.1, other=0.2) X = {1, 3} Y = {0, 2, 4} u, d = bipartite.degrees(G, Y, weight="weight") assert dict(u) == {1: 1.1, 3: 2} assert dict(d) == {0: 0.1, 2: 2, 4: 1} u, d = bipartite.degrees(G, Y, weight="other") assert dict(u) == {1: 1.2, 3: 2} assert dict(d) == {0: 0.2, 2: 2, 4: 1}
def test_bipartite_weighted_degrees(self): G=nx.path_graph(5) G.add_edge(0,1,weight=0.1,other=0.2) X=set([1,3]) Y=set([0,2,4]) u,d=bipartite.degrees(G,Y,weight='weight') assert_equal(u,{1:1.1,3:2}) assert_equal(d,{0:0.1,2:2,4:1}) u,d=bipartite.degrees(G,Y,weight='other') assert_equal(u,{1:1.2,3:2}) assert_equal(d,{0:0.2,2:2,4:1})
def test_bipartite_weighted_degrees(self): G = nx.path_graph(5) G.add_edge(0, 1, weight=0.1, other=0.2) X = set([1, 3]) Y = set([0, 2, 4]) u, d = bipartite.degrees(G, Y, weight='weight') assert_equal(u, {1: 1.1, 3: 2}) assert_equal(d, {0: 0.1, 2: 2, 4: 1}) u, d = bipartite.degrees(G, Y, weight='other') assert_equal(u, {1: 1.2, 3: 2}) assert_equal(d, {0: 0.2, 2: 2, 4: 1})
def partition_strings_2set(X, C, X_file, C_file, params): """ """ G_star = graphs.construct_exact_2set_nearest_neighbor_bipartite_graph( X, C, X_file, C_file, params) # G_star, alignment_graph = graphs.construct_2set_nearest_neighbor_bipartite_graph(X, C, X_file, C_file) G_star_transposed = nx.reverse(G_star) #functions.transpose(G_star) partition = { } # dict with a center as key and a set containing all sequences chosen to this partition # candidate_nodes, read_nodes = bipartite.sets(G_star_transposed) read_nodes = set(n for n, d in G_star_transposed.nodes(data=True) if d['bipartite'] == 0) candidate_nodes = set(G_star_transposed) - read_nodes read_deg, cand_deg = bipartite.degrees(G_star_transposed, candidate_nodes) # print(len(read_nodes), len(candidate_nodes)) # print(read_deg) # print(cand_deg) ###################### while len(candidate_nodes) > 0: read_deg, cand_deg = bipartite.degrees(G_star_transposed, candidate_nodes) read_deg, cand_deg = dict(read_deg), dict(cand_deg) # print(type(read_deg), read_deg) # print(type(cand_deg), cand_deg) # print("reads left:", len(read_deg)) # print("cands left:", len(cand_deg)) m = max(sorted(cand_deg), key=lambda key: cand_deg[key]) reads_supporting_m = list(G_star_transposed.neighbors(m)) partition[m] = set(reads_supporting_m) G_star_transposed.remove_node(m) G_star_transposed.remove_nodes_from(reads_supporting_m) read_nodes = set(n for n, d in G_star_transposed.nodes(data=True) if d['bipartite'] == 0) candidate_nodes = set(G_star_transposed) - read_nodes # candidate_nodes, read_nodes = bipartite.sets(G_star_transposed) # print("total nodes left after removal:", len(G_star_transposed.nodes()), "tot candidate nodes left:", candidate_nodes) # print(read_nodes, [G_star[node] for node in read_nodes]) # print(len(reads_supporting_m) , len(G_star_transposed.nodes()), G_star_transposed.nodes() ) # print([ (m,len(partition[m])) for m in partition] ) ##################### return G_star, partition
def collaborativeness(B): # splitting the types of nodes of the graph object B top_nodes = set(node for node, d in B.nodes(data=True) if d['bipartite'] == 0) #set of top nodes bottom_nodes = set(B) - top_nodes #set of bottom nodes deg_top, deg_bottom = bipartite.degrees( B, bottom_nodes) #dictionary: nodes as keys, degrees as values # creating simple graph and multigraph bottom projections G = bipartite.projected_graph(B, bottom_nodes) Gm = bipartite.projected_graph(B, bottom_nodes, multigraph=True) col_dict = {} #ratio_dict = {} #div_dict = {} for node in bottom_nodes: if G.degree(node) > 0: gamma = 0 shared = 0 for nbr in B[node]: gamma += math.log(B.degree(nbr)) if B.degree(nbr) > 1: shared += 1 col_dict[node] = ((float(shared) / B.degree(node)) * gamma, float(G.degree(node)) / Gm.degree(node)) #ratio_dict[node] = (float(shared)/B.degree(node)) #diversity_dict[node] = float(G.degree(node))/Gm.degree(node) return col_dict
def test_bipartite_degrees(self): G = nx.path_graph(5) X = {1, 3} Y = {0, 2, 4} u, d = bipartite.degrees(G, Y) assert dict(u) == {1: 2, 3: 2} assert dict(d) == {0: 1, 2: 2, 4: 1}
def test_bipartite_degrees(self): G = nx.path_graph(5) X = set([1, 3]) Y = set([0, 2, 4]) u, d = bipartite.degrees(G, Y) assert dict(u) == {1: 2, 3: 2} assert dict(d) == {0: 1, 2: 2, 4: 1}
def test_bipartite_degrees(self): G = nx.path_graph(5) X = set([1, 3]) Y = set([0, 2, 4]) u, d = bipartite.degrees(G, Y) assert_equal(u, {1: 2, 3: 2}) assert_equal(d, {0: 1, 2: 2, 4: 1})
def test_bipartite_degrees(self): G=nx.path_graph(5) X=set([1,3]) Y=set([0,2,4]) u,d=bipartite.degrees(G,Y) assert_equal(u,{1:2,3:2}) assert_equal(d,{0:1,2:2,4:1})
def degree_distribution(G, nodes,weight): if weight == True: degree_values_users, degree_values_posts = bipartite.degrees(G,nodes,'weight') else: degree_values_users, degree_values_posts = bipartite.degrees(G,nodes) #take a look at first 20 entries in each def take(n, iterable): "Return first n items of the iterable as a list" return list(islice(iterable, n)) #print take(20,degree_values_posts.iteritems()) #print take(20,degree_values_users.iteritems()) vals_posts=degree_values_posts.values() average_degree_p = sum(vals_posts)/float(len(vals_posts)) #crop out larger values vals_posts= [s for s in vals_posts if s<=2000] data_posts=Counter(vals_posts) """ vals_users=degree_values_users.values() average_degree_u = sum(vals_users)/float(len(vals_users)) #crop out larger values vals_users=[s for s in vals_users if s<=100] data_users=Counter(vals_users) """ plt.figure(1) plt.subplot(211) plt.hist(data_posts.keys(),label = "Average Degree = %s" %(average_degree_p)) plt.title("Degree Distribution (post-projection) Histogram") plt.xlabel("Degree") plt.ylabel("Number of nodes with degree") plt.legend(loc='best') """ plt.subplot(212) plt.hist(data_users.keys(),label = "Average Degree = %s" %(average_degree_u)) plt.title("Degree Distribution (user-projection) Histrogram") plt.xlabel("Degree") plt.ylabel("Number of nodes with degree") plt.legend(loc='best') """ plt.show()
def get_deg_list_by_partition(graph, partition): """ Get degree distribution for given partition of bipartite graph """ if not bipartite.is_bipartite(graph): return [] nodes = [ node for node in graph.nodes if graph.nodes[node]['bipartite'] == partition ] return bipartite.degrees(graph, nodes)[1]
def suffle_edges_lc(G): # Get the largest component print("Getting largest component ...") components = sorted(nx.connected_components(G), key=len, reverse=True) largest_component = components[0] C = G.subgraph(largest_component) degX, degY = bipartite.degrees(C, nodes_0) degATC = dict(degX).values() degCIE = dict(degY).values() counterATC = collections.Counter(degATC) counterCIE = collections.Counter(degCIE) nodes_0_c = [] nodes_1_c = [] for n in C.nodes(data=True): if n[1]['bipartite'] == 0: nodes_0_c.append(n[0]) if n[1]['bipartite'] == 1: nodes_1_c.append(n[0]) print("Shuffling edges ... ") unfrozen_graph = nx.Graph(C) # C_shuffled = copy.copy(C) k = 0 iter = 2 * unfrozen_graph.size() while k < iter: r1 = random.choice(sorted(dict(degY).keys())) d1 = random.choice(list(unfrozen_graph.neighbors(r1))) r2 = random.choice(sorted(dict(degY).keys())) d2 = random.choice(list(unfrozen_graph.neighbors(r2))) if (unfrozen_graph.has_edge(r1, d2) == False) & (unfrozen_graph.has_edge(r2, d1) == False): unfrozen_graph.add_edge(r1, d2) unfrozen_graph.remove_edge(r1, d1) unfrozen_graph.add_edge(r2, d1) unfrozen_graph.remove_edge(r2, d2) # print(k) k = k + 1 return unfrozen_graph, counterATC, counterCIE, dict(degX), dict( degY), nodes_0_c, nodes_1_c
def from_bipartitegraph_to_mergesplitmetric(bipart_graph, sv_nodes): degX, degY = bipartite.degrees(bipart_graph, sv_nodes) num_of_merges = 0 SVids_merger = [] skeleton_groups = [] for node_id, node_degree in degY.iteritems(): if node_degree > 1: num_of_merges += node_degree - 1 SVids_merger.append(node_id) skeletons = bipart_graph[node_id].keys( ) # This gets all the nodes the node is connected to. skeletons = [int(id, 16) for id in skeletons] skeleton_groups.append(skeletons) num_of_splits = 0 for node_id, node_degree in degX.iteritems(): if node_degree > 1: num_of_splits += node_degree - 1 return num_of_merges, num_of_splits, skeleton_groups, SVids_merger
def commit_here(username): G = nx.Graph() users = set() users.update(user for user in followers(username, page="1", followers_list=[])) users.update(user for user in following(username, page="1", following_list=[])) users = list(users) repos = set() user2repo = [] for user in users: if user == username: continue user_repos = get_repos(user, url="", repo_list=[]) repos.update(repo + "_repo" for repo in user_repos) user2repo += [(user, repo + "_repo") for repo in user_repos] repos = list(repos) G.add_nodes_from(users, bipartite="users") G.add_nodes_from(repos, bipartite="repos") G.add_edges_from(user2repo) for repo in repos: degX, degY = bipartite.degrees(G, repo) break degX = list(degX) repos_only = [] for ind in degX: if ind[0] not in users: repos_only.append(ind) repos_only.sort(key=lambda x: x[-1], reverse=True) repos_only = [list(repo) for repo in repos_only] return repos_only[:10]
#use one less process to be a little more stable #p = multiprocessing.Pool(processes = multiprocessing.cpu_count()-5) p = multiprocessing.Pool() #timing it... start = time.time() # for file in names: # p.apply_async(multip, [file]) for i in range(1, 5, 1): print("Shuffle edges ... iteration " + str(i)) #H = add_and_remove_edges(C, type_proj, dict(degX), dict(degY)) C, counterATC, counterCIE, degX, degY, nodes_0_c, nodes_1_c = suffle_edges_lc( G) # suffle_edges(C, sorted(dict(degX).keys()), sorted(dict(degY).keys())) degX_sh, degY_sh = bipartite.degrees(C, nodes_0_c) degATC_sh = dict(degX_sh).values() degCIE_sh = dict(degY_sh).values() counterATC_sh = collections.Counter(degATC_sh) counterCIE_sh = collections.Counter(degCIE_sh) nx.write_graphml(C, 'networks/bipartite_sh_' + str(i) + '.graphml') print("Apply threshold analysis to shuffled graph ... " + str(i)) for th_icd in sorted(list(counterCIE_sh.keys())): p.apply_async(threshold_analysis, [C, th_icd, 0, len(degY_sh), i]) for th_atc in sorted(list(counterATC_sh.keys())): p.apply_async(threshold_analysis, [C, th_atc, 1, len(degX_sh), i]) # if type_proj == 0: # for th in sorted(list(counterCIE_sh.keys())):
if u in M: del_edges.append((u, v)) B.remove_edges_from(del_edges) sys.stderr.write("\nedges after deletion are: " + str(B.edges())) if nx.is_bipartite(B): logging.info("\n ... graph is bipartite.") else: logging.info("\n ... graph is NOT bipartite.") numOfNodes = B.number_of_nodes() numOfEdges = B.number_of_edges() k = numOfEdges logging.info( '\n...done. Created a bipartite graph with %d nodes and %d edges' % (numOfNodes, numOfEdges)) degN, degM = bipartite.degrees(B, M) degrees = dict(degN) print("degree dict: " + str(degrees)) descending_degrees = sorted(degrees.values(), reverse=True) print("degrees descending: " + str(descending_degrees)) sorted_nodes = sorted(range(len(degrees.values())), key=lambda c: degrees.values()[c], reverse=True) print("nodes sorted by descending degrees: " + str(sorted_nodes)) max_degree = descending_degrees[0] min_degree = descending_degrees[-1] mean = (sum(degrees.values()) * 1.0) / len(degrees) std_dev = np.sqrt((sum([(degrees[i] - mean)**2 for i in degrees]) * 1.0) / len(degrees)) logging.info( '\nMax degree: %s, min degree: %s, mean: %s, and standard deviation: %s.'
def threshold(G, bp): degX, degY = bipartite.degrees(G, nodes_0) degATC = dict(degX).values() degCIE = dict(degY).values() counterATC = collections.Counter(degATC) counterCIE = collections.Counter(degCIE) c_list = [] nc_list = [] nuc_list = [] if bp == 0: for th in sorted(list(counterCIE.keys())): #th = 1 H = nx.Graph() #for v in G.nodes(data = True): # if v[1]['bipartite'] == 0: # H.add_node(v[0]) for n in G.nodes(data=True): if n[1]['bipartite'] == 0: sourceNode = n[0] s_neighbors = set(G.neighbors(n[0])) for m in G.nodes(data=True): if m[1]['bipartite'] == 0: #### Change to 1 to change the projection to active ingredient targetNode = m[0] t_neighbors = set(G.neighbors(m[0])) if sourceNode != targetNode: if len(s_neighbors & t_neighbors) >= th: H.add_node(sourceNode) H.add_node(targetNode) H.add_edge(sourceNode, targetNode) components = sorted(nx.connected_components(H), key=len, reverse=True) #sum(list(map(lambda c: len(c), components))) c_list.append(len(components)) nodes_connected = sum(list(map(lambda c: len(c), components))) nc_list.append(nodes_connected) nuc_list.append(len(nodes_0) - nodes_connected) #nx.write_graphml(H,'proCIE_th_'+str(th)+'.graphml') else: for th in sorted(list(counterATC.keys())): #th = 136 H = nx.Graph() #for v in G.nodes(data = True): # if v[1]['bipartite'] == 1: # H.add_node(v[0]) for n in G.nodes(data=True): if n[1]['bipartite'] == 1: sourceNode = n[0] s_neighbors = set(G.neighbors(n[0])) for m in G.nodes(data=True): if m[1]['bipartite'] == 1: #### Change to 1 to change the projection to active ingredient targetNode = m[0] t_neighbors = set(G.neighbors(m[0])) if sourceNode != targetNode: if len(s_neighbors & t_neighbors) >= th: #print(len(s_neighbors & t_neighbors)) #print(sourceNode + " " + targetNode) H.add_node(sourceNode) H.add_node(targetNode) H.add_edge(sourceNode, targetNode) components = sorted(nx.connected_components(H), key=len, reverse=True) c_list.append(len(components)) nodes_connected = sum(list(map(lambda c: len(c), components))) nc_list.append(nodes_connected) nuc_list.append(len(nodes_1) - nodes_connected) #nx.write_graphml(H,'proATC_th_'+str(th)+'.graphml') #degXH,degYH=bipartite.degrees(H,nodes_0) #degATCH = dict(degXH).values() #degCIEH = dict(degYH).values() #counterATCH = collections.Counter(degATCH) #counterCIEH = collections.Counter(degCIEH) return c_list, nc_list, nuc_list, counterATC, counterCIE
user2repo = [] for user in users: if user == username: # Don't recommend self repos continue user_repos = get_repos(user, url="", repo_list=[]) repos.update(repo + "_repo" for repo in user_repos) user2repo += [(user, repo + "_repo") for repo in user_repos] repos = list(repos) G.add_nodes_from(users, bipartite="users") G.add_nodes_from(repos, bipartite="repos") G.add_edges_from(user2repo) nx.write_edgelist(G, "imro8_bipartite_recommending_repo.edgelist") # G = nx.read_edgelist('imro8_bipartite_recommending_repo.edgelist') # print(G.edges()) # repos = ['teach-flask-through-doing_repo', 'Hades_App_repo'] for repo in repos: degX, degY = bipartite.degrees(G, repo) break degX = list(degX) repos_only = [] for ind in degX: if ind[0] not in users: repos_only.append(ind) repos_only.sort(key=lambda x: x[-1], reverse=True) print(repos_only[:10])
bipartite=0) # Add the node attribute “bipartite” disease G.add_nodes_from(nodes_1, bipartite=1) # active substance # Add edges without weight for m in vdmdata.iterrows(): enfermedad = m[1][0] #peso = m[1][3]; sustancia = m[1][1] G.add_edge(enfermedad, sustancia) print("Getting largest component ...") components = sorted(nx.connected_components(G), key=len, reverse=True) largest_component = components[0] C = G.subgraph(largest_component) degX, degY = bipartite.degrees(C, nodes_0) degATC = dict(degX).values() degCIE = dict(degY).values() counterATC = collections.Counter(degATC) counterCIE = collections.Counter(degCIE) df_icd = pd.DataFrame(dict(degY).items(), columns=['node', 'degree']) df_atc = pd.DataFrame(dict(degX).items(), columns=['node', 'degree']) df_icd = df_icd.sort_values(by=['degree', 'node'], ascending=False) df_atc = df_atc.sort_values(by=['degree', 'node'], ascending=False) nodes_0_c = [] nodes_1_c = [] for n in C.nodes(data=True): if n[1]['bipartite'] == 0:
#-------------------------------------------------------------------------- # Calculate the density of the bipartite graph #-------------------------------------------------------------------------- print(round(bipartite.density(B, bottom_nodes), 3)) #-------------------------------------------------------------------------- # Calculate the degree distribution of universities from the bipartite projected graph. # We need to have a multigraph because it works for counting the mappings #-------------------------------------------------------------------------- U = bipartite.weighted_projected_graph(B, bottom_nodes) #-------------------------------------------------------------------------- # Calculate the degree for the top and bottom nodes of the bipartite graph #-------------------------------------------------------------------------- import operator degX, degY = bipartite.degrees(U, top_nodes, weight='weight') #universites a, b = zip(*degX) degreeCount = collections.Counter(b) deg, cnt = zip(*degreeCount.items()) #The degree seq below does not take into account the weights of the edges #degree_sequence = sorted([d for n, d in U.degree()], reverse=True) # degree sequence #degreeCount = collections.Counter(degree_sequence) plt.rcParams['axes.facecolor'] = 'grey' plt.rcParams['savefig.facecolor'] = 'grey' fig, ax = plt.subplots(figsize=(10, 8)) #plt.title("Degree Histogram and Graph of Universities",fontsize=11) plt.ylabel("Count of links", fontsize=14) plt.xlabel("Degree", fontsize=14)
B = nx.Graph() edges = [] x = 0 for i in range(len(top_nodes)): edges.append((top_nodes[i], bottom_nodes[i], weight[i])) B.add_weighted_edges_from(edges) # print(B.edges()) # 二模转一模 # G=bipartite.projected_graph(B,bottom_nodes,multigraph=True) # print(G.edges(keys=True)) # 计算二模网络的度 degX,degY=bipartite.degrees(B,bottom_nodes,weight='weight') # 计算二模网络的点度中心性 D = bipartite.degree_centrality(B, bottom_nodes) degX_dict, degY_dict, D_dict = dict(degX), dict(degY), dict(D) print('模1的度为:', len(degX), degX_dict, '模2的度为:', len(degY), degY_dict, '模2的点度中心性', len(D), D_dict, sep='\n') arcpy.env.overwriteOutput = True targetsource1 = targetsource + 'output' print(targetsource) arcpy.Copy_management(in_data=targetsource, out_data=targetsource1) mo2fieldname,mo1fieldname,mo2centraldegree = 'mo2degree', 'mo1degree', 'mo2centraldegree' arcpy.AddField_management(targetsource1, mo2fieldname, "FLOAT",field_alias=mo2fieldname, field_is_nullable="NULLABLE") arcpy.AddField_management(targetsource1, mo1fieldname, "FLOAT",field_alias=mo1fieldname, field_is_nullable="NULLABLE")