def augmentNodes(g): r1 = nx.eigenvector_centrality_numpy(g) r2 = nx.degree_centrality(g) # DP MY r3 = nx.betweenness_centrality(g) r5 = nx.load_centrality(g,weight='weight') # DY, WY-writename # Scientific collaboration networks: II. Shortest paths, weighted networks, and centrality, M. E. J. Newman, Phys. Rev. E 64, 016132 (2001). r6 = nx.pagerank(g, alpha=0.85, personalization=None, max_iter=100, tol=1e-08, nstart=None, weight='weight') if nx.is_directed(g) == True: r8 = nx.in_degree_centrality(g) r9 = nx.out_degree_centrality(g) # r10 = nx.hits(g, max_iter=100, tol=1e-08, nstart=None) else: r4 = nx.communicability_centrality(g) r7 = nx.clustering(g, weight='weight') for x in g.nodes(): g.node[x]['eigenvector_centrality_numpy'] = r1[x] g.node[x]['degree_centrality'] = r2[x] g.node[x]['betweenness_centrality'] = r3[x] g.node[x]['load_centrality'] = r5[x] g.node[x]['pagerank'] = r6[x] if nx.is_directed(g) == True: g.node[x]['in_degree_centrality'] = r8[x] g.node[x]['out_degree_centrality'] = r9[x] # g.node[x]['hits'] = r10[x] else: g.node[x]['communicability_centrality'] = r4[x] g.node[x]['clustering'] = r7[x] return g
def net_stat(self): ''' This method is called on every rank with graphs that contain only partial connectivity information. If there are two equal structural out-degree hubs this method only finds the first one. ''' excin=networkx.in_degree_centrality(networkx.DiGraph(self.global_ecm)) excout=networkx.in_degree_centrality(networkx.DiGraph(self.global_ecm)) return (excin,excout)
def test_small_graph_centrality(self): G = nx.empty_graph(create_using=nx.DiGraph) assert_equal({}, nx.degree_centrality(G)) assert_equal({}, nx.out_degree_centrality(G)) assert_equal({}, nx.in_degree_centrality(G)) G = nx.empty_graph(1, create_using=nx.DiGraph) assert_equal({0: 1}, nx.degree_centrality(G)) assert_equal({0: 1}, nx.out_degree_centrality(G)) assert_equal({0: 1}, nx.in_degree_centrality(G))
def test_small_graph_centrality(self): G = nx.empty_graph(create_using=nx.DiGraph) assert {} == nx.degree_centrality(G) assert {} == nx.out_degree_centrality(G) assert {} == nx.in_degree_centrality(G) G = nx.empty_graph(1, create_using=nx.DiGraph) assert {0: 1} == nx.degree_centrality(G) assert {0: 1} == nx.out_degree_centrality(G) assert {0: 1} == nx.in_degree_centrality(G)
def main(): DGTiny = parseEdgeFileToDiGraph(tinyFn) DGSmall = parseEdgeFileToDiGraph(smallFn) # DGLarge = parseEdgeFileToDiGraph(largeFn) print nx.in_degree_centrality(DGTiny) print nx.out_degree_centrality(DGTiny) print "\n" print nx.closeness_centrality(DGTiny)
def add_network_statistics(nodes, links): if len(nodes)==0: return nodes graph = get_network(nodes, links) degree = nx.degree(graph) if max(dict(degree).values()) > 0: hubs, authorities = get_hits(graph) statistics = { 'degree': degree, 'in_degree': graph.in_degree(), 'out_degree': graph.out_degree(), 'degree_centrality': nx.degree_centrality(graph), 'in_degree_centrality': nx.in_degree_centrality(graph), 'out_degree_centrality': nx.out_degree_centrality(graph), 'betweenness_centrality': nx.betweenness_centrality(graph), 'closeness_centrality': nx.closeness_centrality(graph), 'pagerank': get_pagerank(graph), 'hubs': hubs, 'authorities': authorities } else: statistics = {} # for relative in-degree we sort on date derive_date = lambda k: k['date'] if k['date']!='' else '{}-01-01'.format(k['year']) nodes.sort(key=derive_date, reverse=True) for i, node in enumerate(nodes): nodeid = node['id'] for var in statistics.keys(): node[var] = statistics[var][nodeid] if 'in_degree' in node: node['rel_in_degree'] = node['in_degree'] / float(max(i, 1)) get_community(graph, nodes) return nodes
def show_net(g_matrix): G = nx.DiGraph() count = 0 for i in range(len(g_matrix)): for j in range(len(g_matrix)): if g_matrix[i][j]>0.1: number = g_matrix[i][j] # G.add_edge([i,j,number]) count+=1 G.add_weighted_edges_from([(j, i, number)]) nx.draw(G, pos=nx.spring_layout(G),node_color = 'b', edge_color = 'r',alpha = 0.5, with_labels = True,font_size = 15, node_size = 50,width = 0.5) in_degree = nx.in_degree_centrality(G) out_degree = nx.out_degree_centrality(G) i=0 arr = np.zeros(shape=(36,3)) while i<36: arr[i][0]=i if in_degree.__contains__(i): arr[i][1] = in_degree.get(i) else: arr[i][1] = 0.0 if out_degree.__contains__(i): arr[i][2] = out_degree.get(i) else: arr[i][2] = 0.0 i = i+1 data = pd.DataFrame(data=arr,columns=['Motif ID','In-degree','Out-degree']) print(data) figname = "D:/For-F-drive/school/comp/research/Desktop/Email/Lasso_file/figure/trans_matrix_alpha-11_reduced_arrow.png" plt.savefig(figname, dpi=100, bbox_inches='tight') plt.show() return count
def caluclate_network_attributes(Graph): all_nodes = Graph.nodes() graph_df = pd.Series(all_nodes).to_frame(name="Node") degree = nx.degree(Graph) degree_cen = nx.degree_centrality(Graph) in_degree = nx.in_degree_centrality(Graph) out_degree = nx.out_degree_centrality(Graph) closeness = nx.closeness_centrality(Graph) between = nx.betweenness_centrality(Graph) try: eigen = nx.eigenvector_centrality_numpy(Graph) graph_df['Eigenvector'] = pd.Series( [eigen[node] for node in all_nodes]) except eigenerror.ArpackNoConvergence: #if no eigenvector can be caluclated, set all to zero graph_df['Eigenvector'] = pd.Series([0 for n in all_nodes]) graph_df['Degree'] = pd.Series([degree[node] for node in all_nodes]) graph_df['DegreeCentrality'] = pd.Series( [degree_cen[node] for node in all_nodes]) graph_df['InDegree'] = pd.Series([in_degree[node] for node in all_nodes]) graph_df['OutDegree'] = pd.Series([out_degree[node] for node in all_nodes]) graph_df['Closeness'] = pd.Series([closeness[node] for node in all_nodes]) graph_df['Betweeness'] = pd.Series([between[node] for node in all_nodes]) return (graph_df)
def plot_centralities(G): n = G.number_of_nodes() plt.figure('Graph %s: %s - %s' % (str(i), tmsp2str(Tmin + i * dt), tmsp2str(Tmin + (i + 1) * dt))) plt.suptitle('Centrality Measurements (Graph size = ' + str(n) + ')') in_degrees = [(n - 1) * d for d in nx.in_degree_centrality(G).values()] out_degrees = [(n - 1) * d for d in nx.out_degree_centrality(G).values()] degrees = [(n - 1) * d for d in nx.degree_centrality(G).values()] hist_plot('Degrees', [in_degrees, out_degrees, degrees], (3, 1, 1), ['r', 'g', 'b']) plt.legend(['Degree', 'In-Degree', 'Out-Degree']) G = nx.Graph(G) #directed -> undirected hist_plot('Closeness', nx.closeness_centrality(G).values(), (3, 2, 3), 'xkcd:orangered') hist_plot('Betweenness', nx.betweenness_centrality(G).values(), (3, 2, 4), 'xkcd:crimson') hist_plot('Eigenvector', nx.eigenvector_centrality_numpy(G).values(), (3, 2, 5), 'xkcd:teal') hist_plot('Katz', nx.katz_centrality_numpy(G).values(), (3, 2, 6), 'xkcd:brown') plt.tight_layout(rect=(0, 0, 1, 0.95)) if args.PDF: pp.savefig() plt.close() else: plt.show()
def ref_metrics(self, G): ''' See https://networkx.github.io/documentation/latest/reference/algorithms.html for algorithms. Some algorithms don't support directed graphs. More comments on each algorithm in respect to directed graphs. Edges in graph G are directed from a to b in (a, b), where a cites b. :param G: graph :return: a dataframe of network statistics for each node. ''' s = time.perf_counter() df = pd.DataFrame([ # Equals the number of references in a paper as (2, 1) is "2" citing "1" nx.out_degree_centrality(G), # Equals the number of citations nx.in_degree_centrality(G), # (1, 3) and (2, 3) give PageRank to "3" nx.pagerank(G), # (1, 2, 3) gives 0 to "3" as it can't reach any other nodes # Since "if the graph is not completely connected, this algorithm computes the closeness # centrality for each connected part separately," ensure that all papers are connected nx.closeness_centrality(G), # (2, 3, 4) and (4, 3, 2) give higher betweenness to "3" than (2, 3, 4) alone does # nx.betweenness_centrality(G), # nx.current_flow_betweenness_centrality(G), # nx.current_flow_closeness_centrality(G), # nx.eigenvector_centrality(G) ]).T df.columns = ['odc', 'idc', 'pr', 'cc', # 'bc', 'cfbc', 'cfcc', 'ec' ] e = time.perf_counter() print("Metrics is computed in %d seconds" % round(e - s, 1)) return df
def main(): g_directed, g_undirected, all_dfs, labels = __read_csv_files() deg_centrality = nx.degree_centrality(g_directed) deg_in_centrality = nx.in_degree_centrality(g_directed) deg_out_centrality = nx.out_degree_centrality(g_directed) dict_measures = { 'degree centrality': deg_centrality, 'deg_in_centrality': deg_in_centrality, 'deg_out_centrality': deg_out_centrality } count = 0 for hist_title, values in dict_measures.items(): count += 1 subplot(2, 3, count) values_df = pd.DataFrame(values.items(), columns=['id', 'Score']) hist_plot = values_df['Score'].hist(bins=50) hist_plot.set_title(hist_title) hist_plot.set_xlabel('Score') hist_plot.set_ylabel("Number of nodes") plt.margins(x=0) plt.yscale('log', basey=10) # plt.yscale('log', basey=10) plt.show() measures_for_centrality(g_undirected) x = 1
def centrality(G): """ Calculates the in-degree, out-degree, closeness, betweenness centrality for the given graph. If the graph is undirected, return empty dictionary for indegree and outdegree centrality. args: G (nx.DiGraph) : input graph returns: tuple of in-degree, out-degree, closeness, betweenness centrality dictionaries that the keys are nodes. """ in_degree, out_degree = {}, {} if G.is_directed(): print "calculating in_degree centrality..." in_degree = nx.in_degree_centrality(G) print "calculating out_degree centrality..." out_degree = nx.out_degree_centrality(G) print "calculating closeness centrality..." closeness = nx.closeness_centrality(G) print "calculating betweenness centrality..." betweenness = nx.betweenness_centrality(G) return in_degree, out_degree, closeness, betweenness
def set_capacities_degree_gravity(topology, capacities, capacity_unit='Mbps'): """ Set link capacities proportionally to the product of the degrees of the two end-points of the link Parameters ---------- topology : Topology The topology to which link capacities will be set capacities : list A list of all possible capacity values capacity_unit : str, optional The unit in which capacity value is expressed (e.g. Mbps, Gbps etc..) """ if topology.is_directed(): in_degree = nx.in_degree_centrality(topology) out_degree = nx.out_degree_centrality(topology) gravity = {(u, v): out_degree[u] * in_degree[v] for (u, v) in topology.edges()} else: degree = nx.degree_centrality(topology) gravity = {(u, v): degree[u] * degree[v] for (u, v) in topology.edges()} _set_capacities_proportionally(topology, capacities, gravity, capacity_unit=capacity_unit)
def run(): # Create real world graph or random graph G = nx.erdos_renyi_graph(station_count, edge_prob, directed=True) # Calculate in-degree centrality to represent flow of bikes to centre cent = nx.in_degree_centrality(G) # Add centrality values to each node for u in G.nodes(): G.node[u]['in_cent'] = cent[u] # Get order of centrality with most central at start cent_list = centrality_list(cent) print(cent_list) # Set up each station at start of run bikes_init(G) # Run program for number of steps for i in range(nsteps): am_cycle(G, cent_list) empty_list = [(n, G.node[n]['in_cent'], G.node[n]['empty']) for n in G.nodes() if G.node[n]['empty'] >= 1] full_list = [(n, G.node[n]['in_cent'], G.node[n]['full']) for n in G.nodes() if G.node[n]['full'] >= 1] # Trucks can move bikes from full stations to less full stations bike_trucks(G, 2, 10, cent_list) print("Full Count: %s\nEmpty Count %s" % (empty_list, full_list))
def centrality_histogram(g, c): # Creates the centrality histogram specified if c == 'degree': degree_sequence = sorted( [val for key, val in nx.degree_centrality(g).items()]) elif c == 'in_degree': degree_sequence = sorted( [val for key, val in nx.in_degree_centrality(g).items()]) elif c == 'out_degree': degree_sequence = sorted( [val for key, val in nx.out_degree_centrality(g).items()]) elif c == 'closeness': degree_sequence = sorted( [val for key, val in nx.closeness_centrality(g).items()]) elif c == 'betweenness': degree_sequence = sorted( [val for key, val in nx.betweenness_centrality(g).items()]) elif c == 'eigenvector': degree_sequence = sorted( [val for key, val in nx.eigenvector_centrality(g).items()]) elif c == 'katz': degree_sequence = sorted( [val for key, val in nx.katz_centrality(g).items()]) degree_count = col.Counter(degree_sequence) deg, cnt = zip(*degree_count.items()) plt.bar(deg, cnt, width=0.01, color='b') plt.title('Degree Histogram') plt.ylabel('Count') plt.xlabel('Degree') plt.show()
def compute_graph_scores(): f = open('paper_citation_network.txt', 'r') gs = open('graph_scores.txt', 'w') citations = f.readlines() edges = [] for citation in citations: papers = citation.split('==>') papers[0] = papers[0].rstrip(' ') papers[1] = papers[1].rstrip('\n') papers[1] = papers[1].lstrip(' ') edges.append(papers) G = nx.DiGraph() G.add_edges_from(edges) cc = nx.closeness_centrality(G) bc = nx.betweenness_centrality(G) eg = nx.eigenvector_centrality(G, max_iter=1000) ig = nx.in_degree_centrality(G) for i in cc.keys(): gs.write(i + ',' + str(cc[i]) + ',' + str(bc[i]) + ',' + str(eg[i]) + ',' + str(ig[i]) + '\n') gs.close() f.close()
def calculate_network_measures(G): in_degree = nx.in_degree_centrality(G) out_degree = nx.out_degree_centrality(G) betweenness = nx.betweenness_centrality(G, weight=WEIGHT) closeness = nx.closeness_centrality(G, distance=WEIGHT) eigenvector = nx.eigenvector_centrality(G.reverse(), weight=WEIGHT) clustering = nx.clustering(G.to_undirected(), weight=WEIGHT) pagerank = nx.pagerank(G, weight=WEIGHT) hubs, authorities = nx.hits_numpy(G) max_clique = node_clique_number(G.to_undirected()) node_cliques = cliques_containing_node(G.to_undirected()) node_cliques_count = {} for node, cliques in node_cliques.items(): node_cliques_count[node] = len(cliques) network_df = pd.DataFrame(list(G.nodes), columns=[ID]); network_df[IN_DEGREE] = network_df[ID].map(in_degree) network_df[OUT_DEGREE] = network_df[ID].map(out_degree) network_df[BETWEENNESS] = network_df[ID].map(betweenness) network_df[CLOSENESS] = network_df[ID].map(closeness) network_df[EIGENVECTOR] = network_df[ID].map(eigenvector) network_df[CLUSTERING] = network_df[ID].map(clustering) network_df[PAGERANK] = network_df[ID].map(pagerank) network_df[HUBS] = network_df[ID].map(hubs) network_df[AUTHORITIES] = network_df[ID].map(authorities) network_df[MAX_CLIQUE] = network_df[ID].map(max_clique) network_df[CLIQUES_COUNT] = network_df[ID].map(node_cliques_count) return network_df
def compute_centrality(graph): centrality_values = nx.hits(graph) for node_id, centrality in centrality_values[0].items(): graph.nodes[node_id]['hub'] = centrality for node_id, centrality in centrality_values[1].items(): graph.nodes[node_id]['authority'] = centrality centrality_values = nx.pagerank(graph) for node_id, centrality in centrality_values.items(): graph.nodes[node_id]['pagerank'] = centrality centrality_values = nx.in_degree_centrality(graph) for node_id, centrality in centrality_values.items(): graph.nodes[node_id]['in_degree'] = centrality centrality_values = nx.out_degree_centrality(graph) for node_id, centrality in centrality_values.items(): graph.nodes[node_id]['out_degree'] = centrality centrality_values = nx.closeness_centrality(graph) for node_id, centrality in centrality_values.items(): graph.nodes[node_id]['closeness'] = centrality centrality_values = nx.betweenness_centrality(graph) for node_id, centrality in centrality_values.items(): graph.nodes[node_id]['betweenness'] = centrality centrality_values = nx.pagerank(graph) for node_id, centrality in centrality_values.items(): graph.nodes[node_id]['pagerank'] = centrality
def centralities(self, G): c = { "in-degree": nx.in_degree_centrality(G), "betweenness": nx.betweenness_centrality(G), "closeness": nx.closeness_centrality(G) } return c
def centrality_algorithms(graph): # Centrality functions return a dictionary of values # Calculate the maximum and print node name with value # Value stays the same for closness centrality, but the node itself changes centrality_dict = nx.degree_centrality(graph) print('Degree Centrality: ', max(centrality_dict, key=centrality_dict.get), max(centrality_dict.values())) centrality_dict = nx.in_degree_centrality(graph) print('In Degree Centrality: ', max(centrality_dict, key=centrality_dict.get), max(centrality_dict.values())) centrality_dict = nx.out_degree_centrality(graph) print('Out Degree Centrality: ', max(centrality_dict, key=centrality_dict.get), max(centrality_dict.values())) centrality_dict = nx.eigenvector_centrality_numpy(graph) print('Eigenvector Centrality: ', max(centrality_dict, key=centrality_dict.get), max(centrality_dict.values())) centrality_dict = nx.katz_centrality(graph) print('Katz Centrality: ', max(centrality_dict, key=centrality_dict.get), max(centrality_dict.values())) centrality_dict = nx.closeness_centrality(graph) print('Closeness Centrality: ', max(centrality_dict, key=centrality_dict.get), max(centrality_dict.values())) centrality_dict = nx.betweenness_centrality(graph) print('Betweenness Centrality: ', max(centrality_dict, key=centrality_dict.get), max(centrality_dict.values()))
def network_analysis(request): profile_name = request.GET.get('profile_name', '') if profile_name == '': profile_name = None users = MyUser.objects.all() print(users) pair_list = [] avatar = None for user in users: followings = user.followings.all() for person in followings: pair = [user.profile_name, person.profile_name] print(pair) pair_list.append(pair) g = nx.DiGraph() g.add_edges_from(pair_list) for user in users: if user.profile_name not in g.nodes(): g.add_node(user.profile_name) i_d = nx.in_degree_centrality(g) o_d = nx.out_degree_centrality(g) b = nx.betweenness_centrality(g) c = nx.closeness_centrality(g) e = nx.eigenvector_centrality(g, max_iter=1000) cc = nx.clustering(g) draw_graph(g.copy(), nx.spring_layout(g, k=0.55), i_d, 'In Degree Centrality', profile_name) draw_graph(g.copy(), nx.spring_layout(g, k=0.55), o_d, 'Out Degree Centrality', profile_name) draw_graph(g.copy(), nx.spring_layout(g, k=0.55), b, 'Betweenness Centrality', profile_name) draw_graph(g.copy(), nx.spring_layout(g, k=0.55), c, 'Closeness Centrality', profile_name) draw_graph(g.copy(), nx.spring_layout(g, k=0.55), e, 'Eigenvector Centrality', profile_name) draw_network(g.copy(), nx.spring_layout(g, k=0.55)) if profile_name is None: result = [i_d, o_d, b, c, e, cc] else: result = [ i_d.get(profile_name, ''), o_d.get(profile_name, ''), b.get(profile_name, ''), c.get(profile_name, ''), e.get(profile_name, ''), cc.get(profile_name, '') ] return JsonResponse(result, safe=False)
def centrality(DG): in_degree_centrality = nx.in_degree_centrality(DG) out_degree_centrality = nx.out_degree_centrality(DG) with open('/home/sun/PycharmProjects/Network/in_degree_centrality.csv', 'w') as f: for k, v in in_degree_centrality.items(): f.write(str(k) + ': ' + str(v) + '\n') f.close() with open('/home/sun/PycharmProjects/Network/out_degree_centrality.csv', 'w') as f: for k, v in out_degree_centrality.items(): f.write(str(k) + ': ' + str(v) + '\n') f.close() # def main(): # data = '/home/sun/PycharmProjects/Network/C-elegans-frontal.txt' # # data = 'www.adj' # DG = create_network(data) # # # draw_network(DG) # # clustering_coefficient(DG) # # centrality(DG) # degree_distribution(DG) # # if __name__ == '__main__': # main() # # # DG = nx.DiGraph() # # DG.add_edge(1,2) # # print(DG.edges()) # # # pos = nx.nx_agraph.graphviz_layout(DG) # # nx.draw_networkx(DG, pos = nx.spring_layout(DG)) # # plt.show() # # plt.ishold() # # plt.draw(DG)
def get_centrality_measures(node_list_df, arc_list_df): """ A function that generates a range of centrality measures for a generated DiGraph from the Pandas dataframe :param arc_list_df: A data-frame containing a sources, targets, and weights of relationship. """ G = dataframe_to_networkx(arc_list_df) centrality_measures = {} # Degree-based centrality measure centrality_measures.update({'degree': nx.degree_centrality(G)}) centrality_measures.update({'in_degree': nx.in_degree_centrality(G)}) centrality_measures.update({'out_degree': nx.out_degree_centrality(G)}) # Flow-based centrality measure centrality_measures.update({'closeness': nx.closeness_centrality(G)}) centrality_measures.update( {'betweenness': nx.betweenness_centrality(G)}) centrality_measures.update( {'contagion': contagion_centrality(node_list_df, arc_list_df)}) return centrality_measures
def get_node_feat(adjacency_list, nNodes): num_node_feat = 5 node_feat = Variable( torch.zeros(len(adjacency_list), nNodes, num_node_feat)) for t in range(len(adjacency_list)): G = nx.DiGraph(adjacency_list[t].numpy()) in_degree = np.array((nx.in_degree_centrality(G)).values()) out_degree = np.array((nx.out_degree_centrality(G)).values()) closeness = np.array((nx.closeness_centrality(G)).values()) between = np.array((nx.betweenness_centrality(G)).values()) pagerank = np.array((nx.pagerank(G)).values()) to_stack = [in_degree, out_degree, closeness, between, pagerank] assert (len(to_stack) == num_node_feat) node_feat[t] = Variable( torch.from_numpy(np.stack(to_stack, 1)).float()) return node_feat
def extract_g_metrics(G, name): if name == 'degree_centrality': metric = nx.degree_centrality(G).items() if name == 'in_degree_centrality': metric = nx.in_degree_centrality(G).items() if name == 'out_degree_centrality': metric = nx.out_degree_centrality(G).items() if name == 'eigenvector_centrality': metric = nx.eigenvector_centrality(G).items() if name == 'closeness_centrality': metric = nx.closeness_centrality(G).items() if name == 'betweenness_centrality': metric = nx.betweenness_centrality(G).items() if name == 'harmonic_centrality': metric = nx.harmonic_centrality(G).items() if name == 'trophic_levels': metric = nx.trophic_levels(G).items() fname = f'{graph_name}_{name}' get_g_metrics(metric, name=fname)[['content_id', fname]].to_feather(f'../save/{fname}.feather') return
def get_centrality(graph, method, topk=None): if method == "edge_betweeness_centrality": output = nx.edge_betweenness_centrality(graph) elif method == "betweenness_centrality": output = nx.betweenness_centrality(graph) elif method == "closeness_centrality": output = nx.closeness_centrality(graph) elif method == "eigenvector_centrality": output = nx.eigenvector_centrality(graph) elif method == "in_degree_centrality": output = nx.in_degree_centrality(graph) elif method == "out_degree_centrality": output = nx.out_degree_centrality(graph) elif method == "pagerank": output = pagerank(graph) else: return print(len(output)) output = np.array(create_array(output)) mean = round(np.mean(output), 4) if topk: arg_sorted_results = np.argsort(output)[::-1][:topk] else: arg_sorted_results = np.argsort(output)[::-1] return output, arg_sorted_results, mean
def main(): # n = get_node_list('Output.txt') # save_mapper_file(n, 'Mapper.txt') # anonymize_names("Output.txt", 'AnOutput.txt') an = get_node_list('AnOutput.txt') G = create_graph('AnOutput.txt', True) #in_deg_res, out_deg_res = get_degree_counts(G, an) # print(in_deg_res, out_deg_res) G1 = create_graph_for_snap(an, 'AnOutput.txt') # snap_traids = snap.GetTriads(G1) # triads = nx.transitivity(G) pagerank = nx.pagerank(G) max_pagerank = key_with_max_val(pagerank) import operator a = sorted(pagerank.items(), key=operator.itemgetter(1), reverse=True) print max_pagerank centrality = nx.in_degree_centrality(G) a = sorted(centrality.items(), key=operator.itemgetter(1), reverse=True) eigen_vector_centrality = nx.eigenvector_centrality(G) a = sorted(eigen_vector_centrality.items(), key=operator.itemgetter(1), reverse=True) # snap_dia = snap.GetBfsFullDiam(G1, 10) # dia = nx.diameter(G) avg_local_clustering_coeff = nx.average_clustering(G) print avg_local_clustering_coeff #global_clustering_coeff = snap.GetClustCf(G1, -1) #print global_clustering_coeff #plot_data = diameter_phase_transition() pass
def plotNetworkGraph(year,waveMatrix,locations,nodeNames, filename, nodeSize,targetWeights): resolution='l' #Bmap_Amplitude = Basemap(projection='merc',llcrnrlon=lower_left_lon,llcrnrlat=lower_left_lat,urcrnrlon=upper_right_lon,urcrnrlat=upper_right_lat,lat_ts=0,resolution=resolution,suppress_ticks=True) cmap=plt.get_cmap("Reds") Bmap_Amplitude=Basemap(projection='merc',llcrnrlat=-61.4,urcrnrlat=71.56,\ llcrnrlon=-163.7,urcrnrlon=165.65,lat_ts=20,resolution='h') G_Amplitude = nx.DiGraph() for name in nodeNames: latitude=locations[name][0] longitude=locations[name][1] #print(latitude,longitude) x,y=Bmap_Amplitude(longitude,latitude) G_Amplitude.add_node(name,pos=(x,y)) for nm in waveMatrix[year]: if nm[0] not in ['','.','0']: weight = waveMatrix[year][nm] G_Amplitude.add_edge(nm[0], nm[1],weight=weight) degree = nx.in_degree_centrality(G_Amplitude) betweennes = nx.betweenness_centrality(G_Amplitude) closeness = nx.closeness_centrality(G_Amplitude) pickle.dump(degree,open('centralityPickles/degree{}.pickle'.format(year),'wb')) pickle.dump(betweennes,open('centralityPickles/betweennes{}.pickle'.format(year),'wb')) pickle.dump(closeness,open('centralityPickles/closeness{}.pickle'.format(year),'wb')) maxDegree = max([j for i,j in degree.items()]) maxDegreeNodes = ', '.join([i for i,j in degree.items() if j==maxDegree and j!=0.0]) maxBetween = max([j for i,j in betweennes.items()]) maxBetweenNodes = ', '.join([i for i,j in betweennes.items() if j==maxBetween and j!=0.0]) maxClose = max([j for i,j in closeness.items()]) maxCloseNodes = ', '.join([i for i,j in closeness.items() if j==maxClose and j!=0.0]) plt.close() #plt.axis('off') fig, ax = plt.subplots() ax.text(-0.01, 1.02, 'c)', transform=ax.transAxes, size=14,color='purple') plt.scatter(-1,-1,label='Max Degree:{}'.format(maxDegreeNodes),color='r',s=3) plt.scatter(-1,-1,label='Max Betweeness:{}'.format(maxBetweenNodes),color='r',s=3) plt.scatter(-1,-1,label='Max Closeness:{}'.format(maxCloseNodes),color='r',s=3) plt.title('Target Network: {}'.format(year),fontsize = 9) edgewidth_Amplitude = [ d['weight'] for (u,v,d) in G_Amplitude.edges(data=True)] pos=nx.get_node_attributes(G_Amplitude,'pos') nx.draw_networkx_nodes(G_Amplitude,pos, node_color = 'y', node_size = nodeSize, alpha = 0.7) #nx.draw_networkx_edges(G_Amplitude, pos, edge_color = edgewidth_Amplitude, width=edgewidth_Amplitude, alpha = edgewidth_Amplitude) nx.draw_networkx_edges(G_Amplitude, pos, width=[0.5 for i in edgewidth_Amplitude] ,cmap=cmap,edge_color = [cmap(i) for i in edgewidth_Amplitude], alpha = [cmap(0.95) for i in edgewidth_Amplitude]) Bmap_Amplitude.drawcountries() Bmap_Amplitude.drawstates() #Bmap_Amplitude.bluemarble() Bmap_Amplitude.drawlsmask(land_color='white',ocean_color='grey',lakes=True) plt.legend(loc='lower right',prop={'size': 6}) plt.axis('off') print(year) plt.savefig("paperImages/tar_{}.png".format(year), dpi = 600,bbox_inches='tight')
def run(G, csv_file): """ Main function which initializes the graph and calls the number of steps Each step will simulate a number of people moving bikes in the system :param G NetworkX graph :param csv_file: CSV output file """ # Calculate in-degree centrality to represent flow of bikes to centre cent = nx.in_degree_centrality(G) # Add centrality values to each node for u in G.nodes(): G.node[u]['in_cent'] = cent[u] # Get order of centrality with most central at start cent_list = centrality_list(cent, am=True) # Set up each station at start of run bikes_init(G) # Get the number of nodes we want to consider as the centre centre_num = get_centre_count(cent_list, centre_flow, am=True) # Run program for number of steps for i in range(nsteps): bike_flow(G, cent_list, centre_num) #if i == nsteps - 1 or i + 1 % 10 == 0: [csv_file.writerow((n, i+1, G.node[n]['in_cent'], G.node[n]['total'], G.node[n]['spaces'], G.node[n]['full'], G.node[n]['empty'])) for n in G.nodes()] empty_list = [(n, G.node[n]['in_cent'], G.node[n]['empty']) for n in G.nodes() if G.node[n]['empty'] >= 1] full_list = [(n, G.node[n]['in_cent'], G.node[n]['full']) for n in G.nodes() if G.node[n]['full'] >= 1] # Trucks can move bikes from full stations to less full stations bike_trucks(G, 101, 50, cent_list)
def main(): db = ProtocolGraph(database.host, database.user, database.dbname) params = 'parameters: all | frame date time interval_seconds | \ iterall sim | iter sim interval' if len(sys.argv) < 2: print(params) quit() if sys.argv[1] == 'all': g = db.fetch_all() ec = networkx.in_degree_centrality(g) print(ec) elif sys.argv[1] == 'frame' and len(sys.argv) >= 5: date_str = sys.argv[2] time_str = sys.argv[3] secs = int(sys.argv[4]) start = DateTime(date_str=date_str, time_str=time_str) g = db.fetch_frame(start, seconds=secs) ec = networkx.in_degree_centrality(g) print(ec) elif sys.argv[1] == 'iterall' and len(sys.argv) >= 3: sim_name = sys.argv[2] print(db.frame(sim_name)) for g in db.iter(sim_name): (start_e, end_e) = start_end_epoch(g) print('start: {}, end: {}'.format(start_e, end_e)) start_dt = DateTime(epoch=start_e) print('start utc: {}'.format(str(start_dt))) end_dt = DateTime(epoch=end_e) print(' end utc: {}'.format(str(end_dt))) ec = networkx.in_degree_centrality(g) print('In-degree centrality: {}'.format(ec)) elif sys.argv[1] == 'iter' and len(sys.argv) >= 4: sim_name = sys.argv[2] print(db.frame(sim_name)) interval = int(sys.argv[3]) count = 0 for g in db.iter(sim_name, seconds=interval): print('count: {}'.format(count)) ec = networkx.in_degree_centrality(g) print(ec) count += 1 else: print(params) quit()
def sna_calculations(g, play_file): """ :param g: a NetworkX graph object :type g: object :param play_file: the location of a play in .txt format :type play_file: string :return: returns a dictionary containing various network related figures :rtype: dict :note: also writes into results/file_name-snaCalculations.csv and results/allCharacters.csv """ file_name = os.path.splitext(os.path.basename(play_file))[0] sna_calculations_list = dict() sna_calculations_list['playType'] = file_name[0] sna_calculations_list['avDegreeCentrality'] = numpy.mean(numpy.fromiter(iter(nx.degree_centrality(g).values()), dtype=float)) sna_calculations_list['avDegreeCentralityStd'] = numpy.std( numpy.fromiter(iter(nx.degree_centrality(g).values()), dtype=float)) sna_calculations_list['avInDegreeCentrality'] = numpy.mean( numpy.fromiter(iter(nx.in_degree_centrality(g).values()), dtype=float)) sna_calculations_list['avOutDegreeCentrality'] = numpy.mean( numpy.fromiter(iter(nx.out_degree_centrality(g).values()), dtype=float)) try: sna_calculations_list['avShortestPathLength'] = nx.average_shortest_path_length(g) except: sna_calculations_list['avShortestPathLength'] = 'not connected' sna_calculations_list['density'] = nx.density(g) sna_calculations_list['avEigenvectorCentrality'] = numpy.mean( numpy.fromiter(iter(nx.eigenvector_centrality(g).values()), dtype=float)) sna_calculations_list['avBetweennessCentrality'] = numpy.mean( numpy.fromiter(iter(nx.betweenness_centrality(g).values()), dtype=float)) sna_calculations_list['DegreeCentrality'] = nx.degree_centrality(g) sna_calculations_list['EigenvectorCentrality'] = nx.eigenvector_centrality(g) sna_calculations_list['BetweennessCentrality'] = nx.betweenness_centrality(g) # sna_calculations.txt file sna_calc_file = csv.writer(open('results/' + file_name + '-snaCalculations.csv', 'wb'), quoting=csv.QUOTE_ALL, delimiter=';') for key, value in sna_calculations_list.items(): sna_calc_file.writerow([key, value]) # all_characters.csv file if not os.path.isfile('results/allCharacters.csv'): with open('results/allCharacters.csv', 'w') as f: f.write( 'Name;PlayType;play_file;DegreeCentrality;EigenvectorCentrality;BetweennessCentrality;speech_amount;AverageUtteranceLength\n') all_characters = open('results/allCharacters.csv', 'a') character_speech_amount = speech_amount(play_file) for character in sna_calculations_list['DegreeCentrality']: all_characters.write(character + ';' + str(sna_calculations_list['playType']) + ';' + file_name + ';' + str( sna_calculations_list['DegreeCentrality'][character]) + ';' + str( sna_calculations_list['EigenvectorCentrality'][character]) + ';' + str( sna_calculations_list['BetweennessCentrality'][character]) + ';' + str( character_speech_amount[0][character]) + ';' + str(character_speech_amount[1][character]) + '\n') all_characters.close() return sna_calculations
def indegree_centrality(graph_input, directed = False): if type(graph_input) == dict: graph = convert_graph_dict_to_nx_graph(graph_input, directed) else: graph = convert_graph_df_to_nx_graph(graph_input, directed) if len(graph) == 1: return defaultdict(lambda: 0, {}) return defaultdict(lambda: 0, nx.in_degree_centrality(graph))
def sorting(E): in_degree_central = nx.in_degree_centrality(E) sorted(in_degree_central.items(), key=lambda x: x[1], reverse=True)[:10] out_degree_central = nx.out_degree_centrality(E) sorted(out_degree_central.items(), key=lambda x: x[1], reverse=True)[:10] print(in_degree_central) print(out_degree_central)
def get_indeg(G, first, last): indegCent = nx.in_degree_centrality(G) top_indegCent = sorted(indegCent.items(), key=operator.itemgetter(1), reverse=True)[first:last] return indegCent, top_indegCent, pd.DataFrame( top_indegCent, columns=['ScreenName', "In-degree"])
def calculate_in_degree_centrality(self): """ Calculates In - degree centrality for every node of graph. For directed graphs only. """ values = nx.in_degree_centrality(self.graph) nx.set_node_attributes(self.graph, 'in_degree', values)
def getclosenesscentrality(self): closeness_centrality = {'in': {}, 'out': {}} if self.is_directed else {} if self.is_directed: closeness_centrality['in'] = nx.in_degree_centrality(self.G) closeness_centrality['out'] = nx.out_degree_centrality(self.G) else: closeness_centrality = nx.degree_centrality(self.G) return closeness_centrality
def centrailtyM(A,num=5): G=nx.DiGraph(A) ranks=np.zeros((num,8)) ranks[:,0]=np.argsort(nx.in_degree_centrality(G).values())[::-1][:num] ranks[:,1]=np.argsort(nx.closeness_centrality(G).values())[::-1][:num] ranks[:,2]=np.argsort(nx.betweenness_centrality(G).values())[::-1][:num] ranks[:,3]=np.argsort(nx.eigenvector_centrality_numpy(G).values())[::-1][:num] ranks[:,4]=np.argsort(nx.katz_centrality_numpy(G,weight=None).values())[::-1][:num] ranks[:,5]=np.argsort(nx.pagerank_numpy(G,weight=None).values())[::-1][:num] return ranks
def process_data(denom=100000, round=0): f = csv.reader(open("../applab_new_6.csv", 'rb'), delimiter=',') db = nx.DiGraph() full_users = set() i = 0 uniquect = 0 for line in f: if i % 100000 == 0 : print "processed", i, "lines" if i == 1000: break sender, receiver, date, time, duration, cost, location, region = map(lambda x: x.strip(), line) if sender not in full_users: uniquect += 1 full_users.add(sender) if uniquect <= 2: #% denom - round == 0: db.add_node(sender) if db.has_node(receiver) == False: db.add_node(receiver) else: if db.has_node(receiver) == False: db.add_node(receiver) if db.has_edge(sender, receiver): db[sender][receiver]['weight'] += int(duration) else: db.add_edge(sender, receiver, weight=int(duration)) i+=1 #pickle.dump(db, open("users_networkx.p" % str(round), "wb")) #print "degree assortativity coeff:", nx.degree_assortativity_coefficient(db) #print "average degree connectivity:", nx.average_degree_connectivity(db) # print "k nearest neighbors:", nx.k_nearest_neighbors(db) print "calculating deg cent" deg_cent = nx.degree_centrality(db) #sorted(nx.degree_centrality(db).items(), key=lambda x: x[1]) print "calculating in deg cent" in_deg_cent = nx.in_degree_centrality(db) #sorted(nx.in_degree_centrality(db).items(), key=lambda x: x[1]) print "calculating out deg cent" out_deg_cent = nx.out_degree_centrality(db) #sorted(nx.out_degree_centrality(db).items(), key=lambda x: x[1]) print "closeness cent" closeness_cent = nx.closeness_centrality(db) #sorted(nx.closeness_centrality(db).items(), key=lambda x: x[1]) #print "betweenness cent" #btwn_cent = nx.betweenness_centrality(db) #sorted(nx.betweenness_centrality(db).items(), key=lambda x: x[1]) print "done" w = open("../output/user_network_stats.csv", 'w') w.write("uid,deg_cent,in_deg_cent,out_deg_cent,closeness_cent,btwn_cent\n") for user in deg_cent.keys(): try: w.write("%s,%s,%s,%s,%s\n" % (user, deg_cent[user], in_deg_cent[user], out_deg_cent[user], closeness_cent[user])) except: pass w.close() print "drawing..." nx.draw(db) plt.savefig("path.pdf") print "done!" print "edge betweenness centrality:", nx.edge_betweenness_centrality(db) print "communicability:", nx.communicability(db) print "communicability centrality:", nx.communicability_centrality(db)
def graph_degree(g): print "Computing degree centrality..." ac = nx.degree_centrality(g) bc = nx.in_degree_centrality(g) ec = nx.out_degree_centrality(g) ac_hash, bc_hash, ec_hash = {}, {}, {} for n, b in ac.iteritems(): ac_hash.setdefault(tuple(g.node[n]['languages']), []).append(b) for n, b in bc.iteritems(): bc_hash.setdefault(tuple(g.node[n]['languages']), []).append(b) for n, b in ec.iteritems(): ec_hash.setdefault(tuple(g.node[n]['languages']), []).append(b) return (ac_hash, bc_hash, ec_hash)
def in_degree_centrality(self): #Compute the in degree centrality of the graph logging.info("Inside degree centrality") indegree_dict = nx.in_degree_centrality(self.G) logging.info("In degree dic length %s" % (len(indegree_dict.keys()))) indegree_sorted_list = sorted(indegree_dict.items(), key=lambda x:x[1], reverse=True)[:3] for a,b in indegree_sorted_list: logging.info("In degree cent of %s is %s" % (a,b)) indegree_dict = {}
def centralities_euclidean_norm_centrality(G, weight=None, distance=None): """Implementation of Euclidean norm of centralities as centrality measure Centrality measure is the Euclidean norm of the normalized Degree, Closeness and Betweenness centralities, as described in [1] . Parameters ---------- G: networkx graph graph representing social network weight: string or None, optional weight edge attribute for betweenness centrality distance: string or Node, optional distance edge attribute for closeness centrality Returns ------- nodes: dictionary Dictionary of nodes with euclidean norm score as value References ---------- ..[1] Na Li; Gillet, D., "Identifying influential scholars in academic social media platforms," in Advances in Social Networks Analysis and Mining (ASONAM), 2013 IEEE/ACM International Conference on , vol., no., pp.608-614, 25-28 Aug. 2013 """ #normalizing function #Parameters : x - value, di - dictionary #Returns : normalized value (x-min(di)) / (max(di)-min(di)) normalizing=lambda x,di: ((x-min(di.values()))/(max(di.values())-min(di.values()))) if (max(di.values())-min(di.values()))!=0 else 0 #degree centrality deg_dict=nx.in_degree_centrality(G) deg_dict={k:normalizing(v,deg_dict) for k,v in deg_dict.items()} #closeness centrality clo_dict=nx.closeness_centrality(G, distance=distance) clo_dict={k:normalizing(v,clo_dict) for k,v in clo_dict.items()} #betweenness centrality betw_dict=nx.betweenness_centrality(G, weight=weight) betw_dict={k:normalizing(v,betw_dict) for k,v in betw_dict.items()} #euclidean norm nodes={k: math.sqrt( (deg_dict[k])**2 + (clo_dict[k])**2 + (betw_dict[k])**2 ) for k in G.nodes()} return nodes
def compute_graph_parameters(graph,i=0): graph_parameters = {} if nx.is_directed(graph): graph_parameters['in_degree_centrality'] = nx.in_degree_centrality(graph) graph_parameters['out_degree_centrality'] = nx.out_degree_centrality(graph) else: graph_parameters['degree_centrality'] = nx.degree_centrality(graph) graph_parameters['closeness_centrality'] = nx.closeness_centrality(graph) graph_parameters['betweenness_centrality'] = nx.betweenness_centrality(graph) if i==0: graph_parameters['eigenvector_centrality'] = nx.eigenvector_centrality(graph) graph_parameters['pagerank_centrality'] = nx.pagerank(graph,alpha=0.85) graph_parameters['clustering'] = nx.clustering(graph.to_undirected()) return graph_parameters
def output_indegree_centrality_info (graph, path, nodes_dict): """Output In-degree centrality information about the graph. graph : (networkx.Graph) path: (String) contains the path to the output file nodes_dict: (dictionary) maps node id to node name """ indeg_dict = nx.in_degree_centrality(graph) indeg_dict = dict((nodes_dict[key], indeg_dict[key]) for key in nodes_dict if key in indeg_dict) indeg_list = dict_to_sorted_list(indeg_dict) with open(path, 'w') as out: out.write('***In-Degree Centrality***\n') out.write('Node\tLayer\tIn-degree centrality\n') for element in indeg_list: out.write('%d\t%d\t%f\n' % (element[0][0], element[0][1], element[1]))
def describe_graph(G): """Graph description""" # GRAPH DESCRIPTION graph_desc = pd.Series() # n. nodes graph_desc["number_of_nodes"] = G.number_of_nodes() # n. edges graph_desc["number_of_edges"] = G.number_of_edges() # n. of selfloops graph_desc["number_of_selfloops"] = len(G.selfloop_edges()) # density graph_desc["average_shortest_path_length"] = nx.average_shortest_path_length(G) # connectivity # graph_desc.append(pd.Series(nx.degree_assortativity_coefficient(G), name="degree_assortativity_coefficient")) graph_desc["degree_pearson_correlation_coefficient"] = nx.degree_pearson_correlation_coefficient(G) # NODE DESCRIPTION node_desc = list() # n. of neighbours node_desc.append(pd.Series(G.degree(), name="degree")) node_desc.append(pd.Series(nx.average_neighbor_degree(G), name="average_neighbor_degree")) # n. of outgoing outgoing = pd.Series(G.in_degree(), name="in_degree") node_desc.append(outgoing) # n. of incoming incoming = pd.Series(G.out_degree(), name="out_degree") node_desc.append(incoming) # fold change out/in ratio = np.log2(outgoing + 1) - np.log2(incoming + 1) node_desc.append(pd.Series(ratio, name="out_in_degree_fold_change")) # centrality # degree based node_desc.append(pd.Series(nx.degree_centrality(G), name="degree_centrality")) node_desc.append(pd.Series(nx.in_degree_centrality(G), name="in_degree_centrality")) node_desc.append(pd.Series(nx.out_degree_centrality(G), name="out_degree_centrality")) # closest-path based # node_desc.append(pd.Series(nx.closeness_centrality(G), name="closeness_centrality")) # node_desc.append(pd.Series(nx.betweenness_centrality(G), name="betweenness_centrality")) # # eigenvector-based # node_desc.append(pd.Series(nx.eigenvector_centrality(G), name="eigenvector_centrality")) # node_desc.append(pd.Series(nx.katz_centrality_numpy(G), name="katz_centrality")) # # load-based # node_desc.append(pd.Series(nx.load_centrality(G), name="load_centrality")) return (graph_desc, pd.DataFrame(node_desc).T)
def analyzer_centrality(request, project): projects = Project.objects.all() obj = get_project(request, project) G = nx.DiGraph() nodes = obj.nodeset_set.all() links = obj.network_set.all() for node in nodes: G.add_node(node.idnumber, name=node.name) for link in links: G.add_edge(link.sourceID, link.targetID, weight=link.weight) indeg_centrality = nx.in_degree_centrality(G) outdeg_centrality = nx.out_degree_centrality(G) deg_centrality = nx.degree_centrality(G) closeness_centrality = nx.closeness_centrality(G) betweenness_centrality = nx.betweenness_centrality(G) for key, value in indeg_centrality.items(): p = obj.nodeset_set.filter(idnumber=key) p.update(indegree_centrality=round(value, 3)) for key, value in outdeg_centrality.items(): p = obj.nodeset_set.filter(idnumber=key) p.update(outdegree_centrality=round(value, 3)) for key, value in deg_centrality.items(): p = obj.nodeset_set.filter(idnumber=key) p.update(degree_centrality=round(value, 3)) for key, value in closeness_centrality.items(): p = obj.nodeset_set.filter(idnumber=key) p.update(closeness_centrality=round(value, 3)) for key, value in betweenness_centrality.items(): p = obj.nodeset_set.filter(idnumber=key) p.update(betweenness_centrality=round(value, 3)) nodeset = obj.nodeset_set.all() context = {'nodeset': nodeset, 'object': obj, 'projects': projects, } return render(request, 'centrality.html', context)
def getHugeStats(g): if nx.is_directed(g) == True: P1 = pd.DataFrame({'load_centrality': nx.load_centrality(g, weight='weight'), 'betweenness_centrality': nx.betweenness_centrality(g, weight='weight'), 'pagerank': pd.Series(nx.pagerank(g, alpha=0.85, personalization=None, max_iter=100, tol=1e-08, nstart=None, weight='weight')), 'eigenvector_centrality': nx.eigenvector_centrality_numpy(g), 'degree_centrality': pd.Series(nx.degree_centrality(g)), 'in_degree_centrality': pd.Series(nx.in_degree_centrality(g)), 'out_degree_centrality': pd.Series(nx.out_degree_centrality(g))}) else: P1 = pd.Panel({'spl': pd.DataFrame(nx.shortest_path_length(g)), 'apdp': pd.DataFrame(nx.all_pairs_dijkstra_path(g)), 'apdl': pd.DataFrame(nx.all_pairs_dijkstra_path_length(g)), 'c_exp': pd.DataFrame(nx.communicability_exp(g))}) return P1
def centralities(g): """ Computes graph centrality (betweenneess, indegree, closeness, pageRank) @type graph: networkx graph @param graph: graph @return: a matrix where each columns is a centrality and each row is a node """ bet = nx.betweenness_centrality(g, weight="weight") ind = nx.in_degree_centrality(g) cls = nx.closeness_centrality(g) prk = nx.pagerank(g) M = zip(bet, bet.values(), ind.values(), cls.values(), prk.values()) return M
def degree(self): """Compute in-degree centrality for words coded by Free Association. Returns ------- degree : dict The association of each word to its in-degree. Each incoming link counts as 1 (i.e. link weights are ignored). Words with zero incoming links are removed from the dict. """ # Assumes a directed unweighted graph. logger.info('Computing FreeAssociation degree') degree = nx.in_degree_centrality(self._norms_graph) self._remove_zeros(degree) logger.info('Done computing FreeAssociation degree') return degree
def analyze_graphs(graphs, days): undirected_graphs = list(map(lambda G: G.to_undirected(), graphs)) graph_days = dict(zip(undirected_graphs, days)) connected_graphs = list(filter(lambda G: nx.is_connected(G), undirected_graphs)) connected_days = dict(zip(connected_graphs, list(map( lambda G: graph_days[G], connected_graphs)))) metrics = { #"average_shortest_path_lengths": [lambda G: nx.average_shortest_path_length(G), connected_graphs, connected_days], "clustering": [lambda G: nx.average_clustering(G), undirected_graphs, graph_days], "average_neighbor_degree": [lambda G: nx.average_neighbor_degree(G), graphs, graph_days], "min_weighted_vertex_cover": [lambda G: len(min_weighted_vertex_cover(G)), undirected_graphs, graph_days], #"eccentricity": [lambda G: np.mean(nx.eccentricity(G).values()), connected_graphs, connected_days], #"diameter": [lambda G: nx.diameter(G), connected_graphs, connected_days], #"periphery": [lambda G: len(nx.periphery(G)), connected_graphs, connected_days], "degree_centralities": [lambda G: np.mean(nx.degree_centrality(G).values()), graphs, graph_days], "in_degree_centralities": [lambda G: np.mean(nx.in_degree_centrality(G).values()), graphs, graph_days], "out_degree_centralities": [lambda G: np.mean(nx.out_degree_centrality(G).values()), graphs, graph_days], "closeness_centralities": [lambda G: np.mean(nx.closeness_centrality(G).values()), graphs, graph_days], "betweenness_centralities": [lambda G: np.mean(nx.betweenness_centrality(G).values()), graphs, graph_days] } for metric in metrics: print("Analyzing {}...".format(metric)) function = metrics[metric][0] which_graphs = metrics[metric][1] which_days = metrics[metric][2].values() yArray = list(map(function, which_graphs)) print(which_days) print(yArray) plt.plot(which_days, yArray) plt.xlabel("Day") plt.ylabel(metric) plt.title("{} Over Time".format(metric)) plt.savefig("{}_VS_Time.png".format(metric)) plt.close()
def calculate_centrality_measures(G, create_using, directed): measures = [] centrality_dict = {} #check for directed or undirected if (directed): centrality_dict['in_degree'] = nx.in_degree_centrality(G) centrality_dict['out_degree'] = nx.out_degree_centrality(G) else: centrality_dict['degree'] = nx.degree_centrality(G) #print "Completed degree" #calculate harmonic if graph is disconnected if is_connected(G, directed): centrality_dict['closeness'] = nx.closeness_centrality(G) else: centrality_dict['harmonic'] = nx.harmonic_centrality(G) #print "Completed closeness_centrality" centrality_dict['betweenness'] = nx.betweenness_centrality(G) #print "Completed betweenness" centrality_dict['eigen'] = nx.eigenvector_centrality(G) centrality_dict['pagerank'] = nx.pagerank(G) G_prime = G if directed: G_prime = nx.read_edgelist(sys.argv[1], nodetype=int) centrality_dict['clustering'] = nx.clustering(G_prime) print_tsv(centrality_dict)
def degree_centrality(G): #degree_centrality dictionary_centrality = nx.in_degree_centrality(directed_G) return dictionary_centrality
def degree_centrality(G): dc = nx.in_degree_centrality(G)#degree dc1 = sorted(dc.iteritems(),key=itemgetter(1),reverse=True)#排序 ndc = [e[0] for e in dc1] return ndc[:10]
def test_indegree_centrality(self): d = nx.in_degree_centrality(self.G) exact = {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0, 5: 0.625, 6: 0.125, 7: 0.125, 8: 0.125} for n,dc in d.items(): assert_almost_equal(exact[n], dc)
def add_in_degree_node(graf): print "Adding IN degree to nodes" d_dict = nx.in_degree_centrality(graf) nx.set_node_attributes(graf, 'deg_in', d_dict)
def createGraph(infile, seed, flag): data = loadData(infile) DG = nx.DiGraph() for node in data: DG.add_node(node) DG.node[node]['layer'] = data[node]['layer'] for node in data: edges = [(node, ref) for ref in data[node]['refs'] if ref in data] DG.add_edges_from(edges) ### Plot graph, assigning each layer a different color outfile = "test_layer_{0}.png".format(flag) pos = nx.pygraphviz_layout(DG) colors = [DG.node[node]['layer'] for node in DG.nodes()] size_cm = 90 size_sp = 180 sizes = [size_cm + size_sp*(node==seed) for node in DG.nodes()] nx.draw_networkx(DG, pos, node_color = colors, cmap=plt.get_cmap('jet'), node_size=sizes, with_labels=False) plt.savefig(outfile) plt.clf() ### Graphviz A = nx.to_agraph(DG) layer_of_nodes = [] layer = 0 sorted_nodes = sorted(data.items(), key = lambda x: x[1]['layer']) layer_of_nodes = [k[0] for k in sorted_nodes if k[1]['layer'] == layer] while (len(layer_of_nodes) > 0): A.add_subgraph(layer_of_nodes, rank='same') layer += 1 layer_of_nodes = [k[0] for k in sorted_nodes if k[1]['layer'] == layer] outfile = "test2_{0}.png".format(flag) A.draw(outfile, prog='dot') ### Find Communities #seed = 7037476 G = DG.to_undirected() partition = community.best_partition(G) num_of_communities = sorted(partition.values(), reverse=True)[0] + 1 print "number of communities: ", num_of_communities # number of nodes in each communites values = [partition.get(node) for node in G.nodes()] seed_community = partition.get(seed) print "seed belongs to community ", seed_community seed_community_lst = [node for node in G.nodes() if partition.get(node) == seed_community] saveSeedCommunity(seed_community_lst, 'seed_community.p') counter = collections.Counter(values) print "number of nodes in each community: ", counter.most_common(num_of_communities) outfile = "test_communities_{0}.png".format(flag) pos = nx.pygraphviz_layout(DG) colors = [partition.get(node) for node in DG.nodes()] size_cm = 90 size_sp = 180 sizes = [size_cm + size_sp*(node==seed) for node in DG.nodes()] nx.draw_networkx(DG, pos, node_color = colors, cmap=plt.get_cmap('jet'), node_size = sizes, with_labels=False) #nx.draw_networkx_nodes(G, pos, nodelist=[seed], node_size=size_sp, node_color = [partition.get(seed)], with_labels=False) plt.savefig(outfile) plt.clf() ### Draw community graph (each community is denoted as one node) CG = nx.DiGraph() keywords = community_keywords(data, partition) for i in range(num_of_communities): CG.add_node(i) CG.node[i]['keywords'] = keywords[i] for i in range(num_of_communities): if i == partition.get(seed): CG.node[i]['distance'] = 0 else: CG.node[i]['distance'] = community_distance(DG, partition, seed, i) print nx.get_node_attributes(CG, 'distance') nodes_distance_lst = sorted(CG.nodes(), key = lambda x: CG.node[x]['distance'], reverse=True) for i in range(len(nodes_distance_lst)): target = nodes_distance_lst[i] for j in range(i+1, len(nodes_distance_lst)): source = nodes_distance_lst[j] if community_direct_connectivity(DG, partition, source, target): CG.add_edge(source, target) """ for source in CG.nodes(): for target in CG.nodes(): if source != target and community_connectivity(DG, partition, source, target): CG.add_edge(source, target) for e in CG.edges(): for k in CG.nodes(): if e[0] != k and (e[0], k) in CG.edges() and (k, e[1]) in CG.edges(): CG.remove_edge(e[0], e[1]) break """ print CG.edges() outfile = "test_concentrate_{0}.png".format(flag) pos = nx.pygraphviz_layout(CG) colors = [node for node in CG.nodes()] size_cm = 180 size_sp = 270 sizes = [size_cm + size_sp*(node==partition.get(seed)) for node in CG.nodes()] nx.draw_networkx(CG, pos, node_color = colors, cmap=plt.get_cmap('jet'), node_size = sizes, with_labels=False) nx.draw_networkx_labels(CG, pos, labels = keywords) #nx.draw_networkx_nodes(G, pos, nodelist=[seed], node_size=size_sp, node_color = [partition.get(seed)], with_labels=False) plt.savefig(outfile) plt.clf() ### Find representatives in each community (naive way: based on degree centrality) degreeCentl = nx.in_degree_centrality(DG) print "representatives in each community: " community_index = 0 representatives = [] while(community_index < num_of_communities): nodes_lst = [node for node in DG if partition.get(node) == community_index] tmp = sorted(nodes_lst, key = lambda x:degreeCentl[x], reverse=True)[0:len(nodes_lst)/5] #tmp = sorted(nodes_lst, key = lambda x:degreeCentl[x], reverse=True)[0:1] print tmp representatives += tmp community_index += 1 # add the seed node representatives.append(seed) # community representative graph RG = nx.DiGraph() for node in representatives: RG.add_node(node) nodes_time_lst = sorted(RG.nodes(), key = lambda x: getYear(data[x]['date'])) for i in range(len(nodes_time_lst)): target = nodes_time_lst[i] for j in range(i+1, len(nodes_time_lst)): source = nodes_time_lst[j] if nx.has_path(DG, source, target): RG.add_edge(source, target) break # add direct reference edge #for node in nodes_time_lst: # tmp = [k for k in data[node]['refs'] if k in nodes_time_lst] # for ref in tmp: # RG.add_edge(node, ref) """ for source in representatives: for target in representatives: if source != target and nx.has_path(DG, source, target): RG.add_edge(source, target) edge_lst = RG.edges() for e in RG.edges(): for k in representatives: if e[0] != k and (e[0], k) in RG.edges() and (k, e[1]) in RG.edges(): RG.remove_edge(e[0], e[1]) break """ outfile = "representative_graph_{0}.png".format(flag) pos = nx.spring_layout(RG) size_cm = 180 size_sp = 270 colors = [partition.get(node) for node in RG] sizes = [size_cm + size_sp*(node==seed) for node in RG] nx.draw_networkx(RG, pos, node_color = colors, cmap=plt.get_cmap('jet'), node_size = sizes, with_labels = True) plt.savefig(outfile) plt.clf() # draw the "important" papers layer-by-layer layer = 0 RG.node[seed]['layer'] = layer curr_layer = [seed] while(len(curr_layer) > 0): next_layer = list(set([e[1] for e in RG.edges() if e[0] in curr_layer])) layer += 1 for node in next_layer: RG.node[node]['layer'] = layer curr_layer = next_layer A = nx.to_agraph(RG) layer = 0 layer_of_nodes = [k for k in RG.nodes() if RG.node[k]['layer'] == layer] while (len(layer_of_nodes) > 0): A.add_subgraph(layer_of_nodes, rank='same') layer += 1 layer_of_nodes = [k for k in RG.nodes() if RG.node[k]['layer'] == layer] outfile = "test3_{0}.png".format(flag) A.draw(outfile, prog='dot') """
''' Created on Oct 20, 2013 @author: dhanyatha.manjunath ''' import networkx as nx from operator import itemgetter from collections import Counter mygraph=nx.read_edgelist("E:/Social Media Mining/Project/Crawler Run/edge-list.txt", delimiter=',', create_using=nx.DiGraph(), data="false") eigen_vec_cen=Counter(nx.eigenvector_centrality(mygraph,max_iter=300)) y=sorted(eigen_vec_cen.items(), key=itemgetter(1), reverse=True) in_deg_ce=Counter(nx.in_degree_centrality(mygraph)) x=sorted(in_deg_ce.items(), key=itemgetter(1), reverse=True) top_degree=Counter(x[:3]) print("Top three degree centrality nodes are") for e in top_degree: print("Total degree is"+ str(mygraph.degree(e))) print("Indegree is"+str(mygraph.in_degree(e))) print("OutDegree is"+ str(mygraph.out_degree(e))) print("Degree Centrality=") print(top_degree[e[1]]) print("Eigen vector centrality=") print(eigen_vec_cen[e[0]]) print("\n")
def main(): # 1.0 Loading a local data file # Load the Hartford drug users data, a directed binary graph. # We will specify that the graph be generated as a directed graph, and # that the nodes are integers (rather than strings) hartford=nx.read_edgelist("../../data/hartford_drug.txt",create_using=nx.DiGraph(),nodetype=int) nx.info(hartford) # Check the the data has been loaded properly # 2.0 Connecting to a database # 3.0 Building a network directly from the Internet # WARNING: This can take a long time to run! seed="imichaeldotorg" # Set the seed user within livejournal.com seed_url="http://"+seed+".livejournal.com" # 3.1 Scrape, parse and build seed's ego net sg=get_sg(seed_url) net,newnodes=create_egonet(sg) nx.write_pajek(net,"../../data/"+seed+"_ego.net") # Save data as Pajek nx.info(net) # 3.2 Perform snowball search, where k=2 k=2 for g in range(k): net,newnodes=snowball_round(net,newnodes) nx.write_pajek(net,"../../data/"+seed+"_step_"+str(g+1)+".net") # 4.0 Calculate in-degree centrality for Hartford data in_cent=nx.in_degree_centrality(hartford) # 5.0 Calculating multiple measures, and finding # most central actors hartford_ud=hartford.to_undirected() hartford_mc=nx.connected_component_subgraphs(hartford_ud)[0] # First, extract MC # 5.1 Calculate multiple measures on MC bet_cen=nx.betweenness_centrality(hartford_mc) clo_cen=nx.closeness_centrality(hartford_mc) eig_cen=nx.eigenvector_centrality(hartford_mc) # 5.2 Find the actors with the highest centrality for each measure, print("Actor "+str(highest_centrality(bet_cen))+" has the highest Betweenness centrality") print("Actor "+str(highest_centrality(clo_cen))+" has the highest Closeness centrality") print("Actor "+str(highest_centrality(eig_cen))+" has the highest Eigenvector centrality") # 6.0 Calculating degree distribution ba_net=nx.barabasi_albert_graph(1000,2) # Create a Barabasi-Albert network # 6.1 NX has a nice built-in function for degree distribution dh=nx.degree_histogram(ba_net) # 6.2 Plot using same method as http://networkx.lanl.gov/examples/drawing/degree_histogram.html pos=nx.spring_layout(ba_net) P.figure(figsize=(8,8)) P.loglog(dh,'b-',marker='o') P.title("Degree rank plot (log-log)") P.ylabel("Degree") P.xlabel("Frequency") # 6.4 Draw graph in inset P.axes([0.45,0.45,0.45,0.45]) P.axis('off') nx.draw_networkx_nodes(ba_net,pos,node_size=20) nx.draw_networkx_edges(ba_net,pos,alpha=0.4) P.savefig("../../images/figures/ba_10000.png") # 6.0 Finding community structure clus=nx.clustering(hartford_mc,with_labels=True) # 6.1 Get counts of nodes membership for each clustering coefficient unique_clus=list(unique(clus.values())) clus_counts=zip(map(lambda c: clus.values().count(c),unique_clus),unique_clus) clus_counts.sort() clus_counts.reverse() # 6.2 Create a subgraph from nodes with most frequent clustering coefficient mode_clus_sg=nx.subgraph(hartford_mc,[(a) for (a,b) in clus.items() if b==clus_counts[0][1]]) P.figure(figsize=(6,6)) nx.draw_spring(mode_clus_sg,with_labels=False,node_size=60,iterations=1000) P.savefig('../../images/networks/mode_clus_sg.png') # 7.0 Plot Eigenvector centrality vs. betweeness in matplotlib centrality_scatter(bet_cen,eig_cen,"../../images/figures/drug_scatter.png",ylab="Eigenvector Centrality",xlab="Betweenness Centrality",title="Hartford Drug Network Key Actor Analysis",reg=True) # 8.0 Outputting network data # First, output the data as an adjaceny list nx.write_adjlist(hartford_mc,"../../data/hartford_mc_adj.txt") # 8.1 Add metric data to the network object hartford_mc_met=add_metric(hartford_mc,eig_cen) print(hartford_mc_met.nodes(data=True)[1:10]) # Check the the data was stored # 8.2 output data using the Pajak format to save the node attribute data nx.write_pajek(hartford_mc,"../../data/hartford_mc_metric.net") # NX will automatically add all attibute data to output # 9.0 Exporting data to a CSV file csv_data={"Betweeness":bet_cen,"Closeness":clo_cen,"Eigenvector":eig_cen} # 9.1 After we have all the data in a single dict, we send it to out function # to export the data as a CSV csv_exporter(csv_data,"../../data/drug_data.csv") # 10.0 Visualization basics # 10.1 Use subplots to draw random and circular layouts # of drug net side-by-side fig1=P.figure(figsize=(9,4)) fig1.add_subplot(121) nx.draw_random(hartford_mc,with_labels=False,node_size=60) fig1.add_subplot(122) nx.draw_circular(hartford_mc,with_labels=False,node_size=60) P.savefig("../../images/networks/rand_circ.png") # 10.2 Draw spring, spectral layouts P.figure(figsize=(8,8)) nx.draw_spring(hartford_mc,with_labels=False,node_size=60,iterations=10000) P.savefig("../../images/networks/spring.png") P.figure(figsize=(8,8)) nx.draw_spectral(hartford_mc,with_labels=False,node_size=60,iterations=10) P.savefig("../../images/networks/spectral.png") # 10.3 Draw shell layout with inner-circle as the 25th percentile # Eigenvector centrality actors P.figure(figsize=(8,8)) # Find actors in 25th percentile max_eig=max([(b) for (a,b) in eig_cen.items()]) s1=[(a) for (a,b) in eig_cen.items() if b>=.25*max_eig] s2=hartford_mc.nodes() # setdiff1d is a very useful NumPy function! s2=list(setdiff1d(s2,s1)) shells=[s1,s2] # Calculate psotion and draw shell_pos=nx.shell_layout(hartford_mc,shells) nx.draw_networkx(hartford_mc,shell_pos,with_labels=False,node_size=60) P.savefig("../../images/networks/shell.png") # 11.0 Adding analysis to visualization P.figure(figsize=(15,15)) P.subplot(111,axisbg="lightgrey") spring_pos=nx.spring_layout(hartford_mc,iterations=1000) # 11.1 Use betweeneess centrality for node color intensity bet_color=bet_cen.items() bet_color.sort() bet_color=[(b) for (a,b) in bet_color] # 11.2 Use Eigenvector centrality to set node size eig_size=eig_cen.items() eig_size.sort() eig_size=[((b)*2000)+20 for (a,b) in eig_size] # 11.3 Use matplotlib's colormap for node intensity nx.draw_networkx(hartford_mc,spring_pos,node_color=bet_color,cmap=P.cm.Greens,node_size=eig_size,with_labels=False) P.savefig("../../images/networks/analysis.png")
def make_net(centrality_name, in_path, out_path): #sample code #import _2_time_based_data_network_feature #make_net_in_path = "../3.time_based_data/1.cite_relation_devide/" #make_net_out_path = "../3.time_based_data/2.centrality_data/" #_2_time_based_data.make_net( "in_degree", make_net_in_path, make_net_out_path) #네트워크를 만들고 Centurality를 계산하고 저장할 것이다. import networkx as nx global Dump Dump = {} make_net_initialize(in_path) start_time = time.time() temp_start_time = time.time() print "============= make_net start:" + centrality_name + " ==============" print "============= from 1951 to 2015 ==============" for year in range(1951, 2016): print year f_in = open(in_path + str(year) + "_cite.csv","r") lines = f_in.readlines() f_in.close() edge_list = [] for line in lines: data = line.split(",") data_tuple = (data[0].strip(), data[1].strip()) edge_list.append(data_tuple) Net = nx.DiGraph(edge_list) Cen_in = {} if (centrality_name == "in_degree"): Cen_in = nx.in_degree_centrality(Net) elif (centrality_name == "degree"): Cen_in = nx.degree_centrality(Net) elif (centrality_name == "eigenvector"): Cen_in = nx.eigenvector_centrality_numpy(Net) elif (centrality_name == "katz"): Cen_in = nx.katz_centrality(Net) elif (centrality_name == "pagerank"): Cen_in = nx.pagerank(Net) elif (centrality_name == "communicability"): Net = nx.Graph(edge_list) Cen_in = nx.communicability_centrality(Net) elif (centrality_name == "load"): Cen_in = nx.load_centrality(Net) for j in Cen_in: key = j val = Cen_in[j] Dump[key][year] = val #저장하는 코드 f_out = open(out_path + centrality_name +"_centrality.csv", "w") for key in Dump: line = str(key) for year in range(1951, 2016): data = Dump[key].get(year, 0) line = line + ","+ str(data) line = line + "\n" f_out.write(line) f_out.close() print "============= make_net end ==============" print(centrality_name + "takes %s seconds" % (time.time() - temp_start_time)) temp_start_time = time.time()
def main(argv): #Standardvalues partitionfile = "data/partitions/final_partitions_p100_200_0.2.csv" project = "584" to_pajek = False try: opts, args = getopt.getopt(argv,"p:s:o") except getopt.GetoptError: print 'group_bridging.py -p <project_name> -s <partitionfile> -o [if you want pajek output]' sys.exit(2) for opt, arg in opts: if opt in ("-p"): project = arg elif opt in ("-s"): partitionfile = arg elif opt in ("-o"): to_pajek = True else: print 'group_bridging.py -p <project_name> -s <partitionfile> -o [if you want pajek output]' print "##################### GROUP BRIDGING ########################" print "Project %s " % project print "Partition %s" % partitionfile ff_edges_writer = csv.writer(open("results/%s_ff_bridging_edges.csv" % project, "wb")) at_edges_writer = csv.writer(open("results/%s_at_bridging_edges.csv" % project, "wb")) rt_edges_writer = csv.writer(open("results/%s_rt_bridging_edges.csv" % project, "wb")) csv_bridging_writer = csv.writer(open('results/spss/group bridging/%s_group_bridging.csv' % project , 'wb')) csv_bridging_writer.writerow(["Project", "Name", "Member_count", "Competing_Lists", "FF_bin_degree", "FF_bin_in_degree", "FF_bin_out_degree", "FF_volume_in","FF_volume_out", "FF_bin_betweeness","FF_bin_closeness", "FF_bin_pagerank", #"FF_bin_eigenvector", "FF_bin_c_size","FF_bin_c_density","FF_bin_c_hierarchy","FF_bin_c_index", "AT_bin_degree", "AT_bin_in_degree", "AT_bin_out_degree", "AT_bin_betweeness", "AT_bin_closeness", "AT_bin_pagerank", #"AT_bin_eigenvector", "AT_bin_c_size","AT_bin_c_density","AT_bin_c_hierarchy","AT_bin_c_index", "AT_volume_in", "AT_volume_out", "RT_volume_in", "RT_volume_out", "FF_rec", "AT_rec", "AT_avg", "FF_avg"]) # Get the overall network from disk FF = nx.read_edgelist('data/networks/%s_FF.edgelist' % project, nodetype=str, data=(('weight',float),),create_using=nx.DiGraph()) AT = nx.read_edgelist('data/networks/%s_solr_AT.edgelist' % project, nodetype=str, data=(('weight',float),),create_using=nx.DiGraph()) RT = nx.read_edgelist('data/networks/%s_solr_RT.edgelist' % project, nodetype=str, data=(('weight',float),),create_using=nx.DiGraph()) # Read in the partition tmp = hp.get_partition(partitionfile) partitions = tmp[0] groups = tmp[1] #Read in members count for each project reader = csv.reader(open("results/stats/%s_lists_stats.csv" % project, "rb"), delimiter=",") temp = {} reader.next() # Skip first row for row in reader: temp[row[0]] = {"name":row[0],"member_count":int(row[3])} #Read in the list-listings for individuals listings = {} indiv_reader = csv.reader(open(partitionfile)) for row in indiv_reader: if listings.has_key(row[1]): listings[row[1]]["competing_lists"] += int(row[3]) else: listings[row[1]] = {"competing_lists": int(row[3])} # Add dummy nodes if they are missing in the networks for partition in partitions: for node in partition: FF.add_node(node) AT.add_node(node) RT.add_node(node) #Blockmodel the networks into groups according to the partition P_FF = nx.blockmodel(FF,partitions) P_AT = nx.blockmodel(AT,partitions) P_RT = nx.blockmodel(RT,partitions) #Name the nodes in the network #TODO check: How do I know that the names really match? mapping = {} mapping_pajek = {} i = 0 for group in groups: mapping_pajek[i] = "\"%s\"" % group # mapping for pajek mapping[i] = "%s" % group i += 1 H_FF = nx.relabel_nodes(P_FF,mapping) H_AT = nx.relabel_nodes(P_AT,mapping) H_RT = nx.relabel_nodes(P_RT,mapping) #Outpt the networks to pajek if needed if to_pajek: OUT_FF = nx.relabel_nodes(P_FF,mapping_pajek) OUT_AT = nx.relabel_nodes(P_AT,mapping_pajek) OUT_RT = nx.relabel_nodes(P_RT,mapping_pajek) #Write the blocked network out to disk nx.write_pajek(OUT_FF,"results/networks/%s_grouped_FF.net" % project) nx.write_pajek(OUT_AT,"results/networks/%s_grouped_AT.net" % project) nx.write_pajek(OUT_RT,"results/networks/%s_grouped_RT.net" % project) ########## Output the Edges between groups to csv ############## # Needed for the computation of individual bridging # Edges in both directions between the groups are addded up processed_edges = [] for (u,v,attrib) in H_FF.edges(data=True): if "%s%s" %(u,v) not in processed_edges: processed_edges.append("%s%s" % (u,v)) if H_FF.has_edge(v,u): processed_edges.append("%s%s" % (v,u)) ff_edges_writer.writerow([u,v,attrib["weight"]+H_FF[v][u]["weight"]]) else: ff_edges_writer.writerow([u,v,attrib["weight"]]) processed_edges = [] for (u,v,attrib) in H_AT.edges(data=True): if "%s%s" %(u,v) not in processed_edges: processed_edges.append("%s%s" % (u,v)) if H_AT.has_edge(v,u): processed_edges.append("%s%s" % (v,u)) at_edges_writer.writerow([u,v,attrib["weight"]+H_AT[v][u]["weight"]]) else: at_edges_writer.writerow([u,v,attrib["weight"]]) processed_edges = [] for (u,v,attrib) in H_RT.edges(data=True): if "%s%s" %(u,v) not in processed_edges: processed_edges.append("%s%s" % (u,v)) if H_RT.has_edge(v,u): processed_edges.append("%s%s" % (v,u)) rt_edges_writer.writerow([u,v,attrib["weight"]+H_RT[v][u]["weight"]]) else: rt_edges_writer.writerow([u,v,attrib["weight"]]) ########## TRIM EDGES ################ # For meaningfull results we have to trim edges in the AT and FF network so the whole network just doesnt look like a blob # It is chosen this way so the network remains as one component THRESHOLD = min([hp.min_threshold(H_AT),hp.min_threshold(H_FF)])-1 H_FF = hp.trim_edges(H_FF, THRESHOLD) H_AT = hp.trim_edges(H_AT, THRESHOLD) ########## MEASURES ############## #Get the number of nodes in the aggregated networks #FF_nodes = {} #for node in H_FF.nodes(data=True): # FF_nodes[node[0]] = node[1]["nnodes"] #Get the FF network measures of the nodes # Works fine on binarized Data FF_bin_degree = nx.degree_centrality(H_FF) FF_bin_in_degree = nx.in_degree_centrality(H_FF) # The attention paid towards this group FF_bin_out_degree = nx.out_degree_centrality(H_FF) # The attention that this group pays towards other people FF_bin_betweenness = nx.betweenness_centrality(H_FF,weight="weight") # How often is the group between other groups FF_bin_closeness = nx.closeness_centrality(H_FF) #FF_bin_eigenvector = nx.eigenvector_centrality(H_FF) FF_bin_pagerank = nx.pagerank(H_FF) FF_bin_struc = sx.structural_holes(H_FF) # AT network measures of the nodes AT_bin_degree = nx.degree_centrality(H_AT) AT_bin_in_degree = nx.in_degree_centrality(H_AT) AT_bin_out_degree = nx.out_degree_centrality(H_AT) AT_bin_betweenness = nx.betweenness_centrality(H_AT,weight="weight") AT_bin_closeness = nx.closeness_centrality(H_AT) #AT_bin_eigenvector = nx.eigenvector_centrality(H_AT) AT_bin_pagerank = nx.pagerank(H_AT) AT_bin_struc = sx.structural_holes(H_AT) # Tie strengths dAT_avg_tie = hp.individual_average_tie_strength(H_AT) dFF_avg_tie = hp.individual_average_tie_strength(H_FF) dAT_rec = hp.individual_reciprocity(H_AT) dFF_rec = hp.individual_reciprocity(H_FF) # Dependent Variable see csv # TODO A measure that calculates how often Tweets travel through this group: Eventually betweeness in the RT graph #Arrange it in a list and output for node in FF_bin_degree.keys(): csv_bridging_writer.writerow([project, node, int(temp[node]["member_count"]), listings[node]["competing_lists"], FF_bin_degree[node], FF_bin_in_degree[node], FF_bin_out_degree[node], H_FF.in_degree(node,weight="weight"), H_FF.out_degree(node,weight="weight"), FF_bin_betweenness[node],FF_bin_closeness[node],FF_bin_pagerank[node], #FF_bin_eigenvector[node], FF_bin_struc[node]['C-Size'],FF_bin_struc[node]['C-Density'],FF_bin_struc[node]['C-Hierarchy'],FF_bin_struc[node]['C-Index'], AT_bin_degree[node], AT_bin_in_degree[node], AT_bin_out_degree[node], AT_bin_betweenness[node], AT_bin_closeness[node], AT_bin_pagerank[node], #AT_bin_eigenvector[node], AT_bin_struc[node]['C-Size'],AT_bin_struc[node]['C-Density'],AT_bin_struc[node]['C-Hierarchy'],AT_bin_struc[node]['C-Index'], H_AT.in_degree(node,weight="weight"), H_AT.out_degree(node,weight="weight"), H_RT.in_degree(node,weight="weight"), H_RT.out_degree(node,weight="weight"), dFF_rec[node],dAT_rec[node],dAT_avg_tie[node],dFF_avg_tie[node] ])