def set_up_topology(topology, number_of_nodes, desired_avg_degree, ba_m): # generate network depending on topology parameter if topology == "UNIFORM": net_p2p = nx.random_degree_sequence_graph( [desired_avg_degree for i in range(number_of_nodes)]) elif topology == "ER": p = desired_avg_degree / number_of_nodes net_p2p = nx.fast_gnp_random_graph(number_of_nodes, p) elif topology == "BA": net_p2p = nx.barabasi_albert_graph(number_of_nodes, ba_m) # get largest connected component lcc_set = max(nx.connected_components(net_p2p), key=len) net_p2p = net_p2p.subgraph(lcc_set).copy() # some nodes may have been removed because they were not port of the lcc. # relabel nodes so that only nodes in lcc are labelled. (without it we run into problems where node labels are higher than the number of nodes -> loops run into indexing problems) net_p2p = nx.convert_node_labels_to_integers( net_p2p, first_label=0) # some nodes may have been removed as they were not part of the lcc -> update num nodes number_of_nodes = len(net_p2p) # (brute-forcing number of selfish nodes to stay unchanged) number_honest_nodes = number_of_nodes - number_selfish_nodes return net_p2p, number_honest_nodes
def random_simple_deg_seq(sequence, brain_size=[7., 7., 7.], seed=None, tries=10): '''Wrapper function to get a SIMPLE (no parallel or self-loop edges) graph that has a given degree sequence. This graph is used conventionally as a control because it yields a random graph that accounts for degree distribution. Parameters: sequence: list of int Degree of each node to be added to the graph. brain_size: list of 3 floats Size of the brain to use when distributing node locations. Added for convenience, but does not affect connectivity pattern. seed: hashable object for random seed Seed for the random number generator. tries: int Number of attempts at creating graph (function will retry if self-loops exist. Returns: Networkx graph object, adjacency matrix, and random distances''' G = nx.random_degree_sequence_graph(sequence=sequence, seed=seed, tries=tries) A = nx.adjacency_matrix(G) N = len(sequence) centroids = np.random.uniform([0, 0, 0], brain_size, (N, 3)) D = aux_tools.dist_mat(centroids) return G, A, D
def build_graph(self): while True: deg_list = np.random.randint(low=1, high=self.max_conn_per_node, size=self.n_nodes) if (nx.is_graphical(deg_list)): break graph = nx.random_degree_sequence_graph(deg_list, seed=123, tries=1000) graph = graph.to_directed() return graph
def grab_data(i, null=True): G1 = nx.random_degree_sequence_graph(deg_seq) if null: G2 = nx.random_degree_sequence_graph(deg_seq) else: G2 = nx.grid_2d_graph(N, M) A1, A2 = [nx.adjacency_matrix(G).todense() for G in [G1, G2]] adj_distances = pd.Series( [distance(dfun, A1, A2) for dfun in distances], index=labels, name="Adjacency Distances", ) data = pd.concat([adj_distances], axis=1) return data
def randomMaxDeg4Graph(self): while True: try: seq = seqGen(self.n) g = nx.random_degree_sequence_graph(seq) break except nx.NetworkXError: pass for (u, v) in g.edges(): g[u][v]['w'] = random.randint(1, 2**self.n) return g
def __generate_graph_by_degree(degrees: List[int] = None, *, seed: int = None, variable_degree: bool = False, n_nodes: int = None, min_degree: int = 0, max_degree: int = 0, **kwargs) -> nx.Graph: degree_sequence = degrees if variable_degree: if n_nodes is not None: graph = None proposed_n_nodes = n_nodes while True: try: _degrees = range(min_degree, max_degree + 1, 1) degree_sequence = random.choices(_degrees, k=proposed_n_nodes) graph = nx.random_degree_sequence_graph( sequence=degree_sequence, seed=seed) except nx.NetworkXUnfeasible: proposed_n_nodes += 1 continue print(f"Took {proposed_n_nodes-n_nodes} tries") return graph else: raise ValueError() else: if degree_sequence is None or len(degree_sequence) == 0: raise ValueError() return nx.random_degree_sequence_graph(sequence=degree_sequence, seed=seed)
def gen_graph(n, delta): for m in range(3, n - 1): deg_sequence = [delta - 1] * (n - m) + [delta] * m for _ in range(100): try: g = nx.random_degree_sequence_graph(deg_sequence, tries=100) d = g.degree() core = g.subgraph([u for u in range(n) if d[u] == delta]) if max(dict(core.degree()).values()) == 2: yield g except nx.exception.NetworkXUnfeasible: pass except nx.exception.NetworkXError: break
def generate_graphs(delta, n, repeats=1000, underfull=True): r = [delta - 1, delta] for _ in range(repeats): seq = [delta] + [random.choice(r) for _ in range(n - 1)] if not nx.is_graphical(seq): continue try: g = nx2graph(nx.random_degree_sequence_graph(seq)) if is_overfull(g) != underfull: yield g except nx.NetworkXUnfeasible: pass except nx.NetworkXException: pass
def FindGraph(deg_seq, MakeGIF, cycle, num, noplotting): #After having done these by hand I wanted to find an algorithmic way of doing it. #That desire culminated in me finding this paper on Arxiv: https://arxiv.org/pdf/cs/0702124.pdf #The algorithm described in that paper was implemented in the python library networkx. #The goal then is to take the networkx implementation and making an animated "growth" #that would enable one to pick out different patterns. #More on the networkx library can be found here: #https://networkx.github.io/documentation/networkx-2.0 n = num + 1 for seq in deg_seq: seq.sort(reverse=True) exists = Existence(seq) if exists == False: print(exists) if (exists) and noplotting == False: if cycle: #The algorithm for this is described in the homework. G = nx.cycle_graph(n) else: #Since the algorithm is randomly seeded it has a failure rate directly proportional to n, #thus we should give it a number of tries proportional to n, 3n seems to be a good guess. G = nx.random_degree_sequence_graph(seq, tries=3 * n) plt.title('n: ' + str(n)) if len(seq) > 70: #This is a quality of life feature so the screen isn't crowded by numbers. #Further, the node size should be a monotonically decreasing function of the number of nodes #so that the picture isn't just a big splotch of blue. nx.draw_circular(G, with_labels=False, node_size=800 / (n / 2)) else: nx.draw_circular(G, with_labels=True, node_size=800 / (n / 2)) #Formatting to save as nnnnnnnn.png plt.savefig( str(len(seq)).replace(',', '').replace('[', '').replace( ']', '').replace(' ', '') + '.png') #pyplot is dumb and doesn't realize that it should clear itself after it's been saved. plt.clf() n += 1 if MakeGIF and noplotting == False: images = [] for file in listdir(getcwd()): if '.png' in file: #Take all of the png's generated above and form a GIF images.append(imageio.imread(file)) remove(file) imageio.mimsave('GrowthBy' + str(num) + '.gif', images, duration=min(30 / (n - num - 1), .5)) return
def generate_graph(vertices: int, edges: int, maximum_grade: int) -> nx.Graph: if edges > maximum_grade * vertices / 2: return None elif edges > vertices * (vertices - 1) / 2: # Test more edges than a complete graph return None elif edges == vertices * (vertices - 1) / 2: # Complete graph return nx.complete_graph(vertices) else: while True: sequence = generate_degree_sequence(vertices, edges, maximum_grade) try: G = nx.random_degree_sequence_graph(sequence) return G except Exception: pass
def syntheticInferred(n, connectedDegree = True, keepConnected = True): dd = infer.infer_degree_sequence(n) mat = infer.infer_assortativity_matrix(n) if connectedDegree: G = havel_hakimi_custom_graph(dd) else: G = nx.random_degree_sequence_graph(dd) """ print("Degree distribution : " + str(dd)) print("Nb cc : " + str(nx.number_connected_components(G))) dh2 = nx.degree_histogram(G) print("Result Degree distribution : " + str(dh2))""" G = transform_graph_assortativity_coef(G,mat,keepConnected) return G
def scale_free_powerlaw(n=4000, lam=3, k_avg=4): """ n : number of nodes lam : exponent """ noftries = 2147483647 standard = k_avg + 0.5 while (1): s = generate(n, lam) ratio = standard / np.mean(s) for i in range(len(s)): s[i] = int(ratio * s[i]) if (nx.is_valid_degree_sequence(s)): G = nx.random_degree_sequence_graph(s, tries=noftries) break return G
def degree_sequence_graphs(): print("Degree sequence") print("Configuration model") z = nx.utils.create_degree_sequence(30, powerlaw_sequence) G = nx.configuration_model(z) draw_graph(G) # to remove paralel edges G = nx.Graph(G) draw_graph(G) # to remove self loops G.remove_edges_from(G.selfloop_edges()) draw_graph(G) print("Directed configuration model") D = nx.DiGraph([(0, 1), (1, 2), (2, 3), (1, 3)]) # directed path graph din = list(D.in_degree().values()) dout = list(D.out_degree().values()) din.append(1) dout[0] = 2 D = nx.directed_configuration_model(din, dout) D = nx.DiGraph(D) # to remove paralell edges D.remove_edges_from(D.selfloop_edges()) # to remove self loops draw_graph(D) print("Expected degree graphs") z = [i for i in range(10)] G = nx.expected_degree_graph(z) draw_graph(G) print("Havel Hakimi graphs") z = [2, 4, 5, 6, 7, 3] G = nx.havel_hakimi_graph(z) draw_graph(G) print("Directed Havel Hakimi graphs") inds = [2, 4, 5, 6, 7, 3] outds = [2, 4, 5, 6, 7, 3] G = nx.directed_havel_hakimi_graph(in_deg_sequence=inds, out_deg_sequence=outds) draw_graph(G) print("Degree Sequence Tree") dg = [1, 2, 3, 4, 2, 3] G = nx.degree_sequence_tree(dg) draw_graph(G) print("Random Degree Sequence") sequence = [1, 2, 2, 3] G = nx.random_degree_sequence_graph(sequence) sorted(G.degree().values()) draw_graph(G)
def synthetic(n, connectedDegree = True, keepConnected = True): F = data.readFeederData(n); dh = nx.degree_histogram(F) mat = nx.degree_mixing_matrix(F) dd = utils.degreehisto_to_degreeseq(dh) if connectedDegree: G = havel_hakimi_custom_graph(dd) else: G = nx.random_degree_sequence_graph(dd) """print("Degree distribution : " + str(dh)) print("Nb cc : " + str(nx.number_connected_components(G))) dh2 = nx.degree_histogram(G) print("Result Degree distribution : " + str(dh2))""" G = transform_graph_assortativity_coef(G,mat,keepConnected) return G
def get_edge_list(): try: cn = random_degree_sequence_graph(GC.cn_degree_sequence, tries=GC.cn_tries, seed=GC.random_number_seed) except NetworkXUnfeasible: from os import chdir chdir(GC.START_DIR) assert False, "Contact network degree sequence is not graphical" except NetworkXError: from os import chdir chdir(GC.START_DIR) assert False, "NetworkX failed to produce graph after %d tries" % GC.cn_tries if GC.random_number_seed is not None: GC.random_number_seed += 1 out = GC.nx2favites(cn, 'u') f = gopen(expanduser("%s/contact_network.txt.gz" % GC.out_dir), 'wb', 9) f.write('\n'.join(out).encode()) f.write(b'\n') f.close() return out
def main(): deg = 3 num_graphs = 1000 ty = sys.argv[1] if ty in ['TRIANGLE_EX' or 'LCC_EX' or 'MDS_EX']: sps = [('train', 20), ('test', 100)] else: sps = [('train', 20), ('test', 20)] for sp in sps: n = sp[1] Gs = [] for _ in range(num_graphs): g = nx.random_degree_sequence_graph([deg for i in range(n)]) G = [[] for i in range(n)] for e in g.edges: G[e[0]].append(e[1]) G[e[1]].append(e[0]) if ty in ['TRIANGLE', 'TRIANGLE_EX']: l = tri_check(G) elif ty in ['LCC', 'LCC_EX']: l = local_cluster_coefficient(G) else: l = [0 for i in range(n)] Gs.append((G, l)) basedir = f'dataset/{ty}' if not os.path.exists(basedir): os.makedirs(basedir) with open(f'{basedir}/{ty}_{sp[0]}.txt', 'w') as f: f.write(f'{num_graphs}\n') for i in range(num_graphs): f.write(f'{n} 0\n') G, l = Gs[i] for j in range(n): f.write(f'{l[j]} {deg}') for k in G[j]: f.write(f' {k}') f.write('\n')
def GenEdges(S,Group,Lambda): import networkx as nx import random import numpy as np Dtotal=[] CC=len(Group) Edges=[] for i in range(0,CC): Nodes_CC=Group[i] D=GenGraph(Nodes_CC,Lambda) Dtotal.append(D) G = nx.random_degree_sequence_graph(D, tries=100) mapping={} for i in range(0,len(Nodes_CC)): mapping[i]=Nodes_CC[i] H=nx.relabel_nodes(G,mapping) for item in H.edges(): Edges.append(item) G=0 #print(Edges) Adj=np.zeros([S,S]) for i in Edges: j=i[0] k=i[1] if random.randint(0, 1)==0: Adj[j,k]=1 else: Adj[k,j]=1 return(Adj,Dtotal,CC)
def test_random_degree_sequence_graph(): d = [1, 2, 2, 3] G = nx.random_degree_sequence_graph(d) assert_equal(d, sorted(d for n, d in G.degree()))
def test_random_degree_sequence_graph(): d = [1, 2, 2, 3] G = nx.random_degree_sequence_graph(d, seed=42) assert d == sorted(d for n, d in G.degree())
print 'Building graphs...' # Load mouse connectivity graph G_brain, W_brain, _ = extract.brain_graph.binary_undirected() n_nodes = len(G_brain.nodes()) n_edges = len(G_brain.edges()) p_edge = float(n_edges) / ((n_nodes * (n_nodes - 1)) / 2.) # Calculate degree & clustering coefficient distribution brain_degree = nx.degree(G_brain).values() brain_clustering = nx.clustering(G_brain).values() brain_degree_mean = np.mean(brain_degree) # Build standard graphs & get their degree & clustering coefficient # Configuration model (random with fixed degree sequence) G_CM = nx.random_degree_sequence_graph(brain_degree, tries=100) CM_degree = nx.degree(G_CM).values() CM_clustering = nx.clustering(G_CM).values() # Watts-Strogatz G_WS = nx.watts_strogatz_graph(n_nodes, int(round(brain_degree_mean)), SW_REWIRE_PROB) WS_degree = nx.degree(G_WS).values() WS_clustering = nx.clustering(G_WS).values() # Barabasi-Albert G_BA = nx.barabasi_albert_graph(n_nodes, int(round(brain_degree_mean / 2.))) BA_degree = nx.degree(G_BA).values() BA_clustering = nx.clustering(G_BA).values() ##################
# get small world coefficient #from the clustering coefficient (CC) and the average path length (PL) = # CC(actual network)/CC(random graph) divided by PL(actual network)/PL(random graph) # use just the largest connected component gcsize=G.number_of_nodes() apl=networkx.average_shortest_path_length(G) Gclust=networkx.average_clustering(G) sw=[] for i in range(36): try: rand=networkx.random_degree_sequence_graph(G.degree().values(),tries=10) Grand=networkx.connected_component_subgraphs(rand)[0] except: print 'problem on round',i continue print i sw.append((Gclust/networkx.average_clustering(Grand))/(apl/networkx.average_shortest_path_length(Grand))) if len(sw)>0: meansw=numpy.mean(sw) else: meansw=0 alldata=numpy.array([modularity_infomap,eff,cc,bc,clust,rcc_at_cutoff,apl,power_exp,meansw])
sequence = sequence + [ i for i in itertools.repeat(int(Edges[0]), int(Edges[1])) ] return sequence ###CALLING FUNCTIONS### Degree_file = 'Data/Degree_file' Corr_matrix = 'Data/Corr_matrix' path_random_graph = 'Data/Random_graphs/' #Loop to create 10000 random graphs with the same degree sequence as the original network and finding their optimal communities with MolTi software. for i in range(0, 10000): deg_seq = sequence(Degree_file) G = nx.random_degree_sequence_graph( deg_seq, tries=10 ) #Return a simple random graph with the given degree sequence. Adj = nx.to_dict_of_dicts( G, edge_data=1 ) #Return adjacency representation of graph as a dictionary of dictionaries. fun = ncol_format(corr_matrix=Corr_matrix, random_graph=Adj) #Creating the files in the suitable NCOL format to give the input to MolTi software. t = '' for key in fun: for key2 in fun[key]: if t == '': t = str(key) + '\t' + str(key2[0]) + '\t' + str(key2[1]) + '\n' else: t += str(key) + '\t' + str(key2[0]) + '\t' + str( key2[1]) + '\n' f3 = open(path_random_graph + 'Random_graph_micro_' + str(i), 'w')
def csv_test_unparallel(): eg.__eigen_info = True print("Strategy," + "Graph," + str("EigErr") + "," + str("DegCorr") + "," + str("ClustRatio") + "," + str("EigVErr") + "," + str("NodeDistCorr") + "," + str("DegBetCorr") + "," + str("KCoreCorr") + "," + str("CommNeighDist") + "," + str("PartRatio") + "," + str("AvgNeighDegCorr") + "," + str("Connected"), file=sys.stderr) for filo in os.listdir("/home/baldo/tmp/graph_generator/PL200/"): with open("/home/baldo/tmp/graph_generator/PL200/" + filo, "r") as net: eg.info(filo) eg.info("Loading graph..") G = nx.read_weighted_edgelist(net) # , delimiter=":") # G = read_graphml(net) A = nx.to_numpy_matrix(G) n = nm.shape(A)[0] joint_degrees = nx.algorithms.mixing.degree_mixing_dict(G) eg.info("Computing centrality..") x, l = eg.eigen_centrality(A) for i in range(10): eg.info("Run: " + str(i)) eg.info("Building JDM graph..") H = joint_degree_graph(joint_degrees) B = nx.to_numpy_matrix(H) write_statistics(A, B, "2k", filo, x, l) eg.info("Building degree sequence graph..") H = nx.random_degree_sequence_graph((nx.degree(G).values())) B = nx.to_numpy_matrix(H) write_statistics(A, B, "1k", filo, x, l) precision = 0.01 eg.info("Building eigen " + str(precision) + " graph..") B = eg.build_matrix(x, l, precision) write_statistics(A, B, "eig" + str(precision), filo, x, l) precision = 0.001 eg.info("Building eigen " + str(precision) + " graph..") B = eg.build_matrix(x, l, precision) write_statistics(A, B, "eig" + str(precision), filo, x, l) precision = 0.0001 eg.info("Building eigen " + str(precision) + " graph..") B = eg.build_matrix(x, l, precision) write_statistics(A, B, "eig" + str(precision), filo, x, l) m = 0.25 eg.info("Building spectral " + str(m) + " graph..") B = eg.sample_simm_matrix(A, int(round(n * m))) write_statistics(A, B, "spectre" + str(m), filo, x, l) m = 0.5 eg.info("Building spectral " + str(m) + " graph..") B = eg.sample_simm_matrix(A, int(round(n * m))) write_statistics(A, B, "spectre" + str(m), filo, x, l) m = 0.75 eg.info("Building spectral " + str(m) + " graph..") B = eg.sample_simm_matrix(A, int(round(n * m))) write_statistics(A, B, "spectre" + str(m), filo, x, l) m = 0.9 eg.info("Building spectral " + str(m) + " graph..") B = eg.sample_simm_matrix(A, int(round(n * m))) write_statistics(A, B, "spectre" + str(m), filo, x, l) m = 0.95 eg.info("Building spectral " + str(m) + " graph..") B = eg.sample_simm_matrix(A, int(round(n * m))) write_statistics(A, B, "spectre" + str(m), filo, x, l) eg.info("Building D2.5 graph..") test25 = Estimation() gen25 = Generation() test25.load_graph("", graph=G) test25.calcfull_CCK() test25.calcfull_JDD() gen25.set_JDD(test25.get_JDD('full')) gen25.set_KTRI(test25.get_KTRI('full')) gen25.construct_triangles_2K() gen25.mcmc_improved_2_5_K(error_threshold=0.05) H = gen25.G B = nx.to_numpy_matrix(H) write_statistics(A, B, "25k", filo, x, l)
def graph_worker(inputlist, queue, print_queue): for filo in inputlist: if filo.split(".")[-1] == "graphml": G = read_graphml(filo) else: G = nx.read_weighted_edgelist(filo) A = nx.to_numpy_matrix(G) n = nm.shape(A)[0] joint_degrees = nx.algorithms.mixing.degree_mixing_dict(G) x, l = eg.eigen_centrality(A) H = nx.random_degree_sequence_graph((nx.degree(G).values())) B = nx.to_numpy_matrix(H) print_queue.put(write_statistics(A, B, "1k", filo, x, l, output=False)) print_queue.put("\n") H = joint_degree_graph(joint_degrees) B = nx.to_numpy_matrix(H) print_queue.put(write_statistics(A, B, "2k", filo, x, l, output=False)) print_queue.put("\n") precision = 0.01 B = eg.build_matrix(x, l, precision) print_queue.put( write_statistics(A, B, "eig" + str(precision), filo, x, l, output=False)) print_queue.put("\n") precision = 0.001 B = eg.build_matrix(x, l, precision) print_queue.put( write_statistics(A, B, "eig" + str(precision), filo, x, l, output=False)) print_queue.put("\n") precision = 0.0001 B = eg.build_matrix(x, l, precision) print_queue.put( write_statistics(A, B, "eig" + str(precision), filo, x, l, output=False)) print_queue.put("\n") m = 0.25 B = eg.sample_simm_matrix(A, int(round(n * m))) print_queue.put( write_statistics(A, B, "spectre" + str(m), filo, x, l, output=False)) print_queue.put("\n") m = 0.5 B = eg.sample_simm_matrix(A, int(round(n * m))) print_queue.put( write_statistics(A, B, "spectre" + str(m), filo, x, l, output=False)) print_queue.put("\n") m = 0.75 B = eg.sample_simm_matrix(A, int(round(n * m))) print_queue.put( write_statistics(A, B, "spectre" + str(m), filo, x, l, output=False)) print_queue.put("\n") m = 0.9 B = eg.sample_simm_matrix(A, int(round(n * m))) print_queue.put( write_statistics(A, B, "spectre" + str(m), filo, x, l, output=False)) print_queue.put("\n") m = 0.95 B = eg.sample_simm_matrix(A, int(round(n * m))) print_queue.put( write_statistics(A, B, "spectre" + str(m), filo, x, l, output=False)) print_queue.put("\n") test25 = Estimation() gen25 = Generation() test25.load_graph("", graph=G) test25.calcfull_CCK() test25.calcfull_JDD() gen25.set_JDD(test25.get_JDD('full')) gen25.set_KTRI(test25.get_KTRI('full')) gen25.construct_triangles_2K() gen25.mcmc_improved_2_5_K(error_threshold=0.05) H = gen25.G B = nx.to_numpy_matrix(H) print_queue.put(write_statistics(A, B, "25k", filo, x, l, output=False)) print_queue.put("\n")
# Punto 5 : Mundos Pequeños nx.draw(cg) # networkx draw() plt.draw() # pyplot draw() plt.show() C= nx.average_clustering(cg) print("Coeficiente de clustering C para cg: " + str(C)) l=nx.average_shortest_path_length(cg) print("Camino mínimo medio l para cg: " + str(l)) #random graph con la misma distribucón de grado rg = nx.random_degree_sequence_graph(sorted([e[1] for e in list(nx.degree(cg))], reverse=True)) nx.draw(rg) # networkx draw() plt.draw() # pyplot draw() plt.show() print("Coeficiente de clustering C para rg: " + str(nx.average_clustering(rg))) print("Camino mínimo medio l para rg: " + str(nx.average_shortest_path_length(rg))) # Punto 6 : Estrellas
def test_random_degree_sequence_graph(): d = [1, 2, 2, 3] G = nx.random_degree_sequence_graph(d, seed=42) assert_equal(d, sorted(d for n, d in G.degree())) G = nx.random_degree_sequence_graph(d) assert_equal(d, sorted(d for n, d in G.degree()))
def generate_one_graph_sample(initial_graph, seed=42): degree_sequence = [d for n, d in initial_graph.degree()] sample_graph = nx.random_degree_sequence_graph(degree_sequence, seed=seed) return sample_graph
def graph_worker_oneshot(inputlist, queue, print_queue): for duty in inputlist: name = duty[0] G = duty[1] algo = duty[2] param = duty[3] A = nx.to_numpy_matrix(G) # x, l = eg.eigen_centrality(A) eg.info("Setup completed") start_time = time.time() if algo == "1k": H = nx.random_degree_sequence_graph((nx.degree(G).values())) # B = nx.to_numpy_matrix(H) elif algo == "2k": joint_degrees = nx.algorithms.mixing.degree_mixing_dict(G) H = joint_degree_graph(joint_degrees) # B = nx.to_numpy_matrix(H) elif algo == "eig": precision = float(param) # B = eg.build_matrix(x, l, precision) B = eg.generate_matrix(x, l * x, precision, gu.get_degrees(A)) H = None algo += str(precision) elif algo == "modeig": precision = float(param) B = eg.synthetic_modularity_matrix(A, precision) H = None algo += str(precision) elif algo == "spectre": m = float(param) n = nm.shape(A)[0] B = eg.sample_simm_matrix2(A, int(round(n * m))) H = gu.simm_matrix_2_graph(B) while nx.is_isomorphic(G, H): B = eg.sample_simm_matrix2(A, int(round(n * m))) H = gu.simm_matrix_2_graph(B) algo += str(m) elif algo == "laplacian": m = float(param) n = nm.shape(A)[0] B = eg.laplacian_clone_matrix(A, int(round(n * m))) H = gu.simm_matrix_2_graph(B) while nx.is_isomorphic(G, H): B = eg.sample_simm_matrix2(A, int(round(n * m))) H = gu.simm_matrix_2_graph(B) algo += str(m) elif algo == "modspec": m = float(param) n = nm.shape(A)[0] B = eg.modspec_clone_matrix(A, int(round(n * m))) H = None algo += str(m) elif algo == "franky": m = float(param) n = nm.shape(A)[0] B = eg.franky_clone_matrix(A, int(round(n * m))) H = None algo += str(m) elif algo == "modularity": m = float(param) n = nm.shape(A)[0] B = eg.modularity_clone_matrix(A, int(round(n * m))) H = gu.simm_matrix_2_graph(B) while nx.is_isomorphic(G, H): B = eg.modularity_clone_matrix(A, int(round(n * m))) H = gu.simm_matrix_2_graph(B) algo += str(m) elif algo == "25k": test25 = Estimation() gen25 = Generation() test25.load_graph("", graph=G) test25.calcfull_CCK() test25.calcfull_JDD() gen25.set_JDD(test25.get_JDD('full')) gen25.set_KTRI(test25.get_KTRI('full')) gen25.construct_triangles_2K() gen25.mcmc_improved_2_5_K(error_threshold=0.05) H = gen25.G # B = nx.to_numpy_matrix(H) eg.info("Graph Generated") stat = get_statistics1(G, H, time.time() - start_time) s = algo + "," + name + "," + str(len(G.nodes())) for el in stat: s += "," + str(el) print_queue.put(s) print_queue.put("\n") gc.collect()
def test_random_degree_sequence_large(): G1 = nx.fast_gnp_random_graph(100, 0.1) d1 = (d for n, d in G1.degree()) G2 = nx.random_degree_sequence_graph(d1, seed=42) d2 = (d for n, d in G2.degree()) assert_equal(sorted(d1), sorted(d2))
import numpy as np flag = True G = None while flag: flag = False try: n_vertices = np.random.randint(6, 10) degrees = [2, 4, 6, 8] degree_sequence = None for i in range(n_vertices): degree_sequence = np.random.choice(degrees, n_vertices, replace=True) G = nx.random_degree_sequence_graph(degree_sequence) except (nx.NetworkXUnfeasible, nx.NetworkXError): flag = True matrix = nx.adjacency_matrix(G) matrix = np.array(matrix.todense(), dtype=int) print(matrix) with open('euler.txt', 'wt') as f: for row in range(0, n_vertices): for col in range(0, n_vertices): f.write("%d" % matrix[row, col]) if col == n_vertices - 1: f.write("\n") else: f.write(" ")
brain_degree = nx.degree(G_brain).values() brain_degree_mean = np.mean(brain_degree) # Initialize repetition matrices for standard graphs # ER_deg_mat = -1 * np.ones((repeats, n_nodes)) RAND_deg_mat = -1 * np.ones((repeats, n_nodes)) WS_deg_mat = -1 * np.ones((repeats, n_nodes)) BA_deg_mat = -1 * np.ones((repeats, n_nodes)) print 'this could take a while...' for r in np.arange(repeats): # Erdos-Renyi (pure random) # ER_deg_mat[r, :] = er(n_nodes, edge_density).degree().values() # Degree controlled random RAND_deg_mat[r, :] = nx.random_degree_sequence_graph( brain_degree, tries=100).degree().values() # Watts-Strogatz WS_deg_mat[r, :] = ws(n_nodes, int(round(brain_degree_mean)), SW_REWIRE_PROB).degree().values() # Barabasi-Albert BA_deg_mat[r, :] = ba(n_nodes, int(round(brain_degree_mean / 2.))).degree().values() print 'Finished repeat: ' + str(r) deg_dists = [ RAND_deg_mat.flatten(), WS_deg_mat.flatten(), BA_deg_mat.flatten() ]
def test_random_degree_sequence_large(): G1 = nx.fast_gnp_random_graph(100, 0.1) d1 = (d for n, d in G1.degree()) G2 = nx.random_degree_sequence_graph(d1, seed=0) d2 = (d for n, d in G2.degree()) assert_equal(sorted(d1), sorted(d2))
brain_degree = nx.degree(G_brain).values() brain_degree_mean = np.mean(brain_degree) # Initialize repetition matrices for standard graphs # ER_deg_mat = -1 * np.ones((repeats, n_nodes)) RAND_deg_mat = -1 * np.ones((repeats, n_nodes)) WS_deg_mat = -1 * np.ones((repeats, n_nodes)) BA_deg_mat = -1 * np.ones((repeats, n_nodes)) print 'this could take a while...' for r in np.arange(repeats): # Erdos-Renyi (pure random) # ER_deg_mat[r, :] = er(n_nodes, edge_density).degree().values() # Degree controlled random RAND_deg_mat[r, :] = nx.random_degree_sequence_graph( brain_degree, tries=100).degree().values() # Watts-Strogatz WS_deg_mat[r, :] = ws(n_nodes, int(round(brain_degree_mean)), SW_REWIRE_PROB).degree().values() # Barabasi-Albert BA_deg_mat[r, :] = ba(n_nodes, int(round(brain_degree_mean / 2.))).degree().values() print 'Finished repeat: ' + str(r) deg_dists = [RAND_deg_mat.flatten(), WS_deg_mat.flatten(), BA_deg_mat.flatten()] colors = [RAND_COLOR, WS_COLOR, BA_COLOR] graph_names = ['Random', 'Small-world', 'Scale-free'] graph_ls = ['-', '-', '-']
from pylab import * import networkx as nx subplot(2, 2, 1) nx.draw(nx.gnm_random_graph(10, 20)) title('random graph with\n10 nodes, 20 edges') subplot(2, 2, 2) nx.draw(nx.gnp_random_graph(20, 0.1)) title('random graph with\n 20 nodes, 10% edge probability') subplot(2, 2, 3) nx.draw(nx.random_regular_graph(3, 10)) title('random regular graph with\n10 nodes of degree 3') subplot(2, 2, 4) nx.draw(nx.random_degree_sequence_graph([3, 3, 3, 3, 4, 4, 4, 4, 5, 5])) title('random graph with\n degree sequence\n[3,3,3,3,4,4,4,4,5,5]') show()
rcc_at_cutoff = 0.0 # get small world coefficient #from the clustering coefficient (CC) and the average path length (PL) = # CC(actual network)/CC(random graph) divided by PL(actual network)/PL(random graph) # use just the largest connected component gcsize = G.number_of_nodes() apl = networkx.average_shortest_path_length(G) Gclust = networkx.average_clustering(G) sw = [] for i in range(36): try: rand = networkx.random_degree_sequence_graph(G.degree().values(), tries=10) Grand = networkx.connected_component_subgraphs(rand)[0] except: print 'problem on round', i continue print i sw.append((Gclust / networkx.average_clustering(Grand)) / (apl / networkx.average_shortest_path_length(Grand))) if len(sw) > 0: meansw = numpy.mean(sw) else: meansw = 0 alldata = numpy.array([