def print_graph_detail(graph): """ 格式化显示Graph参数 :param graph: :return: """ import networkx as nx dst = { "nodes": nx.number_of_nodes(graph), "edges": nx.number_of_edges(graph), "selfloops": nx.number_of_selfloops(graph), "isolates": nx.number_of_isolates(graph), "覆盖度": 1 - nx.number_of_isolates(graph) / nx.number_of_nodes(graph), } print_table(dst)
def get_network_statistics(G, year=None): # G.name = year n_connected_components = 1 for C in (G.subgraph(c).copy() for c in sorted(nx.connected_components(G), key=len)): largest_C = C n_connected_components -= 1 maxK = sorted(G.degree, key=lambda x: x[1], reverse=True)[0] info = { 'Number of Isolates': nx.number_of_isolates(G), 'No. of nodes': float(nx.info(G).split('\n')[-3].split(':')[-1].strip()), 'No. of edges': float(nx.info(G).split('\n')[-2].split(':')[-1].strip()), 'Average no. of edges': len(G.edges) / len(G.nodes), 'Average degree': float(nx.info(G).split('\n')[-1].split(':')[-1].strip()), 'Max Degree': maxK[1], 'Average Clustering coefficient': nx.average_clustering(G), 'No. of nodes in largest connected component': len(largest_C.nodes), 'Diameter of largest connected component': nx.diameter(largest_C), 'Average shortest path length of LCC': nx.average_shortest_path_length(largest_C) } df_stats = pd.DataFrame.from_records([info]).T df_stats = df_stats.reset_index() df_stats.columns = ['Attributes', 'Statistics'] return df_stats
def info(G): """ Compute and print out standard statistics of undirected multigraph G. """ tic = time() print("{0:>15s} | '{1:s}'".format('Graph', G.name.replace('_', '-'))) multi = False for edge in G.edges(): if G.number_of_edges(edge[0], edge[1]) > 1: multi = True break print("{0:>15s} | '{1:s}'".format('Type', '===' if multi else '---')) print("{0:>15s} | {1:,d} ({2:,d})".format('Nodes', G.number_of_nodes(), nx.number_of_isolates(G))) print("{0:>15s} | {1:,d} ({2:,d})".format('Edges', G.number_of_edges(), nx.number_of_selfloops(G))) ks = [k for _, k in G.degree()] print("{0:>15s} | {1:.1f} ({2:,d}, {3:,d})".format( 'Degree', 2.0 * G.number_of_edges() / G.number_of_nodes(), min(ks), max(ks))) print("{0:>15s} | {1:.8f}".format( 'Density', 2.0 * G.number_of_edges() / G.number_of_nodes() / (G.number_of_nodes() - 1.0))) CCs = sorted(nx.connected_component_subgraphs(G), key=len, reverse=True) print("{0:>15s} | {1:.1f}% ({2:,d})".format( 'Components', 100.0 * CCs[0].number_of_nodes() / G.number_of_nodes(), len(CCs))) d, D = dists(CCs[0]) print("{0:>15s} | {1:.3f} ({2:,d})".format('Distances', d, D)) print("{0:>15s} | {1:.6f}".format('Clustering', nx.average_clustering(nx.Graph(G)))) print("{0:>15s} | {1:.1f} sec\n".format('Time', time() - tic))
def calculate_networks_indicators(graph): """计算基本网络指标""" degree_centrality = nx.degree_centrality(graph) nodes = list(degree_centrality.keys()) betweenness_centrality = nx.betweenness_centrality(graph, weight='weight') network_indicators = pd.DataFrame({ 'nodes': nodes, 'degree_centrality': [degree_centrality[node] for node in nodes], 'betweenness_centrality': [betweenness_centrality[node] for node in nodes] }) network_indicators['local_reaching_centrality'] = [ nx.local_reaching_centrality(graph, node, weight='weight') for node in nodes ] constraint = nx.constraint(graph, weight='weight') network_indicators['constraint'] = [constraint[node] for node in nodes] effective_size = nx.effective_size(graph, weight='weight') network_indicators['effective_size'] = [ effective_size[node] for node in nodes ] triangles = nx.triangles(graph) network_indicators['triangles'] = [triangles[node] for node in nodes] clustering = nx.clustering(graph, weight='weight') network_indicators['clustering'] = [clustering[node] for node in nodes] weight_dict = { item[0]: item[1] for item in nx.degree(graph, weight='weight') } degree_dict = {item[0]: item[1] for item in nx.degree(graph)} average_weight_dict = { weight_key: (weight_dict[weight_key] / degree_dict[weight_key] if degree_dict[weight_key] != 0 else 0) for weight_key in weight_dict.keys() } network_indicators['tie_strength'] = [ average_weight_dict[node] for node in nodes ] network_indicators['number_of_node'] = nx.number_of_nodes(graph) network_indicators['density'] = nx.density(graph) cliques = nx.graph_clique_number(graph) if cliques >= 3: network_indicators['cliques'] = cliques else: network_indicators['cliques'] = 0 network_indicators['efficiency'] = nx.global_efficiency(graph) network_indicators['isolates'] = nx.number_of_isolates(graph) network_indicators = network_indicators[[ 'nodes', 'degree_centrality', 'betweenness_centrality', 'local_reaching_centrality', 'constraint', 'effective_size', 'triangles', 'clustering', 'tie_strength', 'number_of_node', 'density', 'cliques', 'efficiency', 'isolates' ]] return network_indicators
def print_statistics(self): message("-------------------------------------------") message("-- Graph Statistics -----------------------") message() message(" isolates:", nx.number_of_isolates(self.graph)) message(" density:", nx.density(self.graph)) message(" bridges:", len(list(nx.bridges(self.graph)))) message(" cliques:", nx.graph_clique_number(self.graph)) message(" conn-comps:", nx.number_connected_components(self.graph)) message() message("-------------------------------------------")
def macroscopic_measurements(G, start, final_leaders): """ Function which computes the macroscopic attributes of the newtork: 1. total nodes 2. total edges 3. graph's density 4. number of isolated nodes 5. number of self loops 6. average_shortest_path """ number_of_total_nodes = len(G) number_of_total_edges = len(G.edges) sys.stderr.write("Nodes and edges' number calculated! Runtime: %s\n" % (time.time() - start)) # fraction of existing edges out of all potentially possiblie edges => number between 0 e 1 graph_density = nx.density(G) sys.stderr.write("Graph's density calculated! Runtime: %s\n" % (time.time() - start)) # check if there are isolated nodes [a node with no neighbors (that is, with degree zero)] isolated_nodes = nx.number_of_isolates(G) sys.stderr.write("Isolates nodes calculated! Runtime: %s\n" % (time.time() - start)) # check if there are self-loops (edge that has the same node at both ends) self_loops = G.number_of_selfloops() sys.stderr.write("Self loops calculated! Runtime: %s\n" % (time.time() - start)) G.remove_edges_from(G.selfloop_edges()) # remove self-loops f = open("netstats_directed_old/directed_graph_macro_stats", 'a') f.write("Number nodes = %s \n" % number_of_total_nodes) f.write("\n") f.write("Number edges = %s \n" % number_of_total_edges) f.write("\n") f.write("Density = %s \n" % graph_density) f.write("\n") f.write("Isolated nodes = %s \n" % isolated_nodes) f.write("\n") f.write("Self-loops = %s \n" % self_loops) f.write("\n") f.close()
def display_info(sn_graph): try: print(nx.info(sn_graph)) #Betweennss betweenness = nx.betweenness_centrality(sn_graph, normalized=True).values() print("betweeness centrality (maximum): ", np.max(np.array(list(betweenness)))) print("betweenness centrality (average): ", np.mean(np.array(list(betweenness)))) #Closeness closeness = nx.closeness_centrality(sn_graph).values() print("closeness centrality (maximum): ", np.max(np.array(list(closeness)))) print("closeness centrality (average): ", np.mean(np.array(list(closeness)))) #Any seprate node? print("Any seprate node: ", nx.number_of_isolates(sn_graph)) #BigestSubgraph subgraphs = sorted(nx.connected_component_subgraphs(sn_graph), key=len, reverse=True) print("Biggest sub component : ", subgraphs[0].order(), subgraphs[0].size()) #diameter diameter=nx.diameter(sn_graph) print("graph diameter : ",diameter) except : print("Measure Error - diameter!!! ")
def __init__(self, lines: list[LineString]): """Construct a directed graph from a set of LineStrings Parameters: lines: geometries in the network Returns: directed network graph """ super().__init__() # add the nodes endpoints = [] for line in lines: endpoints.append(line.coords[0]) endpoints.append(line.coords[-1]) for i, p in enumerate(set(endpoints)): self.add_node(i, geom=Point(p)) # add the edges for line in lines: from_node = None to_node = None for n, data in self.nodes(data=True): p = data['geom'] if p.equals(Point(line.coords[0])): from_node = n elif p.equals(Point(line.coords[-1])): to_node = n self.add_edge(from_node, to_node, geom=line, len=line.length, meas=measure(line)) if nx.number_of_isolates(self) > 1: warnings.warn(ISOLATED_NODES) # if len(list(nx.connected_components(self.to_undirected()))) > 1: if nx.number_connected_components(self.to_undirected()) > 1: warnings.warn(MULTIPLE_SUBGRAPHS) self.vertices = self._vertices()
def metrics(G): # drawing the full network plot_graph(G) show() print(nx.info(G)) clos = nx.closeness_centrality(G).values() bet = nx.betweenness_centrality(G, normalized=True).values() print("isolated nodes: ", nx.number_of_isolates(G)) print("Density:", nx.density(G)) print("Diameter:", nx.diameter(G)) print("Connectivity:", nx.node_connectivity(G)) print("Average short path", nx.average_shortest_path_length(G)) print("Assortativity:", nx.degree_assortativity_coefficient(G)) giant = sorted(nx.connected_component_subgraphs(G), key=len, reverse=True) print("Size of biggest GCC (nodes): ", giant[0].order()) print("Max betweeness", np.max(np.array(list(bet)))) print("Max closeness", np.max(np.array(list(clos)))) print("AVG betweeness", np.mean(np.array(list(bet)))) print("AVG closeness", np.mean(np.array(list(clos)))) PlotMostImp(G)
"""#Criando Grafo""" G = nx.DiGraph() G.add_nodes_from(nodes.name) G.add_edges_from([(s,t) for s,t in zip(edges.name_source, edges.name_target)]) # adicionando as arestas nx.write_graphml(G, "dependencies_py.graphml") nx.set_node_attributes(G, pd.Series(list(nodes.position.str.split(",")), index=nodes.name).to_dict(), 'pos') print(nx.number_of_nodes(G)) print(nx.number_of_edges(G)) print(G.nodes.data()) print(nx.number_of_isolates(G)) #nós isolados G.remove_nodes_from(list(nx.isolates(G)))# removendo nós isolados print(nx.number_of_nodes(G)) print(nx.number_of_edges(G)) print(G.nodes) """# ANÁLISES, MÉTRICAS, GRAU ##Matrizes e mais """ print(list(G.adj['labkit'])) # or list(G.neighbors(1)) print(nx.center(nx.Graph(G))) # ['beautifulsoup4', 'requests', 'six', 'docopt', 'docutils', 'gevent', 'pycrypto', 'distribute', 'lxml', 'argparse', 'pyyaml', 'jinja2', 'simplejson', 'mock', 'numpy', 'sphinx', 'python-dateutil', 'flake8', 'sqlalchemy', 'twisted', 'babel', 'psycopg2', 'click', 'flask', 'pillow', 'pytz', 'pep8'] """##Densidade"""
sparcity = [] for entity in natsorted(os.listdir(simulation)): path_entity = simulation + '/' + entity + '/' if os.path.isdir(path_entity): print(entity) simulated_matrix = np.load(path_entity + 'sim_fc.npy') J = np.loadtxt(path_entity + 'J_ij.csv', delimiter=',') critical_temperature = np.loadtxt(path_entity + 'ctem.csv', delimiter=',') c, r = correlation_function(simulated_matrix, J) print(nx.number_of_isolates(nx.Graph(J))) index_ct = find_nearest(ts, critical_temperature) dimensionality = dim(c, r, index_ct) if dimensionality != 3: # Outliear dimensionality_sim.append(dimensionality) critical_temperature_sim.append(critical_temperature) size_sim.append(J.shape[-1]) degrees = sorted(d for n, d in nx.Graph(J).degree()) degree_sim.append(np.mean(degrees)) sparcity.append(nx.density(nx.Graph(J)) * 100) #dimensionality_.append(np.mean(dimensionality_sim)) results.append([ np.mean(dimensionality_sim), np.mean(size_sim),
def create_gml(json_paths, target_paths, output_dir, taxon_file=None): """Create solution graph from miscoto output and compute stats Args: json_paths (str): {target: path_to_corresponding_json} target_paths (str): {target: path_to_corresponding_sbml} output_dir (str): results directory taxon_file (str): mpwt taxon file for species in sbml folder """ miscoto_stat_output = os.path.join(output_dir, 'miscoto_stats.txt') key_species_stats_output = os.path.join(output_dir, 'key_species_stats.tsv') key_species_json = os.path.join(output_dir, 'key_species.json') gml_output = os.path.join(output_dir, 'gml') if not utils.is_valid_dir(gml_output): logger.critical('Impossible to access/create output directory') sys.exit(1) len_min_sol = {} len_union = {} len_intersection = {} len_solution = {} len_target = {} target_categories = {} for target in target_paths: target_categories[target] = sbml_management.get_compounds( target_paths[target]) if taxon_file: taxon_named_species, all_taxons = get_taxon(taxon_file) else: taxon_named_species = None all_taxons = None key_species_data = {} miscoto_stat_output_datas = [] for target_category in target_categories: key_species_data[target_category] = {} key_species_data[target_category]['essential_symbionts'] = {} key_species_data[target_category]['alternative_symbionts'] = {} target_output_gml_path = os.path.join(gml_output, target_category + '.gml') with open(json_paths[target_category]) as json_data: dicti = json.load(json_data) G = nx.Graph() added_node = [] species_weight = {} if dicti['still_unprod'] != []: logger.warning('ERROR ', dicti["still_unprod"], ' is unproducible') len_target[target_category] = len(dicti['newly_prod']) + len( dicti['still_unprod']) len_min_sol[target_category] = len(dicti['bacteria']) len_union[target_category] = len(dicti['union_bacteria']) len_intersection[target_category] = len(dicti['inter_bacteria']) key_species_types = { organism: 'ES' if organism in dicti['inter_bacteria'] else 'AS' for organism in dicti['union_bacteria'] } if taxon_file: for taxon in all_taxons: key_species_data[target_category]['essential_symbionts'][ taxon] = [ organism for organism in key_species_types if key_species_types[organism] == 'ES' and taxon_named_species[organism].split('__')[0] == taxon ] key_species_data[target_category]['alternative_symbionts'][ taxon] = [ organism for organism in key_species_types if key_species_types[organism] == 'AS' and taxon_named_species[organism].split('__')[0] == taxon ] else: key_species_data[target_category]['essential_symbionts'][ 'data'] = [ organism for organism in key_species_types if key_species_types[organism] == 'ES' ] key_species_data[target_category]['alternative_symbionts'][ 'data'] = [ organism for organism in key_species_types if key_species_types[organism] == 'AS' ] len_solution[target_category] = len(dicti['enum_bacteria']) for sol in dicti['enum_bacteria']: if len(dicti['enum_bacteria'][sol]) > 1: for species_1, species_2 in combinations( dicti['enum_bacteria'][sol], 2): if species_1 not in added_node: if taxon_file: G.add_node(taxon_named_species[species_1], note=key_species_types[species_1]) else: G.add_node(species_1, note=key_species_types[species_1]) added_node.append(species_1) if species_2 not in added_node: if taxon_file: G.add_node(taxon_named_species[species_2], note=key_species_types[species_2]) else: G.add_node(species_2, note=key_species_types[species_2]) added_node.append(species_2) combination_species = '_'.join( sorted([species_1, species_2])) if combination_species not in species_weight: species_weight[combination_species] = 1 else: species_weight[combination_species] += 1 if taxon_file: G.add_edge(taxon_named_species[species_1], taxon_named_species[species_2], weight=species_weight[combination_species]) else: G.add_edge(species_1, species_2, weight=species_weight[combination_species]) elif len(dicti['enum_bacteria'][sol]) == 1: species_1 = dicti['enum_bacteria'][sol][0] if species_1 not in added_node: if taxon_file: G.add_node(taxon_named_species[species_1], note=key_species_types[species_1]) else: G.add_node(species_1, note=key_species_types[species_1]) added_node.append(species_1) # Check if all the nodes of G are not isolates. if len(G.nodes) == nx.number_of_isolates(G): logger.critical( r'/!\ Warning: All the nodes of the solution graph are isolated (they are not connected to other nodes). This lead to powergrasp creating san empty powergraph.' ) logger.critical( 'So m2m_analysis stops at the solution graph step.') sys.exit(1) miscoto_stat_output_datas.append([ target_category, str(len_target[target_category]), str(len_min_sol[target_category]), str(len_union[target_category]), str(len_intersection[target_category]), str(len_solution[target_category]) ]) logger.info('######### Graph of ' + target_category + ' #########') logger.info('Number of nodes: ' + str(G.number_of_nodes())) logger.info('Number of edges: ' + str(G.number_of_edges())) nx.write_gml(G, target_output_gml_path) with open(miscoto_stat_output, 'w') as stats_output: statswriter = csv.writer(stats_output, delimiter="\t") statswriter.writerow([ 'categories', 'nb_target', 'size_min_sol', 'size_union', 'size_intersection', 'size_enum' ]) for miscoto_stat_output_data in miscoto_stat_output_datas: statswriter.writerow(miscoto_stat_output_data) with open(key_species_json, 'w') as json_output: json.dump(key_species_data, json_output, indent=4) with open(key_species_stats_output, 'w') as key_stat_output: key_stats_writer = csv.writer(key_stat_output, delimiter='\t') if all_taxons: key_stats_writer.writerow( ['target_categories', 'key_group', *sorted(all_taxons), 'Sum']) else: key_stats_writer.writerow( ['target_categories', 'key_group', 'data', 'Sum']) for target in key_species_data: if all_taxons: essential_counts = [ len(key_species_data[target]['essential_symbionts'][taxon]) for taxon in sorted(all_taxons) ] alternative_counts = [ len(key_species_data[target]['alternative_symbionts'] [taxon]) for taxon in sorted(all_taxons) ] else: essential_counts = [ len(key_species_data[target]['essential_symbionts'] ['data']) ] alternative_counts = [ len(key_species_data[target]['alternative_symbionts'] ['data']) ] key_counts = list(map(add, essential_counts, alternative_counts)) key_stats_writer.writerow( [target, 'key_species', *key_counts, sum(key_counts)]) key_stats_writer.writerow([ target, 'essential_symbionts', *essential_counts, sum(essential_counts) ]) key_stats_writer.writerow([ target, 'alternative_symbionts', *alternative_counts, sum(alternative_counts) ])
def nr_isolated_nodes(self): return nx.number_of_isolates(self.graph)
def test_number_of_isolates(): G = nx.Graph() G.add_edge(0, 1) G.add_nodes_from([2, 3]) assert_equal(nx.number_of_isolates(G), 2)
def print(graph, precision): if nx.number_of_isolates(graph) < 1: return Utils.print_set( nx.algorithms.covering.min_edge_cover(graph), precision) else: return "Graph has isolate vertice."
def stress(G, output_folder, fI, x_constraint=None, y_constraint=None, weight_threshold=0): # remove weak edges G2 = G.copy() for ij in G.edges: if G.edges[ij]['weight'] < weight_threshold: G2.remove_edge(*ij) # Make another copy G3 = G2.copy() # Check if any nodes have been isolated if nx.number_of_isolates(G2) != 0: # First remove nodes from x and y constraints for i in range(0, len(G2)): # Check if node is isolated if nx.is_isolate(G2, i): # Then check if node has x and y constraints if i in x_constraint: del x_constraint[i] if i in y_constraint: del y_constraint[i] # Make iterator over the isolates iso = nx.isolates(G2) # Use to remove nodes from graph G3.remove_nodes_from(iso) # Mapping should be empty initially mapping = {} # Counter k = 0 # Loop over for i in range(0, len(G2)): # If isolate found if nx.is_isolate(G2, i): # Increment counter k = k + 1 else: # Otherwise save to mapping mapping[i] = i - k # Use to relabel nodes and constraints G3 = nx.relabel_nodes(G3, mapping) # Loop over keys in mapping for i in mapping: # Check if key exists in constraints if i in x_constraint: x_constraint[mapping[i]] = x_constraint.pop(i) if i in y_constraint: y_constraint[mapping[i]] = y_constraint.pop(i) # length has decreased by 1 => This isn't the problem # compute layout X = _sgd(G3, y_constraint=y_constraint, x_constraint=x_constraint) # draw with colours cols_node = list(nx.get_node_attributes(G3, 'color').values()) cols_edge = list(nx.get_edge_attributes(G3, 'color').values()) widths_edge = list(nx.get_edge_attributes(G3, 'width').values()) # Extract x and y labels of nodes xvs = nx.get_node_attributes(G3, 'x') yvs = nx.get_node_attributes(G3, 'y') # Make a copy of xvs to use as labels labels = yvs.copy() # Vector containing alphabet ab = list(string.ascii_lowercase) # Loop over x values for i in yvs: # Check if node is a strain if xvs[i] == 1.0: labels[i] = ab[yvs[i] - 1] nx.draw(G3, pos=X, node_color=cols_node, edge_color=cols_edge, width=widths_edge, labels=labels, arrows=False) plt.axis('equal') if weight_threshold != 0.0: plt.savefig(f'{output_folder}/{G3.graph["name"]}_stress_prun{fI}.png') else: plt.savefig(f'{output_folder}/{G3.graph["name"]}_stress{fI}.png') plt.close()
def min_edge_cover(G, matching_algorithm=None): """Returns a set of edges which constitutes the minimum edge cover of the graph. A smallest edge cover can be found in polynomial time by finding a maximum matching and extending it greedily so that all nodes are covered. Parameters ---------- G : NetworkX graph An undirected bipartite graph. matching_algorithm : function A function that returns a maximum cardinality matching in a given bipartite graph. The function must take one input, the graph ``G``, and return a dictionary mapping each node to its mate. If not specified, :func:`~networkx.algorithms.bipartite.matching.hopcroft_karp_matching` will be used. Other possibilities include :func:`~networkx.algorithms.bipartite.matching.eppstein_matching`, or matching algorithms in the :mod:`networkx.algorithms.matching` module. Returns ------- min_cover : set It contains all the edges of minimum edge cover in form of tuples. It contains both the edges `(u, v)` and `(v, u)` for given nodes `u` and `v` among the edges of minimum edge cover. Notes ----- An edge cover of a graph is a set of edges such that every node of the graph is incident to at least one edge of the set. The minimum edge cover is an edge covering of smallest cardinality. Due to its implementation, the worst-case running time of this algorithm is bounded by the worst-case running time of the function ``matching_algorithm``. Minimum edge cover for bipartite graph can also be found using the function present in :mod:`networkx.algorithms.bipartite.covering` """ if nx.number_of_isolates(G) > 0: # ``min_cover`` does not exist as there is an isolated node raise nx.NetworkXException( "Graph has a node with no edge incident on it, " "so no edge cover exists.") if matching_algorithm is None: matching_algorithm = partial(nx.max_weight_matching, maxcardinality=True) maximum_matching = matching_algorithm(G) # ``min_cover`` is superset of ``maximum_matching`` try: min_cover = set( maximum_matching.items()) # bipartite matching case returns dict except AttributeError: min_cover = maximum_matching # iterate for uncovered nodes uncovered_nodes = set(G) - set([v for u, v in min_cover]) - set( [u for u, v in min_cover]) for v in uncovered_nodes: # Since `v` is uncovered, each edge incident to `v` will join it # with a covered node (otherwise, if there were an edge joining # uncovered nodes `u` and `v`, the maximum matching algorithm # would have found it), so we can choose an arbitrary edge # incident to `v`. (This applies only in a simple graph, not a # multigraph.) u = arbitrary_element(G[v]) min_cover.add((u, v)) min_cover.add((v, u)) return min_cover
def curve_fit_plot(G, nrows=3, ncols=3, size=(15, 15), nbins=12, start_cutoff=0.1, end_cutoff=0.3): """ Plot in log-log scale nrows*ncols degree distributions fitted with curve_fit function The function fitted is: a*np.power(x,-b) a,b reported on each plot Return dataframe with statistical summary """ cut_off = np.linspace(start_cutoff, end_cutoff, nrows * ncols) _, plot = plt.subplots(nrows=nrows, ncols=ncols, figsize=size) subplots = plot.reshape(1, nrows * ncols)[0] stats = collections.defaultdict(list) fit = collections.defaultdict(list) for i, subplot in enumerate(subplots): F = slice_network(G, cut_off[i]) stats['nodes'].append(len(F.nodes())) stats['edges'].append(len(F.edges())) stats['density'].append(nx.density(F)) stats['isolates'].append(nx.number_of_isolates(F)) F.remove_nodes_from(list(nx.isolates(F))) stats['nodes'].append(len(F.nodes())) stats['edges'].append(len(F.edges())) stats['density'].append(nx.density(F)) stats['isolates'].append(nx.number_of_isolates(F)) data = list(dict(nx.degree(F)).values()) d, f = get_degree_dist(F) bins, dens = binned_values(F, nbins) powerlaw.plot_pdf(data, linestyle='-.', c='b', label='fit log-bins', alpha=0.6, ax=subplot) subplot.scatter(bins, dens, s=10, c='b', label='binned data') subplot.scatter(d, f, s=10, c='r', alpha=0.3, label='data') subplot.set_xscale('log') subplot.set_yscale('log') subplot.title.set_text('Weight - slice: {}'.format(round( cut_off[i], 2))) subplot.set_ylim((min(f) - 10e-4, max(f) + 10e-1)) subplot.set_xlim((min(d), max(d) + 200)) subplot.legend() subplot.set_xlabel('Degree') subplot.set_ylabel('freq') ir = ['F', 'T'] cf = np.sort(np.append(cut_off, cut_off)) l = [(c, ir[i % 2]) for i, c in enumerate(cf)] df = pd.DataFrame(stats, index=pd.MultiIndex.from_tuples( l, names=['Weight', 'isolates removed'])) plt.tight_layout(pad=0.4, w_pad=0.5, h_pad=1.0) return df
return exact_bet_dict # Param num_of_graphs = 50 graph_types = ["ER", "SF", "GRP"] for graph_type in graph_types: print("###################") print(f"Generating graph type : {graph_type}") print(f"Number of graphs to be generated:{num_of_graphs}") list_bet_data = list() print("Generating graphs and calculating centralities...") for i in range(num_of_graphs): print(f"Graph index:{i+1}/{num_of_graphs}", end='\r') g_nx = create_graph(graph_type) if nx.number_of_isolates(g_nx) > 0: g_nx.remove_nodes_from(list(nx.isolates(g_nx))) g_nx = nx.convert_node_labels_to_integers(g_nx) g_nkit = nx2nkit(g_nx) bet_dict = cal_exact_bet(g_nkit) list_bet_data.append([g_nx, bet_dict]) fname = "./graphs/" + graph_type + ".pickle" with open(fname, "wb") as fopen: pickle.dump(list_bet_data, fopen) print("") print("Graphs saved") print("End.")
#Randomly add/remove edge and nodes. x = random.uniform(0, 1) if x > 0.5: if len(list(clone.edges)) == 0: error = 1 break else: node_1, node_2 = random.choice(list(clone.edges)) counter = counter + 1 if graph.has_edge(node_1, node_2): clone.remove_edge(node_1, node_2) else: node_1 = random.choice(clone.nodes()) node_2 = random.choice(clone.nodes()) if node_1 != node_2 and not clone.has_edge( node_1, node_2) and not graph.has_edge(node_1, node_2): clone.add_edge(node_1, node_2) counter = counter + 1 if error == 0: #try: isolate = nx.isolates(clone) print(nx.number_of_isolates(clone)) print("Added") if len(clone) == 0 or len(graph) == 0: continue if nx.is_connected(clone) and nx.is_connected(graph): index = transfomer(graph, clone, vals, index) #except: print("Error") continue
import networkx as nx G = nx.DiGraph() #graph constructor for u in range(len(a_links)): #scan the matrix table G.add_node(a_links[u]) #add all strings from a_links table as nodes for v in range(len(a_links)): if matrix[u][v] == 1: #if the is a non zero cell G.add_edge(a_links[u],a_links[v]) #make an edge between the urls2 article and the correspondant a_lists article # In[5]: nx.number_of_isolates(G) # In[28]: p = nx.clustering(G) import operator sorted_cluster_vl = sorted(p.items(), key = operator.itemgetter(1)) print(sorted_cluster_vl) # In[29]: c = nx.degree_centrality(G)
def calculate(graph): if nx.number_of_isolates(graph) < 1 and nx.number_of_nodes(graph) > 1: return len(nx.algorithms.covering.min_edge_cover(graph)) else: return 10**10
print("The number of nodes for SGI graph is: ", len(G_SGI.nodes)) print("The number of links for SGI graph is: ", len(G_SGI.edges)) # Intersection interactome print("The number of nodes for I graph is: ", len(G_I.nodes)) print("The number of links for I graph is: ", len(G_I.edges)) # Union interactome print("The number of nodes for U graph is: ", len(G_U.nodes)) print("The number of links for U graph is: ", len(G_U.edges)) # B. Number of Connected components print("The number of connected components for SGI graph is: ", nx.number_connected_components(G_SGI)) print("The number of connected components for I graph is: ", nx.number_connected_components(G_I)) print("The number of connected components for U graph is: ", nx.number_connected_components(G_U)) # C. Number of isolated nodes print("The number of isolated nodes for SGI graph is: ", nx.number_of_isolates(G_SGI)) print("The number of isolated nodes for I graph is: ", nx.number_of_isolates(G_I)) print("The number of isolated nodes for U graph is: ", nx.number_of_isolates(G_U)) # D. Average Path length # SGI PathLenSGI=[] for g in nx.connected_component_subgraphs(G_SGI): PathLenSGI.append(nx.average_shortest_path_length(g)) print("The average path length for SGI graph is: ", PathLenSGI) print(sum(PathLenSGI)/len(PathLenSGI)) # I PathLenI=[] for g in nx.connected_component_subgraphs(G_I): PathLenI.append(nx.average_shortest_path_length(g))
def __init__(self, configs: Union[Configuration, dict, nx.DiGraph]): if type(configs) == nx.DiGraph: # Assume we're creating a copy super().__init__(configs) return elif type(configs) == dict: configs = SmallWorldTopology.Configuration(**configs) super().__init__() self.__dict__.update(asdict(configs)) assert ( len(self.minicolumn_shape) == 3 ), "Minicolumn shape must be of dimension 3 (3D)" assert ( len(self.macrocolumn_shape) == 3 ), "Macrocolumn shape must be of dimension 3 (3D)" # Initial neuron positions (all separated by neuron_spacing) i, j, k = np.multiply(self.macrocolumn_shape, self.minicolumn_shape) grid = np.mgrid[:i, :j, :k].reshape(3, -1) x, y, z = grid * self.neuron_spacing # Adding minicolumnSpacing (from random to small world topology) if self.minicolumn_spacing > 0: for d in range(3): # For each dimension grid[d] //= self.minicolumn_shape[d] x += grid[0] * self.minicolumn_spacing y += grid[1] * self.minicolumn_spacing z += grid[2] * self.minicolumn_spacing positions = map(lambda p: {"position": p}, zip(x, y, z)) self.add_nodes_from(zip(range(len(x)), positions)) # Distance-based random connectivity positions = np.stack(np.asarray(self.nodes.data("position"))[:, 1]) if ( self.sparse_init ): # Slower but iterative (for adjacency matrices that don't fit in memory) distances = pairwise_distances_chunked( positions, metric="euclidean", n_jobs=-1, reduce_func=lambda chunk, start: bsr_matrix( np.random.random(chunk.shape) < self.p_max * np.exp(-chunk / self.intracolumnar_sparseness) ), working_memory=self.mem_available, ) adjacency_matrix = vstack(list(distances)) adjacency_matrix.setdiag(0) # Avoid self-connections self.add_edges_from(zip(*adjacency_matrix.nonzero())) else: distances = cdist(positions, positions, "euclidean") probabilities = self.p_max * np.exp( -distances / self.intracolumnar_sparseness ) np.fill_diagonal(probabilities, 0) # Avoid self-connections rand_matrix = np.random.random(probabilities.shape) i, j = np.nonzero(rand_matrix < probabilities) self.add_edges_from(zip(i, j)) n_neurons = self.number_of_nodes() self.inhibitory_neurons = set( np.random.permutation(n_neurons)[: int(n_neurons * self.inhibitory_prob)] ) for u, v in self.edges: if u in self.inhibitory_neurons: self.edges[u, v]["weight"] = -np.random.uniform( *self.inhibitory_init_weight_range ) else: self.edges[u, v]["weight"] = np.random.uniform( *self.excitatory_init_weight_range ) if self.spectral_radius_norm: spectral_radius = lambda matrix: np.max(np.abs(np.linalg.eigvals(matrix))) adj = nx.adjacency_matrix(self, weight="weight").todense() scale = 1.0 / spectral_radius(np.abs(adj)) for i, (u, v) in enumerate(self.edges): self.edges[u, v]["weight"] = self.edges[u, v]["weight"] * scale if _logger.isEnabledFor(logging.INFO): # Some extra info about the topology out_degrees = np.array(self.out_degree())[:, 1] reporter.log_metrics( { "number-of-neurons": n_neurons, "number-of-synapses": self.number_of_edges(), "excitatory-ratio": 100.0 * (1.0 - len(self.inhibitory_neurons) / n_neurons), "avg-out-degree": np.mean(out_degrees), "nb-out-degree-0": len(out_degrees) - np.count_nonzero(out_degrees), "nb-isolates": nx.number_of_isolates(self), } )
import math import numpy as np import networkx as nx import matplotlib.pyplot as plt n = 150 g = nx.fast_gnp_random_graph(n, 0.02) nx.draw_random(g) ## ##giant = sorted(nx.connected_component_subgraphs(g),key = len,reverse = True) giant = max(nx.connected_component_subgraphs(g), key=len) nx.draw_random(giant) #%% g_node = nx.number_of_nodes(g) giant_node = nx.number_of_nodes(giant) isolate_node = nx.number_of_isolates(g) print(g_node, "\n") print(giant_node, "\n") print(isolate_node, "\n") prob_g = math.log(g_node) / g_node print(prob_g) #%% #g = nx.fast_gnp_random_graph(100,prob_isolate-0.1) #nx.draw_random(g) prob_g = math.log(g_node) / g_node p = [] for i in range(4): prob_g = prob_g - 0.03 p.append(prob_g) prob_g1 = math.log(g_node) / g_node for i in range(4):
def min_edge_cover(G, matching_algorithm=None): """Returns a set of edges which constitutes the minimum edge cover of the graph. A smallest edge cover can be found in polynomial time by finding a maximum matching and extending it greedily so that all nodes are covered. Parameters ---------- G : NetworkX graph An undirected bipartite graph. matching_algorithm : function A function that returns a maximum cardinality matching in a given bipartite graph. The function must take one input, the graph ``G``, and return a dictionary mapping each node to its mate. If not specified, :func:`~networkx.algorithms.bipartite.matching.hopcroft_karp_matching` will be used. Other possibilities include :func:`~networkx.algorithms.bipartite.matching.eppstein_matching`, or matching algorithms in the :mod:`networkx.algorithms.matching` module. Returns ------- min_cover : set It contains all the edges of minimum edge cover in form of tuples. It contains both the edges `(u, v)` and `(v, u)` for given nodes `u` and `v` among the edges of minimum edge cover. Notes ----- An edge cover of a graph is a set of edges such that every node of the graph is incident to at least one edge of the set. The minimum edge cover is an edge covering of smallest cardinality. Due to its implementation, the worst-case running time of this algorithm is bounded by the worst-case running time of the function ``matching_algorithm``. Minimum edge cover for bipartite graph can also be found using the function present in :mod:`networkx.algorithms.bipartite.covering` """ if nx.number_of_isolates(G) > 0: # ``min_cover`` does not exist as there is an isolated node raise nx.NetworkXException( "Graph has a node with no edge incident on it, " "so no edge cover exists.") if matching_algorithm is None: matching_algorithm = partial(nx.max_weight_matching, maxcardinality=True) maximum_matching = matching_algorithm(G) # ``min_cover`` is superset of ``maximum_matching`` min_cover = set(maximum_matching.items()) # iterate for uncovered nodes uncovered_nodes = set(G) - {v for u, v in min_cover} for v in uncovered_nodes: # Since `v` is uncovered, each edge incident to `v` will join it # with a covered node (otherwise, if there were an edge joining # uncovered nodes `u` and `v`, the maximum matching algorithm # would have found it), so we can choose an arbitrary edge # incident to `v`. (This applies only in a simple graph, not a # multigraph.) u = arbitrary_element(G[v]) min_cover.add((u, v)) min_cover.add((v, u)) return min_cover
g = nx.fast_gnp_random_graph(n, p) pos = layout(G) region += 1 plt.subplot(region) plt.title(p) nx.draw(g, pos, node_size=15) all_components = sorted(nx.connected_component_subgraphs(g), key=len, reverse=True) giant = all_components[0] total_nodes = nx.number_of_nodes(g) giant_nodes = nx.number_of_nodes(giant) print("\nP =", p, "\nNumber of nodes in original graph :", total_nodes) print("Nodes in giant component =", giant_nodes) print('Number of isolates are :', nx.number_of_isolates(g)) #%% #giant component n = 150 pc = 1 / n pmax = math.log(n) / float(n) pvals = [pc, pmax] region = 220 for pv in pvals: g = nx.fast_gnp_random_graph(n, pv) h = max(nx.connected_component_subgraphs(g), key=len) #plt.subplots_adjust(left=0,right=1,bottom=0,top=0.95,wspace=0.1,hspace=0.1)