def draw_automata(dfaStates, dfaDelta, dfaInitialState, dfaFinalStates, fileName): g = ig.Graph(directed=True) edgeLabels = [] g.add_vertices(map(lambda x: x + '*' if x == dfaInitialState else x, dfaStates)) for node, destinations in dfaDelta.iteritems(): for weight, destination in dfaDelta[node].iteritems(): if (node != destination): node = node + '*' if node == dfaInitialState else node destination = destination + '*' if destination == dfaInitialState else destination g.add_edge(node, destination) edgeLabels.append(weight) layout = g.layout("kk") nodeSize = 25 + int(math.log(2, len(dfaFinalStates))) * 30 plotProperties = {} plotProperties["vertex_size"] = nodeSize plotProperties["vertex_color"] = map(lambda x: 'lightblue' if x.replace('*', '') in dfaFinalStates else 'pink', g.vs['name']) plotProperties["vertex_label"] = g.vs["name"] g.es["label"] = edgeLabels plotProperties["edge_label_dist"] = 10 plotProperties["margin"] = nodeSize try: ig.plot(g, fileName + '_solution.png', layout=layout, **plotProperties) except TypeError: raise RuntimeError("You need to have pycairo installed in order to show a visual representation of the automata.")
def generator(N): fa=None while fa==None: net=general(N) fa=vizsgalat(net) igraph.plot(net) return fa
def __init__(self, x_range, y_range, max_dist): self.x_range = x_range self.y_range = y_range self.max_dist = max_dist # opens the json from divvy. f = url.urlopen('http://divvybikes.com/stations/json') con = json.loads(f.read()) slist = con["stationBeanList"] # creates the map; we flip the latitude to correct the map. # the names argument is the street address for the bikes. self.loclist = [(x["longitude"],float(self.y_range - x["latitude"])) for x in slist] self.names = [x["stAddress1"] for x in slist] # constructs the graph and adds vertices named 0,1,2,3... self.g = ig.Graph() self.g.add_vertices(len(self.loclist)) self.make_edges() # visual styling for the graph; feel free to tweak these if you'd like. visual_style = {} visual_style["vertex_size"] = 5 visual_style["vertex_label_size"] = 8 visual_style["vertex_label_dist"] = 3 visual_style["vertex_label"] = self.names visual_style["edge_color"] = "gray" visual_style["layout"] = self.loclist visual_style["bbox"] = (self.x_range, self.y_range) visual_style["margin"] = 50 ig.plot(self.g, **visual_style)
def plot_tree(cluster_indices, parent_clusters, output_directory = None): """Display a bifurcation tree. """ if igraph not in sys.modules: return if output_directory is None: output_directory = getcwd() vertex_sizes = np.bincount(cluster_indices) N_vertices = vertex_sizes.size vertex_sizes = np.divide(vertex_sizes, float(np.sum(vertex_sizes))) vertex_sizes *= 100 * N_vertices vertex_sizes += 40 + (N_vertices / 3) tree = igraph.Graph() tree.add_vertices(N_vertices) cluster_tally = 0 for k, v in parent_clusters.items(): if k > 0: tree.add_edges(zip(v, xrange(cluster_tally, cluster_tally + len(v)))) cluster_tally += len(v) tree.vs['label'] = xrange(N_vertices) layout = tree.layout('fr') name = path.join(output_directory, 'SCUBA_tree.pdf') igraph.plot(tree, name, bbox = (200 * N_vertices, 200 * N_vertices), margin = 250, layout = layout, edge_width = [7] * (N_vertices - 1), vertex_label_dist = 0, vertex_label_size = 30, vertex_size = vertex_sizes.tolist())
def plot(self, target=None, labels=True, **kwargs): """It is almost same az igraph.plot(). But it has not a graph argument, and left and right margins are wider by default, and edges are orange if there are vertex labels. Parameter: target: string or None As in igraph.plot. labels: list or boolean If it is a list, it will passed to the vs["label"]. If it is true, and no "label" attribute, but there is "name" attribute, the "name" will passed to "label". """ if not kwargs.get("layout"): kwargs["layout"] = self.layout_kamada_kawai() if kwargs.get("margin") is None: kwargs["margin"] = (70, 5) * 2 attributes = self.vs.attributes() if isinstance(labels, list): self.vs["label"] = labels elif labels and "label" not in attributes and "name" in attributes: self.vs["label"] = self.vs["name"] igraph.plot(self, target, **kwargs)
def plotGraph(data): #print "Graphing proposed network" G=nx.DiGraph() G.add_weighted_edges_from(data[0]) #G.remove_node(16) nx.draw_networkx(G, data[2], width = data[1]) #plt.pyplot.show() #plt.pyplot.savefig('flows.png') newLinks = [] for link in data[0]: newLinks.append((int(link[0]),int(link[1]))) IG = ig.Graph(25, newLinks, directed = True) IG.es["width"] = data[1] IG.vs["label"] = range(data[4]) sizes = data[5] layout = data[3] oldMin = np.min(sizes) oldMax = np.max(sizes) newMin = 12.5 newMax = 35 newSizes = (((sizes-oldMin)*(newMax-newMin))/(oldMax-oldMin)) + newMin IG.vs["size"] = newSizes smallNodes = IG.vs.select(size_lt=20)["label_size"] = 10 IG.vs.select(label_eq=16)["color"] = "#91CF60" IG.vs.select(label_ne=16)["color"] = "#FC8D59" ig.plot(IG, layout = layout, weighted =True, edge_arrow_size = .6, vertex_label_angle = 0) return G
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 DrawSubGraph(graph, threshold, sublist_nodes=None): """ Args: graph threshold: all edges under this threshold will be deleted. sublist_nodes: names of the nodes that should be kept; default is to keep all nodes """ if sublist_nodes != None: graph = db.IsolateSubGraph(graph, sublist_nodes, "term") # Delete edges below threshold. index_to_delete = [edge.index for edge in graph.es.select(weight_lt=threshold)] graph.delete_edges(index_to_delete) #deletes selected edges np_numberofstudies = np.array(graph.vs['numberofstudies']) nsl = np.log10(np_numberofstudies) #calculates log of number of studies log_number_of_studies = nsl*8 #multiplies constant to create attribute "log" visual_style = {} #sets method of modifying graph characteristics visual_style ["vertex_label"] = graph.vs["term"] # labels the vertices visual_style ["vertex_label_dist"] = 2 # specifies the distance between the labels and the vertices visual_style ["vertex_size"] = log_number_of_studies # specifies size of vertex_size visual_style["bbox"] = (700,700) #sets dimensions for the box layout visual_style["margin"] = 60 igraph.plot(graph, **visual_style) # creates the changes
def spring_embedding(self, file_name): minx = 0 maxx = self.width miny = 0 maxy = self.height area = self.width*self.height # default is the number of vertices maxiter = 500 # number of iterations to perform (default 500) maxdelta = self.n # maximum distance to move a vertex in an iteration (default is the number of vertices) coolexp = 1.5 # cooling component of the simulated annealing (default 1.5) repulserad = self.n**3. # radius at which vertex-vertex repulsion cancels out attraction of adjacent vertices (default len(vertices)^3) #seed = None # if None, uses a random starting layout for the algorithm. If a matrix (list of lists) uses the given matrix as the starting position # print self.weights # self.graph.layout_fruchterman_reingold(self.weights, maxiter, maxdelta, area, coolexp, repulserad,minx, maxx, miny, maxy, 0, 0, seed, self.dim) # self.complex.embed(self.graph) s = [] height = 600 width = 600 d_x = (width - 100)/self.l pos_x = 50 pos_y = 50 for l in self.cover.coverset: if (len(l.clustering.clusters) == 0): pos_y = height/2 s.append([pos_x, height/2]) else: d_y = (height - 100)/len(l.clustering.clusters) for c in l.clustering.clusters: s.append([pos_x, pos_y]) pos_y = pos_y + d_y pos_x = pos_x + d_x pos_y = 50 layout = self.graph.layout_fruchterman_reingold(seed=s) igraph.plot(self.graph, file_name, layout = layout) print self.pal.get(0) print self.pal.get(self.l-1)
def plot(self, margin=50): A = self.get_adjacency_matrix_as_list() convert_to_igraph = ig.Graph.Adjacency(A) g=convert_to_igraph for vertex in self.vertices: index=self.vertices.index(vertex) if vertex.pivot !=None: if type(vertex.pivot)==set: label_pivot = ' in '+str(list(vertex.pivot)) else: label_pivot = ' less than '+str(vertex.pivot) g.vs[index]['label']=str(vertex.split_attribute)+label_pivot g.vs[index]['label_dist']=2 g.vs[index]['label_color']='red' g.vs[index]['color'] = 'red' else: label=str(vertex.predicted_class) g.vs[index]['color']='blue' g.vs[index]['label']=label g.vs[index]['label_dist']=2 g.vs[index]['label_color']='blue' root_index = self.vertices.index(self.get_root()) layout = g.layout_reingold_tilford(root=root_index) ig.plot(g, layout=layout, margin=margin)
def gan_community_detection(): gan = load_gan() graph = ig.Graph(directed=True) graph.add_vertices(load_apps()) elist = [] for e in gan.edges(): u, v = e w = float(gan[u][v]['weight']) elist.append((u, v, w)) # write networkx to file graph = nx.DiGraph() graph.add_weighted_edges_from(elist) nx.write_graphml(graph, GRAPHML_PATH) # read file to construct igraph graph = ig.Graph.Read_GraphML(GRAPHML_PATH) graph.vs['size'] = [10 for i in xrange(len(graph.vs))] clusters = graph.community_spinglass() membership = clusters.membership vc = ig.VertexClustering(graph, membership) result = [] for c in vc: result.append(set([graph.vs[i]['id'] for i in c])) ig.plot(vc, bbox=(2400, 1400)) return result, clusters.modularity
def main(options, other_args): # For local test u = re.compile("(.*):(.*)@(.*)/(.*)") a = u.match(options.source) db_args = a.groups() table_info_list, extra = calc_database_table_relations(db_args) print("Press [i] to ignore this time, [n] means not an id(key), [e] means an id from an external system.") print("") try: query_uncertain_id_fields(table_info_list, extra) except KeyboardInterrupt as e: print('Ignore all uncertain foreign keys') table_info_list, extra = calc_database_table_relations(db_args) if options.graph: graph = init_graph_from_relations(table_info_list) plot(graph, options.graph) if options.way: begin_point, end_point = options.way.split(',') paths = graph.all_paths(begin_point, end_point) count = 1 for path in paths: print('-' * 5, "Way %d" % count, '-' * 5) graph.prints(path) count += 1
def sac_plot_cluster(sac_graph, membership_list, filename): red = colour.Color("red") blue = colour.Color("blue") my_rainbow = list(red.range_to(blue, membership_list.max() + 1)) color_list = [i.get_hex_l() for i in my_rainbow] layout = sac_graph.layout("kk") gp.plot(sac_graph, filename, layout=layout, vertex_color=[color_list[x] for x in membership_list])
def plot_graph(g, layout, filepath, size_tup=(600, 600)): # #palettes # # 'red-yellow-green','gray','red-purple-blue','rainbow', # # 'red-black-green','terrain','red-blue','heat','red-green' #palette=colors.palettes["gray"], plot(g, filepath, size_tup, layout=layout, vertex_order_by=('size', True), edge_color="white", edge_width=0, edge_arrow_size=0.1, edge_arrow_width=0.1)
def five_vertices(): """ Function for the section 1. Reproduce the graph in the subject. """ g = ig.Graph() # TODO ig.plot(g)
def number_of_components_beta(self): #akkor mukodik, ha a grafban nincs fa venum = self.vcount() #a vertexek szama ncount = 0 for v in range(0,venum): #vegigmegyek az osszes csucson if self.neighborhood_size(v)==2: #ha az adott csucs szomszedsaga==2 ncount=ncount+1 #tehat maga + egy, akkor a csucs veg vagy kezdo csucs print ncount//2 igraph.plot(self)
def main(graphFileName, featuresFileName, featureListFile, trainingFileName, k): # Read ego network global graph graph = igraph.Graph.Read_Ncol(graphFileName) graph.vs["membership"] = 0 # Read feature names with open(featureListFile, "r") as featureList: for line in featureList: featureNames.append(line.strip()) graph.vs[line.strip()] = None # Read feature values of nodes with open(featuresFileName, "r") as featuresFile: for line in featuresFile: features = line.split(" ") for feature in features[1:-1]: try: node = graph.vs[int(features[0])] node[";".join(feature.split(";")[0:-1])] = feature.split(";")[-1] except: pass # Run K-Means on the graph clusters = kmeans(graph, k) newClusters = clusters # Store in each node the cluster it belongs to. i = 0 for membership in clusters.membership: graph.vs[i]['membership'] = membership i = i + 1 # Plot final clusters print newClusters igraph.plot(newClusters) # Plot actual clusters from training data actualClusters = getTrainingClusters(graphFileName, trainingFileName) print actualClusters igraph.plot(actualClusters) i = 0 count = 0 for node1 in graph.vs: for node2 in graph.vs: if(actualClusters.membership[node1.index] == actualClusters.membership[node2.index] and newClusters.membership[node1.index] == newClusters.membership[node2.index]): count = count + 1 elif(actualClusters.membership[node1.index] != actualClusters.membership[node2.index] and newClusters.membership[node1.index] != newClusters.membership[node2.index]): count = count + 1 i = i + 1 error = (float(count) / float(i)) print error
def showGraph(graph,filename): ly=graph.layout('fr') visual_style = {} visual_style["vertex_size"] = 5 visual_style['layout']=ly #visual_style["vertex_label"] = g.vs["uid"] visual_style["vertex_label"] = graph.vs["name"] #igraph.plot(graph,"snsPic/{}.png".format(filename),**visual_style) igraph.plot(graph,**visual_style)
def plot(self): cols = ["black","blue","red","green"] vertex_color = [cols[s] for s in self.status] igraph.plot( igraph.Graph.as_undirected(igraph.Graph.Adjacency( self.adj.toarray().tolist())), vertex_color = vertex_color, vertex_label = range(self.numNodes) )
def show_hierachy_graph(g): visual_style={} visual_style['vertex_size']=10 #visual_style['vertex_label']=g.vs['label_count'] #visual_style['vertex_label']=g.vs['label_percentage'] visual_style['margin']=20 #l=g.layout_reingold_tilford_circular() l=g.layout_reingold_tilford() igraph.plot(g,layout=l,**visual_style)
def plotGraph(g, vertexLabel, edgeLabel): layout = g.layout_kamada_kawai() style = {} if vertexLabel: style["vertex_label"] = vertexLabel if edgeLabel: style["edge_label"] = edgeLabel style["layout"] = layout igraph.plot(g, **style)
def plotTreeFromString(treeString, colordict, plotFile): """ Plots a tree from the 'brackets tree' format :param treeString: :param colordict: defines the colors of the nodes by label (e.g. 1 to 5) :param plotFile: output file (.png) :return: """ g = Graph() splitted = treeString.split("(") level = -1 parents = dict() parentIds = dict() levelCount = dict() for part in splitted: if len(part)<1: continue else: #label follows level+=1 count = levelCount.get(level,0) levelCount[level] = count+1 #print "level %d" % level label = part[0] #print part.split() if len(part.split())>1: #leaf node label, wordPlusEnding = part.split() #print part, "at leaf" endings = wordPlusEnding.count(")") word = wordPlusEnding.strip(")") g.add_vertex(label=word, color=colordict[int(label)]) #print "added node %d" % (len(g.vs)-1) currentNode = len(g.vs)-1 p = parents[level-1] g.add_edge(currentNode,p)#add edge to parent #print "added edge %d-%d" % (len(g.vs)-1, parentIds[level-1]) level-=endings #print "word", word else: g.add_vertex(label=label, color=colordict[int(label)]) currentNode = g.vs[len(g.vs)-1] #print "added node %d" % (len(g.vs)-1) if level != 0: p = parents[level-1] g.add_edge(currentNode,p)#add edge to parent #print "added edge %d-%d" % (len(g.vs)-1, parentIds[level-1]) parent = currentNode parentId = len(g.vs)-1 parents[level] = parent parentIds[level] = parentId print parentIds print g.summary() layout = g.layout_reingold_tilford(mode="in", root=0) plot(g, plotFile, layout=layout, bbox = (2000, 1000), margin = 100)
def drawNetwork(self, **kwargs): """ Read the data stored in self.metrics, using column 0 as x axis values. Select the columns specified by *valueCol*, *minCol*, *maxCol* as Y values and print a png chart. args: *matrix* (numpy matrix) matrix of adjacency ----------------------- optional args: *nodeColor* (color) color of the nodes. Defaults to "red". *lineColor* (color) The color of the func line (Y values). It defaults to "grey - #787878". *oudDir* (str) output dir. Defaults to `networks'. *outFile* (str) output filename. Defaults to `testNetwork.png'. """ # manage args matrix = kwargs.get('matrix') title = kwargs.get('title', 'test network') nodeColor = kwargs.get('nodeColor', 'red') lineColor = kwargs.get('lineColor', '#D8D8D8') outDir = kwargs.get('outDir', 'networks') outFile = kwargs.get('outFile', 'testNetwork.png') if not os.path.exists(outDir): os.makedirs(outDir) filePath = outDir + '/' + outFile g = igraph.Graph.Weighted_Adjacency(list(matrix),mode=igraph.ADJ_MAX) visual_style = {} visual_style["title"] = title visual_style["vertex_size"] = 20 visual_style["vertex_color"] = nodeColor visual_style["vertex_label"] = self.legendfeatures visual_style["label_angle"] = 1.57 visual_style["label_dist"] = 100 visual_style["edge_width"] = g.es["weight"] degrees = g.degree() print degrees for i in range(len(degrees)): degrees[i] = degrees[i] * 5 visual_style["vertex_size"] = degrees visual_style["layout"] = g.layout("circle") #bbox = BoundingBox(750, 750, 750, 750) #visual_style["bbox"] = bbox ####FIXME#### visual_style["margin"] = 20 #plotting the network igraph.plot(g, filePath, bbox = (1200,1200), **visual_style)
def p(graph): # #print("pagerank", graph.pagerank()) ## Looks like per-edge attributes aren't working? ig.plot(graph, layout=graph.layout('kk'), target='graph.png', vertex_label="", edge_width=0.3) #ig.plot(graph, layout=graph.layout('grid_fr'), # target='graph.png', vertex_label="", edge_width=0.3) #ig.plot(graph, layout=graph.layout('kamada_kawai'), target='graph.png') subprocess.Popen(['feh', 'graph.png'])
def showGraph(graph,filename): ly=graph.layout('fr') visual_style = {} visual_style["vertex_size"] = 5 visual_style['layout']=ly #visual_style["vertex_label"] = g.vs["uid"] #visual_style["vertex_label"] = graph.vs["name"] if filename is not None: igraph.plot(graph,"{}.png".format(filename),**visual_style) else: igraph.plot(graph,**visual_style)
def draw_ig_graph(timelines, index_to_title, threshold = 0.9): g = igraph.Graph() g.add_vertices(len(timelines)) edges = get_edges(threshold = threshold) g.add_edges(edges) for i, v in enumerate(g.vs): epnum = date_to_epnum[timelines.keys()[i]] v['label'] = epnum v['color'] = member_to_color[epnum_to_member[epnum]] igraph.plot(g, 'graph_kk.png', bbox = (4000, 4000), layout = g.layout('kk'))
def save_cluster(obj, filename, box=(2000, 2000)): p = None if isinstance(obj, Graph): p = plot(obj, bbox=box) elif isinstance(obj, VertexDendrogram) or isinstance(obj, VertexClustering): cl = as_clustering_if_not(obj) p = plot(cl, bbox=box) else: return None p.save('%s.png' % (filename,))
def drawGraph(filename): if len(filename) > 0: visual_style["edge_color"] = [edgeColor for edgeColor in karateClubGraph.es["edge_color"]] visual_style["edge_width"] = [edgeWidth for edgeWidth in karateClubGraph.es["edge_width"]] layout = karateClubGraph.layout("rt_circular") # rt, rt_circular visual_style["layout"] = layout # visual_style["bbox"] = (300, 300) visual_style["margin"] = 20 igraph.plot(karateClubGraph, "./" + folderName + "/" + filename + ".pdf", **visual_style)
def drawFactionsOriginal(filename): if len(filename) > 0: color_dict = {1.0: "red", 2.0: "green"} visual_style["vertex_color"] = [color_dict[node["Faction"]] for node in karateClubGraph.vs] visual_style["edge_color"] = [edgeColor for edgeColor in karateClubGraph.es["edge_color"]] visual_style["edge_width"] = [edgeWidth for edgeWidth in karateClubGraph.es["edge_width"]] layout = karateClubGraph.layout("rt_circular") # rt, rt_circular visual_style["layout"] = layout # visual_style["bbox"] = (300, 300) visual_style["margin"] = 20 igraph.plot(karateClubGraph, "./" + folderName + "/" + filename + ".pdf", **visual_style)
def getSimMSTs(self, inverse=True, plotGraph=True, root="UNK"): rootId1 = self.emb1.d[root] rootId2 = self.emb2.d[root] if inverse == True: d = -1 else: d = 1 g1 = minimum_spanning_tree(csr_matrix(d*self.s1)) g2 = minimum_spanning_tree(csr_matrix(d*self.s2)) a1 = g1.toarray() a2 = g2.toarray() if plotGraph==True: t1 = Graph() t2 = Graph() t3 = Graph() t1.add_vertices(self.emb1.vocab_size) t2.add_vertices(self.emb2.vocab_size) t3.add_vertices(self.emb1.vocab_size) t1.vs["color"] = "white" t2.vs["color"] = "white" t3.vs["color"] = "white" t1.vs["label"] = [w for w,i in sorted(self.emb1.d.items(), key=itemgetter(1))] t2.vs["label"] = [w for w,i in sorted(self.emb2.d.items(), key=itemgetter(1))] t3.vs["label"] = t1.vs["label"] for i in xrange(a1.shape[0]): for j in xrange(a1.shape[1]): if a1[i,j] != 0: t1.add_edge(i,j, weight=a1[i,j], color="blue") t3.add_edge(i,j, weight=a1[i,j], color="blue") for i in xrange(a2.shape[0]): for j in xrange(a2.shape[1]): if a2[i,j] != 0: t2.add_edge(i,j, weight=a2[i,j], color="red") if t3.are_connected(i,j): #edge in both MSTs t3.es[i,j]["color"] = "black" else: t3.add_edge(i,j, weight=a1[i,j], color="red") layout1 = t1.layout_reingold_tilford(mode="in", root=rootId1) layout2 = t2.layout_reingold_tilford(mode="in", root=rootId2) layout3 = t3.layout_reingold_tilford(mode="in", root=rootId1) graphs = [Graph.GRG(10, 0.4) for _ in xrange(5)] figure = Plot(bbox=(0,0,2000,1000)) figure.add(t1, layout=layout1, margin=100, bbox=(0,0,1000,1000)) figure.add(t2, layout=layout2, margin=100, bbox=(1000,0,2000,1000)) plotname1 = "plots/"+NAME+".mst_trees.png" figure.save(plotname1) plotname3 = "plots/"+NAME+".merged_mst.png" plot(t3, plotname3 , layout=layout3, bbox=(1000,1000), margin=100) print("\tSaved MST plots in '%s', '%s'" % (plotname1, plotname3)) return t1,t2,t3
from igraph import Graph from igraph import plot grafo = Graph(edges=[(0, 1), (2, 3), (0, 2), (0, 3)], directed=True) grafo.vs['label'] = ['Fernando', 'Pedro', 'Jose', 'Antonio'] grafo.vs['nota'] = [100, 40, 60, 20] grafo.es['tipoAmizade'] = ['Amigo', 'Inimigo', 'Amigo'] grafo.es['devendo'] = [1, 3, 2, 5] grafo.vs['color'] = ['red', 'yellow', 'orange', 'green'] plot(grafo, bbox=(300, 300), vertex_size=grafo.vs['nota'], edge_width=grafo.es['devendo'], vertex_color=grafo.vs['color'], edge_curved=0.4, vertex_shape='square')
def plot_graph(self): self.ig.vs["label"] = [i for i in range(0, self.nodes.shape[0])] layout = self.ig.layout("kk") # Kamada-Kawai layout igraph.plot(self.ig, layout=layout)
mst = g.spanning_tree(weights=g.es['weight']) print('len(mst.es)', len(mst.es)) assert len(mst.es) == n_samples - 1 # Plot the graph visual_style = {} # Scale vertices based on degree visual_style["vertex_size"] = [20] * n_samples # Don't curve the edges visual_style["edge_curved"] = False # Set bbox and margin visual_style["bbox"] = (800, 800) visual_style["margin"] = 100 visual_style["layout"] = [(X[i, 0], X[i, 1]) for i in xrange(n_samples)] ig.plot( mst, 'figures/moons/moons_' + add_name + 'mst_n' + str(n_samples) + '_m' + str(n_edges) + '.pdf', **visual_style) ig.plot( g, 'figures/moons/moons_' + add_name + 'graph_n' + str(n_samples) + '_m' + str(n_edges) + '.pdf', **visual_style) # APPLY KMEANS kmeans = KMeans(n_clusters=2, random_state=0).fit(X) mst.vs['color'] = [colors[i] for i in list(kmeans.labels_)] ig.plot( mst, 'figures/moons/moons_' + add_name + 'mst_n' + str(n_samples) + '_m' + str(n_edges) + '_Kmeans.pdf', **visual_style) # APPLY CLUSTERING DBMSTClu index_DBMSTClu, DBMSTClu_cuts, y_pred_ix = DBCVI.DBMSTClu(mst, verbose=False)
def save_plot_graph(gc, graph_name, X, group_masks, group_names, all_feature_names, config, case_name=None, is_plot_graph=True, is_print_name=True, remove_isolated=True): fig_graph_path = config.ofname( graph_name, ext=".png", include_set=config.params_sets["diff_graph"]) tsv_graph_path = config.ofname( graph_name, ext=".tsv", include_set=config.params_sets["diff_graph"]) from copy import deepcopy export_cpg_path = deepcopy(graph_name) def add_graph_name_suffix(graph_name, suffix): if type(graph_name) is str: graph_name += "_" + suffix elif type(graph_name[-1]) is str: graph_name[-1] += "_" + suffix else: graph_name[-1][-1] += "_" + suffix return graph_name tsv_vertices_path = config.ofname( add_graph_name_suffix(graph_name, 'vertices'), ext=".tsv", include_set=config.params_sets["diff_graph"]) tsv_list_path = config.ofname(add_graph_name_suffix(graph_name, 'list'), ext=".tsv", include_set=config.params_sets["diff_graph"]) g = gc.copy() g.vs["label"] = all_feature_names if not case_name is None: export_best_cpg_pairs(g, case_name, path=export_cpg_path) if remove_isolated: g.delete_vertices([v.index for v in g.vs if v.degree() < 1]) if is_plot_graph: layout = g.layout("kk") #layout = g.layout("circle") #igraph.plot(g, layout = layout) visual_style = {} visual_style["font_size"] = 5 visual_style["vertex_label_size"] = 10 #visual_style["vertex_color"] = [color_dict[gender] for gender in g.vs["gender"]] visual_style["vertex_label"] = g.vs["label"] #visual_style["edge_width"] = [1 + abs(weight) for weight in g.es["weight"]] visual_style["layout"] = layout visual_style["bbox"] = (700, 700) visual_style["margin"] = 50 visual_style["vertex_label_dist"] = 1.1 visual_style["vertex_shape"] = "circle" fig_g = igraph.plot(g, **visual_style) fig_g.save(fig_graph_path) #os.startfile(fig_graph_path) name = "cpg" if "num_cpgs" in config.params else "gene" df_graph = graph_to_dataframe(g, name) #print(df_graph) df_graph.to_csv(tsv_graph_path, sep='\t') feature_list = list( set(df_graph[name + "_1"].values.tolist() + df_graph[name + "_2"].values.tolist())) _, indices, _ = np.intersect1d(all_feature_names, feature_list, return_indices=True) feature_list = all_feature_names[indices] def add_statistics(d, X, group_masks, group_names): _, indices, _ = np.intersect1d(all_feature_names, d[name], return_indices=True) if len(indices) > 0: for group_mask, group_name in zip(group_masks, group_names): scur = X[group_mask] d[group_name + '_mean'] = scur[:, indices].mean(axis=0) for group_mask, group_name in zip(group_masks, group_names): scur = X[group_mask] d[group_name + '_std'] = scur[:, indices].std(axis=0) return d d = {name: feature_list} d = add_statistics(d, X, group_masks, group_names) df_vlist = pd.DataFrame(d) df_vlist.to_csv(tsv_list_path, sep='\t') d = {name: g.vs["label"]} d = add_statistics(d, X, group_masks, group_names) df_vertices = pd.DataFrame(d) df_vertices.to_csv(tsv_vertices_path, sep='\t') if is_print_name: print(graph_name)
print("Cost matrix:\n%s" % cost) nData = 22 nTasks = 10 edgeProb = 0.2 outgoingEdges = 2 avgDataDep = 3 stddDataDep = 0.5 print("Generating graph...") #g = gdat.g # g = gen.generate_barabasi(nData + nTasks, outgoingEdges) g = gen.generate_realistic(nData, nTasks, avgDataDep, stddDataDep) # g = ig.Graph.Read_Pickle("data/graph_example") ig.plot(g) print("End of generation.") color_dict_vertex = {0: "blue", 1: "red", 2: "green", 3: "pink", 4: "orange"} placement = partitionLP(cost, g, tolerance) partition = [] for vertex in range(len(g.vs)): maxProb = 0 maxPlacement = -1 for c in range(nClusters): if placement[vertex][c] > maxProb: maxProb = placement[vertex][c] maxPlacement = c partition.append(maxPlacement) print("Placement: %s\n" % placement)
def build_power_graph(embeddings, avg_embeddings, power=True, filter_articles=None, entity_map=None, graph_name_str="aziz_power_graph", min_count=8, vertex_scalar=1.5): if power: train = load_power_all(cfg.POWER_AGENCY) preds = get_entity_scores(train, None, None, wgts.power_token_regression, embeddings, avg_embeddings) else: train = load_agency_all(cfg.POWER_AGENCY) preds = get_entity_scores(train, None, None, wgts.agency_token_regression, embeddings, avg_embeddings) # we ultimately need to control for number of co-occurences in the same article # it's easiest to do this 1 article at a time # this is a map from article id to all entites in that article article_to_entity_idx = defaultdict(list) entity_to_article_count = defaultdict(list) edge_tracker = EdgeTracker() for e, idxs in embeddings.entity_to_idx.items(): # this is a verb that has some association with e for idx in idxs: article_id = os.path.basename( embeddings.tupls[idx].filename).split(".")[0] if filter_articles is not None and not str( article_id) in filter_articles: continue article_to_entity_idx[article_id].append((e, idx)) for a, val in article_to_entity_idx.items(): per_article_entity_tracker = defaultdict(EntityScoreTracker) for e, idx in val: if e.lower() in PRONOUNS: continue if entity_map is not None: if not e in entity_map: continue e = entity_map[e] tupl = embeddings.tupls[idx] if tupl.relation == "nsubj": per_article_entity_tracker[e].update(preds[idx], 1, False) elif tupl.relation in ["nsubjpass", "dobj"]: per_article_entity_tracker[e].update(-1 * preds[idx], 1, False) keys = list(per_article_entity_tracker.keys()) # Mark that entities co-occurred in this article for i in range(0, len(keys)): e1 = keys[i] entity_to_article_count[e1].append(a) for j in range(i + 1, len(keys)): e2 = keys[j] edge_tracker.update(e1, e2, per_article_entity_tracker[e1].score, per_article_entity_tracker[e2].score, False) # end all articles # remove all vertices that didn't appear in at least 8 articles to_delete = [] for v in entity_to_article_count: if len(entity_to_article_count[v]) < min_count: to_delete.append(v) edges, edge_weights, vertex_names, vertex_weights, missing = edge_tracker.get_edge_list( to_delete) # make vertex weights all positive m = min(vertex_weights) if m < 0: # scale up for better visualization vertex_weights = [(v + abs(m)) * vertex_scalar for v in vertex_weights] g = igraph.Graph(edges=edges, vertex_attrs={ "name": vertex_names, "v_weights": vertex_weights }, edge_attrs={"weights": edge_weights}, directed=True) # edge_colors = ["red" if a else "blue" for a in missing] visual_style = {} visual_style["vertex_label"] = g.vs["name"] visual_style["vertex_label_size"] = 16 visual_style["edge_width"] = g.es["weights"] visual_style["edge_color"] = 'gray' visual_style["vertex_shape"] = 'circular' visual_style["vertex_frame_color"] = 'gray' visual_style["vertex_size"] = vertex_weights visual_style["margin"] = 55 # visual_style["edge_color"] = edge_colors ts = datetime.now().timestamp() graph_name = graph_name_str + str(ts) + ".png" print("Saving", graph_name) igraph.plot(g, graph_name, **visual_style)
a2=a2-1 print a1 print a2 similarite= (a1+a2)/2 return similarite def main(): g1 = igraph.read("/Users/irene/Desktop/pfe/arguments_politique start.gml", format= "gml") g2 = igraph.read("/Users/irene/Desktop/pfe/arguments_politiques_complets.gml", format = "gml") g3 = igraph.read("/Users/irene/Desktop/pfe/arguments_politique1.gml", format = "gml") gcomp1 = get_giant_component(g1) gcomp2 = igraph.Graph.induced_subgraph(g2,gcomp1.vs["name"]) print graph_summary(g1) print graph_summary(g2) main() layout = gcomp1.layout("kk") g.vs["label"] = g.vs["name"] igraph.plot(gcomp1, layout = layout)
@author: Giovanni """ # Aula 6 - Caminhos e Distâncias com igraph from igraph import Graph from igraph import plot 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] # Colocando em cada aresta o valor da distância: plot(grafo, bbox=(300, 300), edge_label=grafo.es['weight']) # Descobrir a menor rota entre A e H: caminho_vertice = grafo.get_shortest_paths(0, 7, output='vpath') # índice 0 = A; índice 7 = H # output = vpath = cria uma lista com o caminho na saída # Para visualizar o nome do vértice ao invés do índice: for n in caminho_vertice[0]: #print(n) print(grafo.vs[n]['label']) # com 'epath' retorna as arestas que foram visitadas caminho_aresta = grafo.get_shortest_paths(0, 7, output='epath') # Codificação para retornar o valor da distância: caminho_aresta_id = []
vertexBetweennessList = graph.betweenness(vertices=None, directed=False) #print vertexBetweennessList list2 = sorted(range(len(vertexBetweennessList)), key=lambda i: vertexBetweennessList[i])[-5:] print "Five nodes with the highest vertex betweenness are {}, {}, {}, {}, {}".format( list2[0], list2[1], list2[2], list2[3], list2[4]) visual_style = {} visual_style["edge_curved"] = False visual_style["vertex_color"] = "#95D2CB" visual_style["vertex_size"] = 15 visual_style["vertex_label_size"] = 12 #igraph.summary(graph) igraph.plot(graph, "erdosRenyiNetwork.png", **visual_style) visual_style1 = {} visual_style1["edge_curved"] = False visual_style1["vertex_size"] = 15 visual_style1["vertex_label_size"] = 12 #print(communities) louvainCommunity = graph.community_multilevel() #print louvainCommunity print "No of community = {}".format(louvainCommunity.cluster_graph().vcount()) print "Modularity of communities detected by Louvain Algorithm on the Erdos-Renyi graph = {}".format( louvainCommunity.modularity) igraph.plot(louvainCommunity, "LouvainOnErdosRenyi.png", **visual_style1) girvanNewmanCommunity = graph.community_edge_betweenness().as_clustering()
def visualize_gat_properties(model_name=r'gat_PPI_000000.pth', dataset_name=DatasetType.PPI.name, visualization_type=VisualizationType.ATTENTION): # device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # checking whether you have a GPU, I hope so! device = torch.device("cpu") config = { 'dataset_name': dataset_name, 'should_visualize': False, # don't visualize the dataset 'batch_size': 2, # used only for PPI 'ppi_load_test_only': True # used only for PPI (optimization, we're loading only test graphs) } # Step1:准备数据 data_loader_test = load_graph_data(config, device) node_features, node_labels, topology = next(iter(data_loader_test)) node_features = node_features.to(device) node_labels = node_labels.to(device) topology = topology.to(device) # Step2:准备模型 model_path = os.path.join('models/binaries/', model_name) model_state = torch.load(model_path) gat = GAT_ppi(num_of_layers=model_state['num_of_layers'], num_heads_per_layer=model_state['num_heads_per_layer'], num_features_per_layer=model_state['num_features_per_layer'], add_skip_connection=model_state['add_skip_connection'], bias=model_state['bias'], dropout=model_state['dropout'], log_attention_weights=True).to(device) print_model_metadata(model_state) assert model_state['dataset_name'].lower() == dataset_name.lower(), \ f"The model was trained on {model_state['dataset_name']} but you're calling it on {dataset_name}." gat.load_state_dict(model_state["state_dict"], strict=True) gat.eval() with torch.no_grad(): all_nodes_unnormalized_scores, _ = gat( (node_features, topology)) # shape = (N, num of classes) all_nodes_unnormalized_scores = all_nodes_unnormalized_scores.cpu( ).numpy() if visualization_type == VisualizationType.ATTENTION: num_nodes_of_interest = 4 # 选多少个要看的节点 head_to_visualize = 0 # 要看的head,随便改 gat_layer_id = 0 # 要看的层 # assert gat_layer_id == 0, f'Attention visualization for {dataset_name} is only available for the first layer.' # 建立完整图 total_num_of_nodes = len(all_nodes_unnormalized_scores) complete_graph = ig.Graph() complete_graph.add_vertices(total_num_of_nodes) edge_index_tuples = list(zip(topology[0, :], topology[1, :])) complete_graph.add_edges(edge_index_tuples) nodes_of_interest_ids = np.argpartition( complete_graph.degree(), -num_nodes_of_interest)[-num_nodes_of_interest:] """np.argpartition这个函数是快排的partition操作, kth指定第k大的数字,返回的是下标值,在这里就是找度数最大的num_nodes_of_interest个值的下标""" random_node_ids = np.random.randint(low=0, high=total_num_of_nodes, size=num_nodes_of_interest) # 随机取 nodes_of_interest_ids = np.append(nodes_of_interest_ids, random_node_ids) np.random.shuffle(nodes_of_interest_ids) target_node_ids = topology[1] source_nodes = topology[0] for target_node_id in nodes_of_interest_ids: # step1 找邻居 src_nodes_indices = torch.eq(target_node_ids, target_node_id) source_node_ids = source_nodes[src_nodes_indices].cpu().numpy() size_of_neighborhood = len(source_node_ids) # step2 获得标签 labels = node_labels[source_node_ids].cpu().numpy() # step3 获得aij all_attention_weights = gat.gat_net[ gat_layer_id].attention_weights.squeeze(dim=-1) attention_weights = all_attention_weights[ src_nodes_indices, head_to_visualize].cpu().numpy() attention_weights /= np.max(attention_weights) # 归一化 # step4 把原邻居id映射到邻居子图上 id_to_igraph_id = dict( zip(source_node_ids, range(len(source_node_ids)))) # step5 建立子图 ig_graph = ig.Graph() ig_graph.add_vertices(size_of_neighborhood) ig_graph.add_edges([(id_to_igraph_id[neighbor], id_to_igraph_id[target_node_id]) for neighbor in source_node_ids]) visual_style = { "edge_width": attention_weights, "layout": ig_graph.layout_kamada_kawai() # layout_kamada_kawai() 仿真强化 # layout_reingold_tilford_circular() 树状图 } ig.plot(ig_graph, **visual_style) image = ig.plot(ig_graph, **visual_style) image.save( f'可视化/ppi/node{target_node_id}_layer{gat_layer_id }_head{head_to_visualize}.png' ) elif visualization_type == VisualizationType.ENTROPY: num_heads_per_layer = [layer.num_of_heads for layer in gat.gat_net] num_layers = len(num_heads_per_layer) num_of_nodes = len(node_features) target_node_ids = topology[1].cpu().numpy() for layer_id in range(num_layers): all_attention_weights = gat.gat_net[ layer_id].attention_weights.squeeze(dim=-1).cpu().numpy() if dataset_name == DatasetType.PPI.name and layer_id < 2: print( f'Entropy histograms for {dataset_name} are available only for the first,second layer.' ) break for head_id in range(num_heads_per_layer[layer_id]): uniform_dist_entropy_list = [] neighborhood_entropy_list = [] for target_node_id in range(num_of_nodes): neigborhood_attention = all_attention_weights[ target_node_ids == target_node_id].flatten() ideal_uniform_attention = np.ones( len(neigborhood_attention)) / len( neigborhood_attention) neighborhood_entropy_list.append( entropy(neigborhood_attention, base=2)) uniform_dist_entropy_list.append( entropy(ideal_uniform_attention, base=2)) title = f'{dataset_name} entropy histogram layer={layer_id}, attention head={head_id}' draw_entropy_histogram(uniform_dist_entropy_list, title, color='orange', uniform_distribution=True) draw_entropy_histogram(neighborhood_entropy_list, title, color='dodgerblue') fig = plt.gcf() # get current figure plt.show() fig.savefig(f'可视化/ppi/layer_{layer_id}_head_{head_id}.jpg') plt.close()
PlottingTopVorE(mkt_coms, top20_edges, path='F:/BigDataCareer/Python/') # note: the plot may not properly show the name of nodes in IPython when a single plot is produced(at least, in Spyder), so I save the plot as a png picture in the working directory, then the names of nodes are properly displayed # community 0 # top 20 nodes with highest degree # extracting top 20 nodes from the list top20_v_00 = [i[0] for i in sub00_dict_sorted[:20]] # getting a subgraph of 20 nodes sub00_top20_v = mkt_com_ml_sub00.subgraph(top20_v_00) # plotting ig.plot(sub00_top20_v, layout='circular', vertex_label=sub00_top20_v.vs['name'], vertex_size=2, vertex_label_size=30, edge_label=None, bbox=(1500, 1500), margin=50, target='sub00_top20_v.png') sub00_top20_v.density() # top 20 edges with highest weight # extracting top 20 edges from the list top20_e_00 = [i[0] for i in sub00_e_dict_sorted[:20]] # getting a subgraph of 20 edges sub00_top20_e = mkt_com_ml_sub00.subgraph_edges(top20_e_00) # plotting ig.plot(sub00_top20_e, layout='circular', vertex_label=sub00_top20_e.vs['name'],
persons_like_mes1.add(data1_mes[k]['likes']['data'][w]['name']) for l in range(len(data2_mes)): for y in range(len(data2_mes[l]['likes']['data'])): persons_like_mes2.add(data2_mes[l]['likes']['data'][y]['name']) g = ig.Graph() g.add_vertex("MetalGearJp", color="#000", size=150) g.add_vertex("KonamiJp", color="#FFFFFF", size=150) #Se itera sobre las ids de las personas que han puesto like #Esta id se mantiene en vert #Luego se anyade el vertice usando un color cercano al turquesa for vert in (persons_like_mes1 | persons_like_mes2): g.add_vertex(vert, color="#00bbff" size=10) #Se itera sobre las ids de las personas que les gusta la pagina 1 #Se almacena en vert i se añade una linea o arista entre la bola #de la pagina 1 y vert for vert in (persons_like_mes1): g.add_edge(vert,"MetalGearJp") #Se itera sobre las ids de las personas que les gusta la pagina 2 #Se almacena en vert i se añade una linea o arista entre la bola #de la pagina 2 y vert for vert in (persons_like_mes2): g.add_edge(vert,"KonamiJp") #Se genera una imagen del grafico a un tamaño personalizado y de fondo color plomo ig.plot(g, bbox=(1920,1080), background="#171717", layout='lgl')
from igraph import Graph, plot g=Graph() g.add_vertices(3) g.add_edges([(0,1),(1,2)]) layout = g.layout("rt", 2) plot(g, layout=layout)
g = igraph.Graph() vertex = [] for edge in graph_edges: vertex.extend(edge) graph_vertices = list(set(vertex)) g.add_vertices(graph_vertices) # add a list of unique vertices to the graph g.add_edges(graph_edges) # add the edges to the graph. print('Communities:') p = g.community_multilevel() print(p) print('Number of communities') print(len(p)) if print_communities_details: show_big_communities(g, p, graph_vertices, authorship) print_graph_details(g, p) if print_graph: g.vs["label"] = g.vs["name"] # layout = g.layout("mds") layout = g.layout("graphopt") igraph.plot(g, layout=layout, bbox=(10000, 10000), vertex_size=40, edge_width=2, label_size=10)
# Set edges attributes network_i.es['color'] = [ '#e74c3c' if e['beta'] < 0 else '#2ecc71' for e in network_i.es ] # Calculate layout layout = network_i.layout_fruchterman_reingold(maxiter=10000, area=50 * (len(network_i.vs)**2)) print '[INFO] Network layout created: ', network_i.summary() # Export network igraph.plot(network_i, layout=layout, bbox=(0, 0, 360, 360), vertex_label_size=5, vertex_frame_width=0, vertex_size=20, edge_width=1., target='%s/reports/Figure_4.pdf' % wd) print '[INFO] Network exported: ', network_i.summary() # -- Betas heatmap cmap = sns.diverging_palette(220, 10, n=9, as_cmap=True) plot_df = lm_betas_kinases.loc[:, [m in met_name for m in lm_betas_kinases]] plot_df.columns = [met_name[m] for m in plot_df] plot_df.index = [acc_name[i].split(';')[0] for i in plot_df.index] sns.set(style='white', palette='pastel') sns.clustermap(plot_df.T, figsize=(15, 20), cmap=cmap, linewidth=.5) plt.savefig('%s/reports/Figure_Supp_4_kinases_dynamic_betas.pdf' % wd,
def plot_graph(graph: int): lastname = get_friends(graph, 'last_name') vertices = [lastname['items'][i]['first_name'] + ' ' + lastname['items'][i]['last_name'] for i in range(lastname['count'])] edges = get_network(get_friends_id(graph), False) if isinstance(edges, ndarray): g = Graph.Adjacency(edges.tolist(), mode='undirected') g.vs['label'] = vertices g.vs['shape'] = 'triangle' g.vs['size'] = 10 else: # Создание графа g = Graph(vertex_attrs={"shape": "triangle", "label": vertices, "size": 10}, edges=edges, directed=False) # Задаем стиль отображения графа n = len(vertices) visual_style = {"vertex_size": 20, "bbox": (2000, 2000), # размер поля "margin": 100, # расстояние от края до вершин "vertex_label_dist": 1.6, # расстояние между вершинами "edge_color": "gray", "autocurve": True, # кривизна ребер "layout": g.layout_fruchterman_reingold( # Fruchterman-Reingold force-directed algorithm # алгоритм компоновки maxiter=1000, # the maximum distance to move a vertex in an # iteration. The default is the number of vertices area=n ** 3, # he area of the square on which the vertices will # be placed. The default is the square of the number # of vertices. repulserad=n ** 3 # determines the radius at which vertex-vertex # repulsion cancels out attraction of adjacent # vertices. The default is the number of vertices^3. )} g.simplify(multiple=True, loops=True) # Отрисовываем граф clusters = g.community_multilevel() # Finds the community structure of the graph according # to the multilevel algorithm of Blondel et al. ''' Это восходящий алгоритм: первоначально каждая вершина принадлежит отдельному сообществу, а вершины перемещаются между сообществами итеративно таким образом, чтобы максимизировать локальный вклад вершин в общий показатель модульности. Когда достигнут консенсус (т. Е. Ни один шаг не увеличит оценку модульности), каждое сообщество исходного графа сократится до одной вершины (при сохранении общего веса краев инцидентов), и процесс продолжит на следующем уровне. Алгоритм останавливается, когда невозможно увеличить модульность после сжатия сообществ до вершин. ''' pal = igraph.drawing.colors.ClusterColoringPalette(len(clusters)) # A palette suitable for coloring vertices when plotting a clustering. g.vs['color'] = pal.get_many(clusters.membership) plot(g, **visual_style)
from igraph import Graph from igraph import plot grafo1 = Graph(edges=[(0, 1), (1, 2), (2, 3), (3, 0)], directed=True) grafo1.vs['label'] = range(grafo1.vcount()) print(grafo1) plot(grafo1, bbox=(300, 300)) grafo2 = Graph(edges=[(0, 1), (1, 2), (2, 3), (3, 0), (0, 3), (3, 2), (2, 1), (1, 0)], directed=True) grafo2.vs['label'] = range(grafo2.vcount()) plot(grafo2, bbox=(300, 300)) grafo3 = Graph(edges=[(0, 1), (1, 2), (2, 3), (3, 0), (1, 1)], directed=True) grafo3.vs['label'] = range(grafo3.vcount()) plot(grafo3, bbox=(300, 300)) grafo4 = Graph(edges=[(0, 1), (1, 2), (2, 3), (3, 0), (1, 1)], directed=True) grafo4.add_vertex(5) grafo4.vs['label'] = range(grafo4.vcount()) plot(grafo4, bbox=(300, 300))
def plot_wf(wf, view='combined', labels=False, **kwargs): """Plot workflow DAG via igraph.plot. Args: wf (Workflow) view (str): same as in 'to_dot'. Default: 'combined' labels (bool): show a FW's name and id as labels in graph Other **kwargs can be any igraph plotting style keyword, overrides default. See https://igraph.org/python/doc/tutorial/tutorial.html for possible keywords. See `plot_wf` code for defaults. Returns: igraph.drawing.Plot """ dagf = DAGFlow.from_fireworks(wf) if labels: dagf.add_step_labels() # copied from to_dot if view == 'controlflow': dagf.delete_dataflow_links() elif view == 'dataflow': dagf.delete_ctrlflow_links() elif view == 'combined': dlinks = [] for vertex1, vertex2 in combinations(dagf.vs.indices, 2): clinks = list( set(dagf.incident(vertex1, mode='ALL')) & set(dagf.incident(vertex2, mode='ALL'))) if len(clinks) > 1: for link in clinks: if dagf.es[link]['label'] == ' ': dlinks.append(link) dagf.delete_edges(dlinks) # remove non-string, non-numeric attributes because write_dot() warns for vertex in dagf.vs: for key, val in vertex.attributes().items(): if not isinstance(val, (str, int, float, complex)): del vertex[key] if isinstance(val, bool): del vertex[key] # plotting defaults visual_style = DEFAULT_IGRAPH_VISUAL_SYTLE.copy() # generic plotting defaults visual_style["layout"] = dagf.layout_kamada_kawai() # vertex defaults dagf_roots = dagf._get_roots() dagf_leaves = dagf._get_leaves() def color_coding(v): if v in dagf_roots: return DEFAULT_IGRAPH_VERTEX_COLOR_CODING['root'] elif v in dagf_leaves: return DEFAULT_IGRAPH_VERTEX_COLOR_CODING['leaf'] else: return DEFAULT_IGRAPH_VERTEX_COLOR_CODING['other'] visual_style["vertex_color"] = [ color_coding(v) for v in range(dagf.vcount()) ] visual_style.update(kwargs) # special treatment if 'layout' in kwargs and isinstance(kwargs['layout'], str): visual_style["layout"] = dagf.layout(kwargs['layout']) return igraph.plot(dagf, **visual_style)
# initialise edges by value given by vs_dict: input coordinate, ouput val edges = [(vs_dict[key0], vs_dict[key1]) for key0, key1 in lstrings] print("{:21}{:4d}".format("Number of edges: ", len(edges))) G = igraph.Graph() G.add_vertices(len(vs_dict)) G.add_edges(edges) visual_style = {} visual_style["vertex_size"] = 5 visual_style["vertex_shape"] = "circle" visual_style["layout"] = 'lgl' visual_style["bbox"] = (1024, 1024) visual_style["margin"] = 10 layout = G.layout('kk') fig = igraph.plot(G, layout=layout, vertex_size=3) fig.show() # data.apply(shapely.wkb.loads) # data.ST_AsText(SHAPE) = shapely.wkt.loads(data.ST_AsText(SHAPE)) # query_memphis = ("") # lstrings[0].apply # print(type(a)) # print(a) # a.append(shapely.geometry.asLineString(lstrings[0])) # print(type(lstrings)) # fig = plt.figure() # ax = fig.add_subplot(111) # gpd.plotting.plot_linestring_collection(ax, ls, color='blue')
import re import igraph #IN_FILE = "repo-gru.cflow" IN_FILE = "opencv.cflow" with open(IN_FILE) as f: tree = list(f) parent = None graph = igraph.Graph(directed=True) for line in tree: #Check if it's a 0-level function (caller/parent function) if line[0] != " ": regex = re.match("^(.+)?\(\)", line) parent = regex.groups()[0] graph.add_vertex(parent) else: #It is a 1-level function (called by the parent) regex = re.match("^\s{4}(.+)?\(\)", line) called = regex.groups()[0] graph.add_vertex(called) graph.add_edge(parent, called) print("Done generating graph") print("Starting plotting algorithm") igraph.plot(graph, "img.png") #find . -iname "*.c" | xargs cflow -m asdfasdf --depth=2
import igraph as ig from util import get_color_arr N = 13 g = ig.Graph.Tree(N, 3) layout = g.layout_reingold_tilford(mode="in", root=[0]) g.vs['size'] = ['60'] g.vs['color'] = get_color_arr(N, 3) g.vs['label'] = [ '[ ]', '[a]', '[b]', '[c]', '[ad]', '[ae]', '[af]', '[bd]', '[be]', '[bf]', '[cd]', '[ce]', '[cf]' ] g.vs['label_size'] = ['20'] g.write_svg('001.svg', layout=layout, vertex_size=20) ig.plot(g, layout=layout, bbox=(800, 300), margin=50)
#!/usr/bin/env python # coding: utf-8 """Docstring of the module mmd """ from __future__ import division from __future__ import print_function # wh for def cl defs ifmain imp fr _ pdb + <Tab> """Kiírja a maximális és minimális fokszámot. """ import maxmindeg import igraph net = maxmindeg.Network.Formula("a-b-c,d-b-e,f-g,h") for v in net.vs: print(v.index, v["name"]) print(net.vs["name"]) print(net.component(0)) # print(net.maxmindegree()) igraph.plot(net)
import igraph import price # Define variables sv = 3 # starting vertices at = .8 # attractivity ns = 20 # network size """ Create a graph, and print out its properties """ p = price.price(sv, at, ns) # Summary print() print("Starting vertices: ", sv) print("Attractivity: ", at) print("Network size: ", ns) print() print("vcount: ", p.vcount()) print("ecount: ", p.ecount()) print("directed: ", p.is_directed()) print("indegree: ", p.indegree()) print("outdegree:", p.outdegree()) # Plot the graph p.vs["label"] = range(p.vcount()) p.vs["color"] = "yellow" igraph.plot(p)
nodes = pd.read_csv(n) #names of nodes n.close() a_numpy = Adj.as_matrix() conn_indices = np.where(a_numpy) # Get the values as np.array, it's more convenenient. weights = a_numpy[conn_indices] # a sequence of (i, j) tuples, each corresponding to an edge from i -> j edges = zip(*conn_indices) # initialize the graph from the edge sequence G = igraph.Graph(edges=edges, directed=True) # assign node names and weights to be attributes of the vertices and edges # respectively node_names = nodes['id'] G.es['width'] = weights G.vs['label'] = node_names G.es['weight'] = weights G.es['width'] = weights / 10 # plot the graph out = igraph.plot(G, '../Results/Netspy.pdf', layout="rt", labels=True, margin=80) print 'Netspy.pdf saved to Results'
my_links = [] #备用空列表 for i in df.index: #外层循环,轮询excel每个列 for j in df.columns: #内层循环,轮询excel每一行 if df[j][i] > 0: #大于0的值有效 my_links.append({'source': i, 'target': (j), 'value': df[j][i]}) g.add_edge(i, j) weights.append(df[j][i]) else: pass if not g.vs[0]['name']: g.delete_vertices(0) result = g.community_multilevel(weights, True) igraph.plot(result[1], mark_groups=True, margin=20, vertex_label=[str(i) for i in range(len(df.index))]) #colors = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral'] colors_list = [ 'yellowgreen', 'gold', 'lightskyblue', 'lightcoral', 'darkslateblue', '#ADD8E6', '#DDA0DD', '#FAA460', '#F0E68C', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf' ] category_dic = {} for list_data in result[1]: for data in list_data: category_dic[df.index[data]] = df.index[list_data[0]] sym_x = [] sym_y = []
# col.names=FALSE, file="elist_lazega.ncol") g = ig.Graph.Read_Ncol("elist_lazega.ncol", weights="if_present", directed=False) # Created in R via: # attrs <- list.vertex.attributes(lazega) # cols <- vector("list", length(attrs)) # for (i in 1:length(cols)) { # cols[[i]] <- get.vertex.attribute(lazega,attrs[i]) # } # v.attr.lazega <- data.frame(cols) # names(v.attr.lazega) <- list.vertex.attributes(lazega) # > write.csv(v.attr.lazega,row.names=FALSE,file="v_attr_lazega.csv") # (Note: in order to work, this very much depends on the vertices appearing # in the .ncol file in the same order as they appear in the .csv file!) v_attr_df = pd.read_csv("v_attr_lazega.csv") for col in v_attr_df.columns[1:]: g.vs[col] = v_attr_df[col] # Some plotting defaults, to give you the idea. When I run this, I get a file # called "aplot.pdf" produced with the plot. Yours may auto-appear, not sure. style = {'margin': 70} ig.plot(g, "aplot.pdf", vertex_label=g.vs['name'], vertex_size=18, vertex_label_dist=2, layout=g.layout("kk"), **style)
dim = shape(data_mat)[1] col_mean = mean(data_mat, axis=0) data_mat = mat((data_mat - col_mean) / sqrt(diag(cov(data_mat, rowvar=0)))) corr_mat = corrcoef(data_mat, rowvar=0) # screening the correlation matrix omega = matrix(zeros(shape=(dim, dim))) for r in range(0, dim): for c in range(0, dim): if r == c: omega[r, c] = 0 elif abs(corr_mat[r, c]) < threshold: omega[r, c] = 0 else: omega[r, c] = 1 # visualize the graph import igraph plot_path = result_dir + "/graph_py.png" g = igraph.Graph.Adjacency(omega.tolist()).as_undirected() igraph.plot(g, plot_path, vertex_size=[24], vertex_color=["red"], vertex_label=range(1, dim + 1), vertex_label_size=[12], layout=g.layout_fruchterman_reingold(), margin=60, bbox=(690, 460))
g = ig.Graph() g.add_vertices(12) g.add_edges([(0, i) for i in [1, 2, 6, 9, 11]]) g.add_edges([(1, i) for i in [2, 3, 4, 9]]) g.add_edges([(2, i) for i in [3, 6]]) g.add_edges([(3, i) for i in [4, 5]]) g.add_edges([(5, i) for i in [6]]) g.add_edges([(6, i) for i in [7, 11]]) g.add_edges([(7, i) for i in [10, 11]]) g.add_edges([(8, i) for i in [9]]) g.add_edges([(9, i) for i in [10]]) # 11, 10 and 4 do not connect to a higher-index vertex vx = [0.0] * len(g.vs) vy = [0.0] * len(g.vs) label = [""] * len(g.vs) for i, v in enumerate(g.vs): ((x, y, z), rot) = listener.lookupTransform('/world', "/Node%d" % v.index, rospy.Time(0)) vx[i] = x vy[i] = y label[i] = "Node%d" % v.index g.vs["x"] = vx g.vs["y"] = vy g.vs["label"] = label layout = g.layout("auto") ig.plot(g, 'graph.png', layout=layout, label_dist=[100.] * len(g.vs)) g.write_picklez("graph.picklez") print "Saved graph"