def test_project_weighted_jaccard(self): edges = [ ("A", "B", 2 / 5.0), ("A", "C", 1 / 2.0), ("B", "C", 1 / 5.0), ("B", "D", 1 / 5.0), ("B", "E", 2 / 6.0), ("E", "F", 1 / 3.0), ] Panswer = nx.Graph() Panswer.add_weighted_edges_from(edges) P = bipartite.overlap_weighted_projected_graph(self.G, "ABCDEF") assert_equal(P.edges(), Panswer.edges()) for u, v in P.edges(): assert_equal(P[u][v]["weight"], Panswer[u][v]["weight"]) edges = [ ("A", "B", 3 / 3.0), ("A", "E", 1 / 3.0), ("A", "C", 1 / 3.0), ("A", "D", 1 / 3.0), ("B", "E", 1 / 3.0), ("B", "C", 1 / 3.0), ("B", "D", 1 / 3.0), ("C", "D", 1 / 1.0), ] Panswer = nx.Graph() Panswer.add_weighted_edges_from(edges) P = bipartite.overlap_weighted_projected_graph(self.N, "ABCDE") assert_equal(P.edges(), Panswer.edges()) for u, v in P.edges(): assert_equal(P[u][v]["weight"], Panswer[u][v]["weight"])
def test_project_weighted_jaccard(self): edges=[('A','B',2/5.0), ('A','C',1/2.0), ('B','C',1/5.0), ('B','D',1/5.0), ('B','E',2/6.0), ('E','F',1/3.0)] Panswer=nx.Graph() Panswer.add_weighted_edges_from(edges) P=bipartite.overlap_weighted_projected_graph(self.G,'ABCDEF') assert_edges_equal(P.edges(),Panswer.edges()) for u,v in P.edges(): assert_equal(P[u][v]['weight'],Panswer[u][v]['weight']) edges=[('A','B',3/3.0), ('A','E',1/3.0), ('A','C',1/3.0), ('A','D',1/3.0), ('B','E',1/3.0), ('B','C',1/3.0), ('B','D',1/3.0), ('C','D',1/1.0)] Panswer=nx.Graph() Panswer.add_weighted_edges_from(edges) P=bipartite.overlap_weighted_projected_graph(self.N,'ABCDE') assert_edges_equal(P.edges(),Panswer.edges()) for u,v in P.edges(): assert_equal(P[u][v]['weight'],Panswer[u][v]['weight'])
def test_project_weighted_jaccard(self): edges=[('A','B',2/5.0), ('A','C',1/2.0), ('B','C',1/5.0), ('B','D',1/5.0), ('B','E',2/6.0), ('E','F',1/3.0)] Panswer=nx.Graph() Panswer.add_weighted_edges_from(edges) P=bipartite.overlap_weighted_projected_graph(self.G,'ABCDEF') assert_edges_equal(list(P.edges()),Panswer.edges()) for u,v in list(P.edges()): assert_equal(P[u][v]['weight'],Panswer[u][v]['weight']) edges=[('A','B',3/3.0), ('A','E',1/3.0), ('A','C',1/3.0), ('A','D',1/3.0), ('B','E',1/3.0), ('B','C',1/3.0), ('B','D',1/3.0), ('C','D',1/1.0)] Panswer=nx.Graph() Panswer.add_weighted_edges_from(edges) P=bipartite.overlap_weighted_projected_graph(self.N,'ABCDE') assert_edges_equal(list(P.edges()),Panswer.edges()) for u,v in P.edges(): assert_equal(P[u][v]['weight'],Panswer[u][v]['weight'])
def test_project_weighted_overlap(self): edges = [('A', 'B', 2 / 2.0), ('A', 'C', 1 / 1.0), ('B', 'C', 1 / 1.0), ('B', 'D', 1 / 1.0), ('B', 'E', 2 / 3.0), ('E', 'F', 1 / 1.0)] Panswer = nx.Graph() Panswer.add_weighted_edges_from(edges) P = bipartite.overlap_weighted_projected_graph(self.G, 'ABCDEF', jaccard=False) assert_edges_equal(list(P.edges()), Panswer.edges()) for u, v in list(P.edges()): assert P[u][v]['weight'] == Panswer[u][v]['weight'] edges = [('A', 'B', 3 / 3.0), ('A', 'E', 1 / 1.0), ('A', 'C', 1 / 1.0), ('A', 'D', 1 / 1.0), ('B', 'E', 1 / 1.0), ('B', 'C', 1 / 1.0), ('B', 'D', 1 / 1.0), ('C', 'D', 1 / 1.0)] Panswer = nx.Graph() Panswer.add_weighted_edges_from(edges) P = bipartite.overlap_weighted_projected_graph(self.N, 'ABCDE', jaccard=False) assert_edges_equal(list(P.edges()), Panswer.edges()) for u, v in list(P.edges()): assert P[u][v]['weight'] == Panswer[u][v]['weight']
def test_project_weighted_jaccard(self): edges = [ ("A", "B", 2 / 5.0), ("A", "C", 1 / 2.0), ("B", "C", 1 / 5.0), ("B", "D", 1 / 5.0), ("B", "E", 2 / 6.0), ("E", "F", 1 / 3.0), ] Panswer = nx.Graph() Panswer.add_weighted_edges_from(edges) P = bipartite.overlap_weighted_projected_graph(self.G, "ABCDEF") assert_edges_equal(list(P.edges()), Panswer.edges()) for u, v in list(P.edges()): assert P[u][v]["weight"] == Panswer[u][v]["weight"] edges = [ ("A", "B", 3 / 3.0), ("A", "E", 1 / 3.0), ("A", "C", 1 / 3.0), ("A", "D", 1 / 3.0), ("B", "E", 1 / 3.0), ("B", "C", 1 / 3.0), ("B", "D", 1 / 3.0), ("C", "D", 1 / 1.0), ] Panswer = nx.Graph() Panswer.add_weighted_edges_from(edges) P = bipartite.overlap_weighted_projected_graph(self.N, "ABCDE") assert_edges_equal(list(P.edges()), Panswer.edges()) for u, v in P.edges(): assert P[u][v]["weight"] == Panswer[u][v]["weight"]
def jaccard_similarity(TG_graph, gen, tumor_gene_relation_bi_adj_mat): #for jaccard similarity nearest neighbors# G = bipartite.overlap_weighted_projected_graph(TG_graph, gen) print "calculating the link prediction scores", G.number_of_edges() A = nx.to_scipy_sparse_matrix(G) scores = np.dot(tumor_gene_relation_bi_adj_mat, A) return scores
def overlap_weighted_projected_graph(self): E = bipartite.sets(self.B)[0] P = bipartite.overlap_weighted_projected_graph(self.B, E, jaccard=False) self.plot_graph_2(P, 'overlap_weighted_projected_graph') print('overlap_weighted_projected_graph: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.overlap_weighted_projected_graph(self.B, E, jaccard=True) self.plot_graph_2(P, 'overlap_weighted_projected_graph_jaccard_True') print('xxxxxxxxxxxxxxxxxxxxxx') weights = [] for i in list(P.edges(data=True)): weights.append(i[2]['weight']) print(weights)
def project_graph(name='bipartite_reader_network.pickle', method="Count"): """ Create the projected graph, with weights. :param book_weights_dict: the weights dictionary, which is of the form {(title1_gid, title2_gid) : weight, ...} :param method: This tells us how to weight the edges. "Rating count" sums all the ratings for a weight. "Average" takes the average. "Count" just counts the number of times the edge is shared (co-read). :return: A nx graph. """ print("Projecting Graph with {} method.".format(method)) bi_graph = read(name) if not bipartite.is_bipartite(bi_graph): raise Exception("Projecting non-bipartite graphs is felony.") # Make top nodes (users) to project down onto bottom nodes (books) top_nodes = { n for n, d in bi_graph.nodes(data=True) if d['bipartite'] == 0 } bottom_nodes = set(bi_graph) - top_nodes # Various projection methods if method == "Count": # Count the number of co-reads proj_graph = bipartite.generic_weighted_projected_graph( bi_graph, bottom_nodes) elif method == "Collaboration": # Newman's collaboration metric proj_graph = bipartite.collaboration_weighted_projected_graph( bi_graph, bottom_nodes) elif method == "Overlap": # Proportion of neighbors that are shared proj_graph = bipartite.overlap_weighted_projected_graph( bi_graph, bottom_nodes) elif method == "Average Weight": # todo proj_graph = bipartite.collaboration_weighted_projected_graph( bi_graph, bottom_nodes) elif method == "Divergence": # todo proj_graph = bipartite.collaboration_weighted_projected_graph( bi_graph, bottom_nodes) else: raise Exception("{} is not a valid projection method".format(method)) # Save print("Saving projection_graph_{}.pickle".format(method)) overwrite(proj_graph, "projection_graph_{}.pickle".format(method)) print("Saving projection_graph_{}.gml".format(method)) nx.write_gml(proj_graph, "projection_graph_{}.gml".format(method)) return proj_graph
#plt.semilogx() plt.show() # projection onto a given set of nodes, with weights equivalent to the Jaccard index # Jaccard index is the ratio of the size of the intersection of the two neighborhoods # to the union of the two neighborhoods all_node_data = my_graph.nodes(data=True) seg_nodes = [] for node in all_node_data: node_dict = node[1] if node_dict['cat']=='segment': seg_nodes.append(node[0]) #print(seg_nodes) my_graph_projection = bipartite.overlap_weighted_projected_graph(my_graph, seg_nodes) projected_edges = my_graph_projection.edges(data=True) proj_list = [] with open('all_proj_edges.csv','w') as result_file: wr = csv.writer(result_file, dialect='excel') for p_edge in projected_edges: add_dis = [p_edge[0], p_edge[1], p_edge[2]['weight']] wr.writerow(add_dis) print("The clustering coefficient of the projection is", nx.average_clustering(my_graph_projection)) print("The shortest average path length for each component in the projection is") for g in nx.connected_component_subgraphs(my_graph_projection): print(nx.average_shortest_path_length(g))
def projected_graph(self,input_0,input_1,input_2): # Make sure the right fields exist if 'bipartite_0' not in input_0: return[False,'Parameter bipartite_0 does not exist in given input',{}] if 'bipartite_1' not in input_0: return[False,'Parameter bipartite_1 does not exist in given input',{}] if 'edges' not in input_0: return[False,'Parameter edges does not exist in given input',{}] if 'nodes' not in input_1: return[False,'Parameter nodes does not exist in given input',{}] # Checking given graph is valid bipartite graph ret_val = self.bipartite_graph({'bipartite_0':input_0['bipartite_0'],'bipartite_1':input_0['bipartite_1']},{'edges':input_0['edges']}) if not ret_val[0]: return ret_val # Checking validity of the nodes parameter if not isinstance(input_1['nodes'], list): return[False,'Parameter nodes does not contain an array',{}] if len(input_1['nodes']) <= 0: return [False, 'Parameter nodes does not contain at least one element', {}] # Checking nodes to project onto all belong to a single biparition and of course # they are actually found in one of the bipartitions edge = None if input_1['nodes'][0] in input_0['bipartite_0']: edge = 0 elif input_1['nodes'][0] in input_0['bipartite_1']: edge = 1 else: return [False, 'Node element at zero-indexed position 0 is not contained in either of the bipartitions', {}] edge_text = 'bipartite_' + str(edge) # Make sure that all elements are found in the discovered bipartition for i in range(len(input_1['nodes'])): if input_1['nodes'][i] not in input_0[edge_text]: return [False, 'Node element at zero-indexed position {} is not contained in {}'.format(i,edge_text), {}] P = None if input_2 == 'none': P = bipartite.projected_graph(self.networkx_graph, input_1['nodes']) elif input_2 == 'multigraph': P = bipartite.projected_graph(self.networkx_graph, input_1['nodes'],multigraph=True) elif input_2 == 'degree': P = bipartite.weighted_projected_graph(self.networkx_graph, input_1['nodes']) elif input_2 == 'degree_ratio': P = bipartite.weighted_projected_graph(self.networkx_graph, input_1['nodes'], ratio=True) elif input_2 == 'Newman': P = bipartite.collaboration_weighted_projected_graph(self.networkx_graph, input_1['nodes']) elif input_2 == 'Jaccard': P = bipartite.overlap_weighted_projected_graph(self.networkx_graph, input_1['nodes']) elif input_2 == 'Jaccard_modified': P = bipartite.overlap_weighted_projected_graph(self.networkx_graph, input_1['nodes'], jaccard=False) else: return [False, 'Unkown weighting logic specified', {}] output = {} output['nodes'] = list(P.nodes()) output['edges'] = [] output['weights'] = [] weight_q_mark = True for i in list(P.edges(data=True)): output['edges'].append(list(i)[:2]) if weight_q_mark: if 'weight' in list(i)[2]: output['weights'].append(list(i)[2]['weight']) else: weight_q_mark = False return [True,'success',output]
nodes = pd.read_csv(options.input_filename, sep='\t', header=None) B = Graph() for row in nodes.iterrows(): B.add_node(row[1][0], bipartite=0) B.add_node(row[1][1], bipartite=1) B.add_edge(row[1][0], row[1][1]) top_nodes = set(n for n, d in B.nodes(data=True) if d['bipartite'] == 0) bottom_nodes = set(B) - top_nodes top = list(top_nodes) bottom = list(bottom_nodes) print "Generating network projection" if options.metric == "hypergeometric": G = bipartite.generic_weighted_projected_graph( B, top_nodes, weight_function=hypergeometric) #HYPERGEOMETRIC elif options.metric == "jaccard": G = bipartite.generic_weighted_projected_graph( B, top_nodes, weight_function=jaccard) #Jaccard elif options.metric == "PCC": G = bipartite.generic_weighted_projected_graph( B, top_nodes, weight_function=pcc_weight) #PCC elif options.metric == "simpson": G = bipartite.overlap_weighted_projected_graph(B, top_nodes, jaccard=False) #Simpson write_weighted_edgelist(G, options.output_filename, delimiter="\t") print "Execution finished"
# Create co-affiliation network G = bipartite.projected_graph(B, pollinators) # Create figure plt.figure(figsize=(30,30)) # Calculate layout pos = nx.spring_layout(G, k=0.5) # Draw edges, nodes, and labels nx.draw_networkx_edges(G, pos, width=3, alpha=0.2) nx.draw_networkx_nodes(G, pos, node_color="#9f9fff", node_size=6000) nx.draw_networkx_labels(G, pos) plt.savefig('output-4.3.png', dpi=150) G = bipartite.weighted_projected_graph(B, plants) list(G.edges(data=True))[0] # Create co-affiliation network G = bipartite.overlap_weighted_projected_graph(B, pollinators) # Get weights weight = [G.edges[e]['weight'] for e in G.edges] # Create figure plt.figure(figsize=(30,30)) # Calculate layout pos = nx.spring_layout(G, weight='weight', k=0.5) # Draw edges, nodes, and labels nx.draw_networkx_edges(G, pos, edge_color=weight, edge_cmap=plt.cm.Blues, width=6, alpha=0.5) nx.draw_networkx_nodes(G, pos, node_color="#9f9fff", node_size=6000) nx.draw_networkx_labels(G, pos) plt.savefig('output-4.4.png', dpi=150)