def generateNetwork(N,cnType,weighted): # Input: # N - number of nodes # cnType - network type (i.e. scale-free, small-world, Erdos-Renyi random graph) # weighted - weighted or unweighted network # Output: # G - a network with random generated topology acoording with the input parameters if (cnType == "scale-free"): G = nx.powerlaw_cluster_graph(N, 5, 0.3) while (nx.is_connected(G) == False): G = nx.powerlaw_cluster_graph(N, 5, 0.3) if (cnType == "small-world"): G = nx.newman_watts_strogatz_graph(N, 6, 0.6) while (nx.is_connected(G) == False): G = nx.newman_watts_strogatz_graph(N, 6, 0.6) if (cnType == "Erdos-Renyi"): G = nx.fast_gnp_random_graph(N, 0.01) while (nx.is_connected(G) == False): G = nx.fast_gnp_random_graph(N, 0.01) if (weighted): G = generateWeightedNetwork(G) else: G = generateUnweightedNetwork(G) return G
def __init__(self, graph_type, min_n, max_n, p, m=None, seed=None): cur_n = np.random.randint(max_n - min_n + 1) + min_n if graph_type == 'erdos_renyi': self.g = nx.erdos_renyi_graph(n=cur_n, p=p, seed=seed) elif graph_type == 'powerlaw': self.g = nx.powerlaw_cluster_graph(n=cur_n, m=m, p=p, seed=seed) elif graph_type == 'barabasi_albert': self.g = nx.barabasi_albert_graph(n=cur_n, m=m, seed=seed) elif graph_type == 'gnp_random_graph': self.g = nx.gnp_random_graph(n=cur_n, p=p, seed=seed) while self.g.number_of_edges == 0: if graph_type == 'erdos_renyi': self.g = nx.erdos_renyi_graph(n=cur_n, p=p, seed=seed) elif graph_type == 'powerlaw': self.g = nx.powerlaw_cluster_graph(n=cur_n, m=m, p=p, seed=seed) elif graph_type == 'barabasi_albert': self.g = nx.barabasi_albert_graph(n=cur_n, m=m, seed=seed) elif graph_type == 'gnp_random_graph': self.g = nx.gnp_random_graph(n=cur_n, p=p, seed=seed) self.adj_dense = nx.to_numpy_matrix(self.g, dtype=np.int32)
def createGraphsAndCommunities(): g = nx.scale_free_graph(500, alpha=0.40, beta=0.40, gamma=0.20) g1 = nx.powerlaw_cluster_graph(500, 10, 0.2) g2 = nx.barabasi_albert_graph(500, 10) g3 = nx.newman_watts_strogatz_graph(500, 10, 0.2) nx.write_graphml (g, direc+"sfg.graphml") nx.write_graphml(g1, direc+"pcg.graphml") nx.write_graphml(g2, direc+"bag.graphml") nx.write_graphml(g3, direc+"nwsg.graphml") graphs = {} graphs["sfg"] = graph_tool.load_graph(direc+"sfg.graphml") graphs["pcg"] = graph_tool.load_graph(direc+"pcg.graphml") graphs["bag"] = graph_tool.load_graph(direc+"bag.graphml") graphs["nwsg"] = graph_tool.load_graph(direc+"nwsg.graphml") graphs["price"] = graph_tool.generation.price_network(1000) for i,h in graphs.iteritems(): s = graph_tool.community.minimize_blockmodel_dl(h) b = s.b graph_tool.draw.graph_draw(h, vertex_fill_color=b, vertex_shape=b, output=direc+"block"+str(i)+".pdf") com = graph_tool.community.community_structure(h, 10000, 20) graph_tool.draw.graph_draw(h, vertex_fill_color=com, vertex_shape=com, output=direc+"community"+str(i)+".pdf") state = graph_tool.community.minimize_nested_blockmodel_dl(h) graph_tool.draw.draw_hierarchy(state, output=direc+"nestedblock"+str(i)+".pdf") pagerank = graph_tool.centrality.pagerank(h) graph_tool.draw.graph_draw(h, vertex_fill_color=pagerank, vertex_size = graph_tool.draw.prop_to_size(pagerank, mi=5, ma=15), vorder=pagerank, output=direc+"pagerank"+str(i)+".pdf") h.set_reversed(is_reversed=True) pagerank = graph_tool.centrality.pagerank(h) graph_tool.draw.graph_draw(h, vertex_fill_color=pagerank, vertex_size = graph_tool.draw.prop_to_size(pagerank, mi=5, ma=15), vorder=pagerank, output=direc+"reversed_pagerank"+str(i)+".pdf")
def generate_powerlaw_graph(nodes, d, p, ind=1): graph = [] graph.extend([(i, j, ind) for (i, j) in nx.powerlaw_cluster_graph( nodes, d, p, seed=np.random.randint(0, 10000000)).edges()]) graph_edges = np.array(graph) return graph_edges
def set_graph(self, graphtype, graphparams): if graphtype == 'hexagonal': self.G = nx.triangular_lattice_graph(**graphparams) elif graphtype == 'watts strogatz': self.G = nx.watts_strogatz_graph(**graphparams) elif graphtype == 'newman watts strogatz': self.G = nx.newman_watts_strogatz_graph(**graphparams) elif graphtype == 'square': self.G = nx.grid_2d_graph(**graphparams) elif graphtype == 'random blocks': self.G = nx.stochastic_block_model(**graphparams) elif graphtype == 'powerlaw cluster': self.G = nx.powerlaw_cluster_graph(**graphparams) elif graphtype == 'scale-free small world': self.G = clustered_scalefree(**graphparams) elif graphtype == 'barabasi-albert': self.G = nx.barabasi_albert_graph(**graphparams) else: print('Using complete graph') self.G = nx.complete_graph(**graphparams)
def initialize(): global g global wr global f global initialConditions initialConditions=0 # Inicialite file for saving data cola= dt.datetime.now().strftime('%H%M') outputfilename = 'competicion_01_{}.csv'.format( cola) fileOut = open(outputfilename, 'w') wr = csv.writer(fileOut,quoting = csv.QUOTE_NONE) wr.writerow(['Tipo 1','Tipo 2','Tipo 3','Patogeno']) f = open( 'competicion_01_{}.ini'.format( cola), "w") # g = nx.karate_club_graph() g=nx.powerlaw_cluster_graph(100,3,0.3) g.pos = nx.spring_layout(g) for i in g.nodes_iter(): if random() < .33: g.node[i]['tipo'] = 0 elif random() < .33: g.node[i]['tipo'] = 1 elif random() < .33: g.node[i]['tipo'] = 2 elif random() < .33: g.node[i]['tipo'] = 3 else: g.node[i]['tipo'] = 4
def fromPowerLaw(cls, specs): ''' :param specs: a tupple containing (n, m, p, seed, bw, delay, cpu) :return: a substrate ''' n, m, p, seed, bw, delay, cpu = specs n = int(n) m = int(m) p = float(p) seed = int(seed) g = nx.powerlaw_cluster_graph(n, m, p, seed) session = Session() nodes = [Node(name=str(n), cpu_capacity=cpu) for n in g.nodes()] session.add_all(nodes) session.flush() edges = [Edge (node_1=session.query(Node).filter(Node.name == str(e[0])).one(), node_2=session.query(Node).filter(Node.name == str(e[1])).one(), bandwidth=bw, delay=delay ) for e in g.edges() ] session.add_all(edges) session.flush() return cls(edges, nodes )
def add_edges_to_groups(output_graph, groups_list, edges_to_add, prob, level): global template_created total_groups = len(groups_list) edges_per_node = max((3 - level), 1) triangle_prob = 0.1*level if False: random_graph = nx.random_regular_graph(int(total_groups/3), total_groups) else: random_graph = nx.powerlaw_cluster_graph(total_groups, edges_per_node, triangle_prob, random.random()*10) if template_created: template_created = False plt.axis('off') position = nx.graphviz_layout(random_graph, prog='sfdp') nx.draw_networkx_nodes(random_graph, position, node_size=30, node_color='r') #output_graph.degree().values()) nx.draw_networkx_edges(random_graph, position, alpha=0.3) plt.savefig(dataset_name2 +"/"+ "template_" + image_name, bbox_inches='tight', dpi=500) print "plot saved as ", image_name random_edges = random_graph.edges() for edge in random_edges: e0 = edge[0] e1 = edge[1] if random.random() > 0.3: e0, e1 = e1, e0 print("adding level{} edges between group{} and group{}".format(level, e0, e1)) add_edges_to_two_groups(output_graph, groups_list[e0], groups_list[e1], edges_to_add, prob)
def __init__(self, N, m, p): self.name = 'Default Power-Law random graph SF_%i (Poisson distribution)' % N self.N = N self.G = nx.powerlaw_cluster_graph(N, m, p) self.params = dict() self.state = None
def get_graph(objects, properties): graph_type = properties['graph_type'] n = len(objects) - 1 if 'num_nodes_to_attach' in properties.keys(): k = properties['num_nodes_to_attach'] else: k = 3 r = properties['connection_probability'] tries = 0 while (True): if graph_type == 'random': x = nx.fast_gnp_random_graph(n, r) elif graph_type == 'erdos_renyi_graph': x = nx.erdos_renyi_graph(n, r) elif graph_type == 'watts_strogatz_graph': x = nx.watts_strogatz_graph(n, k, r) elif graph_type == 'newman_watts_strogatz_graph': x = nx.newman_watts_strogatz_graph(n, k, r) elif graph_type == 'barabasi_albert_graph': x = nx.barabasi_albert_graph(n, k, r) elif graph_type == 'powerlaw_cluster_graph': x = nx.powerlaw_cluster_graph(n, k, r) elif graph_type == 'cycle_graph': x = nx.cycle_graph(n) else: ##Star by default x = nx.star_graph(len(objects) - 1) tries += 1 cc_conn = nx.connected_components(x) if len(cc_conn) == 1 or tries > 5: ##best effort to create a connected graph! break return x, cc_conn
def test_pagerank(self): size = 1000 g = nx.DiGraph(nx.powerlaw_cluster_graph(size, 3, 0.001)) N = len(g.nodes()) tmp_file = tempfile.NamedTemporaryFile(delete=False) for node in g.nodes(): outlinks = g.out_edges(nbunch=[node]) outlinks = map(str, [n2 for n1, n2 in outlinks]) if not outlinks: value = 'pr_results,%s,%s' % (1.0/N, N) tmp_file.write('%s\t%s\n' % (node, value)) else: outlinks_str = ','.join(outlinks) value = 'pr_results,%s,%s,' % (1.0/N, N) value += outlinks_str tmp_file.write('%s\t%s\n' % (node, value)) tmp_file.flush() input_path = tmp_file.name job_id = 'unittest' sorted_ids = pagerank(job_id, self.iter_count, input_path, self.top_n) fs = HadoopFS() fs.rmr('%s/hat_results' % job_id) if self.top_n <= size: self.assertEqual(len(sorted_ids), self.top_n, 'some ids is missing') id_ranges = range(0, 1000) for _id in sorted_ids: self.assertIn(int(_id), id_ranges, 'node should in graph')
def create_graph(num_nodes): """ Creates directed graph with agents assigned to the nodes and trust values assigned to the edges :param num_nodes: integer, number of nodes in the graph :return: graph: nx.DiGraph, a directed graph representing the connections between the agents """ graph = nx.powerlaw_cluster_graph(num_nodes, 3, 0.5) graph = graph.to_directed() # Set weights on edges for node in graph.nodes(): # Set out-degree as weight on out-going edges out_degree = graph.out_degree[node] for edge in graph.edges(node): graph.edges[edge]['weight'] = out_degree # Normalize over in-going edges for node in graph.nodes(): sum_ingoing = np.sum(attr['weight'] for a, b, attr in graph.in_edges(node, data=True)) for edge in graph.in_edges(node): graph.edges[edge]['weight'] /= sum_ingoing return graph
def get_graph(objects, properties): graph_type = properties['graph_type'] n = len(objects)-1 if 'num_nodes_to_attach' in properties.keys(): k = properties['num_nodes_to_attach'] else: k = 3 r = properties['connection_probability'] tries = 0 while(True): if graph_type == 'random': x = nx.fast_gnp_random_graph(n,r) elif graph_type == 'erdos_renyi_graph': x = nx.erdos_renyi_graph(n,r) elif graph_type == 'watts_strogatz_graph': x = nx.watts_strogatz_graph(n, k, r) elif graph_type == 'newman_watts_strogatz_graph': x = nx.newman_watts_strogatz_graph(n, k, r) elif graph_type == 'barabasi_albert_graph': x = nx.barabasi_albert_graph(n, k, r) elif graph_type == 'powerlaw_cluster_graph': x = nx.powerlaw_cluster_graph(n, k, r) elif graph_type == 'cycle_graph': x = nx.cycle_graph(n) else: ##Star by default x = nx.star_graph(len(objects)-1) tries += 1 cc_conn = nx.connected_components(x) if len(cc_conn) == 1 or tries > 5: ##best effort to create a connected graph! break return x, cc_conn
def create_graph(self, params): # case statements on type of graph if self.type == 'small_world': self.graph = nx.watts_strogatz_graph( int(params[0]), int(params[1]), float(params[2]), None if len(params) < 4 else int(params[3])) cg.SWC += 1 self.idx = cg.SWC self.path = 'smallWorldGraphs' elif self.type == 'small_world_connected': self.graph = nx.connected_watts_strogatz_graph( int(params[0]), int(params[1]), float(params[2]), 100 if len(params) < 4 else int(params[3]), None if len(params) < 5 else int(params[4])) cg.SWCC += 1 self.idx = cg.SWCC self.path = 'smallWorldConnectedGraphs' elif self.type == 'small_world_newman': self.graph = nx.newman_watts_strogatz_graph( int(params[0]), int(params[1]), float(params[2]), None if len(params) < 4 else int(params[3])) cg.SWNC += 1 self.idx = cg.SWNC self.path = 'smallWorldNewmanGraphs' elif self.type == 'power_law': self.graph = nx.powerlaw_cluster_graph( int(params[0]), int(params[1]), float(params[2]), None if len(params) < 4 else int(params[3])) cg.PLC += 1 self.idx = cg.PLC self.path = 'powerLawGraphs' elif self.type == 'power_law_tree': self.graph = nx.random_powerlaw_tree( int(params[0]), 3 if len(params) < 2 else float(params[1]), None if len(params) < 3 else int(params[2]), 100 if len(params) < 4 else int(params[3])) cg.PLTC += 1 self.idx = cg.PLTC self.path = 'powerLawTreeGraphs' elif self.type == 'random_graph': self.graph = nx.gnm_random_graph( int(params[0]), int(params[1]), None if len(params) < 3 else int(params[2]), False if len(params) < 4 else bool(params[3])) cg.RGC += 1 self.idx = cg.RGC self.path = 'randomGraphs' elif self.type == 'erdos_renyi_random': self.graph = nx.erdos_renyi_graph( int(params[0]), float(params[1]), None if len(params) < 3 else int(params[2]), False if len(params) < 4 else bool(params[3])) cg.ERRC += 1 self.idx = cg.ERRC self.path = 'erdosRenyiRandomGraphs' else: print 'GRAPH TYPE:', self.type raise Exception('Invalid Type of Graph input into argv[2]')
def generate_graph(n, m, p, seed): G = nx.powerlaw_cluster_graph(n, m, p, seed) data = json_graph.node_link_data(G) with open('./Working/graph.json', 'w') as f: json.dump(data, f) with open('./Working/graph_flag', mode='w', encoding='utf-8') as fh: fh.write("i look at you")
def __update_structure(self): self.structure = nx.powerlaw_cluster_graph( self.num_nodes, self.node_degree, self.prob_triad, self.seed ) if nx.is_connected(self.structure): return components = nx.connected_components(self.structure) biggest_comp = [] comp_index = -1 for i, component in enumerate(components): if len(component) > len(biggest_comp): biggest_comp = component comp_index = i if self.seed: random.seed(self.seed) del components[comp_index] for component in components: for left_node in component: right_node = random.choice(biggest_comp) self.structure.add_edge(left_node, right_node)
def __init__(self, population_size, initial_outbreak_size, spread_chance): print("Beginning model setup...\n") self.population_size = population_size print("Creating graph...") self.graph = nx.powerlaw_cluster_graph(population_size, 100, 0.5) #self.graph = nx.complete_graph(population_size) print(len(self.graph.edges)) print("Initializing grid...") self.grid = NetworkGrid(self.graph) self.schedule = SimultaneousActivation(self) self.initial_outbreak_size = initial_outbreak_size self.spread_chance = spread_chance print("Initializing data collector...") self.datacollector = DataCollector({ "Infected:": count_infected, "Susceptible:": count_susceptible, "Removed:": count_removed }) for i, node in enumerate(self.graph.nodes()): a = Person(i, self, State.SUSCEPTIBLE, spread_chance) self.schedule.add(a) self.grid.place_agent(a, i) if i % 100 == 0: print("Finished with agent ", i) infected_nodes = self.random.sample(self.graph.nodes(), self.initial_outbreak_size) for a in self.grid.get_cell_list_contents(infected_nodes): a.status = State.INFECTED self.datacollector.collect(self) print("Model initialized...\n")
def gen_graph(num_min, num_max, g_type, path, i, n_type='uniform'): cur_n = random.randint(num_max - num_min + 1) + num_min if g_type == 'erdos_renyi': g = nx.erdos_renyi_graph(n=cur_n, p=0.15) elif g_type == 'powerlaw': g = nx.powerlaw_cluster_graph(n=cur_n, m=4, p=0.05) elif g_type == 'small-world': g = nx.connected_watts_strogatz_graph(n=cur_n, k=8, p=0.1) elif g_type == 'barabasi_albert': g = nx.barabasi_albert_graph(n=cur_n, m=4) if n_type != 'uniform': if n_type == 'random': weights = {} for node in g.nodes(): weights[node] = random.uniform(0, 1) else: degree = nx.degree_centrality(g) maxDegree = max(dict(degree).values()) weights = {} for node in g.nodes(): weights[node] = degree[node] / maxDegree nx.set_node_attributes(g, weights, 'weight') path = '%s/%s-%s' % (path, str(num_min), str(num_max)) if not os.path.exists(path): os.mkdir(path) nx.write_gml(g, '%s/g_%s' % (path, str(i)))
def gen_graph(opt): max_n = int(opt['max_n']) min_n = int(opt['min_n']) g_type = opt['g_type'] max_w = 10 min_w = 1 graph_id = np.random.randint(MAX_VAL) cur_n = np.random.randint(max_n - min_n + 1) + min_n if g_type == 'erdos_renyi': p = float(opt['density']) e_g = nx.erdos_renyi_graph(n=cur_n, p=p, seed=graph_id) lcc = max(nx.connected_component_subgraphs(e_g), key=len) g = nx.convert_node_labels_to_integers(lcc) elif g_type == 'powerlaw': g = nx.powerlaw_cluster_graph(n=cur_n, m=4, p=p, seed=graph_id) elif g_type == 'barabasi_albert': p = int(opt['density']) if p == 0: max_p = 16 min_p = 1 p = np.random.randint(max_p - min_p + 1) + min_p g = nx.barabasi_albert_graph(n=cur_n, m=p, seed=graph_id) for edge in nx.edges(g): pert = np.random.uniform(-0.5, 0.5) weight = np.random.randint(max_w - min_w + 1) + min_w g[edge[0]][edge[1]]['weight'] = (weight + pert) * w_scaling return g
def __update_structure(self): self.structure = nx.powerlaw_cluster_graph(self.num_nodes, self.node_degree, self.prob_triad, self.seed) if nx.is_connected(self.structure): return components = nx.connected_components(self.structure) biggest_comp = [] comp_index = -1 for i, component in enumerate(components): if len(component) > len(biggest_comp): biggest_comp = component comp_index = i if self.seed: random.seed(self.seed) del components[comp_index] for component in components: for left_node in component: right_node = random.choice(biggest_comp) self.structure.add_edge(left_node, right_node)
def __init__(self, graph_type, cur_n=0, p=None, m=None, seed=None): """ initialize a graphing problem :param graph_type: type of random graph to generate :param cur_n: size of graph :param p: probability of being connected :param m: :param seed: seed used to gen graph under """ self.graph_type = graph_type self.cur_n = cur_n self.seed = seed self.m, self.p = "_", "_" if m: self.m = m if p: self.p = p if graph_type == "prototype": pass elif graph_type == 'erdos_renyi': self.g = nx.erdos_renyi_graph(n=cur_n, p=p, seed=seed) elif graph_type == 'powerlaw': self.g = nx.powerlaw_cluster_graph(n=cur_n, m=m, p=p, seed=seed) elif graph_type == 'barabasi_albert': self.g = nx.barabasi_albert_graph(n=cur_n, m=m, seed=seed) elif graph_type == 'gnp_random_graph': self.g = nx.gnp_random_graph(n=cur_n, p=p, seed=seed) self.solution = None self.approx = None
def create(self, model, kwargs): if model == 1: degree = kwargs.get("degree", self.degree) nodes = kwargs.get("nodes", self.nodes) self.graph = nx.random_regular_graph(degree, nodes) elif model == 2: nodes = kwargs.get("nodes", self.nodes) edge_prob = kwargs.get("edge_prob", self.edge_prob) self.graph = nx.binomial_graph(nodes, edge_prob) # elif model == 3: # self.graph = nx.gaussian_random_partition_graph(self.nodes, self.nodes/self.neighbour_edges, # self.nodes / self.neighbour_edges, # self.edge_prob, self.edge_prob) elif model == 3: nodes = kwargs.get("nodes", self.nodes) neighbour_edges = kwargs.get("neighbour_edges", self.neighbour_edges) edge_prob = kwargs.get("edge_prob", self.edge_prob) self.graph = nx.powerlaw_cluster_graph(nodes, neighbour_edges, edge_prob) elif model == 4: # self.graph = nx.scale_free_graph(self.nodes) # else: nodes = kwargs.get("nodes", self.nodes) neighbour_edges = kwargs.get("neighbour_edges", self.neighbour_edges) self.graph = nx.barabasi_albert_graph(nodes, neighbour_edges) return self.graph
def ShowGraph(): def RandomLetter(): string.ascii_letters import random letter = random.choice(string.ascii_lowercase) return letter # erdos renyi graph # generate a graph which has n=20 nodes, probablity p = 0.2. ER = nx.random_graphs.erdos_renyi_graph(20, 0.2) PW = nx.powerlaw_cluster_graph(20,3,0) # the shell layout pos = nx.shell_layout(ER) NER = [] for e in nx.to_edgelist(ER): T = (e[0],e[1],RandomLetter()) NER.append(T) print (NER) nx.draw(ER, pos, with_labels = False, node_size = 30) plt.show() query = "a.b.c.d" querylist=query.split("+", query.count(".", 0, len(query))) print (querylist) query1 ="a[2,3].h.(b+c+d.(e+f+g+t)+u).a[2,3].(b+c+d+e.(f+g))).y.(i+9)"
def powerlaw_cluster_graph(N, deg, dia, dim, domain): ''' Parameters of the graph: n (int) – the number of nodes m (int) – the number of random edges to add for each new node p (float,) – Probability of adding a triangle after adding a random edge Formula for m: (m^2)- (Nm)/2 + avg_deg * (N/2) = 0 => From this equation we need to find m : p : Does not vary the average degree or diameter so much. : Higher value of p may cause average degree to overshoot intended average_deg so we give the control of average degree to parameter m: by setting a lower value of p: 0.1 :return: Graph Object ''' ## Calculating thof nodes: 10\nNumber of edges: 16\nAverage degree: 3.2000' strt_time = time() m = int(round((N - np.sqrt(N ** 2 - 4 * deg * N)) / 4)) p = 0.2 ## G at center: G = nx.powerlaw_cluster_graph(n=N, m=m, p=p) lcc, _ = graph_util.get_nk_lcc_undirected(G) best_G = lcc best_diam = nx.algorithms.diameter(best_G) best_avg_deg = np.mean(list(dict(nx.degree(best_G)).values())) end_time = time() print('Graph_Name: powerlaw_cluster_graph') print('Num_Nodes: ', nx.number_of_nodes(best_G), ' Avg_Deg : ', best_avg_deg, ' Diameter: ', best_diam) print('TIME: ', end_time - strt_time) return best_G, best_avg_deg, best_diam
def init_random(self, n=200, k=10, typ='random', p=.1, weighted=False, seed=None): # add n nodes to the network in the start state -> S self.add_mult(n, state='S', traced=False) # initialize the rewire probability to k/n if p=None provided p = k / n if p is None else p links_to_create_dict = { # Generate random pairs (edges) without replacement 'random': lambda: rand_pairs(n, int(n * k / 2), seed=seed), 'binomial': lambda: list(nx.fast_gnp_random_graph(n, p, seed=seed).edges), # small-world network 'ws': lambda: list(nx.watts_strogatz_graph(n, k, p, seed=seed).edges), 'newman-ws': lambda: list(nx.newman_watts_strogatz_graph(n, k, p, seed=seed).edges), # scale-free network 'barabasi': lambda: list(nx.barabasi_albert_graph(n, m=k, seed=seed).edges), 'powerlaw-cluster': lambda: list(nx.powerlaw_cluster_graph(n, m=k, p=p, seed=seed).edges), # fully connected network 'complete': lambda: list(nx.complete_graph(n).edges), } try: links_to_create = links_to_create_dict[typ]() except KeyError: print("The inputted network type is not supported. Default to: random", file=stderr) links_to_create = links_to_create_dict['random']() len_links = len(links_to_create) if weighted: # Create random weights from 1 to 10 and append them to the list of edge tuples weights = random.choices(range(1,10), k=len_links) links_to_create = [links_to_create[i] + (weights[i],) for i in range(len_links)] # Add the random edges with/without weights depending on 'weighted' parameter # we do not update the counts here because they will be updated after the infection has been seeded with first_inf self.add_links(links_to_create, update=False)
def RandomHolmeKim(n, m, p, seed=None): """ Returns a random graph generated by the Holme and Kim algorithm for graphs with power law degree distribution and approximate average clustering. INPUT: - ``n`` - number of vertices. - ``m`` - number of random edges to add for each new node. - ``p`` - probability of adding a triangle after adding a random edge. - ``seed`` - for the random number generator. From the NetworkX documentation: The average clustering has a hard time getting above a certain cutoff that depends on m. This cutoff is often quite low. Note that the transitivity (fraction of triangles to possible triangles) seems to go down with network size. It is essentially the Barabasi-Albert growth model with an extra step that each random edge is followed by a chance of making an edge to one of its neighbors too (and thus a triangle). This algorithm improves on B-A in the sense that it enables a higher average clustering to be attained if desired. It seems possible to have a disconnected graph with this algorithm since the initial m nodes may not be all linked to a new node on the first iteration like the BA model. EXAMPLE: We show the edge list of a random graph on 8 nodes with 2 random edges per node and a probability `p = 0.5` of forming triangles. :: sage: graphs.RandomHolmeKim(8, 2, 0.5).edges(labels=False) [(0, 2), (0, 5), (1, 2), (1, 3), (2, 3), (2, 4), (2, 6), (2, 7), (3, 4), (3, 6), (3, 7), (4, 5)] :: sage: G = graphs.RandomHolmeKim(12, 3, .3) sage: G.show() # long time REFERENCE: - [1] Holme, P. and Kim, B.J. Growing scale-free networks with tunable clustering, Phys. Rev. E (2002). vol 65, no 2, 026107. """ if seed is None: seed = current_randstate().long_seed() import networkx return graph.Graph(networkx.powerlaw_cluster_graph(n, m, p, seed=seed))
def powerlaw_cluster_graph(n=100, m=50, p=0.5): """powerlaw cluster graph :param n: node num :param m: the number of random edges to add for each new node :param p: prob :return: powerlaw_cluster_graph instance """ return nx.powerlaw_cluster_graph(n, m, p)
def generate_topo(n): topo = nx.powerlaw_cluster_graph(n,2,0.08) # topo = fnss.waxman_1_topology(n=50,alpha=0.6,beta=0.3) # topo = fnss.fat_tree_topology(n) fnss.set_weights_constant(topo,1) fnss.set_delays_constant(topo, 1, 'ms') fnss.set_capacities_edge_betweenness(topo,[100,500,1000],'Mbps') fnss.write_topology(topo,'topo_pl_50.xml')
def generate_graph(): # Try these included graphs! Play around with the constants! # Feel free to define your own graph for testing. #return nx.random_regular_graph(5, GRAPH_SIZE, seed=GRAPH_SEED) #return nx.barabasi_albert_graph(GRAPH_SIZE, 5) #return grid_graph() return nx.powerlaw_cluster_graph(GRAPH_SIZE, 5, 0.7)
def clusterGraph(nodes,edges,p): """Holme and Kim algorithm for growing graphs with powerlaw degree distribution and approximate average clustering. p is a ptobability of adding a triangle after adding a random edge. edges = number of random edges to add for each new node https://networkx.github.io/documentation/networkx-1.10/reference/generated/networkx.generators.random_graphs.powerlaw_cluster_graph.html#networkx.generators.random_graphs.powerlaw_cluster_graph """ g = nx.powerlaw_cluster_graph(nodes,edges,p) return g
def graph_space_iter(): i = 20 n = 0 while n < 1000000: G = nx.powerlaw_cluster_graph(i, 10, 0.1) G = nx.convert_node_labels_to_integers(G) n = G.number_of_edges() i *= 2 yield G.number_of_nodes(), G
def random_graphs(): print("Random graphs") print("fast GNP random graph") G = nx.fast_gnp_random_graph(n=9, p=0.4) draw_graph(G) print("GNP random graph") G = nx.gnp_random_graph(n=9, p=0.1) draw_graph(G) print("Dense GNM random graph") G = nx.dense_gnm_random_graph(n=19, m=28) draw_graph(G) print("GNM random graph") G = nx.gnm_random_graph(n=11, m=14) draw_graph(G) print("Erdős Rényi graph") G = nx.erdos_renyi_graph(n=11, p=0.4) draw_graph(G) print("Binomial graph") G = nx.binomial_graph(n=45, p=0.4) draw_graph(G) print("Newman Watts Strogatz") G = nx.newman_watts_strogatz_graph(n=9, k=5, p=0.4) draw_graph(G) print("Watts Strogatz") G = nx.watts_strogatz_graph(n=9, k=2, p=0.4) draw_graph(G) print("Watts Strogatz") G = nx.watts_strogatz_graph(n=9, k=2, p=0.4) draw_graph(G) print("Connected Watts Strogatz") G = nx.connected_watts_strogatz_graph(n=8, k=2, p=0.1) draw_graph(G) print("Random Regular Graph") G = nx.random_regular_graph(d=2, n=9) draw_graph(G) print("Barabasi Albert Graph") G = nx.barabasi_albert_graph(n=10, m=2) draw_graph(G) print("Powerlow Cluster Graph") G = nx.powerlaw_cluster_graph(n=10, m=2, p=0.2) draw_graph(G) print("Duplication Divergence Graph") G = nx.duplication_divergence_graph(n=10, p=0.2) draw_graph(G) print("Random lobster Graph") G = nx.random_lobster(n=10, p1=0.2, p2=0.8) draw_graph(G) print("Random shell Graph") constructor = [(10, 20, 0.8), (20, 40, 0.8)] G = nx.random_shell_graph(constructor) draw_graph(G) print("Random Powerlow Tree") G = nx.random_powerlaw_tree(n=24, gamma=3) draw_graph(G) print("Random Powerlow Tree Sequence") G = nx.random_powerlaw_tree(n=13, gamma=3) draw_graph(G)
def setup_network(alpha, beta, gamma, infected, directory=None, name=None, size=None, edge_p=None, knn=None, rewire_p=None, drop=None, m=None, n_edges=None, triangle_p=None): # Network topology # Create Graph if edge_p != None: print("Making ER Graph") g = nx.erdos_renyi_graph(size, edge_p) elif knn != None: print("Making NWS Graph with drops") g = nx.newman_watts_strogatz_graph(size, knn, rewire_p) # drop random edges for i in range(drop): e = random.choice(list(g.edges)) g.remove_edge(e[0], e[1]) elif m != None: print("Making BA Graph") g = nx.barabasi_albert_graph(size, m) elif triangle_p != None: print("Making Powerlaw Cluster Graph") g = nx.powerlaw_cluster_graph(n=size, m=n_edges, p=triangle_p) else: print("Loading custom Graph") g = nx.read_adjlist(os.path.join(directory, name), delimiter='\t', nodetype=int) # Model selection m = ep.SEIRModel(g) # Model Configuration cfg = mc.Configuration() cfg.add_model_parameter('beta', beta) cfg.add_model_parameter('gamma', gamma) cfg.add_model_parameter('alpha', alpha) cfg.add_model_parameter("fraction_infected", infected) m.set_initial_status(cfg) return m
def save_syn(): clustering_bins = np.linspace(0.3, 0.6, 7) print(clustering_bins) path_bins = np.linspace(1.8, 3.0, 7) print(path_bins) powerlaw_k = np.arange(2, 12) powerlaw_p = np.linspace(0, 1, 101) ws_k = np.arange(4, 23, 2) ws_p = np.linspace(0, 1, 101) counts = np.zeros((8, 8)) thresh = 4 graphs = [] n = 64 while True: k, p = np.random.choice(powerlaw_k), np.random.choice(powerlaw_p) g = nx.powerlaw_cluster_graph(n, k, p) clustering = nx.average_clustering(g) path = nx.average_shortest_path_length(g) clustering_id = np.digitize(clustering, clustering_bins) path_id = np.digitize(path, path_bins) if counts[clustering_id, path_id] < thresh: counts[clustering_id, path_id] += 1 default_feature = torch.ones(1) nx.set_node_attributes(g, default_feature, 'node_feature') graphs.append(g) print(np.sum(counts)) if np.sum(counts) == 8 * 8 * thresh: break with open('scalefree.pkl', 'wb') as file: pickle.dump(graphs, file) counts = np.zeros((8, 8)) thresh = 4 graphs = [] n = 64 while True: k, p = np.random.choice(ws_k), np.random.choice(ws_p) g = nx.watts_strogatz_graph(n, k, p) clustering = nx.average_clustering(g) path = nx.average_shortest_path_length(g) clustering_id = np.digitize(clustering, clustering_bins) path_id = np.digitize(path, path_bins) if counts[clustering_id, path_id] < thresh: counts[clustering_id, path_id] += 1 default_feature = torch.ones(1) nx.set_node_attributes(g, default_feature, 'node_feature') graphs.append(g) print(np.sum(counts)) if np.sum(counts) == 8 * 8 * thresh: break with open('smallworld.pkl', 'wb') as file: pickle.dump(graphs, file)
def pl_cluster_new(n, m, p, random_seed=None): Gw=nx.powerlaw_cluster_graph(n, m, p, seed=random_seed) Gs=nx.Graph() Gs.add_nodes_from(Gw.nodes(),state=1.0) Gs.add_edges_from(Gw.edges(),weight=1.0) ##remove self-edges Gs.remove_edges_from(Gs.selfloop_edges()) return Gs
def pl_cluster_new(n, m, p, random_seed=None): Gw = nx.powerlaw_cluster_graph(n, m, p, seed=random_seed) Gs = nx.Graph() Gs.add_nodes_from(Gw.nodes(), state=1.0) Gs.add_edges_from(Gw.edges(), weight=1.0) ##remove self-edges Gs.remove_edges_from(Gs.selfloop_edges()) return Gs
def __init__(self, graph_type, cur_n, p, m=None, seed=None): if graph_type == 'erdos_renyi': self.g = nx.erdos_renyi_graph(n=cur_n, p=p, seed=seed) elif graph_type == 'powerlaw': self.g = nx.powerlaw_cluster_graph(n=cur_n, m=m, p=p, seed=seed) elif graph_type == 'barabasi_albert': self.g = nx.barabasi_albert_graph(n=cur_n, m=m, seed=seed) elif graph_type == 'gnp_random_graph': self.g = nx.gnp_random_graph(n=cur_n, p=p, seed=seed)
def create_scale_free_graph(N_nodes,p_edge,n_infected): #scale free and small world #Growing Scale-Free Networks with Tunable Clustering n = N_nodes m = int(0.5*p_edge*N_nodes) p = 1.0 #Random graph #p_coop is the fraction of cooperators G = nx.powerlaw_cluster_graph(n,m,p) return set_graph_strategies(G, n_infected)
def topo_pl(nodes): bws = [1,2,3,4,5,6,7,8,9] network = nx.powerlaw_cluster_graph(nodes,2,0.13) g = nx.Graph() g.add_nodes_from(network.nodes()) for link in network.edges(): bw = random.choice(bws) g.add_edge(link[0],link[1],{'weight':bw}) g.add_edge(link[1],link[0],{'weight':bw}) return g
def gen_graph(self, num_min, num_max): cur_n = np.random.randint(num_max - num_min + 1) + num_min if self.g_type == 'erdos_renyi': g = nx.erdos_renyi_graph(n=cur_n, p=0.15) elif self.g_type == 'small-world': g = nx.connected_watts_strogatz_graph(n=cur_n, k=8, p=0.1) elif self.g_type == 'barabasi_albert': g = nx.barabasi_albert_graph(n=cur_n, m=4) elif self.g_type == 'powerlaw': g = nx.powerlaw_cluster_graph(n=cur_n, m=4, p=0.05) return g
def gen_graph(opt): max_n = int(opt['max_n']) min_n = int(opt['min_n']) cur_n = np.random.randint(max_n - min_n + 1) + min_n if opt['g_type'] == 'erdos_renyi': g = nx.erdos_renyi_graph(n = cur_n, p = 0.15) elif opt['g_type'] == 'powerlaw': g = nx.powerlaw_cluster_graph(n = cur_n, m = 4, p = 0.05) elif opt['g_type'] == 'barabasi_albert': g = nx.barabasi_albert_graph(n = cur_n, m = 4) return g
def gen_graph(self): cur_n = np.random.randint(self.min_nodes, self.max_nodes) if self.graph_type == 'erdos_renyi': return nx.erdos_renyi_graph(n=cur_n, p=0.15) elif self.graph_type == 'small-world': return nx.connected_watts_strogatz_graph(n=cur_n, k=8, p=0.1) elif self.graph_type == 'barabasi_albert': return nx.barabasi_albert_graph(n=cur_n, m=4) elif self.graph_type == 'powerlaw': return nx.powerlaw_cluster_graph(n=cur_n, m=4, p=0.05) raise ValueError(f'{self.graph_type} graph type is not supported yet')
def initialize(): global g # g = nx.karate_club_graph() g=nx.powerlaw_cluster_graph(100,3,0.3) g.pos = nx.spring_layout(g) for i in g.nodes_iter(): if random() < .3: g.node[i]['state'] = 1 elif random() < .3: g.node[i]['state'] = 2 elif random() < .3: g.node[i]['state'] = 3 else: g.node[i]['state'] = 0
def main(): parser = argparse.ArgumentParser() parser.add_argument('--input', help="Input file path", default=None) parser.add_argument( '-o', '--output', help="Output file path", default=None) parser.add_argument( '--page-rank', help="Adds page rank to the output network", action='store_const', default=False, const=True) parser.add_argument( '--eigenvector', help="Adds eigenvector centrality to the output network", action='store_const', default=False, const=True) parser.add_argument( '--betweenness', help="Adds betweenness centrality to the output network", action='store_const', default=False, const=True) namespace = parser.parse_args() if namespace.input is None: graph = nx.powerlaw_cluster_graph(100, 8, 0.1) else: graph = read_network(namespace.input) if namespace.page_rank: page_rank_dictionary = nx.pagerank(graph) for node, rank in page_rank_dictionary.iteritems(): graph.add_node(node, pagerank=rank) if namespace.eigenvector: eig_dictionary = nx.eigenvector_centrality(graph) for node, rank in eig_dictionary.iteritems(): graph.add_node(node, eigenvector_centrality=rank) if namespace.betweenness: betw_dictionary = nx.betweenness_centrality(graph) for node, rank in betw_dictionary.iteritems(): graph.add_node(node, betweenness=rank) graph_dict = convert_network(graph) if namespace.output is None: out = sys.stdout else: out = file(namespace.output, 'w') json.dump(graph_dict, out)
def __init__(self, vertices, m, c, seed = int(time.time())): """ Construct a Powerlaw Clustered network. The vertices argument contains objects of type Vertex representing the vertices of the network. The m argument specifies the number of attachments made from the new vertex to the existing vertices during the network construction process. The c argument specifies the desired level of clustering. The seed argument is the seed for the random number generator used to build the network. Note that the desired level of clustering may not always be achievable. """ self.vertices = vertices self.m = m self.c = c self.seed = seed p = 0.0 g = networkx.powerlaw_cluster_graph(len(vertices), m, p, seed = seed) while p < 1 and networkx.average_clustering(g) < c: g = networkx.powerlaw_cluster_graph(len(vertices), m, p) p += 0.01 self.g = g self.__adj_list_map__ = {}
def emulate(tmp_file, size=1000): g = nx.DiGraph(nx.powerlaw_cluster_graph(size, 3, 0.001)) N = len(g.nodes()) for node in g.nodes(): outlinks = g.out_edges(nbunch=[node]) outlinks = map(str, [n2 for n1, n2 in outlinks]) if not outlinks: value = 'pr_results,%s,%s' % (1.0/N, N) tmp_file.write('%s\t%s\n' % (node, value)) else: outlinks_str = ','.join(outlinks) value = 'pr_results,%s,%s,' % (1.0/N, N) value += outlinks_str tmp_file.write('%s\t%s\n' % (node, value)) return tmp_file
def __init__(self, vertices, m, p, seed = int(time.time())): """ Construct a Powerlaw Clustered network. The vertices argument contains objects of type Vertex representing the vertices of the network. The m argument specifies the number of attachments made from the new vertex to the existing vertices during the network construction process. The p argument specifies the probability of adding a triangle after adding a random edge. The seed argument is the seed for the random number generator used to build the network. """ self.vertices = vertices self.m = m self.p = p self.seed = seed self.g = networkx.powerlaw_cluster_graph(len(vertices), m, p, seed = seed) self.__adj_list_map__ = {}
def add_edges_to_groups(output_graph, groups_list, edges_to_add, prob, level): total_groups = len(groups_list) edges_per_node = max((3 - level), 1) triangle_prob = 0.1*level if False: random_graph = nx.random_regular_graph(int(total_groups/3), total_groups) else: random_graph = nx.powerlaw_cluster_graph(total_groups, edges_per_node, triangle_prob, random.random()*10) random_edges = random_graph.edges() for edge in random_edges: e0 = edge[0] e1 = edge[1] if random.random() > 0.3: e0, e1 = e1, e0 print("adding level{} edges between group{} and group{}".format(level, e0, e1)) add_edges_to_two_groups(output_graph, groups_list[e0], groups_list[e1], edges_to_add, prob)
def GraphType(num_nodes, str, p=0.05, m=3): """ :param num_nodes: the number of nodes of the graph (if that option is available) :param str: the type of graph that is used. We have 'erdos' an erdos renyi graph 'powerlaw' a graph with powerlaw degree distribution 'enron' a social network graph loaded from http://snap.stanford.edu/data/email-Enron.html. (36692 nodes) 'karateclub' some karate club graph 'women' women social network :return: the graph """ if str == 'erdos': graph = nx.erdos_renyi_graph(num_nodes, p) elif str == 'powerlaw': graph = nx.powerlaw_cluster_graph(num_nodes, m, p) elif str == 'enron': graph = nx.Graph() edges = np.loadtxt('Enron.txt',skiprows=4) graph.add_edges_from(edges) elif str == 'karateclub': graph = nx.karate_club_graph() elif str == 'women': graph = nx.davis_southern_women_graph() elif str == 'pair': graph = nx.DiGraph() graph.add_edge(0,1) graph.add_edge(1,0) elif str == 'star': graph = nx.star_graph(num_nodes) elif str == 'cycle': graph = nx.cycle_graph(num_nodes) elif str == 'config': max_degree = int(num_nodes/5) #Create some degrees degrees = np.asarray(np.round(np.exp(np.log(max_degree) * np.random.uniform(size=num_nodes))), np.int) #Ensure the total number of degrees is even if sum(degrees) % 2 != 0: degrees[np.random.randint(num_nodes)] += 2 * np.random.randint(2) - 1 #Create a graph and apply the configuration model graph = nx.Graph() graph = nx.configuration_model(degrees, graph) graph = graph.to_directed() return graph
def create_graph(self, params): # case statements on type of graph if self.type == 'small_world': self.graph = nx.watts_strogatz_graph(int(params[0]), int(params[1]), float(params[2]), None if len(params) < 4 else int(params[3])) cg.SWC += 1 self.idx = cg.SWC self.path = 'smallWorldGraphs' elif self.type == 'small_world_connected': self.graph = nx.connected_watts_strogatz_graph(int(params[0]), int(params[1]), float(params[2]), 100 if len(params) < 4 else int(params[3]), None if len(params) < 5 else int(params[4])) cg.SWCC += 1 self.idx = cg.SWCC self.path = 'smallWorldConnectedGraphs' elif self.type == 'small_world_newman': self.graph = nx.newman_watts_strogatz_graph(int(params[0]), int(params[1]), float(params[2]), None if len(params) < 4 else int(params[3])) cg.SWNC += 1 self.idx = cg.SWNC self.path = 'smallWorldNewmanGraphs' elif self.type == 'power_law': self.graph = nx.powerlaw_cluster_graph(int(params[0]), int(params[1]), float(params[2]), None if len(params) < 4 else int(params[3])) cg.PLC += 1 self.idx = cg.PLC self.path = 'powerLawGraphs' elif self.type == 'power_law_tree': self.graph = nx.random_powerlaw_tree(int(params[0]), 3 if len(params) < 2 else float(params[1]), None if len(params) < 3 else int(params[2]), 100 if len(params) < 4 else int(params[3])) cg.PLTC += 1 self.idx = cg.PLTC self.path = 'powerLawTreeGraphs' elif self.type == 'random_graph': self.graph = nx.gnm_random_graph(int(params[0]), int(params[1]), None if len(params) < 3 else int(params[2]), False if len(params) < 4 else bool(params[3])) cg.RGC += 1 self.idx = cg.RGC self.path = 'randomGraphs' elif self.type == 'erdos_renyi_random': self.graph = nx.erdos_renyi_graph(int(params[0]), float(params[1]), None if len(params) < 3 else int(params[2]), False if len(params) < 4 else bool(params[3])) cg.ERRC += 1 self.idx = cg.ERRC self.path = 'erdosRenyiRandomGraphs' else: print 'GRAPH TYPE:', self.type raise Exception('Invalid Type of Graph input into argv[2]')
dataset_name = "output" if len(sys.argv) == 6: dataset_name = sys.argv[5]; image_name = dataset_name + ".png" dot_name = dataset_name + ".dot" pckl_name = dataset_name + ".pckl" neo4j_data = dataset_name + "-neo4j.txt" total_edges = 0 nodes_per_group = int(sys.argv[1]) random_edges_per_node = int(sys.argv[2]) triangle_prob = float(sys.argv[3]) edge_addition_prob = float(sys.argv[4]) G = nx.powerlaw_cluster_graph(nodes_per_group, random_edges_per_node, triangle_prob,10) Gnode_count = G.number_of_nodes() Gnodes = G.nodes() print "Edges in group G: ", G.number_of_edges() H = nx.powerlaw_cluster_graph(nodes_per_group, random_edges_per_node, triangle_prob,10) H = nx.convert_node_labels_to_integers(H,first_label=nodes_per_group) Hnodes = H.nodes() Hnode_count = H.number_of_nodes() print "Edges in group H: ", H.number_of_edges() I = nx.powerlaw_cluster_graph(nodes_per_group, random_edges_per_node, triangle_prob,10) I = nx.convert_node_labels_to_integers(I,first_label=nodes_per_group*2) Inodes = I.nodes() Inode_count = I.number_of_nodes() print "Edges in group I: ", I.number_of_edges()
#!/usr/bin/env python import networkx as nx N = 100 E = int(round((N**2)/1.5)) dense = nx.dense_gnm_random_graph(N, E) nx.write_edgelist(dense, 'dense.dat', data=False) karate = nx.karate_club_graph() nx.write_edgelist(karate, 'karate.dat', data=False) plaw = nx.powerlaw_cluster_graph(N * 10, N/10, 0.3) nx.write_edgelist(plaw, 'plaw.dat', data=False)
# Convert to networkx graph object G = network_gen.import_weights_to_graph(W_net_dict) N = len(G.nodes()) # These are the new params, derived from adjusting the proverbial knobs G_ER = nx.erdos_renyi_graph(N,0.087) G_WS = nx.watts_strogatz_graph(N,36,0.159) #G_BA = standard_graphs.symmetric_BA_graph(N,20,0.52) G_BA = nx.barabasi_albert_graph(N,20) G_BA = standard_graphs.symmetric_BA_graph(N,20,0.52) #G_BA = nx.barabasi_albert_graph(N,19) G_PWC = nx.powerlaw_cluster_graph(N,19,1) print 'Generating biophysical graph...' G_BIO,A,D = aux_random_graphs.biophysical_graph(N=426,N_edges=7804,L=1.,power=1.5,mode=0) if plot_functions: # Here you can specify which plotting function you want to run. # It needs to take a single graph as input! plotfunction = plot_net.plot_clustering_coeff_pdf Fig, axs = plt.subplots(2,2, facecolor=[1,1,1]) plotfunction(axs[0,0],G) #plotfunction(axs[0,1],G_PWC) plotfunction(axs[0,1],G_ER) plotfunction(axs[1,0],G_BA)
class Node(Node): def activate(self): pass class Simulation(simulation.Simulation): class configurator_type(configurators.NXGraphConfigurator): node_type = Node node_options = {} # trck.track_class(core.Agent, resolution_level=5) # trck.track_class(Node, resolution_level=5) st.print_diff() g = nx.powerlaw_cluster_graph(5000, 20, 0.1) # trck.track_object(g, resolution_level=5) # trck.create_snapshot('Graph only') st.print_diff() sim = Simulation() sim.run(starting_graph=g) st.print_diff() # trck.create_snapshot('With agents') # trck.stats.print_summary() from pympler import refbrowser import types
row_labels = range(n) col_labels = range(n) G, W_net, _ = aux_random_graphs.biophysical_graph(n, N_edges=7804, L=1, power=1.5, mode=0) # Put everything in a dictionary net_dict = {'row_labels': row_labels, 'col_labels': col_labels, 'data': W_net} else: n = 426 row_labels = range(n) col_labels = range(n) # Create networkx graph if network_type == 'powerlaw_cluster': temp_G = nx.powerlaw_cluster_graph(n=n, m=19, p=1) elif network_type == 'scale_free': temp_G = nx.barabasi_albert_graph(n=n, m=19) elif network_type == 'random': temp_G = nx.erdos_renyi_graph(n, 0.123) elif network_type == 'small_world': # small_world temp_G = nx.watts_strogatz_graph(n, 36, 0.159) else: print 'Network type not recognized' # Set weights for all the egdes wts = {} for e in temp_G.edges(): wts[e] = 1. nx.set_edge_attributes(temp_G, 'weight', wts)
with open(combined_dir, 'rb') as f: adj, features = pickle.load(f) fb_graphs['combined'] = (adj, features) ### ---------- Create Random NetworkX Graphs ---------- ### # Dictionary to store all nx graphs nx_graphs = {} # Small graphs N_SMALL = 200 nx_graphs['er-small'] = nx.erdos_renyi_graph(n=N_SMALL, p=.02, seed=RANDOM_SEED) # Erdos-Renyi nx_graphs['ws-small'] = nx.watts_strogatz_graph(n=N_SMALL, k=5, p=.1, seed=RANDOM_SEED) # Watts-Strogatz nx_graphs['ba-small'] = nx.barabasi_albert_graph(n=N_SMALL, m=2, seed=RANDOM_SEED) # Barabasi-Albert nx_graphs['pc-small'] = nx.powerlaw_cluster_graph(n=N_SMALL, m=2, p=.02, seed=RANDOM_SEED) # Powerlaw Cluster nx_graphs['sbm-small'] = nx.random_partition_graph(sizes=[N_SMALL/10]*10, p_in=.1, p_out=.01, seed=RANDOM_SEED) # Stochastic Block Model # Larger graphs N_LARGE = 1000 nx_graphs['er-large'] = nx.erdos_renyi_graph(n=N_LARGE, p=.01, seed=RANDOM_SEED) # Erdos-Renyi nx_graphs['ws-large'] = nx.watts_strogatz_graph(n=N_LARGE, k=3, p=.1, seed=RANDOM_SEED) # Watts-Strogatz nx_graphs['ba-large'] = nx.barabasi_albert_graph(n=N_LARGE, m=2, seed=RANDOM_SEED) # Barabasi-Albert nx_graphs['pc-large'] = nx.powerlaw_cluster_graph(n=N_LARGE, m=2, p=.02, seed=RANDOM_SEED) # Powerlaw Cluster nx_graphs['sbm-large'] = nx.random_partition_graph(sizes=[N_LARGE/10]*10, p_in=.05, p_out=.005, seed=RANDOM_SEED) # Stochastic Block Model # Remove isolates from random graphs for g_name, nx_g in nx_graphs.iteritems(): isolates = nx.isolates(nx_g) if len(isolates) > 0: for isolate_node in isolates:
#!/usr/bin/env python import numpy as np import matplotlib.pyplot as plt import networkx as nx from math import sqrt from operator import itemgetter import random import Network_solve as ns import sfg as sfg from functions import * import timeit nodes = 30 steps = 20000 G = nx.powerlaw_cluster_graph(nodes, 3, 0.2) np.savetxt("./settings/adjacency.txt", nx.adjacency_matrix(G).todense()) np.savetxt("./settings/mismatch.txt", np.random.randn(steps, nodes)) start = timeit.default_timer() ns.networkSolver(nodes) end = timeit.default_timer() print "time to solve %d timesteps: %2.2f" % (steps, (end - start)) print "average %f sec per step" % ((end - start) / steps)
def generate_PL_graph(N, m, p, filename, directed=True): G = nx.powerlaw_cluster_graph(N, m, p, None, directed) nx.write_edgelist(G, filename, '#', '\t', False, 'utf-8')