def plotGraph(self, path): if self.graph is None: raise Exception("The graph has not been generated") values = [self.colorScheme(n) for n in self.graph.nodes()] nx.draw_spring(self.graph, cmap="jet", node_color=values, node_size=100) plt.savefig(path) plt.close()
def draw_networkx_ex(): G = nx.dodecahedral_graph() nx.draw(G) plt.show() nx.draw_networkx(G, pos=nx.spring_layout(G)) limits = plt.axis('off') plt.show() nodes = nx.draw_networkx_nodes(G, pos=nx.spring_layout(G)) plt.show() edges = nx.draw_networkx_edges(G, pos=nx.spring_layout(G)) plt.show() labels = nx.draw_networkx_labels(G, pos=nx.spring_layout(G)) plt.show() edge_labels = nx.draw_networkx_edge_labels(G, pos=nx.spring_layout(G)) plt.show() print("Circular layout") nx.draw_circular(G) plt.show() print("Random layout") nx.draw_random(G) plt.show() print("Spectral layout") nx.draw_spectral(G) plt.show() print("Spring layout") nx.draw_spring(G) plt.show() print("Shell layout") nx.draw_shell(G) plt.show() print("Graphviz")
def construct_de_bruijn_velvet(kmers, draw, outfile): #make list of k-1mers for quick edge construction k1mers = [x[:-1] for x in kmers.keys()] k1mers_array = np.array(k1mers) #find overlaps edge_list = [] for kmer in kmers.keys(): matches = np.where(k1mers_array==kmer[1:]) for match in matches[0]: #print match edge_list.append((kmer, kmers.keys()[match])) #make graph G = nx.DiGraph() #add seq_kmers as nodes and overlaps as edges for kmer in kmers.items(): G.add_node(kmer[0], num=kmer[1]) G.add_edges_from(edge_list) # draw the graph if desired if draw == "True": nx.draw_spring(G) plt.show() #output adjacency list format of the graph if desired if outfile != "": nx.write_adjlist(G, outfile) return G
def get_communities(graph): betweenness = nx.edge_betweenness_centrality(graph) sorted_betweeness = [x[0] for x in sorted(betweenness.items(), key = lambda x : x[1], reverse = True)] best_partitions = [] max_modularity = -1.0 graph_copy = graph.copy() while sorted_betweeness: communities = [list(x) for x in nx.connected_components(graph_copy)] partitions = {} for i in range(len(communities)): for node in communities[i]: partitions[node] = i modularity = community.modularity(partitions, graph_copy) if modularity > max_modularity: best_partitions = communities max_modularity = modularity elif modularity <= max_modularity: break; graph_copy.remove_edge(*sorted_betweeness[0]) del sorted_betweeness[0] for partition in best_partitions: print sorted(partition) val_map = {} for partition in best_partitions: value = random.random() while value in val_map.values(): value = random.random() for node in partition: val_map[node] = value values = [val_map.get(node) for node in graph.nodes()] nx.draw_spring(graph, node_color = values, node_size = 500, with_labels = True) plt.savefig(sys.argv[2])
def get_topics_noun_phrases(num_news, draw=False, url='http://cnn.com'): texts = get_news(url, num_news) gb = NounPhraseGraphBuilder(text_processing.clean_punctuation_and_stopwords) gb.load_texts(texts) G = gb.create_graph() print "Graph built" partition = community.best_partition(G) words_by_part = get_words_by_partition(partition) print_topics_from_partitions(G, words_by_part, 10) mod = community.modularity(partition,G) print("modularity:", mod) #print_topics_from_partitions(G, words_by_part, 10) if draw: values = [partition.get(node) for node in G.nodes()] nx.draw_spring(G, cmap = plt.get_cmap('jet'), node_color = values, node_size=30, with_labels=False) plt.show() topics = get_topics_from_partitions(G, words_by_part, 10) return G, topics
def print_graph_nx(vertices, edges, name, draw_spring=False, print_dist=False): G=nx.DiGraph() labels = [] for v in vertices: G.add_node(v) for v in vertices: for e in edges: if(len(e)) > 2: G.add_edge(e[0], e[1], weight=int(e[2])) else: G.add_edge(e[0], e[1]) print("Nodes of graph: ") print(G.nodes()) print("Edges of graph: ") print(G.edges()) if not draw_spring: nx.draw(G, with_labels=True, node_color='y') else: nx.draw_spring(G, with_labels=True, node_color='y') #nx.draw_networkx_edge_labels(G,labels) plt.savefig("%s.png" % name) # save as png #plt.show() plt.clf()
def draw_graph(graph, showLabels = True): # extract nodes from graph nodes = set([n1 for n1, n2 in graph] + [n2 for n1, n2 in graph]) # create network graph G=nx.Graph() # add nodes for node in nodes: G.add_node(node) # add edges for edge in graph: G.add_edge(edge[0], edge[1]) # draw graph 1 in shell layout pos = nx.shell_layout(G) nx.draw(G, pos) plt.figure() # draw graph 2 with a random layout # might need to zoom in to see edges # labels are now on top of the nodes nx.draw_random(G) plt.figure() nx.draw_spring(G, node_size=100, with_labels=showLabels, font_size=16, edge_color="grey", width=0.5) # draw graph 3 the standard way and save plt.savefig("fig1.png") plt.show()
def lattice_plot(component_list, file_path): """ Creates a lattice style plot of all graph components """ graph_fig=plt.figure(figsize=(20,10)) # Create figure # Set the number of rows in the plot based on an odd or # even number of components num_components=len(component_list) if num_components % 2 > 0: num_cols=(num_components/2)+1 else: num_cols=num_components/2 # Plot subgraphs, with centrality annotation plot_count=1 for G in component_list: # Find actor in each component with highest degree in_cent=nx.degree(G) in_cent=[(b,a) for (a,b) in in_cent.items()] in_cent.sort() in_cent.reverse() high_in=in_cent[0][1] # Plot with annotation plt.subplot(2,num_cols,plot_count) nx.draw_spring(G, node_size=35, with_labels=False) plt.text( 0,-.1,"Highest degree: "+high_in, color="darkgreen") plot_count+=1 plt.savefig(file_path)
def draw_graph(self, G, node_list=None, edge_colour='k', node_size=15, node_colour='r', graph_type='spring', back_bone=None, side_chains=None, terminators=None): # determine nodelist if node_list is None: node_list = G.nodes() # determine labels labels = {} for l_atom in G.nodes_iter(): labels[l_atom] = l_atom.symbol # draw graphs based on graph_type if graph_type == 'circular': nx.draw_circular(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size, edge_color=edge_colour, node_color=node_colour) elif graph_type == 'random': nx.draw_random(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size, edge_color=edge_colour, node_color=node_colour) elif graph_type == 'spectral': nx.draw_spectral(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size, edge_color=edge_colour, node_color=node_colour) elif graph_type == 'spring': nx.draw_spring(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size, edge_color=edge_colour, node_color=node_colour) elif graph_type == 'shell': nx.draw_shell(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size, edge_color=edge_colour, node_color=node_colour) # elif graph_type == 'protein': # self.draw_protein(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size, # edge_color=edge_colour, node_color=node_colour, back_bone, side_chains, terminators) else: nx.draw_networkx(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size, edge_color=edge_colour, node_color=node_colour) plt.show()
def randBearGenealogy(self): """show all direct older relatives of a random bear""" G = nx.Graph() bear = self.getRandomBear() self.helpGenes(G, bear.mom) self.helpGenes(G, bear.dad) nx.draw_spring(G) plt.show()
def draw_Graph( G ): nx.draw_spring(G, node_color=[float(G.degree(v)) for v in G], node_size=40, with_labels=False, cmap=plt.cm.Reds, ) plt.show()
def main(): if len(sys.argv) > 1: id = sys.argv[1] else: id = input("Enter user ID or screen_name: ").lstrip() # Authorization session = vk.AuthSession(access_token=VkData.TOKEN) vk_api = vk.API(session, v=VkData.VERSION) # If user enters screen_name, we need to get his ID id = vk_api.users.get(user_ids=id)[0]["id"] # Friends Graph is dictionary # Key - friend, graph vertex # Value - list of mutual friends, adjacent vertices graph = {} # Get list of friends for entered ID friends = get_friends(vk_api, id) # Fill graph for friend in friends: print('Processing', "\tid: ", friend.id, "\tName : ", friend.first_name, friend.last_name) # If the profile is not hidden if not friend.is_closed: # Get friends of friend all_friends = get_friends(vk_api, friend.id) # Find mutual friends mutual = [] for i in all_friends: for j in friends: if i.id == j.id: mutual.append(j) # Add value in dictionary graph[friend] = mutual else: graph[friend] = list() # Graph visualisation g = nx.from_dict_of_lists(graph) options = { 'node_color': 'red', 'node_size': 100, 'line_color': 'black', 'with_labels': True, 'font_color': 'black', 'style': 'dotted', } nx.draw_spring(g, **options) plt.show()
def graph_object(data_1, data_2, data_3): #instantiate a networkx graph object G = nx.Graph() head = 1171944902 G.add_node(head) #converts dictionaries into list format from data points 1,2 and 3 list_data_1 = list(data_1.keys()) G.add_nodes_from(list_data_1) list_data_2 = [] for element in data_2: for i in element.keys(): list_data_2.append(i) list_data_3 = [] for element in data_3: for i in element.keys(): list_data_3.append(i) #add edges from my account and my top 5 most popular friends for i in range(0, len(list_data_1)): G.add_edges_from([(1171944902, list_data_1[i])]) #add edges between distance 1 friends and distance 2 friends for j in range(0, len(data_2)): for k in list(data_2[j].keys()): G.add_edges_from([(list_data_1[j], k)]) #add edges between distance 2 friends and distance 3 friends for l in range(0, len(data_3)): for m in list(data_3[l].keys()): G.add_edges_from([(list_data_2[l], m)]) #Just generate a little title for my graph plot plt.title("Daniel Fatade's Social Media Network") nx.draw_spring(G, node_color='bisque', with_labels=True) #This saves the graph figure. #plt.savefig('my_network_graph') #These functions calculate the diamter of the graph, the number of nodes and edges present in the graph #and the average distance of the graph n_edges = G.number_of_edges() diameter = nx.diameter(G) average_dist = nx.average_shortest_path_length(G) n_nodes = G.nodes() print("This graph contains {0} distinct nodes with {1} edges. ".format( len(n_nodes), n_edges)) print("The Diameter of this network is: {0} ".format(diameter)) print("The average distance between each node in the Graph is: {0}".format( average_dist))
def main(): Arestas = np.loadtxt('ha30_dist.txt') G = nx.from_numpy_matrix(Arestas) A = kruskal(G) print(A.edges) nx.draw_spring(A, with_labels=True) plt.savefig("grafo_mst.png")
def main(): """For testing with iPython""" # nx.draw_spring(g, with_labels=True) dfs = nx.Graph() # for k, v in tarjan(draw_network(), "sum1")[0].items(): # for k, v in tarjan(draw_small(), "A")[0].items(): for k, v in tarjan(draw_wiki(), "A")[0].items(): dfs.add_edge(k, v) nx.draw_spring(dfs, with_labels=True)
def draw_graph_spring(y, clusters='blue', ns=30): G = nxG(y) plt.figure() nx.draw_spring(G, cmap=plt.get_cmap('jet'), node_color=clusters, node_size=30, with_labels=False)
def draw_graph_labels(labels): d = array_to_dict(labels) values = [d.get(node) for node in G.nodes()] nx.draw_spring(G, map=plt.get_cmap('jet'), node_color=values, node_size=30, with_labels=False) plt.show()
def showGraph( graph ) : # pos = nx.spring_layout(graph, k=1) # nx.draw_networkx_nodes(graph, pos, node_size=4000, node_color="white") # nx.draw_networkx_edges(graph, pos, width=3, alpha=0.5, edge_color="black", arrows=True) # nx.draw_networkx_labels(graph, pos, font_size=12) # nx.draw_networkx_edge_labels(graph, pos, label_pos=0.6, font_size = 10) # plt.axis('off') nx.draw_spring (graph) plt.show ()
def show(graph): # nx.draw(graph, with_labels=True, font_weight='bold') # nx.draw_circular(graph, with_labels=True, font_weight='bold') # nx.draw_kamada_kawai(graph, with_labels=True, font_weight='bold') # nx.draw_spectral(graph, with_labels=True, font_weight='bold') nx.draw_spring(graph, with_labels=True, font_weight='bold') # nx.draw(graph, with_labels=True, font_weight='bold') # nx.draw(graph, with_labels=True, font_weight='bold') plt.show()
def graph(self, plot=False): import networkx as nx G = nx.DiGraph() for n1,n2 in self.probas: G.add_edge(n1,n2,{'p':self.probas[n1,n2]}) if plot: nx.draw_spring(G) else: return G
def main(): cities = {} paths = defaultdict(int) ants = [] #init city data with open('cities.txt') as cityFile: for line in cityFile: line = line.split() # to deal with blank if line: cities[ line[0] ] = int(line[1]) numberOfAnts = int(len(cities)*1.5) numberOfIterations = 10 optimalDistance = 1000000 optimalPath = [] money = 0 for i in range(numberOfIterations): #init distance data with open('distances.txt') as distanceFile: for line in distanceFile: line = line.split() if line: initMatrixAtIndexes(paths,line[0],line[1],int(line[2]),cities) ALPHA = random.randint(1,1) BETA = random.randint(1,1) #EVAPORATION_RATE = random.random() ants = [] for i in range(numberOfAnts): a = Ant('INITIAL') ants.append(a) for a in ants: #Tour until stuck or until visited all cities for i in range(len(cities)): if not a.hasVisitedAllCities(cities) and not a.isStuck(): evaporatePheromones(paths,ants) a.moveToNextEdge(paths) elif not a.hasReturnedHome() and not a.isStuck(): evaporatePheromones(paths,ants) a.returnToStartingCity(paths) if (a.getTravelledDistance()<optimalDistance and not a.isStuck()): optimalPath = a.getPath() optimalDistance = a.getTravelledDistance() money = a.getMoney() g=nx.DiGraph() for i in range (len(optimalPath)-1): g.add_weighted_edges_from([(optimalPath[i],optimalPath[i+1],paths[(optimalPath[i],optimalPath[i+1])]['distance'])]) nx.draw_spring(g) plt.savefig("file.png") nx.write_dot(g,'file.dot') print optimalDistance, optimalPath, money
def ego(): ''' This node is deceptively connected because it's from the index (page 750 of volume2.pdf). ''' g_9_56_090 = nx.ego_graph(g, '9.56.090') nx.draw_spring(g_9_56_090) plt.savefig("9.56.090.png") print nodes['9.56.090']
def communities(publications: List[Tuple[int, Set[int]]]) -> None: graph = get_collaboration_graph(publications, 2006, 2016) partition = community_louvain.best_partition(graph) values = [partition.get(node) for node in graph.nodes()] networkx.draw_spring(graph, cmap=matplotlib.pyplot.get_cmap('tab20'), node_size=60, node_color=values, font_size=8, with_labels=True) matplotlib.pyplot.show()
def test_edge_colormap(): colors = range(barbell.number_of_edges()) nx.draw_spring( barbell, edge_color=colors, width=4, edge_cmap=plt.cm.Blues, with_labels=True, )
def main(args): if len(args) != 1: sys.exit("Usage: python ?.py <graphml file>") net = args[0] G = networkx.read_graphml(net) G = networkx.convert_node_labels_to_integers(G) investment_dataframe = pandas.read_csv('investment.csv', header=None) investment_narray = numpy.array(investment_dataframe) #np.ndarray() investment_list = investment_narray.tolist() #list investment = [] nodes_color = [] nodes_size = [] for i in range(len(investment_list)): [inv] = investment_list[i] investment.append(inv) '''度的节点size大''' for i in range(len(G)): d = G.degree()[i] if d >= 0 and d < 2: nodes_size.append(20) elif d >= 2 and d < 4: nodes_size.append(50) elif d >= 4 and d < 6: nodes_size.append(100) elif d >= 6 and d < 8: nodes_size.append(160) elif d >= 8 and d < 10: nodes_size.append(200) elif d >= 10: nodes_size.append(1000) '''投资大的颜色偏红''' for i in range(len(G)): invest = investment[i] if invest >= 0 and invest < 0.2: nodes_color.append('#FFFFB9') elif invest >= 0.2 and invest < 0.4: nodes_color.append('#FFFF37') elif invest >= 0.4 and invest < 0.6: nodes_color.append('#FF8000') elif invest >= 0.6 and invest < 0.8: nodes_color.append('#F75000') elif invest >= 0.8 and invest < 0.9: nodes_color.append('#F75000') elif invest >= 1: nodes_color.append('#EA0000') networkx.draw_spring(G, width=0.5, with_labels=False, font_size=10, node_size=nodes_size, node_color=nodes_color, node_width=0) plt.show() #可以将这个网络图形显示出来 plt.savefig('RELITU.png')
def draw_community(self): part = community.best_partition(self.graph) values = [part.get(node) for node in self.graph.nodes()] nx.draw_spring(self.graph, cmap=plt.get_cmap('jet'), node_color=values, node_size=30, with_labels=False) plt.show()
def showGraph(self): """show a graph of all bears that are alive""" G = nx.Graph() for bear in self.bears: mom = bear.mom dad = bear.dad if dad!=None and mom != None: G.add_edges_from([(str(mom),str(mom)+"-"+str(dad)),(str(mom)+str(dad),str(dad)), (str(mom)+str(dad), str(bear))]) nx.draw_spring(G) plt.show()
def graphattempt(): G = nx.Graph() for friend in frndct: for person in frndct[friend]: G.add_edge(friend, person) nx.write_gexf(G, 'networkforge.gexf') pos=nx.spring_layout(G) nx.draw_spring(G, with_labels=True, font_size=20, font_color='black', node_color = "steelblue") plt.show()
def plot_graph_community(graph): parts = community_louvain.best_partition(graph) values = [parts.get(node) for node in graph.nodes()] nx.draw_spring(graph, cmap=plt.get_cmap('jet'), node_color=values, node_size=35, with_labels=False) plt.axis('off') plt.show()
def plot_graph(graph, race_dict): print(graph.number_of_nodes()) # print(graph.nodes[:5]) print(graph.number_of_edges()) # nx.draw(graph) nx.draw_spring(graph) # plt.savefig("graph.png") # save as png plt.show() pass
def test_remove_vertices(g): g_save = g.copy(False) g_save.remove_node(1) g_save.remove_node(2) g_save.remove_node(3) g_save.remove_node(4) g_save.remove_node(5) nx.draw_spring(g_save, with_labels=True) plt.savefig("Illustrations/my_graph_with_less_vertices.pdf") plt.close()
def main(): n = 16 m = 25 G = nx.gnm_random_graph(n, m) # nx.draw(G, with_labels=True, font_weight='bold') nx.draw_spring(G, with_labels=True, font_weight='bold') plt.show() for node in nx.nodes(G): pass
def bn_ex(): print("BN Example") fig, ax = newfig(1.0) G = nx.DiGraph() for (p, q) in [('A', 'C'), ('B', 'C'), ('C', 'D')]: G.add_edge(p, q) nx.draw_spring(G, node_color='w', ax=ax, with_labels=True, font_size=10) savefig('bn_ex')
def p_create(p): """ create : parameter | equal_var | empty """ print("TREE", p[1]) print('Status: ' + str(use(p[1]))) nx.draw_spring(graph(p[1]), with_labels=True) plt.savefig('output.png')
def save_graph(graph): """ Networkx draw function does not look nice. Function needs improvements in the future. """ nx.draw_spring(graph, with_labels = True) plt.draw() #plt.show() plt.savefig('graph_with_labels.png') plt.clf()
def get_motif_example(self, motif_length=25): """Method that gets an example motif of motif_length.""" motifs = mf.get_motifs(self.project_ids, motif_length, self.num_motifs_to_sample, self.commits_dl) second_most_common_motif = sorted(motifs, key=motifs.get, reverse=True)[1] fig, ax = plt.subplots() nx.draw_spring(second_most_common_motif, node_size=100, ax=ax) fig.suptitle('Common Git Motif \n Length {}'.format(motif_length), fontsize=20) fig.savefig('results/motif_example.png') return fig
def buffer_match_mappings(graph, title='buffer matches'): labels = nx.get_node_attributes(graph, 'label') matches_colour = { i: ("#00f208" if (graph.nodes[i]['buffer_match'] == True) else "#c0c1c2") for i in graph.nodes } nx.draw_spring(graph, node_color=list(matches_colour.values()), labels=labels) plt.show()
def show_graph( Graph ): edges=[] for k,v in g.items(): for x in v: edges.append((k,x)) G=nx.Graph() G.add_edges_from(edges) nx.draw_spring(G) plt.show()
def transitive_closure_road_accident(): print( "Znajdź domknięcie przechodnie relacji hiperonimi dla pierwszego znaczenia wyrażenia wypadek drogowy i przedstaw je w postaci grafu skierowanego." ) meaning = d.WNQUERY.lookUpSense('wypadek drogowy', 1, 'n') dfs(d.WNQUERY, meaning.wnid, 'n', 'hypernym') diGraph = networkx.DiGraph() diGraph.add_edges_from(graph) plt.figure(figsize=(12, 3)) networkx.draw_spring(diGraph, with_labels=True) plt.show()
def test_draw(self): # hold(False) N = self.G nx.draw_spring(N) pylab.savefig("test.png") nx.draw_random(N) pylab.savefig("test.ps") nx.draw_circular(N) pylab.savefig("test.png") nx.draw_spectral(N) pylab.savefig("test.png")
def test_draw(self): # hold(False) N=self.G nx.draw_spring(N) pylab.savefig("test.png") nx.draw_random(N) pylab.savefig("test.ps") nx.draw_circular(N) pylab.savefig("test.png") nx.draw_spectral(N) pylab.savefig("test.png")
def draw_and_show_with_edge_labels(self): """ Draws the graph and displays it with node/edge labels displays. This is somewhat experimental and can be buggy dependent on the number of nodes and how edge labels are displayed. :return: """ nx.draw_spring(self.current_graph, with_labels=True) nx.draw_networkx_edge_labels(self.current_graph, pos=nx.spring_layout(self.current_graph)) plt.waitforbuttonpress() return True
def run_mini_pipeline(): atlas = datasets.fetch_atlas_msdl() atlas_img = atlas['maps'] labels = pd.read_csv(atlas['labels'])['name'] masker = NiftiMapsMasker(maps_img=atlas_img, standardize=True, memory='/tmp/nilearn', verbose=0) data = datasets.fetch_adhd(number_subjects) figures_folder = '../figures/' count=0 for func_file, confound_file in zip(data.func, data.confounds): # fit the data to the atlas mask, regress out confounds time_series = masker.fit_transform(func_file, confounds=confound_file) correlation = np.corrcoef(time_series.T) #plotting starts here plt.figure(figsize=(10, 10)) plt.imshow(correlation, interpolation="nearest") x_ticks = plt.xticks(range(len(labels)), labels, rotation=90) y_ticks = plt.yticks(range(len(labels)), labels) corr_file = figures_folder+'subject_number_' + str(count) + '_correlation.pdf' plt.savefig(corr_file) atlas_region_coords = [plotting.find_xyz_cut_coords(img) for img in image.iter_img(atlas_img)] threshold = 0.6 plotting.plot_connectome(correlation, atlas_region_coords, edge_threshold=threshold) connectome_file = figures_folder+'subject_number_' + str(count) + '_connectome.pdf' plt.savefig(connectome_file) #graph setup #binarize correlation matrix correlation[correlation<threshold] = 0 correlation[correlation != 0] = 1 graph = nx.from_numpy_matrix(correlation) partition=louvain.best_partition(graph) values = [partition.get(node) for node in graph.nodes()] plt.figure() nx.draw_spring(graph, cmap = plt.get_cmap('jet'), node_color = values, node_size=30, with_labels=True) graph_file = figures_folder+'subject_number_' + str(count) + '_community.pdf' plt.savefig(graph_file) count += 1 plt.close('all')
def draw(draw_graph): options = { 'node_color': 'black', 'node_size': 50, 'line_color': 'grey', 'linewidths': 0, 'width': 0.1, 'with_labels': True } nx.draw_spring(draw_graph, **options) plt.show()
def test_multilayer(): net = Multilayer([2,5,1]) print net.network_inputs print net.network_outputs print net.hidden_layers print net.network.edges() print net.evaluate_pattern([1.0, 1.0]) import matplotlib.pyplot as plt import networkx networkx.draw_spring(net.network) plt.show()
def plot_giant_component(self): ''' Plots the whole graph ''' try: nx.draw_spring(self.giant_component) except: print('Giant component initialized. Run giant_component method')
def draw_graph(G): """ A helper function to draw a nx graph with community. """ groups =nx.get_node_attributes(G,'club').values() color_list = plt.cm.tab10(np.linspace(0, 1, len(groups))) color_dict = dict(zip(groups, color_list)) nx.draw_spring(G,seed=0, nodelist=G.nodes(), node_color=[color_dict[x] for x in groups], alpha=0.8)
def draw_graph(G): """ Genera una imagen con formato .png del grafo.<br/> **:param G:** Recibe un grafo no dirigido de tipo networkx.<br/> **:return:** Una imagen .png del grafo.<br/> """ nx.draw_spring(G, with_labels=True) labels = nx.get_edge_attributes(G, 'costo') # nx.draw_networkx_edge_labels(G, nx.spring_layout(G), edge_labels=labels) plt.savefig(MEDIA_ROOT + '/item_trazabilidad.png') plt.clf()
def metagraph_to_spring( dgl_graph ): # konwersja grafu dgl_heterograph i wyświetlenie spring_layout # link do dokumentacji: https://networkx.org/documentation/stable/reference/generated/networkx.drawing.layout.spring_layout.html dgl_metagraph = dgl_graph.metagraph() G = nx.MultiGraph() G.add_nodes_from(dgl_metagraph.nodes) G.add_edges_from(dgl_metagraph.edges) pos = nx.spring_layout(G) nx.draw_spring(G) #return nx.draw(G, pos) plt.show()
def show(W, lamda, f, m): fm, fn = np.shape(f) print('fm,fn:', fm, fn) lamdaIndicies = np.argsort(lamda) first = 0 second = 0 print(lamdaIndicies[0], lamdaIndicies[1]) for i in range(fm): if lamda[lamdaIndicies[i]].real > 1e-2: # 找到特征值比较小的2个,但是不为0的! print(lamda[lamdaIndicies[i]]) first = lamdaIndicies[i] second = lamdaIndicies[i + 1] break print(first, second) for i in range(m): nx_G = read_graph() # 利用networkx包读取Graph信息 color = [] vertex = [] vertex.append(i) for j in range(m): if j == i: color.append(0.7) elif W[i, j] == 0: color.append(0.1) # 为0或1 else: color.append(0.9) vertex.append(j) #顶点j有关的所有边 # print(vertex) # 通过相关联的点进行加边 for ii in range(m): for jj in range(m): if nx_G.has_edge(ii, jj): if (ii in vertex or jj in vertex): continue else: nx_G.remove_edge(ii, jj) """ fig=plt.figure('lowdata') ax2 = fig.add_subplot(111) ax2.scatter(f[:,first], f[:,second], c=color, cmap=plt.cm.Spectral) plt.show() """ nx.draw_spring(nx_G, with_labels=True, node_color=color) return return
def wypadek_drogowy_hypernym(query: WNQuery): wnid = query.lookUpSense("wypadek drogowy", 1, "n").wnid cl = closure(query, wnid, 'n', 'hypernym') cl = [(query.getSynset(a, 'n').toString(), query.getSynset(b, 'n').toString()) for (a, b) in cl] graph = nx.DiGraph() graph.add_edges_from(cl) plt.figure(figsize=(15, 10)) nx.draw_spring(graph, arrows=True, with_labels=True) plt.show()
def graphCommunities(filename): """ Partitions and colors graphs into communities w/ best_partition. Displays graph with spring layout (perhaps spectral would be better?) and saves. Unsuccessful attempts made to separate clusters visually. """ # generate graph graph = makeGraphFromJSON(filename) name = filename.split(".json")[0] # find the groups each node belongs to part = community.best_partition(graph) # get total number of clusters and set up dictionary clusters = {} total = max(part.values()) + 1 for i in range(total): clusters[i] = [] # sort nodes into clusters for node, group in part.items(): clusters[group].append(node) # turn clusters into a separate graph for c, nodes in clusters.items(): clusters[c] = graph.subgraph(clusters[c]) ## Now display clustering of original graph by fixing a point from each ## cluster and letting networkx arrange the rest of nodes fixed = {} x = 0 for _, c in clusters.items(): # find node of highest degree centrality within each cluster deg = nx.degree_centrality(c) deg = sorted(deg.items(),key=itemgetter(1), reverse=True)[0] x += 1 #return clusters, total # graph fig = plt.figure() plt.axis("off") #pos = nx.spring_layout(graph, fixed=fixed.keys(), pos=fixed) values = [part.get(node) for node in graph.nodes()] #nx.draw_networkx(graph, pos=pos, cmap = plt.get_cmap('jet'), node_color = values, node_size=30, with_labels=True) nx.draw_spring(graph, cmap = plt.get_cmap('jet'), node_color = values, node_size=30, with_labels=True) # save figure fig.savefig(name + ".png")
def test_draw(self): N=self.G nx.draw_spring(N) plt.savefig("test.ps") nx.draw_random(N) plt.savefig("test.ps") nx.draw_circular(N) plt.savefig("test.ps") nx.draw_spectral(N) plt.savefig("test.ps") nx.draw_spring(N.to_directed()) plt.savefig("test.ps") os.unlink('test.ps')
def fun_save_graph(self,graph,file_name,str_time): # prints the graph you hand it as a .png file in the directory specified by file_name import matplotlib import matplotlib.pyplot as plt import networkx as nx plt.figure() nx.draw_spring(graph,node_color='w',with_labels=True,node_size=1000,arrows=True) plt.savefig("out/" + str_time + "/%(pHolder_file_name)s" %dict(pHolder_file_name = file_name)) print('Saved graph '+"out/" + str_time + "/%(file_name)s" %dict(file_name = file_name))
def plot_induced_subgraphs(self): plt.figure(1) partition = self.find_partition()[1] communities = [partition[v] for v in partition] newGraph=self.G for community in communities: nx.subgraph(newGraph, [key for key in partition if partition[key]==community]) node_color=[float(partition[v]) for v in partition] labels = {} for node in newGraph.nodes(): labels[node]= newGraph.node[node].get('name', '') nx.draw_spring(newGraph,node_color=node_color, labels=labels) plt.show() plt.savefig("C:\\Users\\Heschoon\\Dropbox\\ULB\\Current trends of artificial intelligence\\Trends_project\\graphs\\graph_induced.pdf")
def draw_spring_communities(self, full_names='False', k=None, iterations=50, scale=1.0): partition = self.find_partition()[1] #colors = ['red', 'blue', 'green', 'cyan', 'magenta', 'yellow'] #node_color=[colors[partition[v]] for v in partition] node_color=[float(partition[v])*2.0 for v in partition] if not(full_names): labels = self.compute_labels() else: labels = {} for node in self.G.nodes(): labels[node]= self.G.node[node].get('name', '') nx.draw_spring(self.G,node_color=node_color, labels=labels, k=k, iterations=iterations, scale=scale, cmap=plt.cm.hsv) plt.show() plt.savefig("C:\\Users\\Heschoon\\Dropbox\\ULB\\Current trends of artificial intelligence\\Trends_project\\graphs\\graph_spring.pdf")
def run_and_trace(self, name, workload, old=False, sync_period=0, step_size=1, ignore_remaining=False, show_graph=False, staleness=0): """ Run and produce a log of the simulation for each timestep Convert an old format workload to new format if old=TRUE Dump the metrics, workload, and (if old-format) the converted new-format workload to JSON as files """ filename = 'logs/' + name dir = os.path.dirname(filename) try: os.stat(dir) except: os.mkdir(dir) f = open(filename + '.workload', 'w') print >>f, json.dumps(workload,sort_keys=True, indent=4) f.close() if (old): # log the converted old_to_new network graph workload = old_to_new(workload) f = open(filename + '.newworkload', 'w') print >>f, json.dumps(workload,sort_keys=True, indent=4) f.close() metrics = self.run(workload, sync_period, step_size, ignore_remaining, show_graph=show_graph, staleness=staleness) else: metrics = self.run(workload, sync_period, step_size, ignore_remaining, show_graph=show_graph, staleness=staleness) f = open(filename + '.metrics', 'w') print >>f, json.dumps(metrics, sort_keys=True, indent=4) f.close() if show_graph: # log the network graph if not already drawn try: os.stat(filename + ".pdf") except: nx.draw_spring(self.graph) plt.savefig(filename + ".pdf") plt.close() return metrics
def main(): # Create a NetworkX graph object gmail_graph=graphFromCSV("../email_analysis/email_graph.csv") # Draw entire graph full_graph=plt.figure(figsize=(10,10)) nx.draw_spring(gmail_graph, arrows=False, node_size=50, with_labels=False) plt.savefig("../../../images/graphs/full_graph.png") # Draw [email protected]'s Ego graph ego_plot(gmail_graph, "*****@*****.**", "../../../images/graphs/ann9enigma_ego.png") # Create a lattice plot of all weakly connected components gmail_components=nx.weakly_connected_component_subgraphs(gmail_graph) lattice_plot(gmail_components, "../../../images/graphs/gmail_subgraphs.png")
def draw_graph(D): D = D.to_undirected() plot.figure(figsize=(16,16)) nx.draw_spring(D, node_color=[float(D.degree(v)) for v in D], #edge_color=[np.log(D[e1][e2]["weight"]+1) for e1,e2 in D.edges()], width=3, edge_cmap=plot.cm.Reds, with_labels=True, cmap=plot.cm.Reds, node_size=1000, font_size=8, iterations=100000) plot.title("Spring Network Layout of %s" % D.name) plot.savefig("results/network_graphs/%s.png" % D.name) plot.close()