def print_graph_info(graph): e = nx.eccentricity(graph) print 'graph with %u nodes, %u edges' % (len(graph.nodes()), len(graph.edges())) print 'radius: %s' % nx.radius(graph, e) # min e print 'diameter: %s' % nx.diameter(graph, e) # max e print 'len(center): %s' % len(nx.center(graph, e)) # e == radius print 'len(periphery): %s' % len(nx.periphery(graph, e)) # e == diameter
def calculate(network): try: n = nx.radius(network) except: return 0 return round(n, 7)
def NetStats(G): return { 'radius': nx.radius(G), 'diameter': nx.diameter(G), 'connected_components': nx.number_connected_components(G), 'density' : nx.density(G), 'shortest_path_length': nx.shortest_path_length(G), 'clustering': nx.clustering(G)}
def netstats_simple(graph): G = graph if nx.is_connected(G): d = nx.diameter(G) r = nx.radius(G) else: d = 'NA - graph is not connected' #should be calculatable on unconnected graph - see example code for hack r = 'NA - graph is not connected' #using dictionary to pack values and variablesdot, eps, ps, pdf break equally result = {#"""single value measures""" 'nn': G.number_of_nodes(), 'ne': G.number_of_edges(), 'd': d, 'r': r, 'conn': nx.number_connected_components(G), 'asp': nx.average_shortest_path_length(G), # """number of the largest clique""" 'cn': nx.graph_clique_number(G), # """number of maximal cliques""" 'mcn': nx.graph_number_of_cliques(G), # """transitivity - """ 'tr': nx.transitivity(G), #cc = nx.clustering(G) """clustering coefficient""" 'avgcc': nx.average_clustering(G) } # result['d'] = nx.diameter(G) print result return result
def NetStats(G,name): s=0 d = nx.degree(G) for i in d.values(): s = s + i n = len(G.nodes()) m = len(G.edges()) k = float(s)/float(n) #k = nx.average_node_connectivity(G) C = nx.average_clustering(G) l = nx.average_shortest_path_length(G) Cc = nx.closeness_centrality(G) d = nx.diameter(G) #The diameter is the maximum eccentricity. r = nx.radius(G) #The radius is the minimum eccentricity. output = "ESTADISITICOS_"+name SALIDA = open(output,"w") SALIDA.write(("Numero de nodos n = %s \n") % n) SALIDA.write(("Numero de aristas m = %s \n") % m) SALIDA.write(("Grado promedio <k> = %s \n") % k) SALIDA.write(("Clustering Coeficient = %s \n") % C) SALIDA.write(("Shortest Path Length = %s \n") % l) #SALIDA.write(("Closeness = %s \n") % Cc) SALIDA.write(("Diameter (maximum eccentricity) = %d \n") % d) SALIDA.write(("Radius (minimum eccentricity) = %d \n") % r)
def get_tree_symmetries_for_traitset(model, simconfig, cultureid, traitset, culture_count_map): radii = [] symstats = stats.BalancedTreeAutomorphismStatistics(simconfig) subgraph_set = model.trait_universe.get_trait_graph_components(traitset) trait_subgraph = model.trait_universe.get_trait_forest_from_traits(traitset) results = symstats.calculate_graph_symmetries(trait_subgraph) for subgraph in subgraph_set: radii.append( nx.radius(subgraph)) mean_radii = np.mean(np.asarray(radii)) sd_radii = np.sqrt(np.var(np.asarray(radii))) degrees = nx.degree(trait_subgraph).values() mean_degree = np.mean(np.asarray(degrees)) sd_degree = np.sqrt(np.var(np.asarray(degrees))) mean_orbit_mult = np.mean(np.asarray(results['orbitcounts'])) sd_orbit_mult = np.sqrt(np.var(np.asarray(results['orbitcounts']))) max_orbit_mult = np.nanmax(np.asarray(results['orbitcounts'])) r = dict(cultureid=str(cultureid), culture_count=culture_count_map[cultureid], orbit_multiplicities=results['orbitcounts'], orbit_number=results['orbits'], autgroupsize=results['groupsize'], remaining_density=results['remainingdensity'], mean_radii=mean_radii, sd_radii=sd_radii, mean_degree=mean_degree, sd_degree=sd_degree, mean_orbit_multiplicity=mean_orbit_mult, sd_orbit_multiplicity=sd_orbit_mult, max_orbit_multiplicity=max_orbit_mult ) #log.debug("groupstats: %s", r) return r
def updateGraphStats(self, graph): origgraph = graph if nx.is_connected(graph): random = 0 else: connectedcomp = nx.connected_component_subgraphs(graph) graph = max(connectedcomp) if len(graph) > 1: pathlength = nx.average_shortest_path_length(graph) else: pathlength = 0 # print graph.nodes(), len(graph), nx.is_connected(graph) stats = { "radius": nx.radius(graph), "density": nx.density(graph), "nodecount": len(graph.nodes()), "center": nx.center(graph), "avgcluscoeff": nx.average_clustering(graph), "nodeconnectivity": nx.node_connectivity(graph), "components": nx.number_connected_components(graph), "avgpathlength": pathlength } # print "updated graph stats", stats return stats
def strongly_connected_components(): conn = sqlite3.connect("zhihu.db") #following_data = pd.read_sql('select user_url, followee_url from Following where followee_url in (select user_url from User where agree_num > 50000) and user_url in (select user_url from User where agree_num > 50000)', conn) following_data = pd.read_sql('select user_url, followee_url from Following where followee_url in (select user_url from User where agree_num > 10000) and user_url in (select user_url from User where agree_num > 10000)', conn) conn.close() G = nx.DiGraph() cnt = 0 for d in following_data.iterrows(): G.add_edge(d[1][0],d[1][1]) cnt += 1 print 'links number:', cnt scompgraphs = nx.strongly_connected_component_subgraphs(G) scomponents = sorted(nx.strongly_connected_components(G), key=len, reverse=True) print 'components nodes distribution:', [len(c) for c in scomponents] #plot graph of component, calculate saverage_shortest_path_length of components who has over 1 nodes index = 0 print 'average_shortest_path_length of components who has over 1 nodes:' for tempg in scompgraphs: index += 1 if len(tempg.nodes()) != 1: print nx.average_shortest_path_length(tempg) print 'diameter', nx.diameter(tempg) print 'radius', nx.radius(tempg) pylab.figure(index) nx.draw_networkx(tempg) pylab.show() # Components-as-nodes Graph cG = nx.condensation(G) pylab.figure('Components-as-nodes Graph') nx.draw_networkx(cG) pylab.show()
def graph_radius(graph): sp = nx.shortest_path_length(graph,weight='weight') ecc = nx.eccentricity(graph,sp=sp) if ecc: rad = nx.radius(graph,e=ecc) else: rad = 0 return rad
def get_graph_info(graph): nodes = networkx.number_of_nodes(graph) edges = networkx.number_of_edges(graph) radius = networkx.radius(graph) diameter = networkx.diameter(graph) density = networkx.density(graph) average_clustering = networkx.average_clustering(graph) average_degree = sum(graph.degree().values()) / nodes return nodes, edges, radius, diameter, density, average_clustering, average_degree
def test_radius(testgraph): """ Testing radius function for graphs. """ a, b = testgraph nx_rad = nx.radius(a) sg_rad = sg.digraph_distance_measures.radius(b, b.order()) assert nx_rad == sg_rad
def get_path_lengths(self): if not hasattr(self,"shortest_path_lenghts") or self.shortest_path_lenghts is None: self.shortest_paths_lengths = nx.all_pairs_shortest_path_length(self.G) self.avg_shortest_path = sum([ length for sp in self.shortest_paths_lengths.values() for length in sp.values() ])/float(self.N*(self.N-1)) self.eccentricity = nx.eccentricity(self.G,sp=self.shortest_paths_lengths) self.diameter = nx.diameter(self.G,e=self.eccentricity) self.radius = nx.radius(self.G,e=self.eccentricity) return self.shortest_paths_lengths
def connectivity(self): components = list(nx.connected_component_subgraphs(self.G)) print('Connected components number: ') print(len(components)) giant = components.pop(0) print('Giant component radius: ') print(nx.radius(giant)) print('Giant component diameter: ') print(nx.diameter(giant)) center = nx.center(giant) print('Giant component center: ') for i in xrange(len(center)): print(self.singer_dict[int(center[i])].split('|')[0]) inf = self.get_graph_info(giant) for i in xrange(len(inf)): print(inf[i])
def write_graph(graph_name, g): radius = nx.radius(g) # https://networkx.github.io/documentation/latest/reference/generated/networkx.algorithms.distance_measures.radius.html diameter = nx.diameter(g) # https://networkx.github.io/documentation/latest/reference/generated/networkx.algorithms.distance_measures.diameter.html closeness = float(sum(nx.algorithms.centrality.closeness_centrality(g).values()))/size # https://networkx.github.io/documentation/latest/reference/generated/networkx.algorithms.centrality.closeness_centrality.html#networkx.algorithms.centrality.closeness_centrality betweenness = float(sum(nx.algorithms.centrality.betweenness_centrality(g).values()))/size # https://networkx.github.io/documentation/latest/reference/generated/networkx.algorithms.centrality.betweenness_centrality.html#networkx.algorithms.centrality.betweenness_centrality clustering = float(sum(nx.algorithms.clustering(g).values()))/size # https://networkx.github.io/documentation/latest/reference/generated/networkx.algorithms.cluster.clustering.html#networkx.algorithms.cluster.clustering print "%s\t%s\t%s\t%s\t%s\t%s" % (graph_name, radius, diameter, closeness, betweenness, clustering)
def PrintGraphStat(self): logging.debug("From SVNFileNetwork.PrintGraphStat") print "%s" % '-' * 40 print "Graph Radius : %f" % NX.radius(self) print "Graph Diameter : %f" % NX.diameter(self) weighted = True closenessdict = NX.closeness_centrality(self, distance=weighted) print "%s" % '-' * 40 print "All nodes in graph" nodeinfolist = [(node, closeness) for node, closeness in closenessdict.items()] # sort the node infolist by closeness number nodeinfolist = sorted( nodeinfolist, key=operator.itemgetter(1), reverse=True) for node, closeness in nodeinfolist: print "\t%s : %f" % (node.name(), closeness) print "%s" % '-' * 40
def report_components(g): components = nx.connected_component_subgraphs(g) print "Components: %d" % len(components) c_data = {} for i in range(len(components)): c = components[i] if len(c.nodes()) > 5: # Avoid reporting on many small components c_data["nodes"] = len(c.nodes()) c_data["edges"] = len(c.edges()) c_data["avg_clustering"] = nx.average_clustering(c) c_data["diameter"] = nx.diameter(c) c_data["radius"] = nx.radius(c) c_data["center"] = len(nx.center(c)) c_data["periphery"] = len(nx.periphery(c)) print "* Component %d:" % i for k in c_data: print "--- %s: %s" % (k, c_data[k]) return c_data
def distance_scores(season, graph): # Take largest connected component g = graph if nx.is_connected(graph) else max(nx.connected_component_subgraphs(graph), key=len) # Ratio of largest connected component subgraph conn = len(max(nx.connected_component_subgraphs(g), key=len)) / float(nx.number_of_nodes(graph)) conn = np.round(conn, 3) # Radius, diameter rad = nx.radius(g) diam = nx.diameter(g) # Average eccentricity ecc = np.mean(nx.eccentricity(g).values()) ecc = np.round(ecc, 3) # Put it all into a dataframe df = pd.DataFrame([[season,conn,rad,diam,ecc]], columns=['season', 'conn', 'rad', 'diam', 'ecc']) return df
def getMetrics(self, layerid=0): # get some overall network metrics undirectedG = self.layergraphs[layerid].to_undirected() metrics = {} try: # must be connected metrics['diameter'] = nx.diameter(undirectedG) metrics['radius'] = nx.radius(undirectedG) metrics['average_clustering'] = round(nx.average_clustering(undirectedG),3) metrics['transitivity'] = round(nx.transitivity(undirectedG),3) metrics['number_connected_components'] = nx.number_connected_components(undirectedG) import operator betweenness_centrality = nx.betweenness_centrality(self.layergraphs[layerid]) metrics['betweenness_centrality'] = sorted(betweenness_centrality.iteritems(),key=operator.itemgetter(1),reverse=True)[0][0] # find node with largest betweenness centrality H = nx.connected_component_subgraphs(undirectedG)[0] # largest connected component metrics['number_of_nodes'] = len(H.nodes()) except: pass return metrics
def __init__(self, graph, feature_list=[]): self.no_feature = 39 self.G = graph self.nodes = nx.number_of_nodes(self.G) self.edges = nx.number_of_edges(self.G) self.Lap = nx.normalized_laplacian_matrix(self.G) # ??? how to check whether comparable, addable? self.eigvals = numpy.linalg.eigvals(self.Lap.A).tolist() try: self.radius = nx.radius(self.G) except nx.exception.NetworkXError: self.radius = "ND" try: self.ecc_dic = nx.eccentricity(self.G) except nx.exception.NetworkXError: self.ecc_dic = {} self.degree_dic = nx.average_neighbor_degree(self.G) self.pagerank = nx.pagerank(self.G).values() if feature_list == []: self.feature_list = list(range(1, self.no_feature + 1)) else: self.feature_list = feature_list self.feature_vector = [] self.feature_time = []
def extended_stats(G, connectivity=False, anc=False, ecc=False, bc=False, cc=False): """ Calculate extended topological stats and metrics for a graph. Many of these algorithms have an inherently high time complexity. Global topological analysis of large complex networks is extremely time consuming and may exhaust computer memory. Consider using function arguments to not run metrics that require computation of a full matrix of paths if they will not be needed. Parameters ---------- G : networkx.MultiDiGraph input graph connectivity : bool if True, calculate node and edge connectivity anc : bool if True, calculate average node connectivity ecc : bool if True, calculate shortest paths, eccentricity, and topological metrics that use eccentricity bc : bool if True, calculate node betweenness centrality cc : bool if True, calculate node closeness centrality Returns ------- stats : dict dictionary of network measures containing the following elements (some only calculated/returned optionally, based on passed parameters): - avg_neighbor_degree - avg_neighbor_degree_avg - avg_weighted_neighbor_degree - avg_weighted_neighbor_degree_avg - degree_centrality - degree_centrality_avg - clustering_coefficient - clustering_coefficient_avg - clustering_coefficient_weighted - clustering_coefficient_weighted_avg - pagerank - pagerank_max_node - pagerank_max - pagerank_min_node - pagerank_min - node_connectivity - node_connectivity_avg - edge_connectivity - eccentricity - diameter - radius - center - periphery - closeness_centrality - closeness_centrality_avg - betweenness_centrality - betweenness_centrality_avg """ stats = {} # create a DiGraph from the MultiDiGraph, for those metrics that require it G_dir = nx.DiGraph(G) # create an undirected Graph from the MultiDiGraph, for those metrics that # require it G_undir = nx.Graph(G) # get the largest strongly connected component, for those metrics that # require strongly connected graphs G_strong = utils_graph.get_largest_component(G, strongly=True) # average degree of the neighborhood of each node, and average for the graph avg_neighbor_degree = nx.average_neighbor_degree(G) stats["avg_neighbor_degree"] = avg_neighbor_degree stats["avg_neighbor_degree_avg"] = sum( avg_neighbor_degree.values()) / len(avg_neighbor_degree) # average weighted degree of the neighborhood of each node, and average for # the graph avg_wtd_nbr_deg = nx.average_neighbor_degree(G, weight="length") stats["avg_weighted_neighbor_degree"] = avg_wtd_nbr_deg stats["avg_weighted_neighbor_degree_avg"] = sum( avg_wtd_nbr_deg.values()) / len(avg_wtd_nbr_deg) # degree centrality for a node is the fraction of nodes it is connected to degree_centrality = nx.degree_centrality(G) stats["degree_centrality"] = degree_centrality stats["degree_centrality_avg"] = sum( degree_centrality.values()) / len(degree_centrality) # calculate clustering coefficient for the nodes stats["clustering_coefficient"] = nx.clustering(G_undir) # average clustering coefficient for the graph stats["clustering_coefficient_avg"] = nx.average_clustering(G_undir) # calculate weighted clustering coefficient for the nodes stats["clustering_coefficient_weighted"] = nx.clustering(G_undir, weight="length") # average clustering coefficient (weighted) for the graph stats["clustering_coefficient_weighted_avg"] = nx.average_clustering( G_undir, weight="length") # pagerank: a ranking of the nodes in the graph based on the structure of # the incoming links pagerank = nx.pagerank(G_dir, weight="length") stats["pagerank"] = pagerank # node with the highest page rank, and its value pagerank_max_node = max(pagerank, key=lambda x: pagerank[x]) stats["pagerank_max_node"] = pagerank_max_node stats["pagerank_max"] = pagerank[pagerank_max_node] # node with the lowest page rank, and its value pagerank_min_node = min(pagerank, key=lambda x: pagerank[x]) stats["pagerank_min_node"] = pagerank_min_node stats["pagerank_min"] = pagerank[pagerank_min_node] # if True, calculate node and edge connectivity if connectivity: # node connectivity is the minimum number of nodes that must be removed # to disconnect G or render it trivial stats["node_connectivity"] = nx.node_connectivity(G_strong) # edge connectivity is equal to the minimum number of edges that must be # removed to disconnect G or render it trivial stats["edge_connectivity"] = nx.edge_connectivity(G_strong) utils.log("Calculated node and edge connectivity") # if True, calculate average node connectivity if anc: # mean number of internally node-disjoint paths between each pair of # nodes in G, i.e., the expected number of nodes that must be removed to # disconnect a randomly selected pair of non-adjacent nodes stats["node_connectivity_avg"] = nx.average_node_connectivity(G) utils.log("Calculated average node connectivity") # if True, calculate shortest paths, eccentricity, and topological metrics # that use eccentricity if ecc: # precompute shortest paths between all nodes for eccentricity-based # stats sp = { source: dict( nx.single_source_dijkstra_path_length(G_strong, source, weight="length")) for source in G_strong.nodes() } utils.log("Calculated shortest path lengths") # eccentricity of a node v is the maximum distance from v to all other # nodes in G eccentricity = nx.eccentricity(G_strong, sp=sp) stats["eccentricity"] = eccentricity # diameter is the maximum eccentricity diameter = nx.diameter(G_strong, e=eccentricity) stats["diameter"] = diameter # radius is the minimum eccentricity radius = nx.radius(G_strong, e=eccentricity) stats["radius"] = radius # center is the set of nodes with eccentricity equal to radius center = nx.center(G_strong, e=eccentricity) stats["center"] = center # periphery is the set of nodes with eccentricity equal to the diameter periphery = nx.periphery(G_strong, e=eccentricity) stats["periphery"] = periphery # if True, calculate node closeness centrality if cc: # closeness centrality of a node is the reciprocal of the sum of the # shortest path distances from u to all other nodes closeness_centrality = nx.closeness_centrality(G, distance="length") stats["closeness_centrality"] = closeness_centrality stats["closeness_centrality_avg"] = sum( closeness_centrality.values()) / len(closeness_centrality) utils.log("Calculated closeness centrality") # if True, calculate node betweenness centrality if bc: # betweenness centrality of a node is the sum of the fraction of # all-pairs shortest paths that pass through node # networkx 2.4+ implementation cannot run on Multi(Di)Graphs, so use DiGraph betweenness_centrality = nx.betweenness_centrality(G_dir, weight="length") stats["betweenness_centrality"] = betweenness_centrality stats["betweenness_centrality_avg"] = sum( betweenness_centrality.values()) / len(betweenness_centrality) utils.log("Calculated betweenness centrality") utils.log("Calculated extended stats") return stats
def co_visiting(): ## create the co_visiting/reviewing network, where nodes are users, edges are number of sharing common restaurant of reviewing, we assume two people have similarity if they visited the same restaurant. # read from numpy matrix A = np.loadtxt("output/covisiting_matrix") G = nx.from_numpy_matrix(A) # select the biggest component for the following analysis connected_components = sorted(nx.connected_component_subgraphs(G), key=len, reverse=True) print("{} connected components found.".format(len(connected_components))) g = connected_components[0] component_id = g.nodes() df = pd.DataFrame(index=g.nodes) df["degree"] = pd.Series(nx.degree_centrality(g)) df["betweenness"] = pd.Series(nx.betweenness_centrality(g)) df["closeness"] = pd.Series(nx.closeness_centrality(g)) df["eigenvector"] = pd.Series(nx.eigenvector_centrality(g)) df["clustering"] = pd.Series(nx.clustering(g)) print(df.sort_values("betweenness", ascending=False).head(10)) exit() df_node_degree = pd.DataFrame(list(dict(g.degree()).items()), columns=["node_name", "degree"]) print(df_node_degree.sort_values("degree", ascending=False).head(10)) print("radius: {:d}\n".format(nx.radius(g))) print("diameter: {:d}\n".format(nx.diameter(g))) print("eccentricity: {}\n".format(nx.eccentricity(g))) print("center: {}\n".format(nx.center(g))) print("periphery: {}\n".format(nx.periphery(g))) print("density: {:f}".format(nx.density(g))) exit() # assign labels to node user_ids = [] with open("output/component_adjlist.txt", 'r') as f: for line in f: data = json.loads(line) user_ids.append(data['user_id']) labels = {} for i in component_id: labels[i] = user_ids[i] # degree distribution plot of the biggest component fig1, ax1 = plt.subplots(1, 1) degree_values = [v for k, v in g.degree()] ax1.hist(list(degree_values), bins=list(range(max(degree_values))), log=True) ax1.set_xlabel("Degree") ax1.set_ylabel("Frequency") ax1.set_title("Degree Distribution") fig1.savefig('/home/dtao2/Dropbox/degree.png') # covisiting network plot of the biggest component fig2, ax2 = plt.subplots(1, 1) pos = nx.spring_layout(g) nx.draw_networkx(g, with_labels=False, node_size=[x[1] * 10 for x in g.degree()], pos=pos, width=0.5, ax=ax2) nx.draw_networkx_labels(g, pos, labels=None, font_size=5) # nx.draw_networkx_labels(g,pos,labels = labels, font_size=5) ax2.axis("off") ax2.set_title("Covisiting Network") fig2.savefig('/home/dtao2/Dropbox/graph.png') return
def test_properties_named_small_graphs(self): G = nx.bull_graph() assert G.number_of_nodes() == 5 assert G.number_of_edges() == 5 assert sorted(d for n, d in G.degree()) == [1, 1, 2, 3, 3] assert nx.diameter(G) == 3 assert nx.radius(G) == 2 G = nx.chvatal_graph() assert G.number_of_nodes() == 12 assert G.number_of_edges() == 24 assert list(d for n, d in G.degree()) == 12 * [4] assert nx.diameter(G) == 2 assert nx.radius(G) == 2 G = nx.cubical_graph() assert G.number_of_nodes() == 8 assert G.number_of_edges() == 12 assert list(d for n, d in G.degree()) == 8 * [3] assert nx.diameter(G) == 3 assert nx.radius(G) == 3 G = nx.desargues_graph() assert G.number_of_nodes() == 20 assert G.number_of_edges() == 30 assert list(d for n, d in G.degree()) == 20 * [3] G = nx.diamond_graph() assert G.number_of_nodes() == 4 assert sorted(d for n, d in G.degree()) == [2, 2, 3, 3] assert nx.diameter(G) == 2 assert nx.radius(G) == 1 G = nx.dodecahedral_graph() assert G.number_of_nodes() == 20 assert G.number_of_edges() == 30 assert list(d for n, d in G.degree()) == 20 * [3] assert nx.diameter(G) == 5 assert nx.radius(G) == 5 G = nx.frucht_graph() assert G.number_of_nodes() == 12 assert G.number_of_edges() == 18 assert list(d for n, d in G.degree()) == 12 * [3] assert nx.diameter(G) == 4 assert nx.radius(G) == 3 G = nx.heawood_graph() assert G.number_of_nodes() == 14 assert G.number_of_edges() == 21 assert list(d for n, d in G.degree()) == 14 * [3] assert nx.diameter(G) == 3 assert nx.radius(G) == 3 G = nx.hoffman_singleton_graph() assert G.number_of_nodes() == 50 assert G.number_of_edges() == 175 assert list(d for n, d in G.degree()) == 50 * [7] assert nx.diameter(G) == 2 assert nx.radius(G) == 2 G = nx.house_graph() assert G.number_of_nodes() == 5 assert G.number_of_edges() == 6 assert sorted(d for n, d in G.degree()) == [2, 2, 2, 3, 3] assert nx.diameter(G) == 2 assert nx.radius(G) == 2 G = nx.house_x_graph() assert G.number_of_nodes() == 5 assert G.number_of_edges() == 8 assert sorted(d for n, d in G.degree()) == [2, 3, 3, 4, 4] assert nx.diameter(G) == 2 assert nx.radius(G) == 1 G = nx.icosahedral_graph() assert G.number_of_nodes() == 12 assert G.number_of_edges() == 30 assert (list( d for n, d in G.degree()) == [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]) assert nx.diameter(G) == 3 assert nx.radius(G) == 3 G = nx.krackhardt_kite_graph() assert G.number_of_nodes() == 10 assert G.number_of_edges() == 18 assert (sorted( d for n, d in G.degree()) == [1, 2, 3, 3, 3, 4, 4, 5, 5, 6]) G = nx.moebius_kantor_graph() assert G.number_of_nodes() == 16 assert G.number_of_edges() == 24 assert list(d for n, d in G.degree()) == 16 * [3] assert nx.diameter(G) == 4 G = nx.octahedral_graph() assert G.number_of_nodes() == 6 assert G.number_of_edges() == 12 assert list(d for n, d in G.degree()) == 6 * [4] assert nx.diameter(G) == 2 assert nx.radius(G) == 2 G = nx.pappus_graph() assert G.number_of_nodes() == 18 assert G.number_of_edges() == 27 assert list(d for n, d in G.degree()) == 18 * [3] assert nx.diameter(G) == 4 G = nx.petersen_graph() assert G.number_of_nodes() == 10 assert G.number_of_edges() == 15 assert list(d for n, d in G.degree()) == 10 * [3] assert nx.diameter(G) == 2 assert nx.radius(G) == 2 G = nx.sedgewick_maze_graph() assert G.number_of_nodes() == 8 assert G.number_of_edges() == 10 assert sorted(d for n, d in G.degree()) == [1, 2, 2, 2, 3, 3, 3, 4] G = nx.tetrahedral_graph() assert G.number_of_nodes() == 4 assert G.number_of_edges() == 6 assert list(d for n, d in G.degree()) == [3, 3, 3, 3] assert nx.diameter(G) == 1 assert nx.radius(G) == 1 G = nx.truncated_cube_graph() assert G.number_of_nodes() == 24 assert G.number_of_edges() == 36 assert list(d for n, d in G.degree()) == 24 * [3] G = nx.truncated_tetrahedron_graph() assert G.number_of_nodes() == 12 assert G.number_of_edges() == 18 assert list(d for n, d in G.degree()) == 12 * [3] G = nx.tutte_graph() assert G.number_of_nodes() == 46 assert G.number_of_edges() == 69 assert list(d for n, d in G.degree()) == 46 * [3] # Test create_using with directed or multigraphs on small graphs pytest.raises(nx.NetworkXError, nx.tutte_graph, create_using=nx.DiGraph) MG = nx.tutte_graph(create_using=nx.MultiGraph) assert sorted(MG.edges()) == sorted(G.edges())
] l = len(words) G = nx.Graph() for i in range(l): G.add_node(words[i]) for i in range(l): for j in range(l): if i != j: cos = model.similarity(words[i], words[j]) if cos >= 0.5: G.add_edge(words[i], words[j], weight=cos) pos = nx.spring_layout(G) nx.draw_networkx_nodes(G, pos, node_color='blue', node_size=50) nx.draw_networkx_edges(G, pos, edge_color='green') nx.draw_networkx_labels(G, pos, font_size=20, font_family='Arial') plt.axis('off') plt.show() deg = nx.degree_centrality(G) imp = [] for nodeid in sorted(deg, key=deg.get, reverse=True): imp.append(nodeid) f = open('Семантическое поле боли.txt', 'w', encoding='utf8') f.write('ХАРАКТЕРИСТИКИ ГРАФА\n') s = imp[0] + ', ' + imp[1] + ', ' + imp[2] + '\n' f.write('Самые центральные слова графа: ' + s) s = '' for comp in list(nx.connected_component_subgraphs(G)): s = s + str(nx.radius(comp)) + ' ' f.write('Радиус (для каждой компоненты связности): ' + s + '\n') f.write('Коэффициент кластеризации: ' + str(nx.average_clustering(G))) f.close()
def answer_ten(): rad = nx.radius(answer_six()) df = pd.Series(nx.eccentricity(answer_six())) df = df.reset_index() return set(df[df[0] == rad]['index'])
scrambled = [ 6, 6, 0, 6, 6, 4, 0, 2, 0, 7, 7, 5, 7, 7, 4, 1, 2, 3, 7, 7, 5, 7, 7, 0, 1, 0, 3 ] draw_cubes(scrambled) c.shortest_path(g, scrambled, alca, labels, c2i) # 6. find out how many shapes there are at given distance from solved shape pred, dist = nx.dijkstra_predecessor_and_distance(g, 0) for i in range(max(dist.values()) + 1): print(i, ":", len(list(filter(lambda x: dist[x] == i, verts)))) # 7. note however the solved shape is chosen the best way it could be! nx.diameter(g) nx.radius(g) [v for v in verts if nx.eccentricity(g, v) == 16] draw_cubes([i2c[v] for v in verts if nx.eccentricity(g, v) == 28], ncol=4) # 8. draw the farthest three shapes and find a path to one of them farthest = [i2c[v] for v in verts if dist[v] == 16] draw_cubes(farthest) c.shortest_path(g, alca, farthest[1], labels, c2i) nx.eccentricity(g, c2i[tuple(farthest[1])]) # 9. shortest paths are too hard - explore stabilizer / feature chains # define a stabilizer chain v0 = set(verts) v1 = {v for v in verts if i2c[v][c.F] == i2c[v][c.DF]} v2 = {v for v in v1 if i2c[v][c.R] == i2c[v][c.DR]}
def radius(self, graph): # returns radius, i.e. min eccentricity in the graph return nx.radius(graph)
G = nx.Graph() G.add_nodes_from(words) for i, word in enumerate(words): for j, other_word in enumerate(words): if j > i and model.similarity(word, other_word) > 0.5: G.add_edge(word, other_word) nx.write_gexf(G, 'graph_file.gexf') pos = nx.spring_layout(G) nx.draw_networkx_nodes(G, pos, node_color='red', node_size=10) nx.draw_networkx_edges(G, pos, edge_color='yellow') nx.draw_networkx_labels(G, pos, font_size=10, font_family='Arial') plt.axis('off') plt.show() deg = nx.degree_centrality(G) print('самое центральное слово графа:') print(sorted(deg, key=deg.get, reverse=True)[0]) print('коэффициент кластеризации:') print(nx.average_clustering(G)) for word in words: if G.neighbors(word) == []: G.remove_node(word) print('у нас всего одна компонента связности, ее радиус:') print(nx.radius(G))
def properties(dim): NUM_PROPERTIES = 3 from server.process.config import args meta = json.load(open(args['meta_json'], 'r')) query = json.load(open(args['query_json'], 'r')) from server.process.dataset import Dataset data = Dataset(args) # add the contrasted node type to the subnetworks if dim not in query['nodes']: query['nodes'].append(dim) # remove the contrasted node type from filters if dim in query['filters']: query['filters'].pop(dim) # initialize property list prop = [{} for i in range(NUM_PROPERTIES)] prop[0]['name'] = 'size' prop[1]['name'] = 'radius' prop[2]['name'] = 'density' prop[0]['labels'] = [] prop[1]['labels'] = [] prop[2]['labels'] = [] for i in meta['label'][dim]: # retrieve network connected to the contrasted node query['filters'][dim] = [i] network = exploration(query, data) sub_graph = json_graph.node_link_graph(network) gen = nx.connected_component_subgraphs(sub_graph) if len(network['nodes']) > 0: connected_graph = max(gen, key=len) prop[0]['labels'].append({ 'name': meta['label'][dim][i][0], 'val': len(network['nodes']) }) prop[1]['labels'].append({ 'name': meta['label'][dim][i][0], 'val': nx.radius(connected_graph) }) prop[2]['labels'].append({ 'name': meta['label'][dim][i][0], 'val': nx.density(connected_graph) }) else: prop[0]['labels'].append({ 'name': meta['label'][dim][i][0], 'val': 0 }) prop[1]['labels'].append({ 'name': meta['label'][dim][i][0], 'val': 0 }) prop[2]['labels'].append({ 'name': meta['label'][dim][i][0], 'val': 0 }) query['filters'].pop(dim) results = {} results['node_type'] = meta['node'][dim]['name'] results['properties'] = prop return results
##G.add_edge(1, 3, weight=4) # вес ребра ##dg = nx.DiGraph() ##dg.add_weighted_edges_from([(1,4,0.5), (3,1,0.75)]) # от кого -- кому и вес ребра print('nodes: ' + str(G.nodes())) print('edges: ' + str(G.edges())) # соседи узла 1 print('neigbours of node 1: ' + str(list(G.neighbors(1)))) # число соседей узла 5 print('degree of node 5: ' + str(G.degree(5))) # Радиус графа, минимальный эксцентриситет среди всех вершин графа print('radius: ' + str(nx.radius(G))) # Диаметр графа, самый длинный путь от одной вершины до другой print('diameter: ' + str(nx.diameter(G))) # Плотность графа, отношение рёбер и узлов print('density: ' + str(nx.density(G))) # Коэффициент ассортативности (насколько сильно развалится если поубирать самые центральные узлы): print('degree pearson correlation coefficient: ' + str(nx.degree_pearson_correlation_coefficient(G))) # вот какой коэффициент у нашего графа print('average clustering: ' + str(nx.average_clustering(G))) print('transitivity: ' + str(nx.transitivity(G)))
def drawNetwork(path1, path2, sele=None, sele1=None, sele2=None, top1=None, top2=None, r=1, edge_norm=None, alpha=0.5, mutations=False, align_with = None, node_color=(0.6, 0.6, 0.6), edge_color1 = (0, 0, 1), palette="colorblind", edge_color2 = (1, 0, 0), labeling='0', norm_expected=False, threshold=0, topk=None, max_compo=None, mean_vp=None, strong_compo=None, around=None, keep_previous=False, compo_size=None, save_cc=None, load_cc=None, compos_to_excel = None, force_binary_color=False, compo_radius=None, compo_diam=None, label_compo='', auto_patch=True, printall=False, sum=False, n_clusters=None, color_by_compo=False, color_by_group=False, show_top_group=None, name1 = None, name2 = None, name_nodes='nodes', userSelection='all', fromstruct=None, color_by_contact_type=False, standard_and_expected=None): ''' Draws a NetworkX network on the PyMol structure ''' #Initialization of labeling variables and retreieving residue XYZ positions if not keep_previous: cmd.delete('*nodes *edges Component* Group*') cmd.label(selection=userSelection, expression="") cmd.hide("licorice", "?mutations") # Building position -- name correspondance stored.posCA = [] stored.names = [] stored.ss = [] userSelection = userSelection + " and ((n. CA) or n. C)" cmd.iterate_state(1, selector.process(userSelection), "stored.posCA.append([x,y,z])") cmd.iterate(userSelection, "stored.ss.append(ss)") cmd.iterate(userSelection, 'stored.names.append(resn+resi+chain)') stored.labels = list(map(relabel, stored.names)) stored.resid = list(map(selection, stored.names)) node2id = dict(zip(stored.labels, stored.resid)) node2CA = dict(zip(stored.labels, stored.posCA)) #Secondary Structure labels prevSS, prevChain = None, None counters = {'': 0, 'H': 0, 'S': 0, 'L': 0} node2SS = dict(zip(stored.labels, stored.ss)) SS2nodelist = {} putflag = lambda X: 'U' if X in ['', 'L'] else X for label in node2SS: ss = node2SS[label] chain = label[-1] if prevChain != chain: for counter in counters: counters[counter] = 0 if prevSS != ss: counters[ss] +=1 labss = putflag(ss)+str(counters[ss])+':'+chain if labss in SS2nodelist: SS2nodelist[labss].append(label) else: SS2nodelist[labss] = [label] prevSS = ss prevChain = chain prevkey, prevChain = None, None order = [] keys = list(SS2nodelist.keys()) for key in keys: if prevChain != key.split(':')[-1]: prevkey = None if key[0] == 'U': if prevkey == None: newkey = 'Head:'+key.split(':')[-1] else: newkey = 'U'+prevkey SS2nodelist[newkey] = SS2nodelist.pop(key) order.append(newkey) else: order.append(key) prevkey = key prevChain = key.split(':')[-1] prevkey = None final = [] for key in order[::-1]: if prevChain != key.split(':')[-1]: prevkey = None if key[0] == 'U': if prevkey == None: newkey = 'Tail:'+key.split(':')[-1] else: newkey = '{}-{}'.format(key[1:], prevkey) SS2nodelist[newkey] = SS2nodelist.pop(key) final.append(newkey) else: final.append(key) prevkey = key prevChain = key.split(':')[-1] # ss_dict = dict(zip(keys, final[::-1])) mapss = {} for key in final: newkey = key.replace('S', 'β').replace('H', 'α').replace('αead', 'Head') if 'IGPS' in str(label_compo): _ = [] for elt in newkey.split('-'): if elt.split(':')[1] in ['A', 'C', 'E']: _.append('𝘧{}'.format(elt.split(':')[0])) elif elt.split(':')[1] in ['B', 'D', 'F']: _.append('𝘩{}'.format(elt.split(':')[0])) newkey = '-'.join(_) mapss[key] = IGPS_mapping[newkey] else: mapss[key] = newkey for ss in SS2nodelist: for node in SS2nodelist[ss]: node2SS[node] = mapss[ss] #Loading external data atom_mat1, atom_mat2 = list(map(load, [path1, path2])) get_ext = lambda X: X.split('.')[-1] ext1, ext2 = list(map(get_ext, [path1, path2])) top1 = load(path1.split('_')[0].split('.')[0]+'.topy') if top1 == None else load(top1) top2 = load(path2.split('_')[0].split('.')[0]+'.topy') if top2 == None else load(top2) #Handling selections if sele != None: sele1, sele2 = [sele]*2 if sele == None and sele1 == None and sele2 == None: sele1, sele2 = ['protein && not hydrogen']*2 print('Default selection protein without hydrogens') sels = [sele1, sele2] #Creating topology matrices for each selection topg1, topd1 = [create_top(sel, top1, fromstruct) for sel in sels] topg2, topd2 = [create_top(sel, top2, fromstruct) for sel in sels] #From atomic to residual contacts and perturbation network computation mat1 = (atom_mat1 @ topd1).transpose() @ topg1 mat2 = (atom_mat2 @ topd2).transpose() @ topg2 #Apply expected norm if necessary if norm_expected: exp1 = (topd1.sum(axis=1).transpose() @ topd1).transpose() @ (topg1.sum(axis=1).transpose() @ topg1) exp2 = (topd2.sum(axis=1).transpose() @ topd2).transpose() @ (topg2.sum(axis=1).transpose() @ topg2) mat1 = divide_expected(mat1, exp1) mat2 = divide_expected(mat2, exp2) mat1, mat2 = list(map(csr_matrix, [mat1, mat2])) if align_with != None: cmd.align(align_with, userSelection, object='aln') raw_aln = cmd.get_raw_alignment('aln') cmd.hide('cgo', 'aln') order_string = [idx[0] for idx in raw_aln[-1]][::-1] trans_mat = dok_matrix(tuple([cmd.count_atoms(X) for X in order_string])) for idx1, idx2 in raw_aln: trans_mat[idx2[1]-1, idx1[1]-1] = 1 trans_mat = csr_matrix(trans_mat) top_t1, top_t2 = [create_top('name CA', top) for top in [top1, top2]] trans_res = (trans_mat @ top_t1).transpose() @ top_t2 mat2 = trans_res @ (mat2 @ trans_res.transpose()) pertmat = mat2 - mat1 pertmat.setdiag(0) pertmat.eliminate_zeros() net = nx.from_scipy_sparse_matrix(pertmat) #Creating labeling dictionnary if str(next(top1.residues))[-1] == '0': offset = 1 else: offset = 0 chain_names = [chr(ord('A') + i) for i in range(26)] t2o = lambda X: three2one[X] if X in three2one else X[0] get_chain = lambda X: chain_names[(X.chain.index % len(chain_names))] res2str = lambda X: t2o(X.name)+str(X.resSeq+offset)+':'+get_chain(X) id2label = {i: res2str(res) for i, res in enumerate(top1.residues)} # if 'IGPS' in label_compo: # igps_label = {} # for elt in id2label.items(): # if elt.split(':')[1] in ['A', 'C', 'E']: # rerelabel[elt] = '𝘧{}'.format(elt.split(':')[0]) # elif elt.split(':')[1] in ['B', 'D', 'F']: # rerelabel[elt] = '𝘩{}'.format(elt.split(':')[0]) #Relabeling network net = nx.relabel_nodes(net, id2label) label2id = {res2str(res): i for i, res in enumerate(top1.residues)} #Auto_patching network labels if not all(elem in node2CA for elem in net.nodes()): print('PDB structure and topology labeling not matching.') if auto_patch: print('Attempting to auto-patch residue names. (this can be disabled with auto_patch=False)') if len(node2CA.keys()) == len(net.nodes()): remap = dict(zip(net.nodes(), node2CA.keys())) net = nx.relabel_nodes(net, remap) label2id = dict(zip(node2CA.keys(), range(top1.n_residues))) else: print("Auto-patching not working, please try on different PDB file") #Output topK if necessary if type(topk) == int: limit_weight = np.sort([abs(net.edges[(u, v)]['weight']) for u, v in net.edges])[::-1][topk] threshold = limit_weight if type(standard_and_expected) == int: limit_weight = np.sort([abs(net.edges[(u, v)]['weight']) for u, v in net.edges])[::-1][standard_and_expected] relabel_net2 = dict(enumerate(net.nodes())) threshold = limit_weight if max_compo or mean_vp or any(np.array([compo_size, compo_diam, compo_radius, strong_compo])!= None): color_by_compo = True if load_cc != None: cc = np.load(load_cc) else: cc = get_connected_components(pertmat) if save_cc != None: np.save(save_cc, cc) if max_compo: threshold = np.sort(np.abs(pertmat.data))[::-1][np.argmax(cc[::-1])] else: lastmax = np.sort(np.abs(pertmat.data))[::-1][np.argmax(cc[::-1])] print('last maximum: {}'.format(np.round(lastmax, 2))) net.remove_edges_from([(u, v) for u, v in net.edges() if abs(net[u][v]['weight']) < lastmax]) net.remove_nodes_from(list(nx.isolates(net))) components_list = [net.subgraph(c).copy() for c in nx.connected_components(net)] if mean_vp: vanishing_points = [np.max([abs(net[u][v]['weight']) for u, v in c.edges()]) for c in components_list] threshold = np.median(vanishing_points) elif compo_size !=None: robust = [list(c.nodes()) for c in components_list if len(c.edges())>=float(compo_size)] net = net.subgraph([x for robust in list(robust) for x in robust]) threshold = 0 elif compo_diam !=None: robust = [list(c.nodes()) for c in components_list if nx.diameter(c)>=float(compo_diam)] net = net.subgraph([x for robust in list(robust) for x in robust]) threshold = 0 elif compo_radius !=None: robust = [list(c.nodes()) for c in components_list if nx.radius(c)>=float(compo_radius)] net = net.subgraph([x for robust in list(robust) for x in robust]) threshold = 0 elif strong_compo !=None: vanishing_points = [np.max([abs(net[u][v]['weight']) for u, v in c.edges()]) for c in components_list] edges_len = [len(c.edges()) for c in components_list] percentile = float(strong_compo)*len(components_list)/100 vani_ranks = len(vanishing_points)+1-rankdata(vanishing_points, method='max') size_ranks = len(edges_len)+1-rankdata(edges_len, method='max') vani_nodes = [list(c.nodes()) for i, c in enumerate(components_list) if vani_ranks[i]<percentile] size_nodes = [list(c.nodes()) for i, c in enumerate(components_list) if size_ranks[i]<percentile] vani_nodes = [x for vani_nodes in list(vani_nodes) for x in vani_nodes] size_nodes = [x for size_nodes in list(size_nodes) for x in size_nodes] strong = list(set(vani_nodes) & set(size_nodes)) net = net.subgraph(strong) #Detect mutations if mutations: cmd.show_as(representation="cartoon", selection="?mutations") cmd.color(color="grey80", selection="?mutations") cmd.delete("?mutations") mutations_list = [] y = {j: res2str(res) for j, res in enumerate(top2.residues)} for resid in id2label: if resid in y: if id2label[resid] != y[resid]: mutations_list.append((resid, (y[resid][0]+':').join(id2label[resid].split(':')))) cmd.select("mutations", 'resi '+str(id2label[resid].split(':')[0][1:])+ ' and chain '+id2label[resid][-1], merge=1) else: print('Deletion of ', id2label[resid]) print('List of mutations: ', ', '.join([elt[1] for elt in mutations_list])) cmd.show_as(representation="licorice", selection="?mutations") cmd.color(color="magenta", selection="?mutations") #Apply threshold if threshold !=0: print('Applying threshold {}'.format(threshold)) net.remove_edges_from([(u, v) for u, v in net.edges() if abs(net[u][v]['weight']) < threshold]) net.remove_nodes_from(list(nx.isolates(net))) #Induced perturbation network if needed if around !=None: net = net.subgraph(nx.node_connected_component(net, around)) #Setting Pymol parameters cmd.set('auto_zoom', 0) cmd.set("cgo_sphere_quality", 4) if len(net.edges()) == 0: raise ValueError('Computations give empty network') #Norm edges if edge_norm == None: edge_norm = max([net.edges()[(u, v)]['weight'] for u, v in net.edges()])/r elif edge_norm == True: tot_atoms_in_sel = np.sum([np.sum(elt) for elt in [topd1, topd2, topg1, topg2]]) tot_atoms = np.sum([max(elt.shape) for elt in [topd1, topd2, topg1, topg2]]) norm_fact = tot_atoms_in_sel**2/tot_atoms**2 edge_norm = norm_fact*30 print('Global normalization factor: {}'.format(1/norm_fact)) #Function to name edges def name_edges(name, path): if name == None: return '.'.join(basename(path).split('.')[:-1]) return name if type(standard_and_expected) == int: exp1 = (topd1.sum(axis=1).transpose() @ topd1).transpose() @ (topg1.sum(axis=1).transpose() @ topg1) exp2 = (topd2.sum(axis=1).transpose() @ topd2).transpose() @ (topg2.sum(axis=1).transpose() @ topg2) mat1 = divide_expected(mat1, exp1) mat2 = divide_expected(mat2, exp2) mat1, mat2 = list(map(csr_matrix, [mat1, mat2])) net2 = nx.from_scipy_sparse_matrix(mat2-mat1) net2 = nx.relabel_nodes(net2, relabel_net2) limit_weight = np.sort([abs(net2.edges[(u, v)]['weight']) for u, v in net2.edges])[::-1][standard_and_expected] net2.remove_edges_from([(u, v) for u, v in net2.edges() if abs(net2[u][v]['weight']) < limit_weight]) net2.remove_nodes_from(list(nx.isolates(net2))) colors = [(1, 1, 0), (0, 1, 1), (1, 0, 1)] objs_inboth = [] objs_instd = [] objs_inexp = [] nodes = [] for u, v in net.edges(): radius = net[u][v]['weight']/edge_norm if (u, v) in list(net2.edges()): objs_inboth += [CYLINDER, *node2CA[u], *node2CA[v], radius, *colors[0], *colors[0]] else: objs_instd += [CYLINDER, *node2CA[u], *node2CA[v], radius, *colors[1], *colors[1]] nodes += [u, v] edge_norm2 = max([net2.edges()[(u, v)]['weight'] for u, v in net2.edges()])/r for u, v in net2.edges(): radius = net2[u][v]['weight']/edge_norm2 if (u, v) not in list(net.edges()): objs_inexp += [CYLINDER, *node2CA[u], *node2CA[v], radius, *colors[2], *colors[2]] nodes += [u, v] nodelist = set(nodes) objs_nodes = [COLOR, *node_color] for u in nodelist: x, y, z = node2CA[u] objs_nodes += [SPHERE, x, y, z, r] selnodes = ''.join([node2id[u] for u in nodelist])[4:] cmd.load_cgo(objs_inboth, 'in_both_edges') cmd.load_cgo(objs_instd, 'in_std_edges') cmd.load_cgo(objs_inexp, 'in_exp_edges') cmd.load_cgo(objs_nodes, 'nodes') elif color_by_contact_type: expected_matrices = get_expected_type(atom_mat1, atom_mat2, top1, top2, fromstruct) name1, name2 = list(map(name_edges, [name1, name2], [path1, path2])) names = ['{0}_{1}'.format(name1, sel) for sel in ['hydro', 'polar', 'mixed']] + ['{0}_{1}'.format(name2, sel) for sel in ['hydro', 'polar', 'mixed']] nodes_dict = {i: [] for i in range(len(names))} objs_dict = {i: [] for i in range(len(names))} colors = [(1, 0.86, 0.73), (0.68, 0.85, 0.90), (0.60, 0.98, 0.60), (1, 0.86, 0), (0.25, 0.41, 0.88), (0, 0.50, 0)] for u, v in net.edges(): radius = net[u][v]['weight']/edge_norm id_u, id_v = label2id[u], label2id[v] values = list(map(lambda _mat: _mat[id_v, id_u], expected_matrices)) type_of_contact = np.argmax(values) objs_dict[type_of_contact] += [CYLINDER, *node2CA[u], *node2CA[v], radius, *colors[type_of_contact], *colors[type_of_contact]] nodes_dict[type_of_contact] += [u, v] selnodes = '' for toc in nodes_dict: nodelist = set(nodes_dict[toc]) objs_dict[toc]+=[COLOR, *node_color] for u in nodelist: x, y, z = node2CA[u] objs_dict[toc]+=[SPHERE, x, y, z, r] selnodes += ''.join([node2id[u] for u in nodelist])[4:] for i, name in zip(objs_dict.keys(), names): cmd.load_cgo(objs_dict[i], '{}_edges'.format(name)) #Coloring by components elif color_by_compo: components_list = [net.subgraph(c).copy() for c in nx.connected_components(net)] diameters = [nx.diameter(c) for c in components_list] ranking = np.argsort(diameters)[::-1] colors = sns.color_palette(palette, n_colors=len(components_list)+1) for i, c in enumerate(colors): if c[0] == c[1] == c[2]: print(c) colors.pop(i) break selnodes = '' for i, rank in enumerate(ranking): color, compo = colors[rank], components_list[rank] _obj, nodelist = [], [] for u, v in compo.edges(): radius = net[u][v]['weight']/edge_norm if abs(net[u][v]['weight']) >= threshold: if not force_binary_color: _obj+=[CYLINDER, *node2CA[u], *node2CA[v], radius, *color, *color] else: if net[u][v]['weight'] <= 0: _obj+=[CYLINDER, *node2CA[u], *node2CA[v], radius, *edge_color1, *edge_color1] else: _obj+=[CYLINDER, *node2CA[u], *node2CA[v], radius, *edge_color2, *edge_color2] nodelist += [u, v] # cmd.load_cgo(_obj, 'Component{}_edges'.format(i+1)) _obj+=[COLOR, *node_color] nodelist = set(nodelist) selnodes += ''.join([node2id[u] for u in nodelist])[4:] for u in nodelist: x, y, z = node2CA[u] _obj+=[SPHERE, x, y, z, r] cmd.load_cgo(_obj, 'Component{}'.format(i+1)) #Color by group of relevance elif color_by_group: weights = np.array([abs(net[u][v]['weight']) for u, v in net.edges()]).reshape(-1, 1) birch = Birch(n_clusters=n_clusters).fit(weights) labels = birch.predict(weights) ordered_labels = labels[np.argsort(pertmat.data)] _, idx = np.unique(ordered_labels, return_index=True) mapping = dict(zip(ordered_labels[np.sort(idx)], np.sort(np.unique(ordered_labels)))) i2color = dict(zip(ordered_labels[np.sort(idx)], sns.color_palette(palette, len(np.unique(ordered_labels)))[::-1])) selnodes = '' if show_top_group == None: show_top_group = len(mapping.keys()) for j, i in enumerate(list(mapping.keys())[:show_top_group]): _obj, nodelist = [], [] _net = net.copy() to_remove_edges = [(u, v) for j, (u, v) in enumerate(net.edges()) if labels[j] != i] _net.remove_edges_from(to_remove_edges) _net.remove_nodes_from(list(nx.isolates(_net))) for u, v in _net.edges(): radius = net[u][v]['weight']/edge_norm if abs(net[u][v]['weight']) >= threshold: _obj+=[CYLINDER, *node2CA[u], *node2CA[v], radius, *i2color[j], *i2color[j]] nodelist += [u, v] # cmd.load_cgo(_obj, 'Component{}_edges'.format(i+1)) _obj+=[COLOR, *node_color] nodelist = set(nodelist) selnodes += ''.join([node2id[u] for u in nodelist])[4:] for u in nodelist: x, y, z = node2CA[u] _obj+=[SPHERE, x, y, z, r] cmd.load_cgo(_obj, 'Group{}'.format(j+1)) #Default edge coloring else: obj1, obj2, nodelist = [], [], [] for u, v in net.edges(): radius = net[u][v]['weight']/edge_norm if abs(net[u][v]['weight']) >= threshold: if 'color' in net[u][v]: if net[u][v]['color'] == 'r': obj1+=[CYLINDER, *node2CA[u], *node2CA[v], radius, *edge_color1, *edge_color1] else: obj2+=[CYLINDER, *node2CA[u], *node2CA[v], radius, *edge_color2, *edge_color2] else: if net[u][v]['weight'] <= 0: obj1+=[CYLINDER, *node2CA[u], *node2CA[v], radius, *edge_color1, *edge_color1] else: obj2+=[CYLINDER, *node2CA[u], *node2CA[v], radius, *edge_color2, *edge_color2] nodelist+=[u, v] name1, name2 = map(name_edges, [name1, name2], [path1, path2]) cmd.load_cgo(obj1, name1+'_edges') cmd.load_cgo(obj2, name2+'_edges') #Drawing nodes obj=[COLOR, *node_color] nodelist = set(nodelist) selnodes = ''.join([node2id[u] for u in nodelist])[4:] for u in nodelist: x, y, z = node2CA[u] obj+=[SPHERE, x, y, z, r] cmd.load_cgo(obj, name_nodes) #Creating text for labeling components if label_compo != '' or compos_to_excel !=None: if compos_to_excel != None: rows_list = [] objtxt = [] axes = -np.array(cmd.get_view()[:9]).reshape(3,3) components_list = [net.subgraph(c).copy() for c in nx.connected_components(net)] diameters = [nx.diameter(c) for c in components_list] for i, j in enumerate(np.argsort(diameters)[::-1]): row_dict = {} c = components_list[j] sses = sorted(list(set([node2SS[node] for node in c]))) if compos_to_excel !=None: row_dict['Secondary structure elements'] = ','.join(sses) row_dict['Vanishing point'] = np.max([abs(net[u][v]['weight']) for u, v in c.edges()]) row_dict['Diameter'] = nx.diameter(c) row_dict['Size'] = len(c.edges()) row_dict['Size rank'] = i+1 else: print('Component {}\n'.format(i+1), ', '.join(sses)) print('Size (number of edges) {}'.format(len(c.edges()))) print('Vanishing point: {}'.format(np.max([abs(net[u][v]['weight']) for u, v in c.edges()]))) if 'h' in str(label_compo): methods = ['eigenvector', 'hits_hub', 'hits_authority', 'pagerank', 'betweenness', 'katz'] hubs = [get_hubs(c, method) for method in methods] if compos_to_excel !=None: row_dict.update(dict(zip(methods, hubs))) else: print(dict(zip(methods, hubs))) if 'c' in str(label_compo): pos = np.array(node2CA[next(c.__iter__())]) + (axes[0]) cyl_text(objtxt, plain, pos, 'Component {}'.format(i+1), radius=0.1, color=[0, 0, 0], axes=axes) if compos_to_excel: rows_list.append(row_dict) if compos_to_excel: df = pd.DataFrame(rows_list) df.to_excel(compos_to_excel) if 's' in str(label_compo): for ss in SS2nodelist: nodelist = SS2nodelist[ss] print(mapss[ss], ': ', ('{}--{}'.format(nodelist[0], nodelist[-1]) if len(nodelist)>1 else nodelist[0])) # print(objtxt) cmd.set("cgo_line_radius", 0.03) cmd.load_cgo(objtxt, 'txt') #labeling if labeling==1: cmd.label(selection=selnodes, expression="t2o(resn)+resi") if labeling==3: cmd.label(selection=selnodes, expression="resn+resi") #Summing if sum: print('Sum of contacts lost: ', np.sum(pertmat)) if printall: print([(u,v, net[u][v]) for u, v in net.edges()])
max_len = max(lens) print("Eccentricity of 0 vertex is:", max_len - 1) print(eccentricity[max_len]) ddd = eccentricity.keys() if (n<=500): print("Find center?") key4 = input("y/n?") if (key4 == "y"): cent = nx.center(G) print("Center - ",cent) diam = nx.diameter(G) print("Diameter - ",diam) rad = nx.radius(G) print("Radius - ",rad) print("Draw Graph?") key3 = input("y/n? ") if (key3 == "y"): nx.draw(G, with_labels = True) plt.savefig("plot.png") plt.show() print(nx.info(G)) #Поменять количество вершин в графе? print("Do u want another quantity of Vertex? ") key = input("y/n? \n") if (key == "y"): launch = True
def rad(net): return ((nx.radius(net,e=eccentricity_list(net)),'radius'),)
L = nx.Graph() L.add_weighted_edges_from(mas) #веса связного графа fin = open('graphsv.txt', 'r') mas = [[0] * 3 for i in range(82)] for i in range(82): s = fin.readline() k = s.split() for j in range(2): mas[i][j] = k[j] mas[i][2] = int(k[2]) G = nx.Graph() G.add_weighted_edges_from(mas) #b print("rad(G) = ", nx.radius(G), ", diam(G) = ", nx.diameter(G), ", girth(G) = ", len(min(nx.cycle_basis(G))), ", center(G) = ", nx.center(G), ", k_node_connectivity = ", nx.node_connectivity(G), ", k_edge_connectivity = ", nx.edge_connectivity(G)) print() #maxmatching g print("M =", nx.max_weight_matching(L)) print() #mst о MST = nx.Graph(mst.minimum_spanning_tree(G)) print("MST = ", MST.edges) print("MST =", sum(c for (a, b, c) in (MST.edges.data('weight')))) print()
def extended_stats(G, connectivity=False, anc=False, ecc=False, bc=False, cc=False): """ Calculate extended topological stats and metrics for a graph. Global topological analysis of large complex networks is extremely time consuming and may exhaust computer memory. Consider using function arguments to not run metrics that require computation of a full matrix of paths if they will not be needed. Parameters ---------- G : networkx multidigraph connectivity : bool if True, calculate node and edge connectivity anc : bool, if True calculate average node connectivity ecc : bool if True, calculate shortest paths, eccentricity, and topological metrics that use eccentricity bc : bool if True, calculate node betweenness centrality cc : bool if True, calculate node closeness centrality Returns ------- stats : dict dictionary of network measures containing the following elements (some only calculated/returned optionally, based on passed parameters): - avg_neighbor_degree - avg_neighbor_degree_avg - avg_weighted_neighbor_degree - avg_weighted_neighbor_degree_avg - degree_centrality - degree_centrality_avg - clustering_coefficient - clustering_coefficient_avg - clustering_coefficient_weighted - clustering_coefficient_weighted_avg - pagerank - pagerank_max_node - pagerank_max - pagerank_min_node - pagerank_min - node_connectivity - node_connectivity_avg - edge_connectivity - eccentricity - diameter - radius - center - periphery - closeness_centrality - closeness_centrality_avg - betweenness_centrality - betweenness_centrality_avg """ stats = {} full_start_time = time.time() # create a DiGraph from the MultiDiGraph, for those metrics that require it G_dir = nx.DiGraph(G) # create an undirected Graph from the MultiDiGraph, for those metrics that require it G_undir = nx.Graph(G) # get the largest strongly connected component, for those metrics that require strongly connected graphs G_strong = get_largest_component(G, strongly=True) # average degree of the neighborhood of each node, and average for the graph avg_neighbor_degree = nx.average_neighbor_degree(G) stats['avg_neighbor_degree'] = avg_neighbor_degree stats['avg_neighbor_degree_avg'] = sum(avg_neighbor_degree.values())/len(avg_neighbor_degree) # average weighted degree of the neighborhood of each node, and average for the graph avg_weighted_neighbor_degree = nx.average_neighbor_degree(G, weight='length') stats['avg_weighted_neighbor_degree'] = avg_weighted_neighbor_degree stats['avg_weighted_neighbor_degree_avg'] = sum(avg_weighted_neighbor_degree.values())/len(avg_weighted_neighbor_degree) # degree centrality for a node is the fraction of nodes it is connected to degree_centrality = nx.degree_centrality(G) stats['degree_centrality'] = degree_centrality stats['degree_centrality_avg'] = sum(degree_centrality.values())/len(degree_centrality) # calculate clustering coefficient for the nodes stats['clustering_coefficient'] = nx.clustering(G_undir) # average clustering coefficient for the graph stats['clustering_coefficient_avg'] = nx.average_clustering(G_undir) # calculate weighted clustering coefficient for the nodes stats['clustering_coefficient_weighted'] = nx.clustering(G_undir, weight='length') # average clustering coefficient (weighted) for the graph stats['clustering_coefficient_weighted_avg'] = nx.average_clustering(G_undir, weight='length') # pagerank: a ranking of the nodes in the graph based on the structure of the incoming links pagerank = nx.pagerank(G_dir, weight='length') stats['pagerank'] = pagerank # node with the highest page rank, and its value pagerank_max_node = max(pagerank, key=lambda x: pagerank[x]) stats['pagerank_max_node'] = pagerank_max_node stats['pagerank_max'] = pagerank[pagerank_max_node] # node with the lowest page rank, and its value pagerank_min_node = min(pagerank, key=lambda x: pagerank[x]) stats['pagerank_min_node'] = pagerank_min_node stats['pagerank_min'] = pagerank[pagerank_min_node] # if True, calculate node and edge connectivity if connectivity: start_time = time.time() # node connectivity is the minimum number of nodes that must be removed to disconnect G or render it trivial stats['node_connectivity'] = nx.node_connectivity(G_strong) # edge connectivity is equal to the minimum number of edges that must be removed to disconnect G or render it trivial stats['edge_connectivity'] = nx.edge_connectivity(G_strong) log('Calculated node and edge connectivity in {:,.2f} seconds'.format(time.time() - start_time)) # if True, calculate average node connectivity if anc: # mean number of internally node-disjoint paths between each pair of nodes in G # i.e., the expected number of nodes that must be removed to disconnect a randomly selected pair of non-adjacent nodes start_time = time.time() stats['node_connectivity_avg'] = nx.average_node_connectivity(G) log('Calculated average node connectivity in {:,.2f} seconds'.format(time.time() - start_time)) # if True, calculate shortest paths, eccentricity, and topological metrics that use eccentricity if ecc: # precompute shortest paths between all nodes for eccentricity-based stats start_time = time.time() sp = {source:dict(nx.single_source_dijkstra_path_length(G_strong, source, weight='length')) for source in G_strong.nodes()} log('Calculated shortest path lengths in {:,.2f} seconds'.format(time.time() - start_time)) # eccentricity of a node v is the maximum distance from v to all other nodes in G eccentricity = nx.eccentricity(G_strong, sp=sp) stats['eccentricity'] = eccentricity # diameter is the maximum eccentricity diameter = nx.diameter(G_strong, e=eccentricity) stats['diameter'] = diameter # radius is the minimum eccentricity radius = nx.radius(G_strong, e=eccentricity) stats['radius'] = radius # center is the set of nodes with eccentricity equal to radius center = nx.center(G_strong, e=eccentricity) stats['center'] = center # periphery is the set of nodes with eccentricity equal to the diameter periphery = nx.periphery(G_strong, e=eccentricity) stats['periphery'] = periphery # if True, calculate node closeness centrality if cc: # closeness centrality of a node is the reciprocal of the sum of the shortest path distances from u to all other nodes start_time = time.time() closeness_centrality = nx.closeness_centrality(G, distance='length') stats['closeness_centrality'] = closeness_centrality stats['closeness_centrality_avg'] = sum(closeness_centrality.values())/len(closeness_centrality) log('Calculated closeness centrality in {:,.2f} seconds'.format(time.time() - start_time)) # if True, calculate node betweenness centrality if bc: # betweenness centrality of a node is the sum of the fraction of all-pairs shortest paths that pass through node start_time = time.time() betweenness_centrality = nx.betweenness_centrality(G, weight='length') stats['betweenness_centrality'] = betweenness_centrality stats['betweenness_centrality_avg'] = sum(betweenness_centrality.values())/len(betweenness_centrality) log('Calculated betweenness centrality in {:,.2f} seconds'.format(time.time() - start_time)) log('Calculated extended stats in {:,.2f} seconds'.format(time.time()-full_start_time)) return stats
__author__ = 'fhca' import networkx as nx import matplotlib.pyplot as plt import numpy as np g = nx.Graph() g.add_edge("a", "c") g.add_edge("b", "c") g.add_edge("c", "e") g.add_edges_from([("e","d"), ("e","g"), ("e","f")]) g.add_edges_from([("f","g"), ("f","j") ]) g.add_edges_from([("i","h"), ("i","g"), ("i","j")]) g.add_edge("h","g") g.add_edge("j","g") nx.draw_networkx(g) nodos_ordenados = np.sort(g.nodes()) print(nx.to_numpy_matrix(g, nodelist=nodos_ordenados)) print("excentricidad (distancia máxima a otros nodos)", nx.eccentricity(g)) print("centro (nodos con mínima excentricidad)", nx.center(g)) print("periferia (nodos con máxima excentricidad)", nx.periphery(g)) print("radio:", nx.radius(g)) plt.show()
def creationVecteur(G): v = {} # Adding nodes nn = nx.number_of_nodes(G) v["numNodes"] = nn # Adding edges ne = nx.number_of_edges(G) v["numEdges"] = ne # Adding cyclomatic number c = nx.number_connected_components(G) cyclo = ne - nn + c v["numCycles"] = cyclo # Adding link density if nn == 1: linkdensity = "?" else: linkdensity = 2 * ne / ((nn - 1) * nn) v["linkDensity"] = linkdensity # Adding average degree avgdegree = 2 * ne / nn v["avgDegree"] = avgdegree # Adding number of leaves nl = numberLeaves(G) v["numLeafs"] = nl # Adding histogram of the nodes degree v["histDegree0"] = 0 v["histDegree1"] = 0 v["histDegree2"] = 0 v["histDegree3"] = 0 v["histDegree4"] = 0 histDegree = nx.degree_histogram(G) v["histDegree0"] = histDegree[0] if len(histDegree) > 1: v["histDegree1"] = histDegree[1] if len(histDegree) > 2: v["histDegree2"] = histDegree[2] if len(histDegree) > 3: v["histDegree3"] = histDegree[3] if len(histDegree) > 4: v["histDegree4"] = histDegree[4] # Adding sMetric v["sMetric"] = metric(G) # Adding graph energy energ = graphEnergy(G) v["graphEnergy"] = energ # Adding average of the average neighboring degrees of all nodes av = averageNeighDegree(G) v["averageNeighDegree"] = av # Adding average of closeness over all nodes v["averageCloseness"] = average_closeness(G) # Adding pearson coefficient for the degree sequence of all edges of the graph pearson = nx.degree_pearson_correlation_coefficient(G) if np.isnan(pearson): pearson = 0 v["pearson"] = pearson # Adding rich club metric for all nodes with a degree larger than 1 rc = richClub(G) v["richClub"] = rc # Adding algebraic connectivity, i.e. the second smallest eigenvalue of the Laplacian algConnect = nx.laplacian_spectrum(G) algConnect = list(algConnect) algConnect = sorted(algConnect) v["algConnect"] = algConnect[1] # Adding diameter of the graph if nx.is_connected(G): diam = nx.diameter(G) else: diam = "?" v["diameter"] = diam # Adding average shortest path if nx.is_connected(G): avgShortestPath = nx.average_shortest_path_length(G) else: avgShortestPath = "?" v["avgShortPath"] = avgShortestPath # Adding graph radius if nx.is_connected(G): rad = nx.radius(G) else: rad = "?" v["graphRadius"] = rad return v
def detect(self): print('epa_center带权重检测') if self.subgraph.number_of_nodes() == 0: print 'subgraph.number_of_nodes =0' return self.reset_centrality() centrality = {} P_node_prominence = defaultdict(int) for infect_node in self.subgraph.nodes(): # print('是哪个点') # print(infect_node) neigbour_node = nx.neighbors(self.data.graph, infect_node) neigbour_infect_node = [ x for x in neigbour_node if x in self.subgraph.nodes() ] Iv = len(neigbour_infect_node) Ov = len(neigbour_node) P_node_prominence[infect_node] = Iv * 1.0 / Ov * (1 + math.log(Ov)) # print('输出权重') #加一个对感染边权重的处理。 # print(self.data.weights) #分子 molecule = 0 for neigbour_infect in neigbour_infect_node: molecule += ( 1 - self.data.weights[self.data.node2index[infect_node], self.data.node2index[neigbour_infect]]) # print('分子是') # print(molecule) Denominator = 0 for neigbour in neigbour_node: Denominator += ( 1 - self.data.weights[self.data.node2index[infect_node], self.data.node2index[neigbour]]) # print('分母是') # print(Denominator) factor = molecule * 1.0 / Denominator # print('看下factor') # print(factor) P_node_prominence[infect_node] *= factor # print('P_node_prominence') # print(P_node_prominence) radius = nx.radius(self.subgraph) ecc = nx.eccentricity(self.subgraph) # print('ecc') # print(ecc) # print('半径是多少?') # 进行所有点有向树构建,再进行层次遍历。针对每一层都进行传播点/全部的比例计算。 node_every_ratio = [] temp_nodes = self.subgraph.nodes() for source in self.subgraph.nodes(): tree = nx.bfs_tree(self.data.graph, source=source) # 进行层次遍历。返回每一层顶点。 BFS_nodes = self.BFS_nodes(tree, source, self.data.graph, self.subgraph, 2 * radius) # print(BFS_nodes) layer_node_sum = 0 for layer_node in BFS_nodes: for evuery_layer_node in layer_node: layer_node_sum += P_node_prominence[evuery_layer_node] # centrality[source] = Decimal(layer_node_sum) centrality[source] = Decimal(layer_node_sum * 1.0 / ecc[source]) # print('让我看下这个ratio _average的centiality') # print(centrality) nx.set_node_attributes(self.subgraph, 'centrality', centrality) return self.sort_nodes_by_centrality()
def radius(self): if not self.is_connected: raise Exception("Graph is not connected") return nx.radius(self.graph.structure)
def _ComputeRadius(self, graphs): print 'Computing radius' for key in graphs.keys(): self.featuresByGraph[key].append(networkx.radius(graphs[key]))
def radius(g, N, **kwargs): if N == 1: return 0 return nx.radius(g)
def centrality_and_params_graph(g): dict_return = {} degree_counter = [] betweenness_counter = [] closeness_counter = [] eigen_counter = [] deg = nx.degree_centrality(g) for nodeid in sorted(deg, key=deg.get, reverse=True): degree_counter.append(nodeid) biggest_deg = { key: value for key, value in deg.items() if value in sorted(set(deg.values()), reverse=True)[:2] } bet = nx.betweenness_centrality(g) for nodeid in sorted(bet, key=bet.get, reverse=True): betweenness_counter.append(nodeid) biggest_bet = { key: value for key, value in bet.items() if value in sorted(set(bet.values()), reverse=True)[:2] } cls = nx.closeness_centrality(g) for nodeid in sorted(cls, key=cls.get, reverse=True): closeness_counter.append(nodeid) biggest_cls = { key: value for key, value in cls.items() if value in sorted(set(cls.values()), reverse=True)[:2] } eig = nx.eigenvector_centrality(g) for nodeid in sorted(eig, key=eig.get, reverse=True): eigen_counter.append(nodeid) biggest_eig = { key: value for key, value in eig.items() if value in sorted(set(eig.values()), reverse=True)[:2] } radius = nx.radius(g) diameter = nx.diameter(g) assort_coef = nx.degree_pearson_correlation_coefficient(g) clustering = nx.average_clustering(g) node_number = g.number_of_nodes() edge_number = g.number_of_edges() communities = community.greedy_modularity_communities(g) dict_return = { 'biggest_deg': biggest_deg, 'biggest_bet': biggest_bet, 'biggest_cls': biggest_cls, 'biggest_eig': biggest_eig, 'radius': radius, 'diameter': diameter, 'assort_coef': assort_coef, 'clustering': clustering, 'node_number': node_number, 'edge_number': edge_number, 'communities': communities } return dict_return
def _ComputeRadius(self, graph): return networkx.radius(graph)
fin = open('digraph.txt', 'r') mas = [[0] * 3 for i in range(170)] for i in range(90): s = fin.readline() k = s.split() for j in range(2): mas[i][j] = k[j] mas[i][2] = int(k[2]) D = nx.DiGraph() D.add_weighted_edges_from(mas) # b) print("b) |V| = ", G_.number_of_nodes(), ", |E| = ", G_.number_of_edges(), ", min_degree(G) = ", min(val for (node, val) in G.degree()), ", max_degree(G) = ", max(val for (node, val) in G.degree()), ", rad(G) = ", nx.radius(G), ", diam(G) = ", nx.diameter(G), ", girth(G) = ", len(min(nx.cycle_basis(G))), ", center(G) = ", nx.center(G), ", k_node_connectivity = ", nx.node_connectivity(G), ", k_edge_connectivity = ", nx.edge_connectivity(G)) print() # c) Minimum vertex coloring print("c) Colors:", max(nx.greedy_color(G).values()) + 1, ", Z =", nx.greedy_color(G)) print() # d) Minimum edge coloring print("d) Colors:", max(nx.greedy_color(nx.line_graph(G)).values()) + 1, ", E =",
pass labels = {} for i in range(len(words)): if i in G.nodes(): labels[i] = words[i] deg = nx.degree_centrality(G) degs = sorted(deg, key=deg.get, reverse=True) print("Топ-5 центральных слов:") for i in range(0, 5): print(labels[degs[i]]) # Топ-5 центральных radii = [] for c in sorted(nx.connected_component_subgraphs(G), key=len, reverse=True): try: radii.append(nx.radius(c)) except: pass print() print("Радиусы для различных компонент связности:") for r in radii: print(r) # Радиус print() print("Коэффициент кластеризации:") print(nx.average_clustering(G)) # Кластеризация # для начала надо выбрать способ "укладки" графа. Их много, возьмём для начала такой: pos = nx.spring_layout(G) nx.draw_networkx_nodes( G, pos, node_color='red',
spl = nx.shortest_path_length(G, v) print('{} {} '.format(v, spl)) for p in spl: pathlengths.append(spl[p]) # pathlengths #%% print("average shortest path length %s" % (sum(pathlengths) / len(pathlengths))) # histogram of path lengths dist = {} for p in pathlengths: if p in dist: dist[p] += 1 else: dist[p] = 1 print('') print("length #paths") verts = dist.keys() for d in sorted(verts): # print('%s %d' % (d, dist[d])) print('{} {}'.format(d, dist[d])) # print('{}'.format(nx.radius(G))) print("eccentricity: %s" % nx.eccentricity(G)) print("radius: %d" % nx.radius(G)) print("diameter: %d" % nx.diameter(G)) print("center: %s" % nx.center(G)) print("periphery: %s" % nx.periphery(G)) print("density: %s" % nx.density(G))
import networkx as nx g = nx.read_edgelist('0.edges') sg = nx.connected_component_subgraphs(g)[0] ecc = nx.eccentricity(sg) r = nx.radius(sg) center = [node for node in sg.nodes() if ecc[node] == r] print center
# attracting components nx.is_attracting_component(G) nx.number_attracting_components(G) nx.attracting_components(G) # directed acyclic graphs nx.is_directed_acyclic_graph(G) nx.is_aperiodic(G) # distance measure (all for connected graph) nx.center(Gcc) nx.diameter(Gcc) nx.eccentricity(Gcc) nx.periphery(Gcc) nx.radius(Gcc) # flows (seg fault currently) #nx.max_flow(Gcc, 1, 2) #nx.min_cut(G, 1, 2) # isolates nx.is_isolate(G, 1) # False nx.is_isolate(G, 5) # True # HITS nx.hits(G, max_iter=1000) # cannot converge? # maximal independent set nx.maximal_independent_set(G)
from pylab import * import networkx as nx g = nx.karate_club_graph() n = g.number_of_nodes() m = g.number_of_edges() L = nx.average_shortest_path_length(g) D = nx.diameter(g) R = nx.radius(g) Ldiffs = [] Ddiffs = [] Rdiffs = [] for i in range(500): g2 = nx.gnm_random_graph(n, m) if nx.is_connected(g2): Ldiffs.append(nx.average_shortest_path_length(g2) - L) Ddiffs.append(nx.diameter(g2) - D) Rdiffs.append(nx.radius(g2) - R) subplot(1, 3, 1) hist(Ldiffs) title('L diff') subplot(1, 3, 2) hist(Ddiffs) title('D diff') subplot(1, 3, 3) hist(Rdiffs)
Folder_to_load_from = '{}'.format(Folder_to_load_from) Folder_to_save_graphs = str(Folder_to_save_graphs) Name_of_stat_file = '{}'.format(Name_of_stat_file) stats = {} #create graph G = ox.save_load.load_graphml(Graphml_File_Name, folder=Folder_to_load_from) #Calculate the center of graph, the folowing statement would return a list stats['center'] = nx.center(G) #calculate the diameter stats['diameter'] = nx.diameter(G) #caluculate the eccentricity stats['eccentricity'] = nx.eccentricity(G) #calculate the periphery of the graph stats['periphery'] = nx.periphery(G) # caluculate the radius stats['radius'] = nx.radius(G, e=None) # #statsfile=Graphml_File_Name+str('/centrality.csv') filepath = Folder_to_save_graphs + '/' + Name_of_stat_file df = pd.DataFrame.from_dict(stats) df.to_csv(filepath)
full_partition_prefix = sampling_algorithm+'_'+data_set+'_result/'+str(per_format)+'/output-prefix.t0000'+ str(i) re=open(full_partition_prefix +'.graph', 'rb') sample_=nx.read_edgelist(re, nodetype=int) re.close() print 'number of unique nodes:',sample_.number_of_nodes() print 'number of unique edges:',sample_.number_of_edges() #print 'nodes',original.nodes() sample=maximum_connected_components(sample_) #partition sample edges = nx.number_of_edges(sample) listEdges.append(edges) eccentricity = nx.diameter(sample) listEccentricity.append(eccentricity) radius = nx.radius(sample) listRadius.append(radius) part = community.best_partition(nx.Graph(sample)) snapshotCommunities(full_partition_prefix, part) commsfile = full_partition_prefix + '.comms' partition_sample = se.ReadInData(commsfile) first_result_lines = se.Compare3(copy.deepcopy(partition_set), partition_sample, deltas, float(per), commsfile) precision_micro=first_result_lines[0][2] recall_micro=first_result_lines[1][2] p9_precision_micro = first_result_lines[2][2] r9_recall_micro=first_result_lines[3][2]
help='sort by FIELD from specified FIELDS') parser.add_argument('-t', '--top', metavar='NUM_USERS', type=int, help='print only top NUM_USERS') args = parser.parse_args() try: start_time = time.time() G = io.read_graph(args.path) if args.info: print(nx.info(G), '\n') if args.radius: print('Graph radius: ', nx.radius(G)) if args.diameter: print('Graph diameter: ', nx.diameter(G)) if args.avg_friends: print('Average number of friends: ', stats.avg_num_friends(G)) if args.avg_followers: print('Average number of followers: ', stats.avg_num_followers(G)) if args.fields: try: from prettytable import PrettyTable except ImportError: print('This script requires PrettyTable library to be installed.')
def calculate(graph): if nx.is_connected(graph): return nx.radius(graph) else: return 10**10
def test_bound_radius(self): assert_equal(networkx.radius(self.G, usebounds=True), 4)
def test_radius(self): assert_equal(networkx.radius(self.G),4)
import matplotlib.pyplot as plt reseau_social = nx.Graph() reseau_social.add_node('laurent') reseau_social.add_node('pierre') reseau_social.add_node('lucie') reseau_social.add_node('sophie') reseau_social.add_node('martin') reseau_social.add_node('jacques') reseau_social.add_edge('laurent', 'pierre') reseau_social.add_edge('lucie', 'pierre') #reseau_social.add_edge('laurent','lucie') reseau_social.add_edge('sophie', 'lucie') reseau_social.add_edge('sophie', 'pierre') reseau_social.add_edge('sophie', 'martin') reseau_social.add_edge('martin', 'laurent') reseau_social.add_edge('jacques', 'martin') reseau_social.add_edge('jacques', 'laurent') nx.draw(reseau_social, with_labels=True) plt.draw() plt.show() print("nombre de sommets=", reseau_social.number_of_nodes()) print("nombre de arêtes=", reseau_social.number_of_edges()) print("Diamètre=", diameter(reseau_social)) print("Rayon=", radius(reseau_social)) print("Centre=", center(reseau_social))
g.add_edge(row,col) print "Done reading all the files" graphs[item] = g for g in graphs.keys(): try: print "====================== " , g, "===========================" print "number of isolated nodes",'\t\t\t',nx.isolates(graphs[g]) print "is graph biconnected?",'\t\t\t',nx.is_biconnected(graphs[g]) print "cut vertices are: ",'\t\t\t',list(nx.articulation_points(graphs[g])) print "number of nodes",'\t\t\t',len(graphs[g].nodes()) print "number of edges",'\t\t\t',len(graphs[g].edges()) print "degree",'\t\t\t',get_avg(graphs[g].degree()) print "diameter",'\t\t\t', nx.diameter(graphs[g]) print "radius",'\t\t\t', nx.radius(graphs[g]) print "is_bipartite?",'\t\t', bipartite.is_bipartite(graphs[g]) print "average_shortest_path_length",'\t\t', nx.average_shortest_path_length(graphs[g]) print "degree_assortativity_coefficient",'\t\t', nx.degree_assortativity_coefficient(graphs[g]) print "assortativity.average_degree_connectivity",'\t\t', nx.assortativity.average_degree_connectivity(graphs[g]) #print "degree_pearson_correlation_coefficient",'\t\t', nx.degree_pearson_correlation_coefficient(graphs[g]) print "node closeness_centrality",'\t\t\t', get_avg(nx.closeness_centrality(graphs[g])) print "clustering",'\t\t\t', get_avg(nx.clustering(graphs[g])) print "node betweeness",'\t\t\t', get_avg(nx.betweenness_centrality(graphs[g],normalized=False,endpoints=False)) print "edge betweeness",'\t\t\t', get_avg(nx.edge_betweenness_centrality(graphs[g],normalized=False)) #print "spectral_bipartivity",'\t\t', bipartite.spectral_bipartivity(graphs[g]) #print "node betweeness normalized",'\t\t\t', get_avg(nx.betweenness_centrality(graphs[g],normalized=True,endpoints=False)) #print "edge betweeness normalized",'\t\t\t', get_avg(nx.edge_betweenness_centrality(graphs[g],normalized=True)) #print "node closeness_vitality",'\t\t\t', get_avg(nx.closeness_vitality(graphs[g])) #print "communicability_centrality",'\t\t', get_avg(nx.communicability_centrality(graphs[g])) #print "communicability_betweenness_centrality",'\t\t', get_avg(nx.communicability_betweenness_centrality(graphs[g]))
rumorSourceList[0], rumorSourceList[1], weight='weight')) # all_short_length=[] # #求任意两点之间的最短路径。 # for node1 in subinfectG.nodes: # for node2 in subinfectG.nodes: # if node1==node2: # pass # else: # all_short_length.append(nx.dijkstra_path_length(G, node1, node2, weight='weight')) # 求最短距离 # # print (max(all_short_length)) print('#查看感染图半径' + str(nx.radius(subinfectG))) print('查看感染图中心' + str(nx.center(subinfectG))) print('查看感染图直径' + str(nx.diameter(subinfectG))) # print ('查看感染图图外围'+str(nx.periphery(subinfectG))) # print ('查看感染图某点偏心率'+str(nx.eccentricity(G,125))) #随机生成u1,h1,u2.h2来让E(u1,h1,u2,h2)最大。 resutltList, lasth = contactu1h1u2h2( subinfectG, infectG, rumorSourceList, 5, 6) #这里的后三个参数。第一个是真实两源源点,第三个是这个源点的传播h,最后一个是试探h。 #返回的结果是两个heav center以及它的h,因为这里的h是一样的。 #现在分别计算在每个点下,找源点。看看reverse infection algorithm,试下第一个点 #第一步
def extended_stats(G, connectivity=False, anc=False, ecc=False, bc=False, cc=False): """ Calculate extended topological stats and metrics for a graph. Many of these algorithms have an inherently high time complexity. Global topological analysis of large complex networks is extremely time consuming and may exhaust computer memory. Consider using function arguments to not run metrics that require computation of a full matrix of paths if they will not be needed. Parameters ---------- G : networkx multidigraph connectivity : bool if True, calculate node and edge connectivity anc : bool if True, calculate average node connectivity ecc : bool if True, calculate shortest paths, eccentricity, and topological metrics that use eccentricity bc : bool if True, calculate node betweenness centrality cc : bool if True, calculate node closeness centrality Returns ------- stats : dict dictionary of network measures containing the following elements (some only calculated/returned optionally, based on passed parameters): - avg_neighbor_degree - avg_neighbor_degree_avg - avg_weighted_neighbor_degree - avg_weighted_neighbor_degree_avg - degree_centrality - degree_centrality_avg - clustering_coefficient - clustering_coefficient_avg - clustering_coefficient_weighted - clustering_coefficient_weighted_avg - pagerank - pagerank_max_node - pagerank_max - pagerank_min_node - pagerank_min - node_connectivity - node_connectivity_avg - edge_connectivity - eccentricity - diameter - radius - center - periphery - closeness_centrality - closeness_centrality_avg - betweenness_centrality - betweenness_centrality_avg """ stats = {} full_start_time = time.time() # create a DiGraph from the MultiDiGraph, for those metrics that require it G_dir = nx.DiGraph(G) # create an undirected Graph from the MultiDiGraph, for those metrics that # require it G_undir = nx.Graph(G) # get the largest strongly connected component, for those metrics that # require strongly connected graphs G_strong = get_largest_component(G, strongly=True) # average degree of the neighborhood of each node, and average for the graph avg_neighbor_degree = nx.average_neighbor_degree(G) stats['avg_neighbor_degree'] = avg_neighbor_degree stats['avg_neighbor_degree_avg'] = sum(avg_neighbor_degree.values())/len(avg_neighbor_degree) # average weighted degree of the neighborhood of each node, and average for # the graph avg_weighted_neighbor_degree = nx.average_neighbor_degree(G, weight='length') stats['avg_weighted_neighbor_degree'] = avg_weighted_neighbor_degree stats['avg_weighted_neighbor_degree_avg'] = sum(avg_weighted_neighbor_degree.values())/len(avg_weighted_neighbor_degree) # degree centrality for a node is the fraction of nodes it is connected to degree_centrality = nx.degree_centrality(G) stats['degree_centrality'] = degree_centrality stats['degree_centrality_avg'] = sum(degree_centrality.values())/len(degree_centrality) # calculate clustering coefficient for the nodes stats['clustering_coefficient'] = nx.clustering(G_undir) # average clustering coefficient for the graph stats['clustering_coefficient_avg'] = nx.average_clustering(G_undir) # calculate weighted clustering coefficient for the nodes stats['clustering_coefficient_weighted'] = nx.clustering(G_undir, weight='length') # average clustering coefficient (weighted) for the graph stats['clustering_coefficient_weighted_avg'] = nx.average_clustering(G_undir, weight='length') # pagerank: a ranking of the nodes in the graph based on the structure of # the incoming links pagerank = nx.pagerank(G_dir, weight='length') stats['pagerank'] = pagerank # node with the highest page rank, and its value pagerank_max_node = max(pagerank, key=lambda x: pagerank[x]) stats['pagerank_max_node'] = pagerank_max_node stats['pagerank_max'] = pagerank[pagerank_max_node] # node with the lowest page rank, and its value pagerank_min_node = min(pagerank, key=lambda x: pagerank[x]) stats['pagerank_min_node'] = pagerank_min_node stats['pagerank_min'] = pagerank[pagerank_min_node] # if True, calculate node and edge connectivity if connectivity: start_time = time.time() # node connectivity is the minimum number of nodes that must be removed # to disconnect G or render it trivial stats['node_connectivity'] = nx.node_connectivity(G_strong) # edge connectivity is equal to the minimum number of edges that must be # removed to disconnect G or render it trivial stats['edge_connectivity'] = nx.edge_connectivity(G_strong) log('Calculated node and edge connectivity in {:,.2f} seconds'.format(time.time() - start_time)) # if True, calculate average node connectivity if anc: # mean number of internally node-disjoint paths between each pair of # nodes in G, i.e., the expected number of nodes that must be removed to # disconnect a randomly selected pair of non-adjacent nodes start_time = time.time() stats['node_connectivity_avg'] = nx.average_node_connectivity(G) log('Calculated average node connectivity in {:,.2f} seconds'.format(time.time() - start_time)) # if True, calculate shortest paths, eccentricity, and topological metrics # that use eccentricity if ecc: # precompute shortest paths between all nodes for eccentricity-based # stats start_time = time.time() sp = {source:dict(nx.single_source_dijkstra_path_length(G_strong, source, weight='length')) for source in G_strong.nodes()} log('Calculated shortest path lengths in {:,.2f} seconds'.format(time.time() - start_time)) # eccentricity of a node v is the maximum distance from v to all other # nodes in G eccentricity = nx.eccentricity(G_strong, sp=sp) stats['eccentricity'] = eccentricity # diameter is the maximum eccentricity diameter = nx.diameter(G_strong, e=eccentricity) stats['diameter'] = diameter # radius is the minimum eccentricity radius = nx.radius(G_strong, e=eccentricity) stats['radius'] = radius # center is the set of nodes with eccentricity equal to radius center = nx.center(G_strong, e=eccentricity) stats['center'] = center # periphery is the set of nodes with eccentricity equal to the diameter periphery = nx.periphery(G_strong, e=eccentricity) stats['periphery'] = periphery # if True, calculate node closeness centrality if cc: # closeness centrality of a node is the reciprocal of the sum of the # shortest path distances from u to all other nodes start_time = time.time() closeness_centrality = nx.closeness_centrality(G, distance='length') stats['closeness_centrality'] = closeness_centrality stats['closeness_centrality_avg'] = sum(closeness_centrality.values())/len(closeness_centrality) log('Calculated closeness centrality in {:,.2f} seconds'.format(time.time() - start_time)) # if True, calculate node betweenness centrality if bc: # betweenness centrality of a node is the sum of the fraction of # all-pairs shortest paths that pass through node start_time = time.time() betweenness_centrality = nx.betweenness_centrality(G, weight='length') stats['betweenness_centrality'] = betweenness_centrality stats['betweenness_centrality_avg'] = sum(betweenness_centrality.values())/len(betweenness_centrality) log('Calculated betweenness centrality in {:,.2f} seconds'.format(time.time() - start_time)) log('Calculated extended stats in {:,.2f} seconds'.format(time.time()-full_start_time)) return stats
'студент_NOUN', 'студентка_NOUN', 'учиться_VERB', 'экзамен_NOUN', 'школьник_NOUN', 'преподаватель_NOUN', 'учитель_NOUN', 'учебник_NOUN', 'книга_NOUN', 'заочник_NOUN', 'первокурсник_NOUN', 'преподавать_VERB', 'экзаменационный_ADJ', 'пересдавать_VERB', 'урок_NOUN', 'конспект_NOUN' ] G = nx.Graph() for word in words: G.add_node(word) for i in range(len(words)): for k in range(len(words)): if words[i] in model and words[k] in model and i < k: cos = model.similarity(words[i], words[k]) if cos > 0.5: G.add_edge(words[i], words[k]) deg = nx.degree_centrality(G) d = sorted(deg, key=deg.get, reverse=True) print('Пять самых центральных слова графа: %s' % ', '.join(d[:5])) print('Радиус графа: ', nx.radius(G)) print('Коэффициент кластеризации: ', nx.average_clustering(G)) nx.write_gexf(G, 'graph.gexf') pos = nx.spring_layout(G) nx.draw_networkx_nodes(G, pos, node_color='red', node_size=30) nx.draw_networkx_edges(G, pos, edge_color='blue') nx.draw_networkx_labels(G, pos, font_size=12, font_family='Arial') plt.axis('off') plt.show()