def _generate(self): if self.ALWAYS_SAME: np.random.seed(1) # to make all random values same # skills of every person: every person has a list of s elements describing his/her skill values fall in [0-1]. if self.DISTRIBUTION == 'Uniform': self.skills = np.random.rand(self.n, self.s) elif self.DISTRIBUTION == 'Normal': self.skills = np.random.randn(self.n, self.s) * 0.1666 + 0.5 else: raise ValueError('ERROR in DISTRIBUTION value: ' % self.DISTRIBUTION) # risk taking of every person: it is also a value between [0,1]. if self.DISTRIBUTION == 'Uniform': self.risk_takings = np.random.rand(self.n) elif self.DISTRIBUTION == 'Normal': self.risk_takings = np.random.randn(self.n) * 0.1666 + 0.5 # network connectivity (or distance) is a matrix of n*n: we always can for any # graph, compute the shortest path among all nodes # and normalize it between [0,1]. We assume, relationships are not directed. if self.ALWAYS_SAME: # it keeps the same numbers which is helpful for debugging purposes G = nx.to_undirected(nx.scale_free_graph(self.n, seed=1)) else: # it changes the structure every time we run G = nx.to_undirected(nx.scale_free_graph(self.n)) D = nx.floyd_warshall_numpy(G) D /= np.max(D) self.network_connectivity = D
def weighted_DiGraph(n, seed=1.0, mode='random', weights='random', handle_sinks=False, pow_exp=1.0, data_prefix=None): if mode == 'ER': G = nx.erdos_renyi_graph(n, p=0.1, directed=True, seed=seed) elif mode == 'PL': G = nx.scale_free_graph(n * 10, seed=seed) G = nx.DiGraph(G) G.remove_edges_from(G.selfloop_edges()) elif mode == 'BA': G = nx.barabasi_albert_graph(n, 3, seed=None) G = nx.DiGraph(G) elif mode == 'random': G = nx.scale_free_graph(n) G = nx.DiGraph(G) G.remove_edges_from(G.selfloop_edges()) elif data_prefix != None: edgesTS, _, _ = readRealGraph("%s/%s.txt" % (data_prefix, mode)) G = getGraph(edgesTS) G = nx.DiGraph(G) G.remove_edges_from(G.selfloop_edges()) G = nx.DiGraph(getSubgraph(G, n)) else: raise RuntimeError( "You must provide 'data_prefix' to load real datasets.") if handle_sinks: for i in G.nodes(): if G.out_degree(i) == 0: for j in G.nodes(): if i != j: G.add_edge(i, j, weight=1.0) print(nx.info(G)) if weights == 'random': #w = np.random.uniform(1e-5, 1.0, G.number_of_edges()) w = 1 - np.random.power(pow_exp, size=G.number_of_edges()) w /= sum(w) c = 0 for i in G.edges(): G[i[0]][i[1]]['weight'] = w[c] c += 1 elif weights == 'uniform': w = 1.0 / G.number_of_edges() for i in G.edges(): G[i[0]][i[1]]['weight'] = w else: nrm = float(sum(G.out_degree(weight='weight').values())) for i in G.edges(data=True): G[i[0]][i[1]]['weight'] = i[-1]['weight'] / nrm return G
def create_scale_free_graph(n): """Create an undirected and connected scale free graph with n nodes""" _Gsf = nx.Graph(nx.scale_free_graph(n).to_undirected()) while not nx.is_connected(_Gsf): _Gsf = nx.Graph(nx.scale_free_graph(n).to_undirected()) # Copy edges in a new graph and remove [...] Gsf = _Gsf.copy() for u, v in _Gsf.edges(): if u == v: Gsf.remove_edge(u, v) return Gsf
def generate_scale_free_graph(num_nodes=100, active_time_percent=1.0, max_time=3, weight_distribution=(1.0, 1.0)): graph = networkx.scale_free_graph(num_nodes) graph = networkx.DiGraph(graph) for edge in graph.edges(): if edge[0] != edge[1]: graph[edge[0]][edge[1]]['weight'] = random.uniform( weight_distribution[0], weight_distribution[1]) else: graph[edge[0]][edge[1]]['weight'] = 0.001 source, destination = random.sample(graph.nodes(), 2) while not networkx.has_path(graph, source, destination): print source, destination source, destination = random.sample(graph.nodes(), 2) existence_for_node_time = {(source, 0): 1, (destination, max_time): 1} for i in range(1, max_time + 1): existence_for_node_time[(source, i)] = 0 for i in range(0, max_time): existence_for_node_time[(destination, i)] = 0 for node in graph.nodes(): for i in range(0, max_time + 1): if node != source and node != destination: is_active = int(random.random() < active_time_percent) existence_for_node_time[(node, i)] = is_active print len(graph.edges()) return graph, existence_for_node_time, (source, destination)
def main(nodes=30): # Model parameters directory = 'test' globalSharedParameters = {} globalSharedParameters['infection_rate'] = 0.3 globalSharedParameters['inf_dur'] = "self.r.gauss(7, 2)" # Output Parameters statesToMonitor = [INFECTED, SUSCEPTIBLE, RECOVERED] colours = ["r", "--g", ":k"] mapping = {SUSCEPTIBLE: "w", INFECTED: "r", RECOVERED: "0.4"} labels = ["Infected", "Susceptible", "Recovered"] name = "SIR_scale_free" titlePlot = "Simulation on scale free graph, %i trials, %i%% infection prob" \ % (TRIALS, 100 * globalSharedParameters['infection_rate']) titleVisual = "" # Network G = nx.scale_free_graph(nodes) states = [SUSCEPTIBLE for n in G.nodes()] # run simulation simulation = NetworkSimulation(G, states, agentClass, directory, MAX_SIMULATION_TIME, TRIALS, environmentAgent, **globalSharedParameters) simulation.runSimulation() # run visualisation gif = AnimationCreator(directory, name, titleVisual, mapping) gif.create_gif() # plot results p = PlotCreator(directory, name, titlePlot, statesToMonitor, colours, labels) p.plotSimulation()
def __init__(self, seed, link_type = "equal", datac = 0, n=100, h=10, namespace = None): Topo.__init__(self) G=nx.Graph() G=nx.scale_free_graph(n=n, seed=int(seed)) self.topify(G, h, link_type, namespace) if datac > 0: self.add_datacenter(n, h, datac)
def generateScaleFreeNetworks(n): ''' Generate scale-free networks with n number of nodes ''' G_scaleFree = nx.scale_free_graph( n, seed=30 ) # scale free graph with default probabilities (alpha=0.41, beta=0.54, gamma=0.05, delta_in=0.2, delta_out=0, create_using=None,) np.random.seed(0) def setDecimals(x): decimal.getcontext().prec = 10 # 10 decimal points enough return decimal.Decimal(0) + decimal.Decimal(x) # this should include both boundaries as float gets close enough to 1 to make decimal round edges = list(set(G_scaleFree.edges())) scalefree_network = pd.DataFrame(edges, columns=["userID1", "userID0"], dtype=str) scalefree_network = scalefree_network[ scalefree_network["userID0"] != scalefree_network["userID1"]] for action in relationshipTypes: scalefree_network[action] = np.random.uniform( 0, 1, scalefree_network.shape[0]) scalefree_network[action] = scalefree_network[action].apply( lambda x: setDecimals(x)).astype(float) scalefree_inflnetwork = scalefree_network[ scalefree_network.iloc[:, 2:].sum(axis=1) > 0] return scalefree_inflnetwork
def generate_graph_sf(N): ''' Generates a scale-free network. See networkx documentation on the parameters, etc. ''' alpha = 0.01 beta = 0.5 gamma = 0.49 G = nx.scale_free_graph(N, alpha=alpha, beta=beta, gamma=gamma) j = nx.node_link_data(G) nodes = j['nodes'] links = j['links'] node_names = [{"name": 'n%s' % x['id'], "infected": False} for x in nodes] final_links = [] seen_links = set() for link in links: if link['source'] != link['target']: # ignore self-links pairing = (link['source'], link['target']) if not pairing in seen_links: d = { 'source': 'n%s' % link['source'], 'target': 'n%s' % link['target'], } final_links.append(d) seen_links.add(pairing) seen_links.add(pairing[::-1]) return node_names, final_links, None
def run_scalefree(alpha=0.60, beta=0.35, gamma=0.05, delta_in=0.2, delta_out=0, nodes=1000, iterations=1000, epsilon_control=0.1, epsilon_damage=0.001, random_load=True): """ Run on a scale-free graph. Returns (uncontrolled, controlled, df, costs). If random_load is True, load is distributed randomly initially. """ # Generate graph and set up parameters nodes = int(nodes) iterations = int(iterations) G = nx.scale_free_graph(nodes, alpha, beta, gamma, delta_in, delta_out) G = G.to_undirected() # scale_free_graph() creates a digraph # Maximum capacity is a node's degree degrees = nx.degree(G) C = np.array([degrees[i] for i in G.nodes()]) if random_load: p = None else: p = {0: 0.52998, 1: 0.35651, 2: 0.11351} G, L0 = sandpile.initialize_loads(G, p=p, C=C) return do_run(G, L0, C, iterations, epsilon_control, epsilon_damage)
def generate_network(self, filename: str) -> None: """Generates a graph and saves its edgelist into a DataFrame. Parameters ---------- filename: str Name of the network """ n_nodes = self._n_entities graph = nx.scale_free_graph(n_nodes) # Add self-edges with random self activation weights for node in graph.nodes(): graph.add_edge(node, node, weight=2 * np.random.random() - 1) edgelist = [e for e in graph.edges.data()] network_df = pd.DataFrame(columns=["Source", "Dest", "Indicator"]) # Positive or negative influence between genes act_fn = lambda x: "-" if x < 0 else "+" for edge in edgelist: source, dest, weight_dict = edge source_name = self._entity_names[source] dest_name = self._entity_names[dest] weight = weight_dict.get('weight', 2 * np.random.random() - 1) data_to_append = { "Source": source_name, "Dest": dest_name, "Indicator": act_fn(weight) } network_df = network_df.append(data_to_append, ignore_index=True) # Save network file logger.info("Saving network to file {}".format(filename)) network_df.to_csv(filename, sep='\t', index=False, header=False)
def testDegreeComp(): EC = MetabolicNetworkX() EC.load_from_file('ecoli.txt') ST = MetabolicNetworkX() ST.loadXML('MODEL1507180063_url.xml') # Streptococcus thermophilus ST.remove_disconnected() SF = MetabolicNetworkX() SF.mnetwork = nx.scale_free_graph(EC.mnetwork.number_of_nodes(), seed=2424) R = MetabolicNetworkX() R.mnetwork = nx.gnp_random_graph(EC.mnetwork.number_of_nodes(), 0.5, seed=2424) # Erdös–Rényi (ER) model print( 'Comparing Theoretical Scale free and Random Networks with Real Biological Data' ) print('Mean Degree') print(' E.coli: ', EC.mean_degree(), '\n', 'S.thermophilus: ', ST.mean_degree(), '\n', 'Theoretical Scale Free:', SF.mean_degree(), '\n', 'Theoretical Random:', R.mean_degree()) make_probdegree_plot(EC, 'Ecoli') make_probdegree_plot(ST, 'Stermo', 'r') make_probdegree_plot(SF, 'Theoretical Scale Free', 'b') make_probdegree_plot(R, 'Theoretical Random', 'm')
def get_sample(metrictype): g = nx.scale_free_graph(V).to_undirected() # random weight allocations g = get_weightsalloc(g) ## node rank on the basis of egr/weighted spectrum if metrictype == 'egr': ranks = self.get_egrnoderank(g) elif metrictype == 'weightedspectrum': ranks = self.get_wghtspectnoderank(g) # ranks = np.array([2 if ind >= int(0.75*V) else 1 if (ind > int(0.25*V)) and (ind < int(0.75*V)) else 0 for ind in temp_ranks]) ranks = (ranks - min(ranks)) / (max(ranks) - min(ranks)) # ranks = np.array([1/(1+np.exp(-1*ind)) for ind in temp_ranks]) # input node feature with degree degfeat = (np.sum(nx.adj_matrix(g).todense(), axis=1)) x = np.reshape(np.arange(V), (V, 1)) Idenfeat = enc.fit_transform(x).toarray() feat = np.concatenate((Idenfeat, degfeat), axis=1) # return temp_input, ranks, feat, g return ranks, feat, g
def main(): G = nx.complete_graph(10) #完全グラフ G2 = nx.barbell_graph(10, 10) #ようわからん G3 = nx.watts_strogatz_graph(100, 15, 0.1) #small world graph #watts_strogatz_graph(n,k,p) n: number of node, k:nearest neoghbors, G4 = nx.complete_bipartite_graph(3, 3) #完全二部グラフ G5 = nx.scale_free_graph(50) G6 = nx.newman_watts_strogatz_graph(100, 10, 0.05) G7 = nx.binomial_graph(10, 0.2) # z=[int(random.gammavariate(alpha=9.0,beta=2.0)) for i in range(6)] # G8 = nx.configuration_model(z) # aseq = [1,2,1] # bseq = [2,1,1] # G8 = nx.configuration_model(aseq,bseq) G8 = bp.random_graph(5, 5, 0.5) pos = nx.spring_layout(G6) # pos = nx.circular_layout(G5) plt.axis('off') nx.draw(G6, pos, with_labels=False) plt.show()
def scale_free_network(n_nodes): """ returns the adjagency matrix of a scale free network the network is undirected and weighted """ m = np.zeros((n_nodes, n_nodes)) G = nx.scale_free_graph(n_nodes) # ritorna diretto G = nx.to_undirected(G) A = nx.adjacency_matrix(G) rows = A.nonzero()[0] columns = A.nonzero()[1] print(rows.shape, columns.shape) for i in range(rows.shape[0]): l, k = rows[i], columns[i] r = np.random.uniform(0, 1) m[l, k] = r m[k, l] = r return csr_matrix(m)
def semantic_network(n, seed=1): #G = nx.scale_free_graph(n, alpha=0.05, gamma=0.41, delta_out=0.2, delta_in=0, seed=seed) G = nx.scale_free_graph(n,seed=seed) G.remove_edges_from(G.selfloop_edges()) G = nx.DiGraph(G) return G
def get_system(N, v_in=5, D=1): assert N >= 3, 'Cannot add FFL' graph = nx.DiGraph(nx.scale_free_graph(N)) # add FFL graph.remove_edges_from(itertools.product(range(3), repeat=2)) graph.add_edges_from([(0, 1), (1, 2), (0, 2)]) jacobian = np.asarray(nx.to_numpy_matrix(graph)).T np.fill_diagonal(jacobian, -1) external_influence = np.random.randint(0, 2, size=N) * v_in fluctuation_vector = np.random.randint(0, 2, size=N) * D initial_state = np.ones(N) # drive FFL external_influence[0] = v_in fluctuation_vector[0] = D external_influence[[1, 2]] = 0 fluctuation_vector[[1, 2]] = 0 jacobian[0, 0] = -2 jacobian[1, 1] = -2 jacobian[2, 1] = 2 # generate final system system = SDESystem(jacobian, fluctuation_vector, external_influence, initial_state) #system.save('cache/embedded_system.pkl') return system
def main(): output_dir = os.path.join("datasets", "synthetic_scale_free") if not os.path.exists(output_dir): os.makedirs(output_dir, exist_ok=True) N = 1000 for seed in range(30): d = os.path.join(output_dir, "{:02d}".format(seed)) if not os.path.exists(d): os.makedirs(d, exist_ok=True) g = nx.DiGraph(nx.scale_free_graph(N, seed=seed)) print("seed", seed, "number of nodes", len(g), "number of edges", len(g.edges)) nx.set_edge_attributes(g, name="weight", values=1.) nx.write_edgelist(g, os.path.join(d, "edgelist.tsv.gz"), delimiter="\t", data=["weight"]) A = nx.adjacency_matrix(g, nodelist=sorted(g)) save_npz(os.path.join(d, "graph.npz"), A)
class GraphType: BALANCED_TREE = ('Balanced tree', _balanced_tree) BARBELL = ('Barbell', lambda n: nx.barbell_graph(int(n*.4), int(n*.3))) CIRCULAR_LADDER = ('Circular ladder', lambda n: nx.circular_ladder_graph(int(n/2))) COMPLETE = ('Complete', lambda n: nx.complete_graph(int(n))) COMPLETE_BIPARTITE = ('Complete bipartite', lambda n: nx.complete_bipartite_graph(int(n*.6), int(n*.4))) CYCLE = ('Cycle', lambda n: nx.cycle_graph(int(n))) GRID = ('Grid', lambda n: nx.grid_graph([int(np.sqrt(n))]*2)) HYPERCUBE = ('Hypercube', _hypercube) LADDER = ('Ladder', lambda n: nx.ladder_graph(int(n/2))) LOBSTER = ('Lobster', lambda n: nx.random_lobster(int(n / (1 + .7 + .7*.5)), .7, .5)) LOLLIPOP = ('Lollipop', lambda n: nx.lollipop_graph(int(n/2), int(n/2))) PATH = ('Path', lambda n: nx.path_graph(int(n))) REGULAR = ('Regular', lambda n: nx.random_regular_graph(np.random.randint(10)*2, n)) SCALEFREE = ('Scale-free', lambda n: nx.scale_free_graph(int(n))) SHELL = ('Shell', lambda n: nx.random_shell_graph([(int(n*.1), int(n*.1), .2), (int(n*.3), int(n*.3), .8), (int(n*.6), int(n*.6), .5)])) STAR = ('Star', lambda n: nx.star_graph(int(n - 1))) WAXMAN = ('Waxman', lambda n: nx.waxman_graph(int(n))) WHEEL = ('Wheel', lambda n: nx.wheel_graph(int(n))) all = (BALANCED_TREE, BARBELL, CIRCULAR_LADDER, COMPLETE, COMPLETE_BIPARTITE, CYCLE, GRID, HYPERCUBE, LADDER, LOBSTER, LOLLIPOP, PATH, REGULAR, SCALEFREE, SHELL, STAR, WAXMAN, WHEEL)
def scale_free_graph(n, alpha=0.41, beta=0.54, gamma=0.05, delta_in=0.2, delta_out=0, create_using=None, seed=None): G = nx.scale_free_graph(n, alpha=alpha, beta=beta, gamma=gamma, delta_in=delta_in, delta_out=delta_out, create_using=create_using, seed=seed) return G
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 __init__(self, N): self.name = 'Default directed Scale-Free random graph DSF_%i' % N self.N = N self.G = nx.scale_free_graph(N) self.params = dict() self.state = None
def generate_graph_scale_free_structure( output_gml='data/toy_scale_free_network.gml', ): num_nodes = 500 g = nx.Graph(nx.scale_free_graph(num_nodes)) modularity_classes = compute_graph_modularity(g=g) nodes_to_modularity = {} for n in modularity_classes: if not nodes_to_modularity.has_key(modularity_classes[n]): nodes_to_modularity[modularity_classes[n]] = [] nodes_to_modularity[modularity_classes[n]].append(n) sorted_classes = sorted(nodes_to_modularity.items(), key=lambda x: len(x[1]), reverse=True) # Assign trump or hillary status count = 0 for c in sorted_classes: if count % 3 == 1: l = 0 elif count % 3 == 2: l = 1 else: l = 7 attr_dict = dict(zip(c[1], [l for i in range(0, len(c[1]))])) nx.set_node_attributes(g, 'trumporhillary', attr_dict) count += 1 # Output gml nx.write_gml(g, output_gml)
def __init__(self, seed, link_type="equal", servers=0, n=100, h=0, namespace=None): Topo.__init__(self) G = nx.Graph() if not seed: seed = random.randint(1, 10000) G = nx.scale_free_graph(n=n, seed=int(seed)) G.remove_edges_from(G.selfloop_edges()) self.topify(G, h, link_type, namespace) if servers > 0: self.add_server(h, servers) self.trim() print( "----------- Check cardinality of elements in simulation -----------" ) print(self.switches()) print(self.hosts()) print(self.links())
def montar(self, tipo, quantidade_nós, taxa_conexão): if(tipo == "gnp"): self._g = nx.fast_gnp_random_graph(quantidade_nós, taxa_conexão) print("G(n,p): qtd_nós = %d e taxa = %f" %(quantidade_nós, taxa_conexão)) else: self._g = nx.scale_free_graph(quantidade_nós).to_undirected() print("Livre de Escala: qtd_nós = %d" %(quantidade_nós)) nós = self._g.nodes(data=True) self._adicionar_tipo(nós[0], True) for i in range(1, len(nós)): self._adicionar_tipo(nós[i]) latência_máxima = 1 #conexão entre duas placas geralment é menor que 1ms transmissão_máxima = 1000 #Mbps for aresta in self._g.edges(data=True): latência = np.random.rand() * latência_máxima transmissão = np.random.rand() * transmissão_máxima latência_efetiva = latência/(1 - transmissão/transmissão_máxima) aresta[2]["latência"] = latência aresta[2]["latência_efetiva"] = latência_efetiva self.latência_efetiva_média = nx.average_shortest_path_length(self._g, weight="latência_efetiva")
def simulate_network(n_genes, beta, delta, verbose=True): # makes scale-free networks t_0 = time.time() alpha = (1.0 - beta) / 2 gamma = (1.0 - beta) / 2 n_neigh = [] G = nx.scale_free_graph(n_genes, alpha=alpha, beta=beta, gamma=gamma, delta_in=delta, delta_out=delta) if verbose: print("\tgamma:", 1 + (1.0 + delta * (alpha + gamma)) / (alpha + beta)) # convert to undirected, with no self-loops or duplicated edges G = G.to_undirected() G.remove_edges_from(G.selfloop_edges()) G = nx.Graph(G) # node degree distribution for n in G.nodes(): n_neigh.append(len(G[n].keys())) tmp = plt.hist(n_neigh, range=(1, 100), bins=50, density=True) plt.show() if verbose: print_network_stats(G) print("\tmin and max node degree: %s,%s" % (max(n_neigh), min(n_neigh))) print("runtime:", round(time.time() - t_0, 2), "s", file=sys.stderr) return G
def get_overlay_topology(N, f_name=None): g = nx.scale_free_graph(N) g = g.to_undirected() cg_list = nx.connected_component_subgraphs(g) if f_name: save_graph(cg_list[0], f_name) # zdump(np.asarray(nx.to_numpy_matrix(cg_list[0])), 'overlay_adj.pkz') return nx.to_scipy_sparse_matrix(cg_list[0])
def draw_scale_free(n): G = nx.scale_free_graph(n) # Generate scale free network with n nodes. A = np.zeros((n, n)) for i in range(n): for j in range(i, n): if j in G[i]: A[i][j] = 1 return A, G
def generate_scale_free(params={'n': 100}): if 'seed' not in params.keys(): params['seed'] = None G = nx.scale_free_graph(params['n']) G = G.to_undirected() return G, None
def test_read_from_nx(self): import networkx as nx gnx = nx.DiGraph(nx.scale_free_graph(1000)) glnx = lightnx.DiGraph() glnx.add_edges_from(gnx.edges()) assert_equals(set(glnx.edges()), set(gnx.edges())) assert_equals(set(glnx.successors(786)), set(gnx.successors(786))) assert_equals(set(glnx.successors(0)), set(gnx.successors(0))) assert_equals(set(glnx.predecessors(678)), set(gnx.predecessors(678)))
def graph_generator(): import networkx as nx G = nx.scale_free_graph( 1000, alpha=0.43, beta=0.56, gamma=0.01 ) ######## here we make a scale free network which is directed :) please notice : list(G.predecessors(n)) gives us the list of nodes that are following of node n, ie they can cause a change in state of node n and in the graph there is a arrow from them to node n, and list(G.neighbors(n)) gives us the list of nodes that are followers of node n, ie node n can cause a change in state of them and in the graph there is a arrow from node n to them pos = nx.spring_layout( G ) #this command makes a layout of position of all nodes (instead of spring_layout you can use fruchterman_reingold_layout or other layouts so you will have different figures for graph) ,since we want to have different color for different states of nodes so we have to first make a layout then in graph draw function we make node by different colores,in fact ( I seperated this command and also above command (G=nx.Graph()) from the function of graph draw for two reasons : 1- seperating pos command causes we have a fixed layout for all graph draw (for example if initial node is located in south west of picture of graph(in graph draw plot)then for any time we plot graph again (for example for different timesteps) then the initial infected node is still in south west of graph plot, so we can see spread of rumor and its expand from south west of graph during different timesteps 2- by seperating graph generator function (G = nx.Graph command) we save time because we perform this command only one time and for any times that we plot graph we would not use this command again, so plots will be made fastly return G, pos
def scale_free(n, alpha=0.7, beta=0.25, delta_in=0.2, delta_out=0.2): g = nx.scale_free_graph(n, alpha=alpha, beta=beta, delta_in=delta_in, delta_out=delta_out) g = nx2graph(g) g = gtranspose(g) addAring(g) return g
def SF(self, n): return nx.scale_free_graph(n, alpha=0.01, beta=0.495, gamma=0.495, delta_in=0, delta_out=0.2, create_using=None, seed=None)
def setUp(self): print("setUp") tt = test_tools.TestTools(BASE, VERBOSE) self.g1 = nx.scale_free_graph(10) cyjs1 = test_tools.TestTools.networkx_to_cyjs(self.g1) job_id = tt.submit_network_to_service('network_service_1/rt1', cyjs1) res = tt.get_result(job_id, SLEEP_INTERVAL, 10) cyjs2 = res.json() self.g2 = tt.cyjs_to_networkx(cyjs2)
def setUp(self): print("setUp") tt = test_tools.TestTools(BASE, VERBOSE) self.g1 = nx.scale_free_graph(10) cyjs1 = test_tools.TestTools.networkx_to_cyjs(self.g1) job_id = tt.submit_network_to_service('network_service_1/rt1', cyjs1) res = tt.get_result(job_id, SLEEP_INTERVAL, 10) cyjs2 = res.json() self.g2 = tt.cyjs_to_networkx( cyjs2 )
class TestEstadoIncubandoSism(unittest.TestCase): grafo = nx.scale_free_graph(100) modelo = crear_modelo_SISM(grafo, tiempo_incubacion=1, tiempo_inf_mild=0, tiempo_inf_grave=2, probabilidad_de_estar_incubando=1, probabilidad_deceso=1, probabilidad_riesgo=0, probabilidad_infecc_grave_riesgo=0, probabilidad_infecc_grave=1, probabilidad_deceso_riesgo=0) nodo = 0 def test_el_estado_se_instancia_correctamente(self): estado = EstadoInfectadoMildSISM(tiempo_infeccion=5) self.assertEqual(estado.tiempo_infeccion, 5) self.assertEqual(estado.__class__.__name__, ESTADO_INFECTADO_MILD) def test_al_transicionar_el_tiempo_de_infeccion_se_reduce_una_unidad(self): estado = EstadoInfectadoMildSISM(tiempo_infeccion=5) self.grafo.nodes[self.nodo]['riesgo'] = False self.grafo.graph['prob_de_deceso'] = 0 nuevo_estado = estado.transicionar(self.nodo, self.grafo) self.assertEqual(nuevo_estado.tiempo_infeccion, 4) def test_al_transicionar_si_el_tiempo_de_infeccion_no_es_cero_el_estado_no_cambia( self): estado = EstadoInfectadoMildSISM(tiempo_infeccion=5) self.grafo.nodes[self.nodo]['riesgo'] = False self.grafo.graph['prob_de_deceso'] = 0 nuevo_estado = estado.transicionar(self.nodo, self.grafo) self.assertEqual(nuevo_estado.__class__.__name__, ESTADO_INFECTADO_MILD) def test_cuando_el_tiempo_de_infeccion_llega_a_cero_el_estado_pasa_a_susceptible( self): estado = EstadoInfectadoMildSISM(tiempo_infeccion=1) self.grafo.nodes[self.nodo]['riesgo'] = False self.grafo.graph['prob_de_deceso'] = 0 nuevo_estado = estado.transicionar(self.nodo, self.grafo) self.assertEqual(nuevo_estado.__class__.__name__, ESTADO_SUSCEPTIBLE)
def ajax_build_graph_view(request, graph_id): graph = get_object_or_404(Graph, id=graph_id) size = graph.size graph_type = graph.graph_type if graph_type == 'random': G = nx.gnp_random_graph(size,0.1) else: G = nx.scale_free_graph(size) vega_graph = build_vega_graph(G) return HttpResponse(vega_graph, mimetype="text/javascript")
def run(self): # Run simulation for several type of networks, in this case Erdos-Renyi and Random Network self.networks = [ { 'network': nx.scale_free_graph(n = self.nodes), 'name': 'ScaleFree' }, { 'network': nx.erdos_renyi_graph(n = self.nodes, p = 0.1), # 0.2, 0.5 'name': 'ErdosRenyi' }, { 'network': nx.random_regular_graph(n = self.nodes, d = 10), 'name': 'RandomNetwork' } ] for network in self.networks: nxgraph = network['network'] graph = helper.convert_nxgraph_to_dict(nxgraph) # write network in pajek filename = 'pajek/'+ network['name'] + '_' + str(self.nodes) + '.net' nx.write_pajek(nxgraph, filename) for mu in self.mu_values: print 'Starting...' start_time = time.time() # B beta (at least 51 values, B=0.02) beta = 0.0 betas = [] averages = [] for i in range(0, 51): start_time_beta = time.time() sis_initial_model = sis.SIS(graph, mu, beta, self.p0) simulation = mc.MonteCarlo(sis_initial_model, self.rep, self.t_max, self.t_trans) total_average = simulation.run() total_time_beta = time.time() - start_time_beta betas.append(beta) averages.append(total_average) print 'B: {}, average: {}, time: {}s'.format(beta, total_average, total_time_beta) beta += 0.02 total_time = time.time() - start_time print 'total time: {}'.format(total_time) # plot results and save in file helper.plot_results(network['name'], self.nodes, mu, betas, averages) helper.write_results(network['name'], self.nodes, mu, betas, averages) break
def test_networkx_empty_edge_attribute(self): print('\n---------- Edge Att Test 2 Start -----------\n') g = nx.scale_free_graph(5) cyjs = util.from_networkx(g) # print(json.dumps(cyjs, indent=4)) # There is only one edge, so this should be OK... edge = cyjs['elements']['edges'][0] print(json.dumps(edge, indent=4)) self.assertEqual(3, len(edge['data']))
def make_sf(n = 200, alpha = .41, beta = .54, gamma = .05): g0 = nx.scale_free_graph(n = n, alpha = alpha, beta = beta, gamma = gamma) g = nx.DiGraph() g.add_weighted_edges_from([[e[0],e[1],edge_weight_fun()] for e in g0.edges()]) return g
def semantic_network(n, seed=1): #G = nx.scale_free_graph(n, alpha=0.05, gamma=0.41, delta_out=0.2, delta_in=0, seed=seed) G = nx.scale_free_graph(n,seed=seed) G.remove_edges_from(G.selfloop_edges()) G = nx.DiGraph(G) print G print "Max out: ", max(G.out_degree(G.nodes_iter()).values()) print G.out_degree(G.nodes_iter()) print "Max in: ", max(G.in_degree(G.nodes_iter()).values()) print G.in_degree(G.nodes_iter()) return G
def randomNetwork(nodesNum=5): """ :returns: @todo """ edge_set=set() rn=networkx.scale_free_graph(nodesNum) for (s,t,a) in rn.edges(data=True): if s==t: rn.remove_edge(s,t) continue if (s,t) not in edge_set: edge_set.add((s,t)) else: rn.remove_edge(s,t) rn2=networkx.DiGraph() for (s,t) in rn.edges(): rn2.add_edge(str(s), str(t)) return rn2
def main(nodes=30): # Model parameters directory = 'test' globalSharedParameters = {} globalSharedParameters['infection_rate'] = 0.3 globalSharedParameters['inf_dur'] = "7" # Network and initial states G = nx.scale_free_graph(nodes) states = [SUSCEPTIBLE for n in G.nodes()] # run simulation simulation = NetworkSimulation(G, states, agentClass, directory, MAX_SIMULATION_TIME, TRIALS, environmentAgent, **globalSharedParameters) simulation.runSimulation()
def main(nodes=30): # Model parameters directory = 'test' globalSharedParameters = {} globalSharedParameters['infection_rate'] = 0.3 globalSharedParameters['inf_dur'] = "self.r.gauss(7, 2)" # Output Parameters statesToMonitor = [INFECTED, SUSCEPTIBLE, RECOVERED] colours = ["r", "--g", ":k"] mapping = {SUSCEPTIBLE:"w", INFECTED:"r", RECOVERED:"0.4"} labels = ["Infected", "Susceptible", "Recovered"] name = "SIR_scale_free" titlePlot = "Simulation on scale free graph, %i trials, %i%% infection prob" \ % (TRIALS, 100 * globalSharedParameters['infection_rate']) titleVisual = "" # Network G = nx.scale_free_graph(nodes) states = [SUSCEPTIBLE for n in G.nodes()] # run simulation simulation = NetworkSimulation(G, states, agentClass, directory, MAX_SIMULATION_TIME, TRIALS, environmentAgent, **globalSharedParameters) simulation.runSimulation() # run visualisation gif = AnimationCreator(directory, name, titleVisual, mapping) gif.create_gif() # plot results p = PlotCreator(directory, name, titlePlot, statesToMonitor, colours, labels) p.plotSimulation()
def graphGenerators( n, graphName ) : if (graphName == "star") : return make_reflexive (nx.star_graph (n).to_directed ()) elif (graphName == "twostars") : g = nx.star_graph (n) h = nx.star_graph (n) newLabels = { } for i in range (n + 1) : newLabels[i] = i + n + 1 h = nx.relabel_nodes (h, newLabels) gh = nx.union (g, h) if (g.degree (0) > 1) : gh.add_edge (1, n + 1) else : gh.add_edge (0, n + 1) gh.add_edge (n + 1, n + 2) return gh.to_directed () elif (graphName == "complete") : return nx.complete_graph (n).to_directed () elif (graphName == "scalefree") : return nx.scale_free_graph (n)
def gen_sfn(n, num_parts=4, min_edge=1, max_edge=10, alpha=0.5, beta=0.45, gamma=0.05, delta_in=0.2, delta_out=0, create_using=None, seed=None): G = nx.scale_free_graph(n=n, alpha=alpha, beta=beta, gamma=gamma, delta_in=delta_in, delta_out=delta_out, create_using=create_using, seed=seed) adjacency = {} neighbors = {} for i in range(len(G)): adjacency[i] = [] nbrs = {} for j in G.neighbors(i): adjacency[i].append(j) nbrs[j] = randint(min_edge, max_edge) neighbors[i] = nbrs cuts, part_vert = part_graph(num_parts, adjacency) nx.set_node_attributes(G, 'neighbors', neighbors) parts = {} for i in range(len(part_vert)): parts[i] = part_vert[i] nx.set_node_attributes(G, 'part', parts) return G
def test_networkx_scale_free(self): g = nx.scale_free_graph(100) edge_count = g.number_of_edges() g.graph["name"] = "scale_free_test" cyjs_g = util.from_networkx(g) print("\n---------- Scale free network Test Start -----------\n") print("Edge count = " + str(edge_count)) # print(json.dumps(cyjs_g, indent=4)) self.assertIsNotNone(cyjs_g) net_data = cyjs_g["data"] self.assertIsNotNone(net_data) self.assertEqual("scale_free_test", net_data["name"]) self.assertEqual(100, len(cyjs_g["elements"]["nodes"])) self.assertEqual(edge_count, len(cyjs_g["elements"]["edges"])) nodes = cyjs_g["elements"]["nodes"] node0 = nodes[0] self.assertEqual(type("1"), type(node0["data"]["id"]))
def test_networkx_scale_free(self): g = nx.scale_free_graph(100) edge_count = g.number_of_edges() g.graph['name'] = 'scale_free_test' cyjs_g = util.from_networkx(g) print('\n---------- Scale free network Test Start -----------\n') print('Edge count = ' + str(edge_count)) # print(json.dumps(cyjs_g, indent=4)) self.assertIsNotNone(cyjs_g) net_data = cyjs_g['data'] self.assertIsNotNone(net_data) self.assertEqual('scale_free_test', net_data['name']) self.assertEqual(100, len(cyjs_g['elements']['nodes'])) self.assertEqual(edge_count, len(cyjs_g['elements']['edges'])) nodes = cyjs_g['elements']['nodes'] node0 = nodes[0] self.assertEqual(type("1"), type(node0['data']['id']))
def demo2(): g = nx.scale_free_graph(30) iterate(g)
def test_create_from_networkx(self): networkx1 = nx.scale_free_graph(100) network = self.client.network.create_from_networkx(networkx1) self.assertIsNotNone(network)
#!/usr/bin/env python """ Random graph from given degree sequence. Draw degree rank plot and graph with matplotlib. """ __author__ = """Aric Hagberg <*****@*****.**>""" import networkx as nx import matplotlib.pyplot as plt import numpy as np #G = nx.gnp_random_graph(100,0.02) G1 = nx.scale_free_graph(100,alpha=0.05,beta=0.9,gamma=0.05) G2= nx.scale_free_graph(100,alpha=0.9,beta=0.05,gamma=0.05) nx.draw_circular(G1,node_color=range(100),cmap=plt.cm.Blues) nx.draw_circular(G2,node_color=range(100),cmap=plt.cm.Blues) ax=plt.subplot(111) degree_sequence1=sorted(nx.degree(G1).values(),reverse=True) #degree sequence degree_sequence2=sorted(nx.degree(G2).values(),reverse=True) #degree sequence print degree_sequence1 print degree_sequence2 #print "Degree sequence", degree_sequence ax.loglog(degree_sequence1,'bs',marker='o',label="aglomerado") ax.loglog(degree_sequence2,'g^',marker='o',label="pouco-aglomerado")
print L2 #Get CC CC2=NX.average_clustering(SW) print CC2 #Get node degree distribution DD=[] for node in SW.nodes(): DD.append(SW.degree(node)) plt.hist(DD) plt.show() #Creating a scale-free graph SF=NX.scale_free_graph(50) #number of nodes #Draw network NX.draw(SF, NX.shell_layout(SF)) plt.show() #Get L L2=NX.average_shortest_path_length(SF) print L2 #Get node degree distribution DD=[] for node in SF.nodes(): DD.append(SF.degree(node)) plt.hist(DD) plt.show()
def generate_data(file_name): N=2000 n_seed = 100 G = nx.scale_free_graph(N,seed = 1) print "finish generate scale free graph" #purify data net = [] net_reversed = [] random.seed(0) for i in range(N): net.append({}) net_reversed.append({}) for edge in G.edges(): if edge[0] != edge[1]: weight = random.uniform(0.3,0.01) net[edge[0]][edge[1]] = weight net_reversed[edge[1]][edge[0]] = weight del G all_zeros = [] for i in range(N): all_zeros.append(0) def calc_self_product(A,tmp,net): for i in range(N): for j in range(N): sum = tmp[i][j] for item in net[j]: sum += tmp[i][item]*net[j][item] A[i][j] = sum seed_set = [] delta = [] stamp = [] for i in range(N): x = all_zeros[:] x[i] = 1 for i in range(10): x = trans(net_reversed,x,N) sum = np.sum(x) delta.append(sum) stamp.append(0) while len(seed_set) < n_seed: index = -1 max = -1.0 for i in range(N): if i not in seed_set and delta[i] >= max: index, max = i,delta[i] if stamp[index] == len(seed_set): seed_set.append(index) else: x = all_zeros[:] for item in seed_set: x[item] = 1 x[index] = 1 for i in range(10): x = trans(net_reversed,x,N) sum1 = np.sum(x) x = all_zeros[:] for item in seed_set: x[item] = 1 for i in range(10): x = trans(net_reversed,x,N) sum2 = np.sum(x) delta[index] = sum1-sum2 stamp[index] = len(seed_set) X1 = range(1,n_seed) Y1 = [] for i in range(1,n_seed): print i index = seed_set[:i] x = all_zeros[:] for item in index: x[item] = 1 for i in range(10): x = trans(net_reversed,x,N) sum = np.sum(x) Y1.append(sum) X2 = range(1,100) Y2 = [] ave_num = 10 for n_random_seed in range(1,100): sum = 0.0 for i in range(ave_num): index = [] while len(index) != n_random_seed: r = random.randint(0,N-1) if r not in index: index.append(r) x = all_zeros[:] for item in index: x[item] = 1 for i in range(10): x = trans(net_reversed,x,N) sum += np.sum(x) sum /= ave_num Y2.append(sum) with open(file_name,'w') as file: print>>file,repr(X1) print>>file,repr(Y1) print>>file,repr(X2) print>>file,repr(Y2)
r.append(sum) return r def activate(net_reversed,x,N): for i in range(N): if x[i]==0: for item in net_reversed[i]: if random.random() < net_reversed[i][item]: x[i] = 1 break return x N=300 n_seed = 10 n_iteration_list = [200] G = nx.scale_free_graph(N,seed = 1) print "finish generate scale free graph" #purify data net = [] net_reversed = [] random.seed(0) for i in range(N): net.append({}) net_reversed.append({}) for edge in G.edges(): if edge[0] != edge[1]: weight = random.uniform(0.3,0.01) net[edge[0]][edge[1]] = weight net_reversed[edge[1]][edge[0]] = weight del G
import pytest import os from allegedb import ORM import networkx as nx scalefreestart = nx.MultiDiGraph(name='scale_free_graph_5') scalefreestart.add_edges_from([(0, 1), (1, 2), (2, 0)]) testgraphs = [ nx.chvatal_graph(), nx.scale_free_graph(5, create_using=scalefreestart), # nx.chordal_cycle_graph(5, create_using=nx.MultiGraph(name='chordal_cycle_graph_5')), # The standard networkx edges iterator decides to flip some edges about in arbitrary-seeming # ways that I haven't been able to replicate and it doesn't seem worth it. ] # have to name it after creation because it clears the create_using path_graph_9 = nx.path_graph(9) path_graph_9.name = 'path_graph_9' testgraphs.append(path_graph_9) @pytest.fixture def db(): name = 'allegedb_load_test.db' if os.path.exists(name): os.remove(name) with ORM('sqlite:///' + name) as orm: for graph in testgraphs: {
def new_scale_graph(num, gammat): G = nx.scale_free_graph(num, 0.4, 0.59, 0.01, gammat, 0, None, None) nx.draw(G) plt.savefig("1.png") return G
iterations, callback = FR_ITERATIONS, self.update_positions if IS_VERY_LARGE_GRAPH(self.graph): # Don't animate very large graphs iterations, callback = 5, None AnimationThread(iterations, callback).start() def update_positions(self, positions): self.positionsChanged.emit(positions) return self._is_animating def _update_positions(self, positions): for node, pos in zip(self.nodes, positions*300): node.setPos(*pos) qApp.processEvents() if __name__ == '__main__': import sys app = QtGui.QApplication(sys.argv) widget = GraphView() widget.show() import networkx as nx G = nx.scale_free_graph(int(sys.argv[1]) if len(sys.argv) > 1 else 100, seed=0) widget.set_graph(G) print('nodes', len(widget.nodes), 'edges', len(widget.edges)) for node in widget.nodes[:10]: node.setHighlighted(True) sys.exit(app.exec_())
import networkx as nx import numpy as np import pickle # start at 44212 if __name__ == '__main__': # Generate graphs (Warning: takes some time, see below dumped graphs) + TODO: investigate more parameters scale_free_ns = [int(i) for i in np.logspace(5, 17, 200, base=2)] # logspaced_scale_free = [] for n in scale_free_ns[173:]: print("Generating ", n) g = nx.scale_free_graph(n) # logspaced_scale_free.append(g) with open("benchmark/scale_free/5_17_200_{}.pickle".format(n), "wb") as f: pickle.dump(g, f)
def test_basic_roundtrip(self): g1 = nx.scale_free_graph(10) cx1 = cxu.from_networkx(g1) g2 = cxu.to_networkx(cx1) self.assertTrue(nx.is_isomorphic(g1, g2, edge_match=cxu.edge_id_match))