def nodeTravelGraph(pages_visited): rcParams['figure.figsize'] = 8, 4 sb.set_style('white') G = nx.DiGraph() label_dict = {} if not pages_visited: G = nx.gn_graph(1) label_dict.update({0: "Home"}) return G, label_dict #nx.draw_circular(G, labels=label_dict, node_color='white', with_labels=True) else: n_pages = len(pages_visited) for i in range(n_pages): if i + 1 == n_pages & n_pages != 1: label_dict.update({i: pages_visited[i]}) break elif n_pages == 1: G = nx.gn_graph(n_pages) label_dict.update({i: pages_visited[i]}) else: label_dict.update({i: pages_visited[i]}) G.add_edge(i, i + 1) return G, label_dict
def nodeNetworkGraph(nodes_found): #rcParams['figure.figsize'] = 8,4 sb.set_style('ticks') G = nx.DiGraph() label_dict = {} if nodes_found == 0: G = nx.gn_graph(1) label_dict.update({0: "No Nodes Found"}) return G, label_dict else: for i in range(nodes_found): if i + 1 == nodes_found & nodes_found != 1: label_dict.update({i: i + 1}) break elif nodes_found == 1: G = nx.gn_graph(nodes_found) label_dict.update({i: i + 1}) else: label_dict.update({i: i + 1}) G.add_edge(i, i + 1) global node_pos node_pos = nx.circular_layout(G) #graph = nx.draw_networkx(G, pos=node_pos, labels = label_dict, node_color='yellow', with_labels=True) return G, label_dict, node_pos
def RandomDirectedGN(self, n, kernel=lambda x:x, seed=None): """ Returns a random GN (growing network) digraph with n vertices. The digraph is constructed by adding vertices with a link to one previously added vertex. The vertex to link to is chosen with a preferential attachment model, i.e. probability is proportional to degree. The default attachment kernel is a linear function of degree. The digraph is always a tree, so in particular it is a directed acyclic graph. INPUT: - ``n`` - number of vertices. - ``kernel`` - the attachment kernel - ``seed`` - for the random number generator EXAMPLE:: sage: D = digraphs.RandomDirectedGN(25) sage: D.edges(labels=False) [(1, 0), (2, 0), (3, 1), (4, 0), (5, 0), (6, 1), (7, 0), (8, 3), (9, 0), (10, 8), (11, 3), (12, 9), (13, 8), (14, 0), (15, 11), (16, 11), (17, 5), (18, 11), (19, 6), (20, 5), (21, 14), (22, 5), (23, 18), (24, 11)] sage: D.show() # long time REFERENCE: - [1] Krapivsky, P.L. and Redner, S. Organization of Growing Random Networks, Phys. Rev. E vol. 63 (2001), p. 066123. """ if seed is None: seed = current_randstate().long_seed() import networkx return DiGraph(networkx.gn_graph(n, kernel, seed=seed))
def RandomDirectedGN(self, n, kernel=lambda x: x, seed=None): """ Returns a random GN (growing network) digraph with n vertices. The digraph is constructed by adding vertices with a link to one previously added vertex. The vertex to link to is chosen with a preferential attachment model, i.e. probability is proportional to degree. The default attachment kernel is a linear function of degree. The digraph is always a tree, so in particular it is a directed acyclic graph. INPUT: - ``n`` - number of vertices. - ``kernel`` - the attachment kernel - ``seed`` - for the random number generator EXAMPLE:: sage: D = digraphs.RandomDirectedGN(25) sage: D.edges(labels=False) [(1, 0), (2, 0), (3, 1), (4, 0), (5, 0), (6, 1), (7, 0), (8, 3), (9, 0), (10, 8), (11, 3), (12, 9), (13, 8), (14, 0), (15, 11), (16, 11), (17, 5), (18, 11), (19, 6), (20, 5), (21, 14), (22, 5), (23, 18), (24, 11)] sage: D.show() # long time REFERENCE: - [1] Krapivsky, P.L. and Redner, S. Organization of Growing Random Networks, Phys. Rev. E vol. 63 (2001), p. 066123. """ if seed is None: seed = current_randstate().long_seed() import networkx return DiGraph(networkx.gn_graph(n, kernel, seed=seed))
def make_class_hierarchy(n, n_intermediate=None, n_leaf=None): """Create a mock class hierarchy for testing purposes. Parameters ---------- n : int Number of nodes in the returned graph n_intermediate : int Number of intermediate (non-root, non-terminal) nodes in the returned graph n_leaf : int Number of leaf (terminal) nodes in the returned graph Returns ------- G : dict of lists adjacency matrix format representing the class hierarchy """ if n_leaf is None and n_intermediate is None: # No specific structure specified, use a general purpose graph generator G = gn_graph(n=n, create_using=DiGraph()) if n_intermediate == 0: # No intermediate nodes, build a 1-level rooted tree if n_leaf is None: n_leaf = n - 1 G = DiGraph(data=product((ROOT, ), range(n_leaf))) return to_dict_of_lists(G)
def set_random_gn_graph(self, num_nodes, num_edges=None, degree_s=[None, None]): """ Set the graph to a "layered" random dag """ # remove the current graph first self.clear() if num_edges is None: num_edges = int((num_nodes ** 2 / 4)) # # first create a GN graph #G = nx.gn_graph(num_nodes) G = nx.gn_graph(num_nodes) H = nx.DiGraph() for u, v in G.edges(): H.add_edge(v, u, weight=1) G = H for u, v in G.edges(): G[u][v]['weight'] = 1 nodes = nx.topological_sort(G) num_edges = num_edges - G.number_of_edges() for i in range(num_edges): u_idx = random.choice(range(len(nodes)-1)) u = nodes[u_idx] v = random.choice(nodes[u_idx+1:]) if (u,v) in G.edges(): G[u][v]['weight'] += 1 else: G.add_edge(u, v, weight=1) self.set_random_session(G, degree_s)
def _construct_graph_objs(): graphs = [] for graph_type in [nx.Graph, nx.MultiGraph, nx.DiGraph, nx.MultiDiGraph]: g1 = nx.from_edgelist([("2", "1"), ("3", "1"), ("1", "0")], create_using=graph_type) g2 = g1.copy() attrs = { n: { l: i } for i, (n, l) in enumerate(zip(g2.nodes, string.ascii_lowercase)) } nx.set_node_attributes(g2, attrs) g3 = copy.deepcopy(g2) attrs = { e: { l: i } for i, (e, l) in enumerate(zip(g2.edges, string.ascii_lowercase)) } nx.set_edge_attributes(g3, attrs) graphs.extend([(g1, True), (g2, True), (g3, True)]) graphs.extend([ # one out edge; these are 'valid' in `nereid` (nx.gn_graph(25, seed=42), True), # many out edges; these are not 'valid' in `nereid` (nx.gnc_graph(25, seed=42), False), ]) return graphs
def test_directed_raises(self): with pytest.raises(nx.NetworkXNotImplemented): dir_G = nx.gn_graph(n=5) prev_cc = None edge = self.pick_add_edge(dir_G) insert = True nx.incremental_closeness_centrality(dir_G, edge, prev_cc, insert)
def iidG_gn(n, p, gain_var=1, k=None, p_radius=0.75): def aEij(i, j, a=1): Eij = np.zeros((n, n)) Eij[i, j] = a return Eij G = nx.gn_graph(n, kernel=k) G = nx.adjacency_matrix(G) G = G.toarray() B = [np.zeros((n, n)) for i in range(p)] for i, row in enumerate(G.T): for j, x in enumerate(row): if x == 1: b, a = random_arma(p, 0, k=np.random.normal(0, gain_var), p_radius=p_radius) B[0] = B[0] + aEij(i, j, b) B[1:] = [ B_tau + aEij(i, j, a_tau) for (B_tau, a_tau) in zip(B, a[1:]) ] M = block_companion(B) return B, M, G
def gn_semi_preferential(n, pref_coefficient=None, create_using=None, seed=None): """Return the GN digraph with n nodes. The GN (growing network) graph is built by adding nodes one at a time with a link to one previously added node. The graph is always a (directed) tree. Parameters ---------- n : int The number of nodes for the generated graph. pref_coefficient : float between 0 and 1, determining how much an edge choice depends on prior popularity (in-degree) create_using : graph, optional (default DiGraph) Return graph of this type. The instance will be cleared. seed : hashable object, optional The seed for the random number generator. """ # r = random.random() # This kernel sometimes chooses randomly # and sometimes bandwagons. # It bandwagons with probability = pref_coefficient. # x-1 is the in-degree kernel = lambda x: (pref_coefficient * (x - 1)) + (1 - pref_coefficient) # Another kernel to try # kernel = lambda x: x**pref_coefficient G = nx.gn_graph(n, kernel, create_using, seed) return G
def generateSubGraphs(numgraphs=2, nodespersub=5, interconnects=0): kernel = lambda x: x**0.0001 x = temp = nx.gn_graph(nodespersub, kernel) for i in range(numgraphs - 1): temp = nx.gn_graph(nodespersub, kernel) x = nx.disjoint_union(x, temp) #Now add some crosstalk workinglen = len(x) - len(temp) for i in range(interconnects): firstnode = ra.choice(range(workinglen)) secondnode = ra.choice(range(workinglen, len(x))) newedge = [firstnode, secondnode] ra.shuffle(newedge) x.add_edge(newedge[0], newedge[1]) return x
def generateSubGraphs(numgraphs = 2, nodespersub = 5, interconnects = 0): kernel = lambda x: x**0.0001 x = temp = nx.gn_graph(nodespersub, kernel) for i in range(numgraphs-1): temp = nx.gn_graph(nodespersub, kernel) x = nx.disjoint_union(x, temp) #Now add some crosstalk workinglen = len(x) - len(temp) for i in range(interconnects): firstnode = ra.choice(range(workinglen)) secondnode = ra.choice(range(workinglen,len(x))) newedge = [firstnode, secondnode] ra.shuffle(newedge) x.add_edge(newedge[0], newedge[1]) return x
def _construct_graphs(): graphs = [ # one out edge; these are 'valid' in `nereid` (nx.gn_graph(25, seed=42)), # many out edges; these are not 'valid' in `nereid` (nx.gnc_graph(25, seed=42)), ] return graphs
def directed_graphs(): print("Directed graphs") print("Growing network") D = nx.gn_graph(10) # the GN graph draw_graph(D) G = D.to_undirected() # the undirected version draw_graph(G) D = nx.gn_graph(10, kernel=lambda x: x**1.5) # A_k = k^1.5 draw_graph(D) print("Growing network graph") D = nx.gnr_graph(n=11, p=0.3) draw_graph(D) G = D.to_undirected() draw_graph(G) print("Growing network with copying graph") D = nx.gnc_graph(n=7) draw_graph(D) G = D.to_undirected() draw_graph(G) print("Scale-free graph") G = nx.scale_free_graph(10) draw_graph(G)
def main(): nodes = [0, 1, 2, 3] edges = [(0, 1), (1, 0), (0, 2), (2, 1), (3, 0), (3, 1)] #G = nx.DiGraph(edges) # Generate random complete graph G = nx.gn_graph(100) root = random.randint(0, 100) my_visit = bfs(G, root) good_visit = list(nx.bfs_edges(G, source=root)) print(f"My visit: {my_visit}") print(f"Good visit: {good_visit}")
def test_directed_subgraph_hash(): """ A directed graph with no bi-directional edges should yield different subgraph hashes to the same graph taken as undirected, if all hashes don't collide. """ r = 10 for i in range(r): G_directed = nx.gn_graph(10 + r, seed=100 + i) G_undirected = nx.to_undirected(G_directed) directed_subgraph_hashes = nx.weisfeiler_lehman_subgraph_hashes(G_directed) undirected_subgraph_hashes = nx.weisfeiler_lehman_subgraph_hashes(G_undirected) assert directed_subgraph_hashes != undirected_subgraph_hashes
def graph_sel(graphType, n, p): ''' Funzione che genera e restituisce un grafo del tipo prescelto. Viene invocata solo se, nell'inizializzazione del repository, non viene direttamente specifica un grafo ma solo un graph type. ''' return { 'gn': lambda: nx.gn_graph(n), 'gnr': lambda: nx.gnr_graph(n, p), 'gnc': lambda: nx.gnc_graph(n), 'scale_free': lambda: nx.scale_free_graph(n), 'erdos_renyi': lambda: nx.erdos_renyi_graph(n, p, directed=True), 'nSCC_graph': lambda: self.nSCC_graph(n) }.get(graphType, graphType)()
def test_directed(): """ A directed graph with no bi-directional edges should yield different a graph hash to the same graph taken as undirected if there are no hash collisions. """ r = 10 for i in range(r): G_directed = nx.gn_graph(10 + r, seed=100 + i) G_undirected = nx.to_undirected(G_directed) h_directed = nx.weisfeiler_lehman_graph_hash(G_directed) h_undirected = nx.weisfeiler_lehman_graph_hash(G_undirected) assert h_directed != h_undirected
def test_randomgraph_files(self): G = nx.gn_graph(20) targets = defaultdict(dict) depends = defaultdict(dict) allfiles = list() for a, b in G.edges(): f = os.path.join(self.workdir, "{}_{}.txt".format(a, b)) allfiles.append(f) targets[a][b] = depends[b][a] = f shall_fail = set( [random.choice(G.nodes()) for _ in range(int(len(G)**.5))]) nodes = nx.algorithms.dag.topological_sort(G) task_nos = [None for _ in range(len(nodes))] for n in nodes: cmd = "touch /dev/null " + " ".join(targets[n].values()) if n in shall_fail: cmd += " ;exit 1" t = self.ctx.add_task(cmd, name=cmd, targets=list(targets[n].values()), depends=list(depends[n].values())) task_nos[n] = t.task_no # self.ctx.fail_idx = task_nos[G.successors(list(shall_fail)[0])[-1]] self.assertFalse(any(map(os.path.exists, allfiles))) with capture(stderr=StringIO()): import anadama2.reporters with self.assertRaises(anadama2.workflow.RunFailed): rep = anadama2.reporters.LoggerReporter("debug", "/tmp/analog") self.ctx.go(reporter=rep) child_fail = set() for n in shall_fail: task_no = task_nos[n] self.assertIn(task_no, self.ctx.failed_tasks, ("tasks that raise exceptions should be marked" " as failed")) self.assertTrue(bool(self.ctx.task_results[task_no].error), "Failed tasks should have errors in task_results") for _, succ in dfs_edges(G, n): s_no = task_nos[succ] child_fail.add(succ) self.assertIn(s_no, self.ctx.failed_tasks, "all children of failed tasks should fail") self.assertIn("parent task", self.ctx.task_results[s_no].error, ("children of failed tasks should have errors" " in task_results")) for n in set(nodes).difference(shall_fail.union(child_fail)): task_no = task_nos[n] self.assertIn(task_no, self.ctx.completed_tasks) self.assertFalse(bool(self.ctx.task_results[task_no].error))
def test_randomgraph_files(self): G = nx.gn_graph(20) targets = defaultdict(dict) depends = defaultdict(dict) allfiles = list() for a, b in G.edges(): f = os.path.join(self.workdir, "{}_{}.txt".format(a, b)) allfiles.append(f) targets[a][b] = depends[b][a] = f shall_fail = set( [random.choice(G.nodes()) for _ in range(int(len(G)**.5))]) nodes = nx.algorithms.dag.topological_sort(G) task_nos = [None for _ in range(len(nodes))] for n in nodes: cmd = "touch /dev/null " + " ".join(targets[n].values()) if n in shall_fail: cmd += " ;exit 1" slurm_add_task = lambda *a, **kw: self.ctx.add_task_gridable( mem=50, time=5, cores=1, *a, **kw) add_task = self.ctx.add_task if bern(0.5) else slurm_add_task t = add_task(cmd, name=cmd, targets=list(targets[n].values()), depends=list(depends[n].values())) task_nos[n] = t.task_no self.assertFalse(any(map(os.path.exists, allfiles))) with capture(stderr=StringIO()): with self.assertRaises(anadama2.workflow.RunFailed): self.ctx.go(grid_jobs=2) child_fail = set() for n in shall_fail: task_no = task_nos[n] self.assertIn(task_no, self.ctx.failed_tasks, ("tasks that raise exceptions should be marked" " as failed")) self.assertTrue(bool(self.ctx.task_results[task_no].error), "Failed tasks should have errors in task_results") for _, succ in dfs_edges(G, n): s_no = task_nos[succ] child_fail.add(succ) self.assertIn(s_no, self.ctx.failed_tasks, "all children of failed tasks should fail") self.assertIn("parent task", self.ctx.task_results[s_no].error, ("children of failed tasks should have errors" " in task_results")) for n in set(nodes).difference(shall_fail.union(child_fail)): task_no = task_nos[n] self.assertIn(task_no, self.ctx.completed_tasks) self.assertFalse(bool(self.ctx.task_results[task_no].error))
def generateHourGlassGraph(nodes=10, interconnects=0): def flipGraph(g): e = g.edges() g.remove_edges_from(e) g.add_edges_from(zip(*zip(*e)[::-1])) kernel = lambda x: x**0.0001 if nodes < 4: return nx.gn_graph(nodes, kernel) n1, n2 = int(floor(nodes / 2.)), int(ceil(nodes / 2.)) x1 = nx.gn_graph(n1, kernel) x2 = nx.gn_graph(n2, kernel) flipGraph(x2) x = nx.disjoint_union(x1, x2) x.add_edge(0, n1 + 1) for i in range(interconnects): firstnode = ra.choice(range(n1)) secondnode = ra.choice(range(n1, n1 + n2)) #newedge = [firstnode, secondnode] #ra.shuffle(newedge) #x.add_edge(newedge[0], newedge[1]) x.add_edge(firstnode, secondnode) return x
def generateHourGlassGraph(nodes=10, interconnects = 0): def flipGraph(g): e = g.edges() g.remove_edges_from(e) g.add_edges_from(zip(*zip(*e)[::-1])) kernel = lambda x: x**0.0001 if nodes < 4: return nx.gn_graph(nodes,kernel) n1 , n2 = int(floor(nodes/2.)), int(ceil(nodes/2.)) x1 = nx.gn_graph(n1, kernel) x2 = nx.gn_graph(n2, kernel) flipGraph(x2) x = nx.disjoint_union(x1,x2) x.add_edge(0,n1+1) for i in range(interconnects): firstnode = ra.choice(range(n1)) secondnode = ra.choice(range(n1,n1+n2)) #newedge = [firstnode, secondnode] #ra.shuffle(newedge) #x.add_edge(newedge[0], newedge[1]) x.add_edge(firstnode,secondnode) return x
def test_randomgraph_tasks(self): G = nx.gn_graph(20) targets = defaultdict(dict) depends = defaultdict(dict) shall_fail = set( [random.choice(G.nodes()) for _ in range(int(len(G)**.5))]) nodes = nx.algorithms.dag.topological_sort(G) task_nos = [None for _ in range(len(nodes))] for n in nodes: cmd = "touch /dev/null " name = None if n in shall_fail: cmd += " ;exit 1" name = "should fail" slurm_add_task = lambda *a, **kw: self.ctx.add_task_gridable( mem=50, time=5, cores=1, *a, **kw) add_task = self.ctx.add_task if bern(0.5) else slurm_add_task t = add_task(cmd, name=name, depends=[ self.ctx.tasks[task_nos[a]] for a in G.predecessors(n) ]) task_nos[n] = t.task_no with capture(stderr=StringIO()): with self.assertRaises(anadama2.workflow.RunFailed): self.ctx.go(grid_jobs=2) child_fail = set() for n in shall_fail: task_no = task_nos[n] self.assertIn(task_no, self.ctx.failed_tasks, ("tasks that raise exceptions should be marked" " as failed")) self.assertTrue(bool(self.ctx.task_results[task_no].error), "Failed tasks should have errors in task_results") for _, succ in dfs_edges(G, n): s_no = task_nos[succ] child_fail.add(succ) self.assertIn(s_no, self.ctx.failed_tasks, "all children of failed tasks should fail") self.assertIn("parent task", self.ctx.task_results[s_no].error, ("children of failed tasks should have errors" " in task_results")) for n in set(nodes).difference(shall_fail.union(child_fail)): task_no = task_nos[n] self.assertIn(task_no, self.ctx.completed_tasks) self.assertFalse(bool(self.ctx.task_results[task_no].error))
def compute(infile, outfile): start = time.time() df = pd.read_csv(infile) N, n = df.shape G = nx.gn_graph(n) #==========================================# #to verify values # G = nx.DiGraph() # G_new, G_alt = create_random_graph(n, G) #==========================================# bayes = BayesScore(G, df) # This is inside compute G_opt, score_opt = local_search(bayes, G, df) end = time.time() timer = end - start print('total time: %.2', timer) # G_opt = G; score_opt = 100; G_opt = nx.relabel_nodes(G_opt, bayes.idx2node) # plot_graph(G_opt, show=True) # pdb.set_trace() print('best final score:', score_opt) length = df.shape[1] d = bayes.node2idx node_list = sorted(d, key=d.get) # parents_values = [data[parent]-1 for parent in parents] # pdb.set_trace() timestamp = str(int(time.time())) new_dir = str("./out_") + timestamp os.mkdir(new_dir) filename = new_dir + ('/') + outfile write_gph(G_opt, bayes.node2idx, filename) fig = plot_graph(G_opt) title = 'score = %.2f, time taken = %.2f (s)' % (score_opt, timer) plt.title(title) # new_dir = str("./out_")+str(int(time.time()) ) figname = new_dir + ('/') + (infile[:2]) + ('.png') plt.savefig(figname)
def main(): """ Main code: - creates nodes - instanciates a 'drawer' to display a graph of the network """ if len(sys.argv) < 2: sys.stderr.write("Usage: %s number_of_nodes\n" % sys.argv[0]) sys.exit(1) number_of_nodes = int(sys.argv[1]) ### INIT NODES with a graph graph = nx.gn_graph(number_of_nodes) nodes = [] for i in range(number_of_nodes): node_name = "%s" % i neighbors = [ str(node) for node in chain(graph.predecessors(i), graph.successors(i)) ] node = Node(node_name, neighbors) node.consumer.start() nodes.append(node) initialize_network(nodes, str(random.randint(0, number_of_nodes - 1))) graph_attributes = {} for i in range(len(nodes)): graph_attributes[i] = {"node": nodes[i], "label": nodes[i].name} nx.set_node_attributes(graph, graph_attributes) drawer = Drawer(graph) Controller(nodes).start() while True: drawer.generate_graph() drawer.draw_graph()
def generate_random_L(p=10, a=0.3, b=0.7, diag_a=2, diag_b=5, plot=False, G=None): """ randomly generates a lower triangular matrix based on a growing network graph Input: p: number of nodes a: lower bound for off-diagonal b: upper bound for off_diagonal diag_a: lower bound for diagonal diag_b: upper bound for diagonal G: Directed graph Output: L: Lower triangular matrix A: Adjacency matrix G: Directed graph """ if (G is None): G = nx.gn_graph(p) if (nx.is_directed(G) is False): print('G is not directed') exit(1) ### need to relabel vertices to agree with CSCS mapping = dict(zip(G.nodes(), list(range(p - 1, -1, -1)))) G = nx.relabel_nodes(G, mapping) if (plot): import matplotlib.pyplot as plt plt.show() nx.draw_shell(G, with_labels=True, font_weight='bold') A = nx.adjacency_matrix(G).todense() L = np.multiply(A, ((b - a) * np.random.random_sample(size=p * p) + a).reshape(p, p)) np.fill_diagonal(L, np.random.uniform(diag_a, diag_b, p)) return (L, A, G)
# ## 295. Connectivity matrix example # + pycharm={"name": "#%%\n"} import numpy as np import scipy.sparse as sparse A = sparse.random(8, 8, 0.2, data_rvs=np.ones) A.toarray() # To print A # + [markdown] pycharm={"name": "#%% md\n"} # ## 302. Incidence matrix # + pycharm={"name": "#%%\n"} import networkx.linalg.graphmatrix as gm G = nx.gn_graph(5) # oriented=True is needed to get the directed/oriented incidence matrix. gm.incidence_matrix(G, oriented=True).toarray() # + [markdown] pycharm={"name": "#%% md\n"} # ## 305. Incidence matrix # + pycharm={"name": "#%%\n"} n = 4 arc_list = [(1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4)] G = nx.DiGraph() G.add_nodes_from(range(1, n + 1)) G.add_edges_from(arc_list) gm.incidence_matrix(G, oriented=True).toarray() # + [markdown] pycharm={"name": "#%% md\n"}
# -*- coding: utf-8 -*- import networkx as nx import random # Testni graf mGraph = nx.gn_graph(10) for edge in mGraph.edges(): print (edge) ## 1: Funkcija za iskanje števila povezav za vsak node def getNodeInputAndOutputCount(g): #Inicializacija slovarjev countedIn = {} countedOut = {} #Za vsak rob - for edge in g.edges_iter(): #če krajišča še ni v števcih vhoda ali izhoda, ga dodaj in nastavi na 0 if not edge[0] in countedOut: countedOut[edge[0]] = 0 if not edge[1] in countedOut: countedOut[edge[1]] = 0 if not edge[0] in countedIn: countedIn[edge[0]] = 0 if not edge[1] in countedIn: countedIn[edge[1]] = 0 #Krajišču izvora roba prištej ena v števcu izhodov
#!/usr/bin/env python import sys sys.path.append(".") import openpnl import networkx import matplotlib.pyplot as plt nnodes = 26 G = networkx.gn_graph(nnodes) mp = {} for i in range(0,nnodes): mp[i+1] = chr(ord('A')+i-1) G = networkx.relabel_nodes(G, mp) networkx.draw(G) plt.show() pWSBnet = openpnl.pnlExCreateWaterSprinklerBNet() pWSBnet.GetGraph().Dump(); pEvidForWS = openpnl.mkEvidence( pWSBnet, [0], [1] ) pNaiveInf = openpnl.CNaiveInfEngine.Create( pWSBnet ) pNaiveInf.EnterEvidence( pEvidForWS ); nodes = [1,3] pNaiveInf.MarginalNodes( nodes ); pMarg = pNaiveInf.GetQueryJPD() obsVls = openpnl.pConstValueVector()
import networkx as nx import matplotlib.pyplot as plt from random import randint graphs = [] for i in range(100, 1000 + 1, 100): graphs.append(nx.gn_graph(i)) graphs.append(nx.gn_graph(10000)) s = "#use \"projet.ml\"\n\n" for i, graph in enumerate(graphs): name = "ge" + str(graph.number_of_nodes()) s += "let " + name + " = Dag.create ();;\n" s += "\n" for i, node in graph.nodes_iter(data=True): node['name'] = "v" + str(i) node['ressource'] = randint(1, 2) node['cout'] = randint(1, 3) for i, node in graph.nodes(data=True): s += "let " + node['name'] + " = Dag.createv (\"" \ + node['name'] \ + "\", " + str(node['ressource']) \ + ", " + str(node['cout']) \ + ".);;\n" s += "\n" for i, node in graph.nodes(data=True):
from random import randrange #randomized optimal flow algorithms from algorithms.minimum_flow.constrainedBoP_hitting import * from algorithms.minimum_flow.constrainedBoP_nonhitting import * from algorithms.maximum_flow.capacity_constraint import * #graph functions from algorithms.graph_functions.api import * ########### # DATASET # ########### list_of_dataset = [] #generation of graph with 100 nodes T = nx.gn_graph(100, seed=1) G1 = nx.DiGraph() for node_i,node_j in T.edges(): G1.add_edge(node_j, node_i, weight=5, capacity=20, flow=0) list_of_no_succesors = [] for node in G1.nodes(): lenght = sum(1 for _ in G1.successors(node)) if lenght==0: list_of_no_succesors.append(node) for node_no_succ in list_of_no_succesors: G1.add_edge(node_no_succ, 100, weight=5, capacity=20, flow=0) G1.nodes[0]['b'] = 100 G1.nodes[100]['b'] = -100 list_of_dataset.append(G1) #generation of graph with 500 nodes
import random import networkx as nx import dijkstraalgorithm as djk import time import matplotlib.pyplot as plt lista_vertices = list() lista_media_tempo = list() for n in range(0, 5000, 5): print(n) G = nx.gn_graph(n) for (u, v, w) in G.edges(data=True): w['weight'] = random.randint(0, 100) soma = 0. for i in range(1, 11): start = time.time() djk.dijkstra(G, list(G.nodes())[0], G.number_of_nodes() - 1) tempo = time.time() - start soma = soma + tempo lista_vertices.append(n) lista_media_tempo.append(soma / 10) plt.plot(lista_vertices, lista_media_tempo) plt.axis([0, 5000, 0, max(lista_media_tempo) * 2]) plt.ylabel('Tempo de execução (Segundos)') plt.xlabel('Número de Vértices') plt.title("Desempenho Algoritmo de Dijkstra") plt.show()
import networkx as nx import matplotlib.pyplot as plt import collections #generation of a forest fire graph with GN incremental growth model G = nx.gn_graph(100, kernel=lambda x: x**1.5) # Graph display coord = nx.spring_layout(G, iterations=1000) fig = plt.figure() axs = fig.add_subplot(111, aspect='equal') axs.axis('off') nx.draw_networkx_edges(G, coord) nx.draw_networkx_nodes(G, coord, node_size=100, node_color='k') plt.show() # Degree distribution analysis print("Degree Distribution :") print(G.degree()) degree_sequence = sorted([d for n, d in G.degree()], reverse=True) # degree sequence degreeCount = collections.Counter(degree_sequence) deg, cnt = zip(*degreeCount.items()) print("Avg. degree : ", sum(deg) / len(deg), "Max. degree : ", max(deg), "Min. degree : ", min(deg)) fig, ax = plt.subplots() plt.plot(deg, cnt, 'ro-') plt.title("Degree Distribution") plt.ylabel("Count") plt.xlabel("Degree")
import pandas as pd import matplotlib.pyplot as plt import seaborn as sb import networkx as nx from pylab import rcParams #%% rcParams['figure.figsize'] = 5, 4 sb.set_style('whitegrid') #%% # Generating a graph object and edgelist DG = nx.gn_graph(7, seed=25) for line in nx.generate_edgelist(DG, data=False): print(line) #%% # Assign attributes to nodes, such as name, weight, directions. print(DG.node[0]) #%% DG.node[0]["name"] = 'Alice' print(DG.node[0]) #%% DG.node[1]["name"] = 'Bob' DG.node[2]["name"] = 'Claire'
#!/usr/bin/env python import sys sys.path.append(".") import openpnl import networkx import matplotlib.pyplot as plt nnodes = 26 G = networkx.gn_graph(nnodes) mp = {} for i in range(0, nnodes): mp[i + 1] = chr(ord('A') + i - 1) G = networkx.relabel_nodes(G, mp) networkx.draw(G) plt.show() pWSBnet = openpnl.pnlExCreateWaterSprinklerBNet() pWSBnet.GetGraph().Dump() pEvidForWS = openpnl.mkEvidence(pWSBnet, [0], [1]) ## Naive Inference Engine print "Naive Inf Engine" pNaiveInf = openpnl.CNaiveInfEngine.Create(pWSBnet) pNaiveInf.EnterEvidence(pEvidForWS) nodes = [1, 3] pNaiveInf.MarginalNodes(nodes) pMarg = pNaiveInf.GetQueryJPD() obsVls = openpnl.pConstValueVector() print openpnl.convertVector( pMarg.GetMatrix(openpnl.matTable).ConvertToDense().GetVector())
( [["a", "b"], ["b", "c"], ["d", "c"], ["c", "e"], ["c", "e"]], False, ([], [], [["c", "2"]], [["c", "e"]]), ), # duplicate edge ( [["a", "b"], ["b", "c"], ["d", "c"], ["a", "e"]], False, ([], [], [["a", "2"]], []), ), # multiple out edges, a->b & a->e ], ) def test_validate_network(edgelist, isvalid, result): g = nx.from_edgelist(edgelist, create_using=nx.MultiDiGraph) assert isvalid == is_valid(g) assert result == validate_network(g) @pytest.mark.parametrize( "g, expected", [ # multiple out connections (nx.gnc_graph(10, seed=42), False), # multiple out connections, cycles, duplicated edges (nx.random_k_out_graph(10, 2, 1, seed=42), False), (nx.gn_graph(10, seed=42), True), ], ) def test_isvalid(g, expected): assert expected == is_valid(g)