def print_clustering_metrics(graph): print("\n===== Clustering Metrics ======") if not graph.is_multigraph(): print("Transitivity: ", nx.transitivity(graph)) print("") if not nx.is_directed(graph): triangles_values = list(nx.triangles(graph).values()) print("# triangles: ", sum(triangles_values)) print("Average triangles: ", sum(triangles_values)/len(triangles_values)) print("Minimum # triangles: ", min(triangles_values)) print("Maximum # triangles: ", max(triangles_values)) print_top_n_by_metric(nx.triangles(graph),"# of triangles") clustercoff_values = list(nx.clustering(graph).values()) print("Average clustering coefficient: ", sum(clustercoff_values)/len(clustercoff_values)) print("Minimum clustering coefficient: ", min(clustercoff_values)) print("Maximum clustering coefficient: ", max(clustercoff_values)) print_top_n_by_metric(nx.clustering(graph),"clustering coefficient") print("") clustercoff_values = list(nx.square_clustering(graph).values()) print("Average square clustering coefficient: ", sum(clustercoff_values)/len(clustercoff_values)) print("Minimum square clustering coefficient: ", min(clustercoff_values)) print("Maximum square clustering coefficient: ", max(clustercoff_values)) print_top_n_by_metric(nx.square_clustering(graph), "square clustering coefficient") print("") else: print("Multigraph clustering metrics are not supported by Networkx")
def test_path(self): G = nx.path_graph(10) assert_equal(list(nx.square_clustering(G).values()), [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]) assert_equal(nx.square_clustering(G), {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0, 5: 0.0, 6: 0.0, 7: 0.0, 8: 0.0, 9: 0.0})
def test_cubical(self): G = nx.cubical_graph() assert_equal(list(nx.square_clustering(G).values()), [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]) assert_equal(list(nx.square_clustering(G,[1,2]).values()),[0.5, 0.5]) assert_equal(nx.square_clustering(G,[1])[1],0.5) assert_equal(nx.square_clustering(G,[1,2]),{1: 0.5, 2: 0.5})
def test_path(self): G = nx.path_graph(10) assert list(nx.square_clustering(G).values()) == [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, ] assert nx.square_clustering(G) == { 0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0, 5: 0.0, 6: 0.0, 7: 0.0, 8: 0.0, 9: 0.0, }
def test_lind_square_clustering(self): """Test C4 for figure 1 Lind et al (2005)""" G = nx.Graph([ (1, 2), (1, 3), (1, 6), (1, 7), (2, 4), (2, 5), (3, 4), (3, 5), (6, 7), (7, 8), (6, 8), (7, 9), (7, 10), (6, 11), (6, 12), (2, 13), (2, 14), (3, 15), (3, 16), ]) G1 = G.subgraph([1, 2, 3, 4, 5, 13, 14, 15, 16]) G2 = G.subgraph([1, 6, 7, 8, 9, 10, 11, 12]) assert nx.square_clustering(G, [1])[1] == 3 / 43.0 assert nx.square_clustering(G1, [1])[1] == 2 / 6.0 assert nx.square_clustering(G2, [1])[1] == 1 / 5.0
def test_cubical(self): G = nx.cubical_graph() assert (list(nx.square_clustering(G).values()) == [ 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5 ]) assert list(nx.square_clustering(G, [1, 2]).values()) == [0.5, 0.5] assert nx.square_clustering(G, [1])[1] == 0.5 assert nx.square_clustering(G, [1, 2]) == {1: 0.5, 2: 0.5}
def test_lind_square_clustering(self): """Test C4 for figure 1 Lind et al (2005)""" G = nx.Graph([(1,2),(1,3),(1,6),(1,7),(2,4),(2,5), (3,4),(3,5),(6,7),(7,8),(6,8),(7,9), (7,10),(6,11),(6,12),(2,13),(2,14),(3,15),(3,16)]) G1 = G.subgraph([1,2,3,4,5,13,14,15,16]) G2 = G.subgraph([1,6,7,8,9,10,11,12]) assert_equal(nx.square_clustering(G, [1])[1], 3/75.0) assert_equal(nx.square_clustering(G1, [1])[1], 2/6.0) assert_equal(nx.square_clustering(G2, [1])[1], 1/5.0)
def test_cubical(self): G = nx.cubical_graph() assert list(nx.square_clustering(G).values()) == [ 1 / 3, 1 / 3, 1 / 3, 1 / 3, 1 / 3, 1 / 3, 1 / 3, 1 / 3, ] assert list(nx.square_clustering(G, [1, 2]).values()) == [1 / 3, 1 / 3] assert nx.square_clustering(G, [1])[1] == 1 / 3 assert nx.square_clustering(G, [1, 2]) == {1: 1 / 3, 2: 1 / 3}
def clustering(graph, name='cluster'): """ Calculates the squares clustering coefficient for nodes. .. math:: Parameters ---------- graph : networkx.Graph Graph representing street network. Ideally genereated from GeoDataFrame using :py:func:`momepy.gdf_to_nx` name : str, optional calculated attribute name Returns ------- Graph networkx.Graph References ---------- Examples -------- """ netx = graph vals = nx.square_clustering(netx) nx.set_node_attributes(netx, vals, name) return netx
def node_properties_color_map(graph, coloring_method): node_color = {} if coloring_method is 'betwenness_centrality': node_color = nx.betweenness_centrality(graph) elif coloring_method is 'degree_centrality': node_color = nx.degree_centrality(graph) elif coloring_method is 'closeness_centrality': node_color = nx.closeness_centrality(graph) elif coloring_method is 'eigenvector_centrality': node_color = nx.eigenvector_centrality(graph) elif coloring_method is 'connected_components': componentsDictionary = nx.connected_components(graph) componentLabel = 0 for componentNodes in componentsDictionary: for node in componentNodes: node_color[node] = componentLabel componentLabel = componentLabel + 1 elif coloring_method is 'maximum_modularity_partition': node_color = community.best_modularity_partition(graph) elif coloring_method is 'clustering_coefficient': nx.clustering(graph) node_color = nx.square_clustering(graph) elif coloring_method is 'emisphere': node_color = community.best_partition(graph) for n in node_color.keys(): if n[-1] == 'L': node_color[n] = 0.0 else: node_color[n] = 1.0 elif coloring_method is 'maximum_surprise_partition': node_color = community.best_surprise_partition_louvain(graph) else: raise Exception('Non supported coloring_method') return community.__renumber(node_color)
def clustering(graph, name="cluster"): """ Calculates the squares clustering coefficient for nodes. Wrapper around ``networkx.square_clustering``. Parameters ---------- graph : networkx.Graph Graph representing street network. Ideally generated from GeoDataFrame using :func:`momepy.gdf_to_nx` name : str, optional calculated attribute name Returns ------- Graph networkx.Graph Examples -------- >>> network_graph = mm.clustering(network_graph) """ netx = graph.copy() vals = nx.square_clustering(netx) nx.set_node_attributes(netx, vals, name) return netx
def AttackClustering(graph): iteration = 0 pos = nx.spring_layout(graph, k=0.3) clustering = nx.square_clustering(graph) clusteringList = list(clustering.items()) clusteringList.sort(key=lambda i: i[1], reverse=True) size = len(graph.nodes) while True: if (len(graph.nodes) <= 1): return 0, 0 if ((len(graph.nodes) == 0) and (len(graph.edges) != 0)): SaveGraph(graph, size, pos, 'gif/pic%s.png' % iteration) intaktnost = GenerateIntaktnost(graph, size, pos) return intaktnost, iteration if not nx.is_connected(graph): SaveGraph(graph, size, pos, 'gif/pic%s.png' % iteration) intaktnost = GenerateIntaktnost(graph, size, pos) return intaktnost, iteration if ((iteration + 1) % (size / 10)) == 0: SaveGraph(graph, size, pos, 'gif/pic%s.png' % iteration) graph.remove_node(clusteringList[iteration][0]) iteration += 1
def ClusteringSQ_Calc(G): nodeClustering = nx.square_clustering(G) nodeClustering = dict(nodeClustering) maxClustering = max(nodeClustering.values()) minClustering = min(nodeClustering.values()) averageClustering = (sum(nodeClustering.values()) / len(nodeClustering)) return maxClustering, minClustering, averageClustering, nodeClustering
def data_analysis(self, graph): data_vec = [0] * 13 num_vertex = nx.number_of_nodes(graph) data_vec[0] = nx.average_clustering(graph) sq_values = list(nx.square_clustering(graph).values()) data_vec[1] = sum(sq_values) / len(sq_values) g = nx.path_graph(num_vertex) data_vec[2] = nx.average_shortest_path_length( graph) / nx.average_shortest_path_length(g) data_vec[3] = nx.degree_pearson_correlation_coefficient(graph) if math.isnan(data_vec[3]) is True: data_vec[3] = 0 data_vec[4] = nx.diameter(graph) / (num_vertex - 1) data_vec[5] = nx.density(graph) data_vec[6] = nx.edge_connectivity(graph) / (num_vertex - 1) g = nx.star_graph(num_vertex - 1) Freeman_degree_norm = self.freeman_centralization( nx.degree_centrality(g)) Freeman_close_norm = self.freeman_centralization( nx.closeness_centrality(g)) Freeman_between_norm = self.freeman_centralization( nx.betweenness_centrality(g)) # need to change Freeman_eigen_norm = self.freeman_centralization( nx.eigenvector_centrality_numpy(g)) data_vec[7] = self.freeman_centralization( nx.degree_centrality(graph)) / Freeman_degree_norm data_vec[8] = self.freeman_centralization( nx.closeness_centrality(graph)) / Freeman_close_norm data_vec[9] = self.freeman_centralization( nx.betweenness_centrality(graph)) / Freeman_between_norm # warning, the way it normalized may not correct data_vec[10] = self.freeman_centralization( nx.eigenvector_centrality_numpy(graph)) / Freeman_eigen_norm egvl_lap = nx.laplacian_spectrum(graph) egvl_lap = np.sort(egvl_lap) egvl_lap = np.delete(egvl_lap, 0, 0) summ = 0 for mu in egvl_lap: summ += (1 / mu) summ = summ * num_vertex data_vec[11] = (num_vertex - 1) / summ # for simple graph(adj matrix is symmetric), eigenvalue must be real number. egvl_adj = np.real(nx.adjacency_spectrum(graph)) data_vec[12] = max(egvl_adj) / (num_vertex - 1) return data_vec
def square_clustering(self): """Devuelve un diccionario con el valor square_clustering para cada nodo""" try: g = self.g self.metrics_dict['square-clustering'] = nx.square_clustering(g) return self.metrics_dict['square-clustering'] except nx.exception.PowerIterationFailedConvergence: self.logging_message("Clustering:Power iteration failed.") return self.empty_dict()
def print_sna_metrics(g): """ Prints some SNA metrics using the NetworkX library :param g: ResultSet (cypher) """ print start_time = time.time() degree_centrality = nx.degree_centrality(g) print("Degree Centrality spent %s seconds" % (time.time() - start_time)) user = max(degree_centrality, key=degree_centrality.get) print 'User with maximum Degree Centrality:', user, '- Value:', degree_centrality.get( user) print 'Average Degree Centrality:', np.array( degree_centrality.values()).mean() print start_time = time.time() closeness_centrality = nx.closeness_centrality(g) print("Closeness Centrality spent %s seconds" % (time.time() - start_time)) user = max(closeness_centrality, key=closeness_centrality.get) print 'User with maximum Closeness Centrality:', user, '- Value:', closeness_centrality.get( user) print 'Average Closeness Centrality:', np.array( closeness_centrality.values()).mean() print start_time = time.time() betweenness_centrality = nx.betweenness_centrality(g) print("Betweenness Centrality spent %s seconds" % (time.time() - start_time)) user = max(betweenness_centrality, key=betweenness_centrality.get) print 'User with maximum Betweenness Centrality:', user, '- Value:', betweenness_centrality.get( user) print 'Average Betweenness Centrality:', np.array( betweenness_centrality.values()).mean() print start_time = time.time() print 'Graph Density:', nx.density(g) print("Density spent %s seconds" % (time.time() - start_time)) print start_time = time.time() square_clustering = nx.square_clustering(g) print("Square Clustering spent %s seconds" % (time.time() - start_time)) user = max(square_clustering, key=square_clustering.get) print 'User with maximum Square Clustering:', user, '- Value:', square_clustering.get( user) print 'Average Square Clustering:', np.array( square_clustering.values()).mean() print start_time = time.time() print 'Nodes\' Degree:', nx.degree(g) print("Degree spent %s seconds" % (time.time() - start_time))
def f23(self): start = 0 square_dic = nx.square_clustering(self.G) total = sum(square_dic.values()) no = len(square_dic.values()) res = total/no stop = 0 # self.feature_time.append(stop - start) return res
def calculate(network): try: n = nx.square_clustering(network) except: return 0 if len(n.values()) == 0: return 0 else: return round(sum(n.values())/len(n.values()), 7)
def f23(self): start = 0 square_dic = nx.square_clustering(self.G) total = sum(square_dic.values()) no = len(square_dic.values()) res = total / no stop = 0 # self.feature_time.append(stop - start) return res
def data_analysis(self, graph): data_vec = [0] * 10 # print graph.edges data_vec[0] = nx.transitivity(graph) # print(Matrix[0]) try: data_vec[1] = nx.average_clustering(graph) except: data_vec[1] = 0 dic = nx.square_clustering(graph).values() summation = 0 for e in dic: summation = summation + e try: data_vec[2] = summation / len(dic) except: data_vec[2] = 0 if nx.number_connected_components(graph) != 1: Gc = max(nx.connected_component_subgraphs(graph), key=len) if nx.number_of_nodes(Gc) != 1: data_vec[3] = nx.average_shortest_path_length(Gc) else: data_vec[3] = nx.average_shortest_path_length(graph) try: data_vec[4] = nx.degree_assortativity_coefficient(graph) except: data_vec[4] = 0 if math.isnan(data_vec[4]) is True: data_vec[4] = 0 if nx.number_connected_components(graph) != 1: Gc = max(nx.connected_component_subgraphs(graph), key=len) data_vec[5] = nx.diameter(Gc) else: data_vec[5] = nx.diameter(graph) data_vec[6] = nx.density(graph) # triangle part, calculate the ratio of triangle node_N = nx.number_of_nodes(graph) if node_N < 3: data_vec[7] = 0 else: triangle = sum(nx.triangles(graph).values()) / 3 C_Triangle = math.factorial(node_N) / math.factorial( node_N - 3) / math.factorial(3) data_vec[7] = float(triangle) / C_Triangle data_vec[8] = nx.node_connectivity(graph) data_vec[9] = nx.edge_connectivity(graph) # print data_vec return data_vec
def test_peng_square_clustering(self): """Test eq2 for figure 1 Peng et al (2008)""" G = nx.Graph([ (1, 2), (1, 3), (2, 4), (3, 4), (3, 5), (3, 6), ]) assert nx.square_clustering(G, [1])[1] == 1 / 3
def analyzeBipartiteGraph(graph, e_nodes): # average shortest path length L_r = nx.average_shortest_path_length(graph) # square clustering coefficient of electrodes C_r_dict = nx.square_clustering(graph, e_nodes) C_r_list = [] for key in C_r_dict: C_r_list.append(C_r_dict[key]) C_r = sum(C_r_list) / len(C_r_list) # return L_r and C_r for later analysis return [L_r, C_r]
def calculatesquareclustering(network): ''' Compute the squares clustering coefficient for nodes: the fraction of possible squares that exist at the node. ''' try: n = nx.square_clustering(network) except: return 0 if len(n.values()) == 0: return 0 else: return round(sum(n.values())/len(n.values()), 7)
def get_all_proximity_score(G, edges): proximity_score_list = [[] for i in itertools.repeat(None, len(edges))] cc = [ nx.square_clustering(G, edge[0]) + nx.square_clustering(G, edge[1]) for edge in edges ] cn = [ len(list(nx.common_neighbors(G, edge[0], edge[1]))) for edge in edges ] jc = nx.jaccard_coefficient(G, edges) pa = nx.preferential_attachment(G, edges) rai = nx.resource_allocation_index(G, edges) for i, data in enumerate(cc): proximity_score_list[i].append(data) for i, data in enumerate(cn): proximity_score_list[i].append(data) for i, data in enumerate(jc): proximity_score_list[i].append(data[2]) for i, data in enumerate(pa): proximity_score_list[i].append(data[2]) for i, data in enumerate(rai): proximity_score_list[i].append(data[2]) return proximity_score_list
def write_features(all_graphs): with open("", "w") as f: nr_graphs = len(all_graphs) f.write(str(nr_graphs) + "\n") for graph_name, graph in all_graphs.items(): print(graph_name) nr_example, state, _ = graph_name.split("-") label = create_labels(state) print(label) e_centrality = nx.eigenvector_centrality_numpy(graph) bet_centrality = nx.betweenness_centrality(graph, k=30) # cf_closeness_centrality = nx.current_flow_closeness_centrality(graph) # cf_bet_centrality = nx.current_flow_betweenness_centrality(graph) load_centrality = nx.load_centrality(graph) clustering_coeff = nx.clustering(graph) square_clustering_coeff = nx.square_clustering(graph) f.write("{} {}\n".format(str(graph.number_of_nodes()), str(label))) nodes = sorted(list(graph.nodes())) for n in nodes: neighbors = sorted(list(graph.neighbors(n))) if not neighbors: f.write("{} {} ".format(str(tag), str(0))) else: f.write("{} {} ".format(str(tag), str(len(neighbors)))) for neighbor in neighbors: f.write("{} ".format(str(neighbor))) cc = nx.closeness_centrality(graph, u=n) # degree f.write("{} ".format(graph.degree(n))) # eigenvector centrality f.write("{} ".format(e_centrality[n])) # betweeness centrality f.write("{} ".format(bet_centrality[n])) # closeness centrality f.write("{} ".format(cc)) # current flow closeness centrality f.write("{} ".format(cf_closeness_centrality[n])) # current flow betweeness centrality f.write("{} ".format(cf_bet_centrality[n])) # load centrality f.write("{} ".format(load_centrality[n])) # clustering coefficient f.write("{} ".format(clustering_coeff[n])) # square clustering coefficient f.write("{} ".format(square_clustering_coeff[n])) f.write("\n")
def cluster(self): rslt = {} rslt['transitivity'] = nx.transitivity(self.graph) rslt['square_clustering'] = nx.square_clustering(self.graph) if self.directed == 'undirected': rslt['traingles'] = nx.triangles(self.graph) rslt['clustering'] = nx.clustering(self.graph) rslt['average_clustering'] = nx.average_clustering(self.graph) fname_cluster = self.DIR + '/cluster.json' with open(fname_cluster, "w") as f: json.dump(rslt, f, cls=SetEncoder, indent=2) print(fname_cluster)
def summay_results(nets=None, years=None): if years is None: years = default_years if nets is None: nets = networks_by_year() result = {} previous_devs = None for year, G in zip(years, nets): result[year] = {} devs = set(n for n, d in G.nodes(data=True) if d['bipartite']==1) files = set(G) - devs result[year]['guido_in'] = u'Guido van Rossum' in G result[year]['density'] = bp.density(G, devs) cc = sorted(nx.connected_components(G), key=len, reverse=True) result[year]['cc'] = len(cc[0]) / float(G.order()) if cc else 0 bcc = sorted(nx.biconnected_components(G), key=len, reverse=True) result[year]['bcc'] = len(bcc[0]) / float(G.order()) if bcc else 0 result[year]['devs'] = len(devs) result[year]['files'] = len(files) result[year]['py_files'] = len([f for f in files if f.endswith('.py')]) result[year]['c_files'] = len([f for f in files if f.endswith('.c') or f.endswith('.h')]) result[year]['doc_files'] = len([f for f in files if f.lower().endswith('.txt') or f.endswith('.rst') or f.endswith('.tex')]) result[year]['weight'] = sum(nx.degree(G, devs, weight='weight').values()) result[year]['added'] = sum(nx.degree(G, devs, weight='added').values()) result[year]['deleted'] = sum(nx.degree(G, devs, weight='deleted').values()) result[year]['edits'] = sum(nx.degree(G, devs, weight='edits').values()) result[year]['sq_clustering'] = (sum(nx.square_clustering(G, devs).values()) / float(len(devs))) if previous_devs is None: # First year result[year]['new_devs'] = len(devs) result[year]['continue_devs'] = 0 result[year]['lost_devs'] = 0 else: result[year]['new_devs'] = len(devs - previous_devs) result[year]['continue_devs'] = len(devs & previous_devs) result[year]['lost_devs'] = len(previous_devs - devs) previous_devs = devs return result
def cluster_coefficient(): """ calculate the cluster coefficient and sort nodes by high eccentricity :return: sorted list of nodes """ global G, calculated_ranks if len(calculated_ranks['cluster_coefficient']) == 0: cluster_coeff_per_node = list(nx.square_clustering(G).items()) degree_per_node = list(G.degree()) degree_per_node.sort(key=lambda x: x[0]) cluster_coeff_per_node.sort(key=lambda x: x[0]) adj_cluster_coeff_per_node = [ (degree_per_node[i][0], math.log(degree_per_node[i][1]) * cluster_coeff_per_node[i][1]) if degree_per_node[i][1] > 1 else (degree_per_node[i][0], 0) for i in range(len(degree_per_node)) ] calculated_ranks[ 'cluster_coefficient'] = sort_and_map_tuple_list_to_name( adj_cluster_coeff_per_node) return calculated_ranks['cluster_coefficient']
def AttackClustering(graph): iteration = 0 clustering = nx.square_clustering(graph) list_d = list(clustering.items()) list_d.sort(key=lambda i: i[1], reverse=True) while True: if (len(graph.nodes) <= 1): return 0, 0 if ((len(graph.nodes) == 0) and (len(graph.edges) != 0)): intaktnost = GenerateIntaktnost(graph) return intaktnost, iteration if not nx.is_connected(graph): intaktnost = GenerateIntaktnost(graph) return intaktnost, iteration graph.remove_node(list_d[iteration][0]) iteration += 1
def compute_features(self): triang = lambda graph: np.asarray(list(nx.triangles(graph).values()) ).mean() self.add_feature( "num_triangles", triang, "Number of triangles in the graph", InterpretabilityScore("max"), ) transi = lambda graph: nx.transitivity(graph) self.add_feature( "transitivity", transi, "Transitivity of the graph", InterpretabilityScore("max"), ) # Average clustering coefficient clustering_dist = lambda graph: list(nx.clustering(graph).values()) self.add_feature( "clustering", clustering_dist, "the clustering of the graph", InterpretabilityScore("max"), statistics="centrality", ) # generalised degree square_clustering_dist = lambda graph: list( nx.square_clustering(graph).values()) self.add_feature( "square_clustering", square_clustering_dist, "the square clustering of the graph", InterpretabilityScore("max"), statistics="centrality", )
def node_attributes(self): result = {} result['degree_centrality'] = nx.degree_centrality(self.graph) result['in_degree_centrality'] = nx.in_degree_centrality(self.graph) result['out_degree_centrality'] = nx.out_degree_centrality(self.graph) result['closeness_centrality'] = nx.closeness_centrality(self.graph) result['betweenness_centrality'] = nx.betweenness_centrality( self.graph) result['load_centrality'] = nx.load_centrality(self.graph) result['average_neighbor_degree'] = nx.average_neighbor_degree( self.graph) result['square_clustering'] = nx.square_clustering(self.graph) result['closeness_vitality'] = nx.closeness_vitality(self.graph) # nodes attributes node_attributes = [] for node in self.graph.nodes(): node_attributes.append((node, result['degree_centrality'][node], result['in_degree_centrality'][node], result['out_degree_centrality'][node], result['closeness_centrality'][node], result['betweenness_centrality'][node], result['load_centrality'][node], result['average_neighbor_degree'][node], result['square_clustering'][node], result['closeness_vitality'][node])) node_attributes.insert(0, [ 'node', 'degree_centrality', 'in_degree_centrality', 'out_degree_centrality', 'closeness_centrality', 'betweenness_centrality', 'load_centrality', 'average_neighbor_degree', 'square_clustering', 'closeness_vitality' ]) return node_attributes
import networkx as nx import plot_multigraph from matplotlib import pylab as plt n = 80 p = 10. / n G = nx.fast_gnp_random_graph(n, p, seed=42) def to_list(dict_): return [dict_[k] for k in G.nodes()] graph_colors = [ ("eccentricity", to_list(nx.eccentricity(G))), ("clustering", to_list(nx.clustering(G))), ("square_clustering", to_list(nx.square_clustering(G))), ] fig = plot_multigraph.plot_color_multigraph(G, graph_colors, 2, 2, node_size=50) plt.savefig('graphs/distance.png', facecolor=fig.get_facecolor())
if needs_tri: print "[+] Computing number of triangles..." tri = pd.Series(nx.triangles(graph), name='triangles') if needs_clo: print "[+] Computing closeness centrality..." clo = pd.Series(nx.closeness_centrality(graph), name='closeness_centrality') if needs_pag: print "[+] Computing pagerank..." pag = pd.Series(nx.pagerank(graph), name='pagerank') if needs_squ: print "[+] Computing square clustering..." squ = pd.Series(nx.square_clustering(graph), name='square_clustering_coefficient') # Always run: connected components print "[+] Computing connected components" _cco = {} for i, c in enumerate(nx.connected_components(graph)): for e in c: _cco[e] = i cco = pd.Series(_cco, name='connected_component_id') # Putting all results together print "[+] Preparing output" stats = pd.DataFrame(deg) stats = stats.join(cco) if needs_eig:
def test_bipartite_k5(self): G = nx.complete_bipartite_graph(5, 5) assert list(nx.square_clustering(G).values()) == [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]
def test_bipartite_k5(self): G = nx.complete_bipartite_graph(5,5) assert_equal(list(nx.square_clustering(G).values()), [1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
def square_clustering_coefficient_sum(self): return nx.square_clustering(self.graph, [self.node_1])[self.node_1] + nx.square_clustering(Gt, [self.node_2])[self.node_2]
def test_clustering(self): G = nx.Graph() assert_equal(list(nx.square_clustering(G).values()),[]) assert_equal(nx.square_clustering(G),{})
def getSquares(self, graph): squareDict = nx.square_clustering(graph) square = [squareDict[k] for k in squareDict] return square