def convert_to_igraph(road_map): # First, re-index nodes from 0 to N-1 shuffle(road_map.nodes) n = len(road_map.nodes) new_node_ids = {} for i in xrange(n): new_node_ids[road_map.nodes[i].node_id] = i # Now, create a Graph object with the correct number of nodes graph = Graph(n, directed=False) """ # Add the correct links for i in xrange(n): if(i%1000==0): print i for link in road_map.nodes[i].forward_links: j = new_node_ids[link.connecting_node.node_id] graph.add_edge(i,j) """ edge_set = set() for i in xrange(n): for link in road_map.nodes[i].forward_links: j = new_node_ids[link.connecting_node.node_id] x = min(i,j) y = max(i,j) edge_set.add((x,y)) graph.add_edges(list(edge_set)) return graph
def disp_tree(tree): from igraph import Graph, plot g = Graph(directed=True) g.add_vertices(len(tree)) g.vs['label'] = [node.name for node in tree] nodes_to_add = set([0]) while len(nodes_to_add) != 0: i_node = nodes_to_add.pop() node = tree[i_node] g.vs['label'][i_node] = node.name left_node = node.left_child right_node = node.right_child if left_node != None: i_left = tree.index(left_node) g.add_edges((i_node, i_left)) nodes_to_add.add(i_left) if right_node != None: i_right = tree.index(right_node) g.add_edges((i_node, i_right)) nodes_to_add.add(i_right) layout = g.layout_reingold_tilford(root=0) plot(g, layout=layout, bbox=(0, 0, 3000, 1000))
def _gen_graph(self): # make it lazy to support optional addslaves command from igraph import Graph g = Graph().as_directed() g.add_vertices(self.vertex_count) g.es['weight'] = 1 # enable weight return g
def testBug128(self): y = [1, 4, 9] g = Graph(n=len(y), directed=True, vertex_attrs={'y': y}) self.assertEquals(3, g.vcount()) g.add_vertices(1) # Bug #128 would prevent us from reaching the next statement # because an exception would have been thrown here self.assertEquals(4, g.vcount())
def growInstanceGraph(g, pattern, parentPattern, parentIg): ''' Create the instance graph for pattern @pattern from its parent pattern @parentPattern whose instance graph is given by @parentIg ''' childEdges = set([x.index for x in pattern.getEdgeList()]) parentEdges = set([x.index for x in parentPattern.getEdgeList()]) newEdgeIndex = childEdges.difference(parentEdges) dfsCode = str(pattern.getDFSCode()) parentDfsCode = str(parentPattern.getDFSCode()) print pattern.getDFSCode() if dfsCode not in PATTERNS: PATTERNS[dfsCode] = set() if not newEdgeIndex: return None if len(newEdgeIndex) != 1: raise Exception("Cannot grow instance graph beucase has child pattern has %d edges more than the parent pattern"%len(newEdgeIndex)) newEdge = g.es[newEdgeIndex.pop()] [v0, v1] = getVertices(g, newEdge) #V0 and V1 are the vertices of the new edge that is present in the child pattern newIg = Graph() for p in PATTERNS[parentDfsCode]: newPatternList = [] pEdgeIndices = set([x.index for x in p.getEdgeList()]) for gv in p.getVertices(): if gv["nl"] != v0["nl"]: continue for gu in gv.neighbors(): if gu["nl"] != v1["nl"]: continue e = getEdge(g, gv, gu) if e.index in pEdgeIndices: continue newPatternEdges = list(p.getEdgeList()) #TODO: Fix this. newPatternEdges.append(e) newPattern = Pattern(g, newPatternEdges) if newPattern in PATTERNS[dfsCode]: continue PATTERNS[dfsCode].add(newPattern) print newPattern print newPatternList.append(newPattern) newIg.add_vertex() vid = newIg.vs[-1:].indices[0] INSTANCE_GRAPH_NODES[newPattern] = vid #Create edges between vertices of newIg createInstanceGraphEdges(newIg, dfsCode) return newIg
def get_domain_graph(vnames,enames): g = Graph(directed=True) g.add_vertices(vnames) es = [] for en in enames: sn,tn = en.split('-') es.append((sn,tn)) g.add_edges(es) return g
def create_graph(vertice,edges=[]): """Create a graph using igraph :add_vertices() method of the Graph class adds the given number of vertices to the graph. :add_edges() method of the Graph class adds edges, they are specified by pairs of integers, so [(0,1), (1,2)] denotes a list of two edge. igraph uses integer vertex IDs starting from zero """ graph = Graph(directed=True) graph.add_vertices(vertice) graph.add_edges(edges) return graph
def read_graph(file_name): # Input edge list file name and output igraph representation df = pd.read_csv(file_name, sep=" ", names=["Edge1", "Edge2"]) n_vertex, n_edge = df.irow(0) df = df.drop(0) graph = Graph(edges=[(x[1]["Edge1"], x[1]["Edge2"]) for x in df.iterrows()], directed=False) assert(graph.vcount() == n_vertex) assert(graph.ecount() == n_edge) return preprocess_graph(graph)
def merge(g1,g2): """ merges graph g1 and graph g2 into the output graph""" g3nslst = list(set(g1.vs['name'][:]) | set(g2.vs['name'][:])) g3 = Graph(0,directed=True) g3.add_vertices(g3nslst) g3elst = [] for e in g1.get_edgelist(): g3elst.append((g1.vs['name'][e[0]],g1.vs['name'][e[1]])) for e in g2.get_edgelist(): g3elst.append((g2.vs['name'][e[0]],g2.vs['name'][e[1]])) g3.add_edges(g3elst) g3.simplify() #add attributes g1primlst = [vn for i,vn in enumerate(g1.vs['name'][:]) if int(g1.vs['inprim'][i]) == 1] g2primlst = [vn for i,vn in enumerate(g2.vs['name'][:]) if int(g2.vs['inprim'][i]) == 1] g3prim = [1 if vn in g1primlst or vn in g2primlst else 0 for vn in g3.vs['name'][:]] g3pnamelst = [[] for i in range(len(g3.vs['name'][:]))] for i,vn1 in enumerate(g3.vs['name'][:]): for j,vn2 in enumerate(g1.vs['name'][:]): if vn1 == vn2: g3pnamelst[i].extend(g1.vs['pnamelst'][j].strip().split('|')) for j,vn2 in enumerate(g2.vs['name'][:]): if vn1 == vn2: g3pnamelst[i].extend(g2.vs['pnamelst'][j].strip().split('|')) g3.vs['pnamelst'] = ['|'.join(map(str,list(set(inp)))) if inp != [] else '' for inp in g3pnamelst] #print g1.vs['pnamelst'][:] #print g3.vs['name'][:] g3.vs['inprim'] = g3prim return g3
def load_adjlist(filename, directed=True): edgelist = [] names = UniqueIdGenerator() for line in open(filename): parts = line.strip().split() u = names[parts.pop(0)] edgelist.extend([(u, names[v]) for v in parts]) logging.debug("Edgelist for line %s : %s" % (parts, edgelist)) g = Graph(edgelist, directed=directed) g.vs["name"] = names.values() return g
def file2igraph(file): """ Converts graph file into iGraph object, adds artifacts """ with open(file, 'r') as fi: v,e = fi.next().split() e_list = [(int(i.split()[0]), int(i.split()[1])) for i in list(fi)] assert (int(e) == len(e_list)),\ "#edges mentioned and # of edges in file differ" g = Graph() g.add_vertices(int(v)) g.add_edges(e_list) return g
def graph_from_sparse(data, directed=None): from igraph import Graph sources, targets = data.nonzero() if directed==None: from numpy import all directed = not all(data[sources, targets]==data[targets, sources]) from numpy import array g = Graph(zip(sources, targets), directed=directed, edge_attrs={'weight': array(data[sources, targets])[0]}) if g.is_directed(): return g else: return g.simplify(combine_edges="first")
def generate_seed_graph(g, k): vcounts = g.vcount() init_seed = random.randint(0, vcounts) seed_graph = Graph(directed=False) seed_graph.add_vertex(g.vs[init_seed]['name'], degree=g.degree(init_seed)) while seed_graph.vcount() != k: choiced_vertex = random.choice(seed_graph.vs) choiced_vertex_index = g.vs.find(name=choiced_vertex['name']) choiced_neighor = g.vs[random.choice(g.neighbors(choiced_vertex_index))] if choiced_neighor['name'] in seed_graph.vs['name']: continue seed_graph.add_vertex(choiced_neighor['name'], degree=g.degree(choiced_neighor['name'])) choiced_neighor_neighor = g.neighbors(choiced_neighor.index) choiced_neighor_neighor_name = [g.vs[i]['name'] for i in choiced_neighor_neighor] existed_nodes = set(choiced_neighor_neighor_name) & set(seed_graph.vs['name']) for node in existed_nodes: choiced_neighor_id = seed_graph.vs.find(name=choiced_neighor['name']).index node_id = seed_graph.vs.find(name=node).index seed_graph.add_edge(choiced_neighor_id, node_id) return seed_graph
def buildGraph(taskList, tsize, eList): G = Graph(tsize + len(eList), directed=False) G.vs['name'] = taskList.keys() + eList G.vs['type'] = 0 G.vs[tsize:]['type'] = 1 for task, entityList in taskList.iteritems(): for entity, score in entityList.iteritems(): #a dict -- entity: score #print task, entity G[task, entity] = score #print G #print G.is_bipartite() return G
class Physic (BaseInputGraph): def __init__(self): ''' @return: Arxiv ASTRO-PH (Astro Physics) collaboration network as iGraph graph instance ''' edges = [] weights = [] f = open("./physic/compact-physic.txt", "r") for line in f: if line and line[0]!='#': seg = line.split() edges.append( (int(seg[0]), int(seg[1])) ) weights.append( 1 ) maxid = max( edges, key=itemgetter(1) )[1] maxid = max( maxid, max(edges,key=itemgetter(0))[0] ) self.g = Graph() self.g.add_vertices(maxid + 1) self.g.add_edges(edges) self.g.to_undirected() self.g.simplify() self.g.vs["myID"] = [ str(int(i)) for i in range(maxid+1)] print "#nodes=", maxid + 1 print "#edges=", len(self.g.es) def run(self): C = BaseInputGraph.unsupervised_logexpand(self) BaseInputGraph.run(self, C, p0=np.array([0.04, 0.04])) with open("./physic/Physic_weights.pairs", "w+") as txt: for e in self.g.es: txt.write("%d %d %f\n" %(e.tuple[0], e.tuple[1], e["weight"]) )
def __findNegativeCut(self,debug=False): """Best negative cut heuristic. Heuristic to find the best cut value to construct the Gamma Model (RMgamma). Args: debug (bool,optional): Show debug information. Returns: A Heuristic object that contains all the relevant info about the heuristic. """ time_total = time.time() # Graph and unique set construction time_graph_construction = time.time() graph_negative = Graph() graph_negative.add_vertices(self.__n) unique_negative_weights = set() for i in range(self.__n): for j in range (i+1,self.__n): if self.__S[i][j] <= 0: graph_negative.add_edge(i,j,weight=self.__S[i][j]) unique_negative_weights.add(self.__S[i][j]) time_graph_construction = time.time() - time_graph_construction # Sort unique weights and start heuristic to find the best cut value time_find_best_cut = time.time() unique_negative_weights = sorted(unique_negative_weights) # Test different cuts and check connected best_negative_cut = 0 for newCut in unique_negative_weights: edges_to_delete = graph_negative.es.select(weight_lt=newCut) graph_negative.delete_edges(edges_to_delete) if graph_negative.is_connected(): best_negative_cut = newCut else: break time_find_best_cut = time.time() - time_find_best_cut time_total = time.time() - time_total if debug==True: print ("Time Graph Construction: %f" %(time_graph_construction)) print ("Time Heuristic to find best cut: %f" %(time_find_best_cut)) print ("Total Time: %f" %(time_total)) print ("NEW (Best cut-): %d" %(best_negative_cut)) heuristic={} heuristic['cut'] = best_negative_cut heuristic['time_total']=time_total heuristic['time_graph_construction']=time_graph_construction heuristic['time_find_best_cut']=time_find_best_cut return heuristic
def test_shouldReturnCommunityLevelWithMaximumCommunities(self): graph_1 = Graph() graph_1.add_vertices(["1","2","3","4"]) graph_1.add_edges([("1","2"),("2","4"),("1","4"),("2","3")]) graph_2 = Graph() graph_2.add_vertices(["1","3","4"]) graph_2.add_edges([("3","4"),("1","4"),("1","3")]) vertex_clustering_1 = VertexClustering(graph_1) vertex_clustering_2 = VertexClustering(graph_2) community_levels = [vertex_clustering_1, vertex_clustering_2] expected_communities = vertex_clustering_1 actual_communities = SentenceGraph().find_best_community_level(community_levels) self.assertEquals(actual_communities, expected_communities)
class Ring ( BaseInputGraph ): wvalue = 1 g = Graph() # the iGraph graph instance def __init__(self, v): ''' @param v: the weight of edge connecting two cliques @return: the produced ring network as iGraph graph instance ''' self.wvalue = v edges = [] ws = [] clique_num = 30 clique_size = 5 for c in range(0, clique_num): for i in range(clique_size*c, clique_size*(c+1)): for j in range(i+1, clique_size*(c+1)): edges.append((i,j)) ws.append(1) for c in range(0, clique_num): edges.append((clique_size*c, clique_size*( (c+1) % clique_num))) ws.append(self.wvalue) maxid = max( edges, key=itemgetter(1))[1] maxid = max( maxid, max(edges,key=itemgetter(0))[0] ) self.g = Graph() self.g.add_vertices(maxid + 1) self.g.add_edges(edges) self.g.es["weight"] = ws self.g.vs["comm"] = [str( int(_ / clique_size) ) for _ in range(len(self.g.vs))] print "#nodes=", maxid + 1 print "#edges=", len(self.g.es) def run(self): ''' run the algorithm ''' #supervised group = [0,1,2,3,4] C = BaseInputGraph.get_C(self, group) #unsupervised #C = BaseInputGraph.unsupervised_logexpand(self) print C BaseInputGraph.run(self, C) for e in self.g.es: print "(",e.tuple[0]," ,", print e.tuple[1],")=", print e["weight"]
def create_dgraph(self): """ initializes self.graph: the total directed graph of reactions. It ereases any preceding graph. """ self.dgraph = Graph(0,directed = True) cnlst = [] rnlst = [] rlinks = [] for rct in self.rlst: rnlst.append(rct.name) for i in rct.innames: cnlst.append(i) rlinks.append((i,rct.name)) for o in rct.outnames: cnlst.append(o) rlinks.append((rct.name,o)) if rct.reversible == True: rnlst.append(rct.name+'_r') for o in rct.innames: rlinks.append((rct.name+'_r',o)) for i in rct.outnames: rlinks.append((i,rct.name+'_r')) cnlst = list(set(cnlst)) cinpathlst = [self.gsearch(cn).inpath if self.gsearch(cn) != None else [] for cn in cnlst] rnlst = list(set(rnlst)) rinpathlst = [self.rsearch(rn).inpath if '_r' not in rn else self.rsearch(rn[0:len(rn)-2]) for rn in rnlst] cnlst.extend(rnlst) cinpathlst.extend(rinpathlst) self.dgraph.add_vertices(cnlst) self.dgraph.add_edges(rlinks) self.dgraph.vs['inpath'] = cinpathlst #print rlinks[len(rlinks)-3000:len(rlinks)-1] print self.dgraph.summary()
def __init__(self, v): ''' @param v: the weight of edge connecting two cliques @return: the produced ring network as iGraph graph instance ''' self.wvalue = v edges = [] ws = [] clique_num = 30 clique_size = 5 for c in range(0, clique_num): for i in range(clique_size*c, clique_size*(c+1)): for j in range(i+1, clique_size*(c+1)): edges.append((i,j)) ws.append(1) for c in range(0, clique_num): edges.append((clique_size*c, clique_size*( (c+1) % clique_num))) ws.append(self.wvalue) maxid = max( edges, key=itemgetter(1))[1] maxid = max( maxid, max(edges,key=itemgetter(0))[0] ) self.g = Graph() self.g.add_vertices(maxid + 1) self.g.add_edges(edges) self.g.es["weight"] = ws self.g.vs["comm"] = [str( int(_ / clique_size) ) for _ in range(len(self.g.vs))] print "#nodes=", maxid + 1 print "#edges=", len(self.g.es)
def __init__(self, trialval=1): ws = [] edges = [] self.trial = trialval with open("./binary_networks/mu0.5/network%d.dat" % self.trial, "r") as txt: for line in txt: seg = line.split() edges.append((int(seg[0]), int(seg[1]))) ws.append(1) maxid = max( edges, key=itemgetter(1))[1] maxid = max( maxid, max(edges,key=itemgetter(0))[0] ) self.g = Graph() print maxid self.g.add_vertices(maxid + 1) with open("./binary_networks/mu0.5/community%d.dat" % self.trial, "r") as txt: for line in txt: seg = line.split() #print seg[0] self.g.vs[int(seg[0])]["comm"] = seg[1] #note: string is returned self.g.add_edges(edges) self.g.to_undirected() self.g.simplify() self.g.delete_vertices(0) self.g.es["weight"] = ws BaseInputGraph.write_ground_truth(self, "./ground_truth_community%d.groups" % self.trial) print "#nodes=", maxid + 1 print "#edges=", len(self.g.es)
def parse_seed_response(data): g = Graph(directed=False) lines = data.splitlines() #query_count = lines[1] node_attr, edge_attr = [int(i) for i in lines[2].split(' ')] node_count = int(lines[3]) for i in lines[4: node_count+4]: attr_dict = parse_node_attribute(i, node_attr) if not attr_dict: continue g.add_vertex(**attr_dict) for i in lines[node_count+5:]: attr_dict = parse_edge_attribute(i, edge_attr) if not attr_dict: continue g.add_edge(**attr_dict) return g, node_attr, edge_attr
def __init__(self, steps, links=None, nlinks=None, name=None): Graph.__init__(self, directed=True, graph_attrs={'name': name}) for step in steps: self._set_io_fields(step) self.add_vertex(**step) assert len(steps) < 2 or links or nlinks, ( 'steps must be defined with links' ) if nlinks: self._add_ctrlflow_links(self._get_links(nlinks)) elif links: self._add_ctrlflow_links(links) self.validate() self.check_dataflow() self._add_dataflow_links() self.validate()
def createTestGraph(): ''' Test code. Creates a graph to test on''' #g = Graph([(0,1), (0,2), (2,3), (3,4), (4,2), (2,5), (5,0), (6,3), (5,6)]) #Test graph g = Graph([(0,1),(1,2),(0,2),(2,3),(3,4),(4,5),(3,5),(5,6),(3,6),(6,7),(2,7),(7,8),(8,9),(9,10),(8,10),(6,8)]) # Create vertex labels vertex_lables = ["A", "B", "B", "B", "A", "B", "B", "C", "A", "B", "B"] # Create edge labels #edge_labels = ["a", "a", "a", "a", "b", "b", "b", "c", "d"] edge_labels = ["a"] g.vs["l"] = vertex_lables g.es["l"] = edge_labels ''' g = Graph([(0,1), (1,2), (2,0), (2,3)]) g.vs["nl"] = ["A", "B", "C", "D"] g.es["nl"] = ["e"] ''' return g
def __init__(self, name): self._g = Graph(directed=True) self._kernels = dict() self._length = dict() self._max_depth = -1 self._num_kernels = 0 super().__init__(name, 'dag')
def __init__(self): self.br = mechanize.Browser(factory=mechanize.RobustFactory()) self.br.set_handle_robots(False) self.br.addheaders = [('User-agent', 'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.0.1) Gecko/2008\ 071615 Fedora/3.0.1-1.fc9 Firefox/3.0.1')] self.graph = Graph(0, directed=True) self.urls = {} self.path = []
def get_graph_from_matrix(assoc_mat,density,ignore_weights=True): """ get graph from association matrix """ mat = assoc_mat.vmat l = mat.shape[0] g = Graph(directed=True) g.add_vertices(l) g.vs['name'] = assoc_mat.names max_edges = int(l*(l-1)*density) a,b = mat.nonzero() values = sortedlist() es = [] weights = [] for z in range(len(a)): values.add(mat[a[z],b[z]]) if mat.nnz < max_edges: threshold = min(values) else: threshold = values[len(values)-(max_edges+1)] for z in range(len(a)): w = mat[a[z],b[z]] if w >= threshold: es.append((a[z],b[z])) weights.append(w) g.add_edges(es) if not ignore_weights: g.es['weight'] = weights # this amounts to row-normalize the adjacency matrix GraphUtils.normalize_out_weights(g) return g
def translate_cfg(neo4j_db, function_node): cfg_edges = get_cfg_edges(neo4j_db, function_node) #create igraph cfg g = Graph(directed = True) #add edge and edge properties for edge in cfg_edges : start_node = edge.start_node end_node = edge.end_node if start_node is None or end_node is None: print "edge has no start or end node" try: g.vs.find(name=str(start_node._id)) except: g.add_vertex(name=str(start_node._id), **get_node_properties(start_node.properties)) try: g.vs.find(name=str(end_node._id)) except: g.add_vertex(name=str(end_node._id), **get_node_properties(end_node.properties)) g.add_edge(str(start_node._id), str(end_node._id),**get_cfg_edge_properties(edge.properties)) return g
def __json_loads(self, json_str): """ Load graph from json file """ json_dict = json.loads(json_str) cp = Graph() for v in json_dict["nodes"]: node = Node(v["id"], timestamps=v["timestamps"], colors=v["colors"],label=v["id"], attributes=v["attributes"], membership=v["membership"],positions=v["positions"]) cp.__add_node(node) for e in json_dict["edges"]: edge = Edge(e["source"], e["target"], timestamps=e["timestamps"],attributes=e["attributes"], ranges=e["ranges"]) cp.__add_edge(edge) self.__dict__ = json_dict self.nodes = cp.nodes self.edges = cp.edges
def readFromFile(file): """ Function which forms igraph graph object by reading edgelsit from the input file :param file: :return:the graph g, number of vertices of g """ with open(file, mode="r") as f: vertices, edges = f.readline().split() edgeList = list() for line in f: #add each line to edgelist as (a,b) where a and b are vertex ids edgeList.append((int(line.split()[0]), int(line.split()[1]))) g = Graph(int(vertices)) g.add_edges(edgeList) #makes sure that edges are equal to nubmer specified in file assert (int(edges) == len(edgeList)) return g, int(vertices)
from igraph import Graph from igraph import plot grafo5 = Graph(edges=[(0, 1), (2, 3), (0, 2), (0, 3)], directed=True) grafo5.vs['label'] = ['Fernando', 'Pedro', 'Jose', 'Antonio'] grafo5.vs['peso'] = [40, 30, 30, 25] grafo5.es['TipoAmizade'] = ['Amigo', 'Inimigo', 'Inimigo', 'Amigo'] grafo5.es['weight'] = [1, 2, 1, 3] for v in grafo5.vs: print(v) for e in grafo5.es: print(e) grafo5.vs['cor'] = ['blue', 'red', 'yellow', 'green'] plot(grafo5, bbox=(300, 300), vertex_size=grafo5.vs['peso'], edge_width=grafo5.es['weight'], vertex_color=grafo5.vs['cor'], edge_curved=0.4, vertex_shape='square') # tkplot
def calcAllRoutes(net): """ Configures IP routes between all nodes in the emulation topology. This is done in three steps: 1) IP forwarding is enabled on all nodes 2) The igraph lib is used to calculate all shortest paths between the nodes 3) Route add commands are used to actually configure the ip routes :param net: """ mini_nodes = net.hosts mini_links = net.links # Enabling IP forwaring on all nodes info('Configure IP forwarding on all nodes\n') for node in mini_nodes: node.cmd('sysctl -w net.ipv4.ip_forward=1') # Calculate igraph to calculate all shortest paths between nodes node_names = [node.name for node in mini_nodes] links = [] for link in mini_links: links.append((link.intf1.node.name, link.intf2.node.name)) links.append((link.intf2.node.name, link.intf1.node.name)) networkGraph = Graph() networkGraph = networkGraph.as_directed() for node in node_names: networkGraph.add_vertex(node) for (a, b) in links: networkGraph.add_edges([(a, b), (b, a)]) named_paths = [] for from_node in node_names: for to_node in node_names: if from_node != to_node: paths = networkGraph.get_all_shortest_paths(from_node, to_node) if len(paths) == 0: continue shortest_path = paths[0] shortest_path_with_nodenames = [] for node in shortest_path: shortest_path_with_nodenames.append(networkGraph.vs['name'][node]) named_paths.append(shortest_path_with_nodenames) # Iterate over all paths and configure the routes using the 'route add' info('Configure routes on all nodes\n') for path in named_paths: start_node = path[0] end_node = path[-1] mini_start = net.get(start_node) mini_end = net.get(end_node) link_info = IPRoutingHelper.findLinkInformation(mini_links, path[0], path[1]) start_intf = link_info.start_intf_name for intf in mini_end.intfs: addr = mini_end.intfs[intf].ip if len(path) == 2: # For direct connection, configure exit interface info('[{}] route add -host {} dev {}\n'.format(start_node, addr, start_intf)) mini_start.cmd('route add -host {} dev {}'.format(addr, start_intf)) elif len(path) > 2: # For longer paths, configure next hop as gateway gateway_ip = link_info.end_ip info('[{}] route add -host {} dev {} gw {}\n' .format(start_node, addr, start_intf, gateway_ip)) mini_start.cmd('route add -host {} dev {} gw {}' .format(addr, start_intf, gateway_ip))
''' leitura dos arquivos e criacao do dataframe ''' f = os.listdir(rd + "/grafosMes") # lista com os nomes dos grafos f = ordenaNomesArquivos(f) # ordena os nomes cronologicamente for arquivo in f: # percorre todos os grafos mensais em ordem # guarda o ano do grafo A = substringEntreChars(arquivo, '-', '.') dados['ano'].append(A) # guarda o mes do grafo M = substringEntreChars(arquivo, '_', '-') dados['mes'].append(M) # guarda mes do grafo # abre o grafo g = Graph.Read_GML(rd + "/grafosMes/" + arquivo) # calculo e armazenamento do grau medio listaDado = g.degree() dado = somaLista(listaDado) / len(listaDado) dados['mean_degree'].append(dado) # calculo e armazenamento da betweenness media listaDado = g.betweenness() dado = somaLista(listaDado) / len(listaDado) dados['mean_betweenness'].append(dado) # calculo e armazenamento da closeness media listaDado = g.closeness() dado = somaLista(listaDado) / len(listaDado) dados['mean_closeness'].append(dado)
in_edges += subgraph.ecount() print(f"fraction: {in_edges / graph.ecount()}") print("Degree Distribution: ") print(graph.degree_distribution()) return parts.modularity def desc_learners(learners: List[Learner]): result = list() for learner in learners: result.append( [ [round(val, 4) for val in learner._rows], [round(val, 4) for val in learner._cols], ] ) return json.dumps(result) if __name__ == '__main__': graph_name = "4_50_1_10_0.9" test_graph = Graph.Read_GML(f"../data/gaussian/{graph_name}.gml") desc(test_graph) # test_graph.name = graph_name # # get_edges(test_graph, 1, fast_resistance, 1000, 1000)
def group_union(g_a_links, g_b_links): """ Synonym groups are modelled by sets of couples in the DB Input : 2 arrays of links (ngramx_id, ngramy_id) Input : 1 array of links (ngramx_id, ngramy_id) Synonymity is considered transitive so in effect the groups can form a set (defined by the connected component of couples). A requested feature is also that one node dominates others (aka "leader effect"; leader will be in the map, the others won't) Summary of major union effects in various cases: GROUP 1 Group 2 Group 1 ∪ 2 A -> B A -> C A -> B (simple union) A -> C D -> E E -> F D -> E D -> F (D "leader effect") G -> H G -> I G -> H ( transitivity + H -> J G -> I "leader effect") G -> J rloth: this is some slightly amended code from Samuel's in rest_v1_0.ngrams.Group.get TODO use "most frequent" score if leader candidates are ex aequo by degree. """ # output: list of links forming new group new_links = [] # 1) create graph with both lists # ------------------------------- # from igraph import Graph # the set of all our ngram_ids all_vertices = set( [ngid for couple in g_a_links + g_b_links for ngid in couple]) # initialize the synonym graph with size sg = Graph(len(all_vertices), directed=True) # add our IDs as "name" (special attribute good for edge creation) sg.vs['name'] = [str(x) for x in all_vertices] # add the edges as named couples sg.add_edges([(str(x), str(y)) for (x, y) in g_a_links]) #print('UNION A:', g_a_links) #print('initially %i components' % len(sg.as_undirected().components())) # same with the other edges sg.add_edges([(str(x), str(y)) for (x, y) in g_b_links]) #print('UNION B:', g_b_links) #print('after union %i components' % len(sg.as_undirected().components())) # 2) list resulting components # ----------------------------- synonym_components = sg.as_undirected().components() # for example # cs = [[0, 3, 6], [1, 2, 8], [4, 5, 9, 11], [7,10]] # there should be no singletons by construction # list of all outdegrees for "leader" detection # (leader = term most often marked as source by the users) odegs = sg.outdegree() #for i, v in enumerate(sg.vs): # print("%i - name:%s - odeg:%i" % (i, v['name'], odegs[i])) for component in synonym_components: # we map back to our ids, preserving order our_comp = [int(our_id) for our_id in sg.vs[component]['name']] # 3) take main node and unnest into new links list # ------------------------------------------------- # position (within this component) of the best node (by degree) max_odeg = -1 main_node_local_index = None for position, vertex_id in enumerate(component): this_odeg = odegs[vertex_id] if this_odeg > max_odeg: main_node_local_index = position max_odeg = this_odeg # we set it aside in our translated version our_comp main_node = our_comp.pop(main_node_local_index) # and unnest the others for remaining_id in our_comp: new_links.append((main_node, remaining_id)) return new_links
def plotLatticeGraph_colorGroups( inputTuples, name_mapping, different_colors_group, metric="", color_map={}, annotation_F=True, sizeDot="", useMarker=True, show=False, font_size_div=10, font_size_hover_labels=10, showTitle=False, round_v=3, width=None, height=None, showGrid=True, plot_bgcolor="rgb(248,248,248)", displayItemsetLabels=False, font_size_ItemsetLabels=10, ): from igraph import Graph, EdgeSeq G = Graph.TupleList([(k, v) for k, vs in inputTuples.items() for v in vs]) lay = G.layout("rt", root=[0]) nr_vertices = G.vcount() position = {k: lay[k] for k in range(nr_vertices)} Y = [lay[k][1] for k in range(nr_vertices)] M = max(Y) E = [e.tuple for e in G.es()] # list of edges labels = G.vs()["name"] groups = {} groups_labels = {} X_group = {} Y_group = {} if useMarker: markers_type = { "normal": "circle-dot", "lower": "diamond", "greater": "square", "all_greater": "hexagon", } else: markers_type = {k: "circle-dot" for k in different_colors_group} colors = ["#6175c1", "#ff6666", "#008000", "#FFC0CB"] # todo setColorMap = False if color_map != {} else True counter_c = 0 for group_i in different_colors_group: different_color = different_colors_group[group_i] groups[group_i] = [ i for i in range(0, len(labels)) if labels[i] in different_color ] groups_labels[group_i] = [ labels[i] for i in range(0, len(labels)) if labels[i] in different_color ] X_group[group_i] = [position[k][0] for k in groups[group_i]] Y_group[group_i] = [2 * M - position[k][1] for k in groups[group_i]] if setColorMap: color_map[group_i] = colors[counter_c] counter_c = counter_c + 1 Xe = [] Ye = [] for edge in E: Xe += [position[edge[0]][0], position[edge[1]][0], None] Ye += [ 2 * M - position[edge[0]][1], 2 * M - position[edge[1]][1], None ] sizeDot = 10 if sizeDot == "small" else 18 import plotly.graph_objects as go fig = go.Figure() fig.add_trace( go.Scatter( x=Xe, y=Ye, mode="lines", line=dict(color="rgb(210,210,210)", width=1), hoverinfo="none", )) for group_i in different_colors_group: fig.add_trace( go.Scatter( x=X_group[group_i], y=Y_group[group_i], mode="markers", name=metric, marker=dict( symbol=markers_type[group_i], size=sizeDot, color=color_map[group_i], #'#DB4551', line=dict(color="rgb(50,50,50)", width=1), ), text=orderedNameMapping(groups_labels[group_i], name_mapping) if annotation_F else groups_labels[group_i], hoverinfo="text", opacity=0.8, hoverlabel=dict(font_size=font_size_hover_labels), )) if annotation_F: labels_text = [str(round(name_mapping[l], round_v)) for l in labels] axis = dict( showline=False, # hide axis line, grid, ticklabels and title zeroline=False, showgrid=showGrid, showticklabels=False, ) def make_annotations(pos, labels_text, font_size=10, font_color="rgb(0,0,0)"): L = len(pos) if len(labels_text) != L: raise ValueError( "The lists pos and text must have the same len") annotations = [] for k in range(L): annotations.append( dict( text=labels_text[ k], # or replace labels with a different list for the text within the circle x=pos[k][0], # y=2 * M - position[k][1] + 0.05 * (2 * M - position[k][1]), y=2 * M - position[k][1] + 0.03 * (2 * M), xref="x1", yref="y1", font=dict(color=font_color, size=font_size), showarrow=False, )) return annotations fig.update_layout( title=metric if showTitle else None, # TODO - TMP annotations=make_annotations(position, labels_text, font_size=font_size_div), font_size=10, showlegend=False, xaxis=axis, yaxis=axis, margin=dict(l=0, r=0, b=0, t=20) if showTitle else dict(l=0, r=0, b=0, t=0), hovermode="closest", plot_bgcolor=plot_bgcolor, width=width, height=height, ) if displayItemsetLabels: max_len = max([len(i) for i in name_mapping.keys()]) X_range = [abs(lay[k][0]) for k in range(nr_vertices)] X_range = max(X_range) - (min(X_range)) order_mapping = { v: id_v for id_v, v in enumerate(name_mapping) if len(v) in [1, max_len] } for group_i, a in groups_labels.items(): for i, itemset in enumerate(a): if len(itemset) not in [1, max_len]: continue p = (X_group[group_i][i], Y_group[group_i][i]) get_x_pos = lambda pos_x, pad: pos_x - pad * X_range get_y_pos = lambda pos_y, pad: pos_y + pad * pos_y p_ref_x = 0.2 if order_mapping[itemset] % 2 == 0 else 0.25 p_ref_y = -0.045 get_name = lambda v: ", ".join(sorted(list(v))) fig.add_annotation( x=p[0], y=p[1], xref="x", yref="y", text=get_name(itemset), align="left", axref="x", ayref="y", ax=get_x_pos( p[0], p_ref_x + 0.01 * (font_size_ItemsetLabels - 10)) if len(itemset) == 1 else get_x_pos(p[0], -0.7), ay=get_y_pos(p[1], p_ref_y if len(itemset) == 1 else -0.03), showarrow=True, font=dict( # family="Courier New, monospace", size=font_size_ItemsetLabels, color="black", ), bordercolor="white", borderwidth=1, borderpad=4, bgcolor=color_map[group_i], opacity=0.8, # yanchor="middle" ) if show: fig.show() # TMP return fig
au0=ROC('au0') ag0=ROC('ag0') cu0=ROC('cu0') total=a0.join([y0,m0,oi0,rm0,p0,cs0,c0,ap0,sr0,cf0,jd0,ru0,rb0,hc0,i0,j0,jm0,zc0,fg0,sf0,sm0,l0,v0,pp0,ta0,ma0,al0,zn0,au0,ag0,cu0],how='inner').dropna(axis=0) corr=total.corr() sns.heatmap(corr,xticklabels=1,yticklabels=1) plt.show() A=corr.values g=igraph.Graph.Adjacency((A>0).tolist()) g.es['weight'] = A[A.nonzero()] g.vs['label'] = corr.columns cluster=IGraph.community_walktrap(g, g.es['weight']) clusters = IGraph.community_walktrap(g, g.es['weight'],steps=10000).as_clustering(8) nodes = [{"label": node["label"]} for node in g.vs] community = {} for node in nodes: idx = g.vs.find(label=node["label"]).index node["community"] = clusters.membership[idx] if node["community"] not in community: community[node["community"]] = [node["label"]] else: community[node["community"]].append(node["label"]) for c,l in community.items(): print("Community ", c, ": ", l)
""" The following error says that modularity calculation for directed graph is not implemented ---- File "/home/mridul/playground/citation-club/env/lib/python3.8/site-packages/igraph/__init__.py", line 898, in modularity return GraphBase.modularity(self, membership.membership, weights) igraph._igraph.InternalError: Error at ../../../source/igraph/src/community.c:921: modularity is implemented for undirected graphs, Invalid value ---- So we convert our citation network as undirected graph and calculate modularity """ import sys import pickle from igraph import Graph try: journal = sys.argv[1] except IndexError: #journal = "prl" print("usage: python3", sys.argv[0], "[jmlr|prl]") exit(0) g = Graph.Read_Ncol("data/" + journal + "/el_cit", directed=True) lcc = g.components(mode="WEAK").giant() vd = lcc.community_walktrap() cit = vd.as_clustering() lcc.to_undirected() # cit = pickle.load(open("results/experiment1/"+journal+".communities_cit.bin", 'rb')) print("cit net modularity : ", lcc.modularity(cit))
os.makedirs(plot_dir, exist_ok=True) #%% # ============================================================================= # Build class networks # ============================================================================= class_files = [ 'ClassNetPlatoonU.graphml', 'ClassNetPlatoonM.graphml', 'ClassNetPlatoonT.graphml', 'ClassNetPlatoonW.graphml', 'ClassNetPlatoonR.graphml', 'ClassNetPlatoonF.graphml', 'ClassNetPlatoonS.graphml', ] graphs = [Graph.Read_GraphML(os.path.join(net_dir, cf)) for cf in class_files] class_layer_names = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'] class_contacts = bu.get_all_class_contacts_dicts(graphs, class_layer_names, 3) #%% # ============================================================================= # Build housing networks # ============================================================================= h_files = ['RoomNet.graphml', 'HouseholdNet_10.graphml', 'FloorNet.graphml'] hgraphs = [Graph.Read_GraphML(os.path.join(hnet_dir, hf)) for hf in h_files] hlayer_names = ['roommate', 'household', 'floor'] household_contacts = bu.get_all_housing_contacts_dict(hgraphs, hlayer_names) #%%
# Lásd. halozatok_segedlet.tex from igraph import Graph, summary from igraph import plot as iplot # iplot néven, hogy ne keveredjen a pylab.plot függvénnyel # Programfájlban kellene még ez a sor is a -pylab opció helyett: from pylab import plot, average, array, grid, xlabel, ylabel, legend, show # vagy egyszerűen from pylab import * # és minden plot függvény után kellene # show() függvény. import pylab # esetén pedig pylab.függvény() alakban hívhatóak a pylab függvényei. net = Graph.Erdos_Renyi(1000, .001) summary(net) M=net.ecount() N = net.vcount() Mmax = N*(N-1)/2 Mmax M/Mmax p = 1.*M/Mmax net.diameter() net.components() cc=net.components() # (összefüggő) komponensek, (connected) components ccs = cc.sizes()
import os import igraph from igraph import Graph print igraph INFILE = "new_graph.net" OUTFILE_SVG = "new_graph.svg" OUTFILE_PNG = "new_graph.png" #g = Graph.Load("output/SimpleModuleGraphALL.net") g = Graph.Load(INFILE) #g = igraph.load("output/SimpleModuleGraph.net") #print g.es #print g.es["weight"] #print g.cliques() print len(g.vs) # delete edges that have low weight to_del = [] #for e in g.es: # print e # if(e['weight'] < 0): # to_del.append(e.index) #g.delete_edges(to_del) g.simplify() g1 = g.subgraph(g.vs.select(_degree_gt=0)) print len(g1.vs)
from igraph import Graph from igraph import plot # Criação de um gráfico direcionado com pesos entre as arestas grafo = Graph(edges=[(0, 2), (0, 1), (1, 4), (1, 5), (2, 3), (6, 7), (3, 7), (4, 7), (5, 6)], directed=True) grafo.vs['label'] = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] grafo.es['weight'] = [2, 1, 2, 1, 2, 1, 3, 1] # Visualização dos resultados plot(grafo, bbox=(0, 0, 300, 300), edge_label=grafo.es['weight']) # Menor caminho entre A - H (retorna os vértices) caminho_vertice = grafo.get_shortest_paths(0, 7, output='vpath') #vpath vértices caminho_vertice # Retorna as arestas que ligam os dois vértices caminho_aresta = grafo.get_shortest_paths(0, 7, output='epath') #epath arestas caminho_aresta # Mostra o ID dos vértices que fazem parte do caminho caminho_aresta_id = [] for n in caminho_aresta[0]: caminho_aresta_id.append(n) caminho_aresta_id # Mostra o nome dos vértices que fazem parte do caminho caminho_nome_vertices = [] for n in caminho_vertice[0]:
class BaseNetwork(metaclass=abc.ABCMeta): NAME = 'Base Network' CODE = 'base_network' DIRECTED = False # CHANGE NAME NODE_METRICS_TO_PLOT = { 'Tenure in the wiki': { 'key': 'birth_value', 'max': 'max_birth_value', 'min': 'min_birth_value' }, 'Degree': { 'key': 'degree', 'max': 'max_degree', 'min': 'min_degree' }, 'In-degree': { 'key': 'indegree', 'max': 'max_indegree', 'min': 'min_indegree' }, 'Out-degree': { 'key': 'outdegree', 'max': 'max_outdegree', 'min': 'min_outdegree' }, 'Closeness': { 'key': 'closeness', 'max': 'max_closeness', 'min': 'min_closeness' }, 'Betweenness': { 'key': 'betweenness', 'max': 'max_betweenness', 'min': 'min_betweenness' }, 'Page rank': { 'key': 'page_rank', 'max': 'max_page_rank', 'min': 'min_page_rank' } } EDGE_METRICS_TO_PLOT = { 'Weight': { 'key': 'weight', 'min': 'min_weight', 'max': 'max_weight', } } NETWORK_STATS = { 'Nodes': 'num_nodes', 'Edges': 'num_edges', 'Connected comp.': 'components', 'Clusters': 'n_communities', 'Density': 'density', 'Assortativity': 'assortativity_degree', 'Gini of betwee.': 'gini_betweenness', 'Gini of close.': 'gini_closeness', 'Gini of deg.': 'gini_degree', 'Gini of in-deg.': 'gini_indegree', 'Gini of out-deg.': 'gini_outdegree' } def __init__(self, is_directed=False, graph={}, alias=''): if not graph: self.graph = Graph(directed=is_directed) else: self.graph = graph self.alias = alias @abc.abstractmethod def generate_from_pandas(self, df: pd.DataFrame): """ Fill the igraph attribute from pandas data Parameters: -df: A pandas object with the wiki info (coming from the csv file), must be ordered by timestamp """ pass @abc.abstractmethod def get_metric_dataframe(self, metric: str) -> pd.DataFrame: """ This function generates a dateframe with 2 cols, the node name and a node metric value. Prarameters: - metric: an existing metric in the network Return: if metric exist a dataframe, if not None """ pass @abc.abstractclassmethod def get_metric_header(self, metric: str) -> list: """ Returns a list with the header keys of the function get_metric_dataframe """ pass @abc.abstractclassmethod def get_user_info(self) -> dict: """ Return a dict with the user info """ pass @abc.abstractclassmethod def get_node_name(self) -> dict: pass @abc.abstractclassmethod def is_directed(cls) -> bool: pass @abc.abstractclassmethod def get_network_stats(cls) -> dict: pass @abc.abstractclassmethod def get_metrics_to_plot(cls) -> dict: """ This is used to clean NODE_METRICS_TO_PLOT """ pass @abc.abstractclassmethod def get_metrics_to_show(cls) -> dict: """ This is used to clean and prepare NODE_METRICS_TO_PLOT in order to show the data """ pass @abc.abstractclassmethod def get_node_metrics(cls): pass @classmethod def remove_non_directed_node_metrics(cls, metrics): if 'Degree' in metrics: del metrics['Degree'] @classmethod def remove_directed_node_metrics(cls, metrics): if 'In-degree' in metrics: del metrics['In-degree'] if 'Out-degree' in metrics: del metrics['Out-degree'] def add_graph_attrs(self): """ Calculates and adds the graph attrs """ self.graph['num_nodes'] = self.graph.vcount() self.graph['num_edges'] = self.graph.ecount() def to_cytoscape_dict(self) -> dict: """ Transform a network to cytoscape dict Return: A dict with the cytoscape structure, graph attrs are keys, and the cyto. elements are in the key 'network' """ di_net = {} network = [] metrics_to_plot = [ val for key, val in self.NODE_METRICS_TO_PLOT.items() ] metrics_to_plot = metrics_to_plot + [ val for key, val in self.EDGE_METRICS_TO_PLOT.items() ] log_keys = { metric['key'] for metric in metrics_to_plot if 'log' in metric.keys() } # node attrs for node in self.graph.vs: data = {'data': {}} for attr in self.graph.vs.attributes(): val = node[attr] if attr in log_keys: data['data'][f'{attr}_log'] = int(log(val) * 100) data['data'][attr] = val network.append(data) # edge attrs for edge in self.graph.es: data = {'data': {}} for attr in self.graph.es.attributes(): val = edge[attr] if attr == 'id': continue if attr in log_keys: data['data'][f'{attr}_log'] = int(log(val) * 100) data['data'][attr] = val network.append(data) # graph attrs for attr in self.graph.attributes(): di_net[attr] = self.graph[attr] # add max min metrics to plot _max = 0 _min = 0 for metric in metrics_to_plot: if metric['key'] in self.graph.vs.attributes() and len( self.graph.vs[metric['key']]): _max = max(self.graph.vs[metric['key']]) _min = min(self.graph.vs[metric['key']]) elif metric['key'] in self.graph.es.attributes() and len( self.graph.es[metric['key']]): _max = max(self.graph.es[metric['key']]) _min = min(self.graph.es[metric['key']]) if 'log' in metric.keys(): _max = int(log(_max) * 100) _min = int(log(_min) * 100) di_net[metric['max']] = _max di_net[metric['min']] = _min di_net['network'] = network return di_net def write_gml(self, file: str): """ Writes a gml file Parameters: file: path to save """ self.graph.write(f=file, format='gml') def calculate_page_rank(self): """ Calculates the network pageRank """ if not 'page_rank' in self.graph.vs.attributes(): weight = 'weight' if 'weight' in self.graph.es.attributes( ) else None p_r = self.graph.pagerank(directed=self.graph.is_directed(), weights=weight) self.graph.vs['page_rank'] = list( map(lambda x: float(f"{x:.4f}"), p_r)) def calculate_betweenness(self): """ Calculates the network betweenness """ if not 'betweenness' in self.graph.vs.attributes(): weight = 'weight' if 'weight' in self.graph.es.attributes( ) else None bet = self.graph.betweenness(directed=self.graph.is_directed(), weights=weight) self.graph.vs['betweenness'] = list( map(lambda x: float(f"{x:.4f}"), bet)) def calculate_gini_betweenness(self): if 'betweenness' in self.graph.vs.attributes() and 'gini_betweenness'\ not in self.graph.attributes(): gini = ineq.gini_corrected(self.graph.vs['betweenness']) value = 'nan' if gini is not np.nan: value = f"{gini:.2f}" self.graph['gini_betweenness'] = value def calculate_degree(self): if self.graph.is_directed() and 'indegree' not in self.graph.vs: self.graph.vs['indegree'] = self.graph.indegree() self.graph.vs['outdegree'] = self.graph.outdegree() elif 'degree' not in self.graph.vs: self.graph.vs['degree'] = self.graph.degree() def calculate_gini_degree(self): if self.graph.is_directed() and 'gini_indegree' not in\ self.graph.attributes(): gini = ineq.gini_corrected(self.graph.vs['indegree']) value = 'nan' if gini is not np.nan: value = value = f"{gini:.2f}" self.graph['gini_indegree'] = value gini = ineq.gini_corrected(self.graph.vs['outdegree']) value = 'nan' if gini is not np.nan: value = value = f"{gini:.2f}" self.graph['gini_outdegree'] = value elif 'gini_degree' not in self.graph.attributes(): gini = ineq.gini_corrected(self.graph.vs['degree']) value = 'nan' if gini is not np.nan: value = value = f"{gini:.2f}" self.graph['gini_degree'] = value def calculate_communities(self): """ Calculates communities and assigns a color per community """ if not 'n_communities' in self.graph.attributes(): weight = 'weight' if 'weight' in self.graph.es.attributes( ) else None # igraph bug: https://github.com/igraph/python-igraph/issues/17 try: v_d = self.graph.community_walktrap(weights=weight, steps=6) mod = v_d.as_clustering() except: fix_dendrogram(self.graph, v_d) mod = v_d.as_clustering() self.graph.vs['cluster'] = mod.membership self.graph['n_communities'] = len(mod) pal = ClusterColoringPalette(len(mod)) self.graph.vs['cluster_color'] = list(map(lambda x: rgb2hex(x[0],x[1],x[2],\ normalised=True), pal.get_many(mod.membership))) def calculate_assortativity_degree(self): """ Calculates the assortativity degree and put it as an graph attrb. * Reference: Newman MEJ: Assortative mixing in networks, Phys Rev Lett89:208701, 2002.@see:assortativity_degree()when thetypes are the vertex degrees """ if not 'assortativity_degree' in self.graph.attributes(): assortativity = self.graph.assortativity_degree( self.graph.is_directed()) if assortativity: assortativity = f"{assortativity:.2f}" self.graph['assortativity_degree'] = assortativity def calculate_density(self): if not 'density' in self.graph.attributes(): density = f'{self.graph.density():.2f}' self.graph['density'] = density def calculate_components(self): if not 'components' in self.graph.attributes(): components = self.graph.clusters(mode=WEAK) self.graph['components'] = len(components.subgraphs()) def calculate_closeness(self): if 'closeness' not in self.graph.vs.attributes() and 'weight'\ in self.graph.es.attributes(): rounder = lambda x: float(f"{x:.4f}") closeness = self.graph.closeness(weights='weight') closeness = list(map(rounder, closeness)) self.graph.vs['closeness'] = closeness def calculate_gini_closeness(self): if 'closeness' in self.graph.vs.attributes() and 'gini_closeness'\ not in self.graph.attributes(): gini = ineq.gini_corrected(self.graph.vs['closeness']) if gini is not np.nan: self.graph['gini_closeness'] = f"{gini:.2f}" else: self.graph['gini_closeness'] = 'nan' def calculate_gini_article_edits(self): if 'article_edits' in self.graph.vs.attributes() and 'gini_article_edits'\ not in self.graph.attributes(): gini = ineq.gini_corrected(self.graph.vs['article_edits']) if gini is not np.nan: self.graph['gini_article_edits'] = f"{gini:.2f}" else: self.graph['gini_article_edits'] = 'nan' def calculate_gini_talk_edits(self): if 'talk_edits' in self.graph.vs.attributes() and 'gini_talk_edits'\ not in self.graph.attributes(): gini = ineq.gini_corrected(self.graph.vs['talk_edits']) if gini is not np.nan: self.graph['gini_talk_edits'] = f"{gini:.2f}" else: self.graph['gini_talk_edits'] = 'nan' def calculate_gini_user_talk_edits(self): if 'user_talks' in self.graph.vs.attributes() and 'gini_user_talks'\ not in self.graph.attributes(): gini = ineq.gini_corrected(self.graph.vs['user_talks']) if gini is not np.nan: self.graph['gini_user_talks'] = f"{gini:.2f}" else: self.graph['gini_user_talks'] = 'nan' def calculate_metrics(self): """ A method which calculate the available metrics """ self.calculate_page_rank() self.calculate_betweenness() self.calculate_gini_betweenness() self.calculate_degree() self.calculate_gini_degree() self.calculate_assortativity_degree() self.calculate_communities() self.calculate_density() self.calculate_components() self.calculate_closeness() self.calculate_gini_closeness() self.calculate_gini_article_edits() self.calculate_gini_talk_edits() self.calculate_gini_user_talk_edits() def get_degree_distribution(self) -> (list, list): """ Returns the degree distribution: if its directed is the sum of out and in degree if not its the out degree """ degree = self.graph.degree() max_degree = self.graph.maxdegree() # Let's count the number of each degree p_k = [0 for i in range(0, max_degree + 1)] for x in degree: p_k[x] += 1 # Now, we are gonna clean the 0's k = [i for i in range(0, max_degree + 1) if p_k[i] > 0] p_k = list(filter(lambda x: x > 0, p_k)) return (k, p_k) def add_others(self, df): """ It's used to add specific things (e.g. other metrics) """ pass def build_network(self, df: pd.DataFrame, lower_bound: str, upper_bound: str): """ This method is used to generate the network and its metrics and attrs """ dff = self.filter_by_time(df, lower_bound, upper_bound) dff = self.filter_anonymous(dff) self.generate_from_pandas(dff) self.calculate_metrics() self.calculate_abs_longevity(df) self.add_others(dff) self.add_graph_attrs() def filter_by_time(self, df: pd.DataFrame, lower_bound='', upper_bound='') -> pd.DataFrame: dff = df if lower_bound and upper_bound: dff = dff[lower_bound <= dff['timestamp']] dff = dff[dff['timestamp'] <= upper_bound] return dff def filter_anonymous(self, df: pd.DataFrame) -> pd.DataFrame: dff = df if not dff.empty: dff = dff['Anonymous' != dff['contributor_name']] return dff def remove_non_article_data(self, df: pd.DataFrame) -> pd.DataFrame: """ Filter out all edits made on non-article pages. df -- data to be filtered. Return a dataframe derived from the original but with all the editions made in non-article pages removed """ # namespace 0 => wiki article return df[df['page_ns'] == 0] def remove_non_talk_data(self, df: pd.DataFrame) -> pd.DataFrame: """ Filter out all edits made on non-talk pages. df -- data to be filtered. Return a dataframe derived from the original but with all the editions made in non-talk pages removed """ # namespace 1 => wiki talk pages return df[df['page_ns'] == 1] def remove_non_user_talk_data(self, df: pd.DataFrame) -> pd.DataFrame: """ Filter out all edits made on non-user-talk pages. df -- data to be filtered. Return a dataframe derived from the original but with all the editions made in non-user-talk pages removed """ # namespace 3 => wiki user talk pages return df[df['page_ns'] == 3] def calculate_edits(self, df: pd.DataFrame, type_e: str): """ This function adds as a vertex attr the edits from other namespace type_e parameter only accept {talk, article, user_talk} """ allowed_types = {'talk', 'article', 'user_talk'} if type_e not in allowed_types: raise Exception( f"Not allowed type: {type_e}, it must be {allowed_types}") if 'label' not in self.graph.vs.attributes(): return key = 'edits' if type_e == 'talk': dff = self.remove_non_talk_data(df) key = f'{type_e}_{key}' elif type_e == 'article': dff = self.remove_non_article_data(df) key = f'{type_e}_{key}' elif type_e == 'user_talk': raise Exception(f'type: {type_e} is not implemented yet') else: raise Exception(f'type: {type_e} is not defined') mapper = { self.graph.vs[i]['label']: i for i in range(self.graph.vcount()) } edits = [0 for i in range(self.graph.vcount())] pages = [set() for _ in range(self.graph.vcount())] for _, row in dff.iterrows(): if row['contributor_name'] in mapper.keys(): edits[mapper[row['contributor_name']]] += 1 pages[mapper[row['contributor_name']]].add(int(row['page_id'])) sizer = lambda x: len(x) pages = list(map(sizer, pages)) self.graph.vs[f"{type_e}s"] = pages self.graph.vs[key] = edits def calculate_abs_longevity(self, df: pd.DataFrame): """ Calculates the birth of all the vertex without filter_by_time """ inverter = lambda x: 1 / x * 1000 max_date = 0 for node in self.graph.vs: dff = df[node['label'] == df['contributor_name']] if not dff.empty: row = dff.iloc[0] node['birth'] = datetime.strftime(row['timestamp'], "%d/%b/%Y") node['birth_value'] = int( datetime.strptime(str(row['timestamp']), "%Y-%m-%d %H:%M:%S").strftime('%s')) # this is a weak solution to avoid users with no activity if max_date < node['birth_value']: max_date = node['birth_value'] else: node['birth'] = 'Not available' node['birth_value'] = max_date if 'birth_value' in self.graph.vs.attributes(): self.graph.vs['birth_value'] = list( map(inverter, self.graph.vs['birth_value']))
def igraph_from_pandas_edgelist(df, source, target, directed): edgelist = df[[source, target]].apply(tuple, axis=1).tolist() return Graph.TupleList(edgelist, directed=directed)
def check(sol, paths): graph = Graph.Adjacency(sol) graph = graph.as_directed() if not len(paths_from_to(graph, 0, len(sol)-1))==paths: print("ERROR")
def get_cascade_size(self): return Graph.vcount(self.cascade_nx)
class FlatGraph(object): """An internal class for graph flattening.""" def __init__(self, parent: CommonGraph, quiet: bool = False): """Construct a FlatGraph.""" super(FlatGraph, self).__init__() if not isinstance(parent, CommonGraph): raise TypeError("FlatGraph constructor needs a CommonGraph " "parent, received a %s." % parent.__class__.__name__) self.g = None self.clusters = None self.outputDir = parent.outputDir self.vertices = dict() self.edges = set() self.weights = dict() # Step 1. make a copy of the graph without file-file nodes, to # find paths between files that go through apps. if not quiet: tprnt("\t\t\tStep 1: copy graph, excluding file-file nodes...") tprnt("\t\t\t\tCopy graph...") copy = parent.g.copy() # type: Graph types = parent.g.vs['type'] names = parent.g.vs['name'] toBeRemoved = [] namesRemoved = [] if not quiet: tprnt("\t\t\t\tFind edges to delete...") for edge in copy.es: if types[edge.source] == "file" and \ types[edge.target] == "file": toBeRemoved.append(edge) namesRemoved.append((names[edge.source], names[edge.target])) if not quiet: tprnt("\t\t\t\tDelete edges...") copy.delete_edges(toBeRemoved) # Step 2. run an all-pairs shortest path algorithm. # Step 2. pick out file-file paths with no intermediary files. # Step 2. save this info in the form of an edge list. if not quiet: tprnt("\t\t\tStep 2: run an all-pairs shortest path " "algorithm, remove file-file paths with intermediary " "files and gather final file-file edges...") tprnt("\t\t\t\tCopy file nodes...") fileNodes = list( (copy.vs[i] for i, t in enumerate(types) if t == "file")) edges = set() # weights = dict() self.idgen = UniqueIdGenerator() fileNodeCount = len(fileNodes) if not quiet: tprnt("\t\t\t\tGet shortest paths for each of %d file nodes..." % fileNodeCount) threshold = fileNodeCount / 100 nodeI = 0 lastNodePct = 0 nodePct = 0 for v in fileNodes: nodeI += 1 if nodeI >= (threshold * nodePct): nodePct = int(nodeI / threshold) if nodePct >= lastNodePct + 5: print("\t\t\t\t\t... (%d%% done)" % nodePct) lastNodePct = nodePct # Get shortest paths. vPaths = copy.get_shortest_paths(v, to=fileNodes) # Remove unnecessary bits. delSet = set() for (idx, p) in enumerate(vPaths): if len(p) < 1: continue # Ignore paths with intermediary files. for node in p[1:-1]: if types[node] == "file": delSet.add(idx) # Remove unsuitable paths. for i in sorted(list(delSet), reverse=True): del vPaths[i] del delSet # Save the shortest paths remaining as edges. for p in vPaths: if len(p) <= 1: continue key = (self.idgen[names[p[0]]], self.idgen[names[p[-1]]]) edges.add(key) # weights[key] = 1 / (len(p) - 1) # Add edges for removed names if not quiet: tprnt("\t\t\t\tRe-add file-file direct nodes into graph...") for (src, dest) in namesRemoved: edges.add((self.idgen[src], self.idgen[dest])) # Step 3. construct a graph with only file nodes. if not quiet: tprnt("\t\t\tStep 3: construct a graph with only file nodes...") edges = list(edges) self.g = Graph(edges) del edges # self.g.es["weight"] = list((weights[e] for e in edges)) self.g.vs["name"] = self.idgen.values() # Steph 4. apply community information to the nodes. if not quiet: tprnt("\t\t\tStep 4: apply communities to flat graph...") applyCommunities(self, parent.clusters.membership, names) def plot(self, output: str = None): """Plot the graph and its communities to an output file.""" # Get style options set for the base graph plot. vs = {} vs["vertex_size"] = 5 vs["vertex_shape"] = "circle" vs["layout"] = self.g.layout("fr") vs["bbox"] = (2400, 1600) vs["margin"] = 20 # Plot the base graph with colours based on the communities. vs["vertex_color"] = self.membership edge_widths = [] for (s, d) in self.g.get_edgelist(): if self.membership[s] == self.membership[d]: edge_widths.append(1) else: edge_widths.append(3) vs["edge_width"] = edge_widths # Only keep labels for community-bridging vertices. minimal_labels = list(self.g.vs["name"]) for (idx, label) in enumerate(minimal_labels): for neighbour in self.g.neighbors(label): if self.membership[neighbour] != self.membership[idx]: break else: minimal_labels[idx] = None vs["vertex_label"] = minimal_labels try: if output: path = self.outputDir + "/" + output + ".flat.svg" plot(self.clusters, path, **vs) else: plot(self.clusters, **vs) except (OSError) as e: print("Error while plotting to %s: %s " % (self.outputDir + "/" + output + ".flat.svg", e))
from py2neo import Graph from igraph import Graph as IGraph graph = Graph() query = ''' MATCH (c1:Character)-[r:INTERACTS]->(c2:Character) RETURN c1.name, c2.name, r.weight AS weight ''' ig = IGraph.TupleList(graph.run(query), weights=True) clusters = IGraph.community_walktrap(ig, weights="weight").as_clustering()
def generate_net_bert(texts_sents, bert_dir, book_names, sent_dir, net_dir, save_nets=True): nets = [] for sents, book_name in zip(texts_sents, book_names): with open(os.path.join(sent_dir, book_name), 'w') as sent_file: for sent in sents: sent_file.write(' '.join(sent).replace('\n', ' ') + '\n') M = [] # run BERT with the official code from the paper bert_cmd = [ 'python', 'bert/extract_features.py', '--input_file=%s' % os.path.join(sent_dir, book_name), '--output_file=/tmp/out_bert.jsonl', '--vocab_file=%s/vocab.txt' % bert_dir, '--bert_config_file=%s/bert_config.json' % bert_dir, '--init_checkpoint=%s/bert_model.ckpt' % bert_dir, '--layers=-1', '--max_seq_length=128', '--batch_size=8', ] process = subprocess.Popen(bert_cmd, stdout=subprocess.PIPE) process.wait() # load BERT generated features with open('/tmp/out_bert.jsonl') as vectors_file: for line in vectors_file: feature_json = json.loads(line) M.append(feature_json['features'][0]['layers'][0]['values']) eucl = euclidean_distances(M) del M simi_m = 1. / (1. + eucl) k = 1 while True: simi = simi_m.copy() to_remove = simi.shape[0] - (k + 1) for vec in simi: vec[vec.argsort()[:to_remove]] = 0 g = Graph.Weighted_Adjacency(simi.tolist(), mode=ADJ_UNDIRECTED, loops=False) if g.is_connected(): break k += 1 del simi_m if save_nets: to_xnet(g, os.path.join(net_dir, book_name), names=False) #g.write_pajek(os.path.join(net_dir, 'net_' + book_name + '.net')) """ # Code for loading saved networks and reuse part of the pipeline. net_dir = 'output_bert/community_multilevel/net_dir' g = Graph.Read_Pajek(os.path.join(net_dir, 'net_' + book_name + '.net')) """ nets.append(g) return nets
class ArgumentSet(object): """ An ``ArgumentSet`` is modeled as a dependency graph where vertices represent the components of an argument. A vertex corresponding to the conclusion of an argument *A* will **depend on** the premises and exceptions in *A*. The graph is built using the `igraph <http://igraph.org/>`_ library. This allows *attributes* to be associated with both vertices and edges. Attributes are represented as Python dictionaries where the key (which must be a string) is the name of the attribute and the value is the attribute itself. For more details, see the `igraph tutorial\ <http://igraph.org/python/doc/tutorial/tutorial.html#setting-and-retrieving-attributes>`_. """ def __init__(self): self.graph = Graph() self.graph.to_directed() self.arg_count = 1 self.arguments = [] def propset(self): """ The set of :class:`PropLiteral`\ s represented by the vertices in the graph. Retrieving this set relies on the fact that :meth:`add_proposition` sets a value for the ``prop`` attribute in vertices created when a new proposition is added to the graph. """ g = self.graph props = set() try: props = {p for p in g.vs['prop']} except KeyError: pass return props def add_proposition(self, proposition): """ Add a proposition to a graph if it is not already present as a vertex. :param proposition: The proposition to be added to the graph. :type proposition: :class:`PropLiteral` :return: The graph vertex corresponding to the proposition. :rtype: :class:`Graph.Vertex` :raises TypeError: if the input is not a :class:`PropLiteral`. """ if isinstance(proposition, PropLiteral): if proposition in self.propset(): logging.debug("Proposition '{}' is already in graph".\ format(proposition)) else: # add the proposition as a vertex attribute, recovered via the # key 'prop' self.graph.add_vertex(prop=proposition) logging.debug("Added proposition '{}' to graph".\ format(proposition)) return self.graph.vs.select(prop=proposition)[0] else: raise TypeError('Input {} should be PropLiteral'.\ format(proposition)) def add_argument(self, argument, arg_id=None): """ Add an argument to the graph. :parameter argument: The argument to be added to the graph. :type argument: :class:`Argument` :parameter arg_id: The ID of the argument :type arg_id: str or None """ g = self.graph if arg_id is not None: argument.arg_id = arg_id else: argument.arg_id = 'arg{}'.format(self.arg_count) self.arg_count += 1 self.arguments.append(argument) # add the arg_id as a vertex attribute, recovered via the 'arg' key self.graph.add_vertex(arg=argument.arg_id) arg_v = g.vs.select(arg=argument.arg_id)[0] # add proposition vertices to the graph conclusion_v = self.add_proposition(argument.conclusion) self.add_proposition(argument.conclusion.negate()) premise_vs =\ [self.add_proposition(prop) for prop in sorted(argument.premises)] exception_vs =\ [self.add_proposition(prop) for prop in sorted(argument.exceptions)] target_vs = premise_vs + exception_vs # add new edges to the graph edge_to_arg = [(conclusion_v.index, arg_v.index)] edges_from_arg = [(arg_v.index, target.index) for target in target_vs] g.add_edges(edge_to_arg + edges_from_arg) def get_arguments(self, proposition): """ Find the arguments for a proposition in an *ArgumentSet*. :param proposition: The proposition to be checked. :type proposition: :class:`PropLiteral` :return: A list of the arguments pro the proposition :rtype: list(:class:`Argument`) :raises ValueError: if the input :class:`PropLiteral` isn't present\ in the graph. """ g = self.graph # index of vertex associated with the proposition vs = g.vs.select(prop=proposition) try: conc_v_index = vs[0].index # IDs of vertices reachable in one hop from the proposition's vertex target_IDs = [e.target for e in g.es.select(_source=conc_v_index)] # the vertices indexed by target_IDs out_vs = [g.vs[i] for i in target_IDs] arg_IDs = [v['arg'] for v in out_vs] args = [arg for arg in self.arguments if arg.arg_id in arg_IDs] return args except IndexError: raise ValueError("Proposition '{}' is not in the current graph".\ format(proposition)) def draw(self, debug=False): """ Visualise an :class:`ArgumentSet` as a labeled graph. :parameter debug: If :class:`True`, add the vertex index to the label. """ g = self.graph # labels for nodes that are classed as propositions labels = g.vs['prop'] # insert the labels for nodes that are classed as arguments for i in range(len(labels)): if g.vs['arg'][i] is not None: labels[i] = g.vs['arg'][i] if debug: d_labels = [] for (i, label) in enumerate(labels): d_labels.append("{}\nv{}".format(label, g.vs[i].index)) labels = d_labels g.vs['label'] = labels roots = [i for i in range(len(g.vs)) if g.indegree()[i] == 0] ALL = 3 # from igraph layout = g.layout_reingold_tilford(mode=ALL, root=roots) plot_style = {} plot_style['vertex_color'] = \ ['lightblue' if x is None else 'pink' for x in g.vs['arg']] plot_style['vertex_size'] = 60 plot_style['vertex_shape'] = \ ['circle' if x is None else 'rect' for x in g.vs['arg']] plot_style['margin'] = 40 plot_style['layout'] = layout plot(g, **plot_style) def write_to_graphviz(self, fname=None): g = self.graph result = "digraph G{ \n" for vertex in g.vs: arg_label = vertex.attributes()['arg'] prop_label = vertex.attributes()['prop'] if arg_label: dot_str = (arg_label + ' [color="black", fillcolor="pink", width=.75, ' 'shape=box, style="filled"]; \n') elif prop_label: dot_str = ('"{}"'.format(prop_label) + ' [color="black", fillcolor="lightblue", ' 'fixedsize=true, width=1 shape="circle", ' 'style="filled"]; \n') result += dot_str for edge in g.es: source_label = g.vs[edge.source]['prop'] if\ g.vs[edge.source]['prop'] else g.vs[edge.source]['arg'] target_label = g.vs[edge.target]['prop'] if\ g.vs[edge.target]['prop'] else g.vs[edge.target]['arg'] result += '"{}" -> "{}"'.format(source_label, target_label) dot_str = " ; \n" result += dot_str result += "}" if fname is None: fname = 'graph.dot' with open(fname, 'w') as f: print(result, file=f)
from igraph import Configuration from igraph import Graph from igraph import plot ''' Em caso de duvida de instalacao dos pacotes = https://github.com/cleano01/Curso-Livro-BigData-I.A-DeepLearning/commit/7513ff5e442b37aec8f2dbfb5dbb15d660f9cba6 ''' #configuracao para exebir o grafo cfg = Configuration.instance() cfg["apps.eog"] = "start" #edges = arestas #direct = TRUE estamos informando que o grafo sera direcionado grafo1 = Graph(edges=[(0, 1), (1, 2), (2, 3), (3, 0)], directed=True) #vcount() = informa quantos vertices temos grafo1.vs['label'] = range(grafo1.vcount()) #print(grafo1) #plot(grafo1, bbox= (300, 300)) #edges = arestas #direct = TRUE estamos informando que o grafo sera direcionado grafo2 = Graph(edges=[(0, 1), (1, 2), (2, 3), (3, 0), (0, 3), (3, 2), (2, 1), (1, 0)], directed=True) #vcount() = informa quantos vertices temos grafo2.vs['label'] = range(grafo2.vcount()) #print(grafo2) #plot(grafo2, bbox= (300, 300))
def __init__(self): self.graph = Graph() self.graph.to_directed() self.arg_count = 1 self.arguments = []
import numpy as np from igraph import Graph, plot # Создание вершин и ребер vertices = [i for i in range(7)] edges = [(0, 2), (0, 1), (0, 3), (1, 0), (1, 2), (1, 3), (2, 0), (2, 1), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (4, 5), (4, 6), (5, 4), (5, 6), (6, 4), (6, 5)] # Создание графа g = Graph(vertex_attrs={"label": vertices}, edges=edges, directed=False) # Задаем стиль отображения графа N = len(vertices) visual_style = {} visual_style["layout"] = g.layout_fruchterman_reingold(maxiter=1000, area=N**3, repulserad=N**3) # Отрисовываем граф plot(g, **visual_style)
tags[t] = [row[1]] else: tags[t].append(row[1]) #### import matplotlib matplotlib.use('Agg') import matplotlib.pyplot as plt plt.figure() plt.hist([len(pts) for t, pts in tags5.items()], bins=1000) plt.savefig plt.xlabel('posts per tag') plt.ylabel('number of tags') plt.yscale('log') plt.xscale('log') plt.title('Post count per tag') plt.savefig('/tmp/so/tags5_distrib.png') #### edges = [] for t, pts in tags.items(): for p in pts: edges.append(('t' + str(t), 'p' + str(p))) from igraph import Graph g = Graph.TupleList(edges)
def calcAllRoutes(net): """ Configures IP routes between all nodes in the emulation topology. This is done in three steps: 1) IP forwarding is enabled on all nodes 2) The igraph lib is used to calculate all shortest paths between the nodes 3) Route add commands are used to actually configure the ip routes :param net: """ mini_nodes = net.hosts mini_links = net.links # Enabling IP forwaring on all nodes info('Configure IP forwarding on all nodes\n') for node in mini_nodes: node.cmd('sysctl -w net.ipv4.ip_forward=1') # Create the network graph to calculate all shortest paths between nodes node_names = [node.name for node in mini_nodes] links = [] for link in mini_links: links.append((link.intf1.node.name, link.intf2.node.name)) links.append((link.intf2.node.name, link.intf1.node.name)) networkGraph = Graph() networkGraph = networkGraph.as_directed() for node in node_names: networkGraph.add_vertex(node) for (a, b) in links: networkGraph.add_edges([(a, b), (b, a)]) existing_paths = { } # existing_paths stores all paths that are installed shortest_paths = [ ] # List of calculated shorted paths betweeen all nodes # Calculate shortest paths between all nodes using libigraph for from_node in node_names: for to_node in node_names: if from_node != to_node: if (from_node, to_node) in existing_paths \ or (to_node, from_node) in existing_paths: continue paths = networkGraph.get_all_shortest_paths( from_node, to_node) if len(paths) == 0: continue paths.sort(key=lambda x: str(x)) paths.sort(key=lambda x: len(x)) shortest_path = paths[ 0] # Shortest path with node indizes as nodes # Translate node indizes to node names shortest_path_nodenames = [ networkGraph.vs['name'][node] for node in shortest_path ] shortest_paths.append(shortest_path_nodenames) # Iterate over shortest paths and store subpaths that need to be installed on the nodes. # Also, it is made sure that all paths and reverse paths are the same shortest_paths.sort(key=lambda x: len(x), reverse=True) for path in shortest_paths: # Replace already existing subpaths of the path to make sure that no two paths between two # nodes exist path = IPRoutingHelper.replaceExistingSubpaths( path, existing_paths) # Mark all subpaths of path to install on nodes, unless they already exist subpaths = IPRoutingHelper.calculateAllSubPaths(path) for subpath in subpaths: if (subpath[0], subpath[-1]) not in existing_paths: existing_paths[(subpath[0], subpath[-1])] = subpath # Iterate over all paths and configure the routes using the 'route add' info('Configure routes on all nodes\n') for path in existing_paths.values(): start_node = path[0] end_node = path[-1] mini_start = net.get(start_node) mini_end = net.get(end_node) link_info = IPRoutingHelper.findLinkInformation( mini_links, path[0], path[1]) start_intf = link_info.start_intf_name # Configure the route for every IP address of the destination for intf in mini_end.intfs: addr = mini_end.intfs[intf].ip if len(path) == 2: # For direct connection, configure exit interface debug('[{}] route add -host {} dev {}\n'.format( start_node, addr, start_intf)) mini_start.cmd('route add -host {} dev {}'.format( addr, start_intf)) elif len(path) > 2: # For longer paths, configure next hop as gateway gateway_ip = link_info.end_ip debug('[{}] route add -host {} dev {} gw {}\n'.format( start_node, addr, start_intf, gateway_ip)) mini_start.cmd('route add -host {} dev {} gw {}'.format( addr, start_intf, gateway_ip))
def convert_graph(input_path): """ Converts a CRED-like graph into a graph format supported by the igraph library. The input graph must have been generated by cli2 CRED command (look for credResult.json) :param input_path: The path to the CRED graph to convert (credResult.json) """ with open(input_path, encoding="utf8") as f: cred_file = json.load(f) # Locating important elements in the graph cred_data = cred_file[1]['credData'] graph = cred_file[1]['weightedGraph'][1]['graphJSON'][1] cred_node_addresses = graph['sortedNodeAddresses'] # Summary of edges/nodes and also a reminder about dangling edges print( f'Found cred summary data for {len(cred_data["nodeSummaries"])} nodes and {len(cred_data["edgeSummaries"])} edges' ) print( f'The graph has {len(graph["nodes"])} nodes, {len(graph["edges"])} edges and {len(graph["sortedNodeAddresses"])} node addresses' ) print( f'Dangling edges expected: {len(graph["edges"]) - len(cred_data["edgeSummaries"])}' ) g = Graph(directed=True) # Collecting nodes for i, cred_node in enumerate(graph['nodes']): cred_node_address = cred_node_addresses[cred_node['index']] igraph_node_atts = { 'label': cred_node_address[2] + '-' + cred_node_address[-1][:7], 'type': cred_node_address[2], 'timestamp': cred_node['timestampMs'] if cred_node['timestampMs'] is not None else 0, 'totalCred': cred_data['nodeSummaries'][i]['cred'], 'index': cred_node['index'], } g.add_vertex(name=str(cred_node['index']), **igraph_node_atts) # Collecting edges dangling_edges = [] idx = 0 for cred_edge in graph['edges']: # Checking if the edges is a dangling one. If so, we skip. if len(g.vs.select(name_eq=str(cred_edge['srcIndex']))) + len( g.vs.select(name_eq=str(cred_edge['dstIndex']))) < 2: dangling_edges.append({ "srcIndex": cred_edge['srcIndex'], "dstIndex": cred_edge['dstIndex'] }) continue igraph_edge_atts = { 'address': '-'.join(cred_edge['address']), 'timestamp': cred_edge['timestampMs'], 'backwardFlow': cred_data['edgeSummaries'][idx]['backwardFlow'], 'forwardFlow': cred_data['edgeSummaries'][idx]['forwardFlow'], } g.add_edge(str(cred_edge['srcIndex']), str(cred_edge['dstIndex']), **igraph_edge_atts) idx += 1 # Reporting the number of dangling edges found print(f"Dangling edges found: {len(dangling_edges)}") return g
raise ValueError('The lists pos and text must have the same len') annotations = [] for k in range(L): annotations.append( dict( text=labels[k], # or replace labels with a different list for the text within the circle x=pos[k][0], y=2*M-position[k][1], xref='x1', yref='y1', font=dict(color=font_color, size=font_size), showarrow=False) ) return annotations nr_vertices = 13 v_label = list(map(str, range(nr_vertices))) G = Graph.Tree(nr_vertices, 3) # 2 stands for children number lay = G.layout('fr') print(G.get_edgelist()) position = {k: lay[k] for k in range(nr_vertices)} Y = [lay[k][1] for k in range(nr_vertices)] M = max(Y) es = EdgeSeq(G) # sequence of edges E = [e.tuple for e in G.es] # list of edges L = len(position) Xn = [position[k][0] for k in range(L)] Yn = [2*M-position[k][1] for k in range(L)]
def gen_cay(id): g = Graph() g.add_vertices(6) if id != 1: for i in range(6): g.add_edge(i, (i + 1) % 6) else: for i in range(5): g.add_edge(i, i + 1 % 6) if id != 2: g.add_edge(0, 2) g.add_edge(2, 4) g.add_edge(4, 0) g.add_edge(1, 3) g.add_edge(3, 5) g.add_edge(5, 1) return g
def accelgreedy(input_graph: Graph, desired_size: int, method: SolveMethod, verbosity: int = 0) -> GRT: """ Run the CELF algorithm for the DRO IM problem. The Cost Effective Lazy Forward (CELF) algorithm does not evaluate all marginal gains for all possible inputs. It utilises the submodular property and checks if the current best known input is indeed still the best known input, as marginal gains can only decrease, not increase. """ greedy_solution: List[int] = [] marg_gain_return: List[float] = [] compute_times: List[float] = [] if desired_size == 0: return ([], [], []) graph_nodes = [n.index for n in input_graph.vs()] if method == SolveMethod.graph_techniques: pi_: Dict[int, float] = {n: 0 for n in graph_nodes} # Build a distance matrix # This speeds up the expected influence calculation dist_mat = input_graph.shortest_paths(weights="q") marg_gain_list: List[float] = [ sum( marg_dro_inf(input_graph, pi_, node, dist_mat=dist_mat).values()) for node in graph_nodes ] elif method == SolveMethod.linear_program: inf_fun_args = {"input_graph": input_graph} abstract_model = inf_abs_mod(input_graph) inf_fun: Callable[..., Any] = inf_conc_mod inf_fun_args["abs_mod"] = abstract_model inf_fun_args["solve"] = True marg_gain_list = [ inf_fun(seed_set=[node], **inf_fun_args) for node in graph_nodes ] sorted_list = sorted(zip(graph_nodes, marg_gain_list), key=lambda x: x[1], reverse=True) # First seed, always optimal compute_times.append(perf_counter()) greedy_to_add = sorted_list[0][0] if method == SolveMethod.graph_techniques: pi_ = marg_dro_inf(input_graph, pi_, greedy_to_add, dist_mat=dist_mat) cur_spread: float = sorted_list[0][1] greedy_solution.append(greedy_to_add) marg_gain_return.append(cur_spread) sorted_list.pop(0) for k in range(1, desired_size): # Finding next seed with highest marginal gain need_to_re_eval = True while need_to_re_eval: cur_node = sorted_list[0][0] if method == SolveMethod.linear_program: inf_fun_args["seed_set"] = greedy_solution + [cur_node] sorted_list[0] = (cur_node, inf_fun(**inf_fun_args) - cur_spread) else: sorted_list[0] = ( cur_node, sum( marg_dro_inf( input_graph, pi_, cur_node, dist_mat=dist_mat).values()) - cur_spread) sorted_list = sorted(sorted_list, key=lambda x: x[1], reverse=True) need_to_re_eval = sorted_list[0][0] != cur_node # Found highest marginal gain compute_times.append(perf_counter()) greedy_to_add = sorted_list[0][0] if method == SolveMethod.graph_techniques: pi_ = marg_dro_inf(input_graph, pi_, greedy_to_add, dist_mat=dist_mat) greedy_solution.append(greedy_to_add) marg_gain = sorted_list[0][1] cur_spread += marg_gain marg_gain_return.append(marg_gain) sorted_list.pop(0) # Verbose output _verbose_output(verbosity, k, greedy_solution, greedy_to_add, cur_spread) return (greedy_solution, marg_gain_return, compute_times)
if file.endswith(".csv"): with open(path + file, 'rb') as f: for row in f.readlines(): if firstline == True: firstline = False continue parts = row.decode().replace(' ', '').replace('\r\n', '').strip().split(",") try: u, v, e, weight = [i for i in parts] edges.append((u, v, int(weight), e)) except ValueError: continue g = IGraph.TupleList(edges, directed=True, vertex_name_attr='name', edge_attrs=['weight', 'relationship']) #连通子图 subgraph = g.components(mode=WEAK) nodes = [{"name": node["name"]} for node in g.vs] graph = {} for node in nodes: idx = g.vs.find(name=node["name"]).index node["subgraph"] = subgraph.membership[idx] if node["subgraph"] not in graph: graph[node["subgraph"]] = [node["name"]] else: graph[node["subgraph"]].append(node["name"]) graphs = {} for key, value in graph.items():