def computeKnn(graph, knn_file, weight=None): G = nx.path_graph(4) G.edge[1][2]['weight'] = 3 print nx.k_nearest_neighbors(G) knnfs = codecs.open(knn_file, 'w+', encoding='utf-8') knn = nx.average_degree_connectivity(graph) print graph, 'knn as follows:' print knn sumknn = sum(knn.values()) minknn = min(knn.keys()) maxknn = max(knn.keys()) index = maxknn currentSum = 0.0 while index >= minknn: if index in knn.keys(): currentSum = knn[index] else: index -= 1 continue freq = currentSum * 1.0 / sumknn knnfs.write(str(index) + ',' + str(freq) + '\r\n') print index, freq index -= 1 #for (key, value) in knn.items(): # knnfs.write(str(key)+ ',' + str(value) + '\r\n') knnfs.flush() knnfs.close()
def computeKnn(graph, knn_file, weight=None): G = nx.path_graph(4) G.edge[1][2]['weight'] = 3 print nx.k_nearest_neighbors(G) knnfs = codecs.open(knn_file, 'w+', encoding='utf-8') knn = nx.average_degree_connectivity(graph) print graph, 'knn as follows:' print knn for (key, value) in knn.items(): knnfs.write(str(key) + ',' + str(value) + '\r\n') knnfs.flush() knnfs.close()
def apply_knn(lcn, hccs, opts): num_accounts = lcn.number_of_nodes() w_property = opts.weight_property k = int(round(math.log(num_accounts))) log('Choosing k of %d (%d users)' % (k, num_accounts)) knns = nx.k_nearest_neighbors(lcn, weight=w_property) closest_k = k if k in knns else find_closest_knn(k, knns) log('using closest_k: %d' % closest_k) knn = knns[closest_k] #if k in knns else knns[find_closest_knn(k, knns)] log('KNN: %s' % knn) knn_nodes = [n for n, d in lcn.degree() if d > knn] def prep_node_attrs(n): return dict([(k, lcn.nodes[k]) for k in lcn.nodes[k]]) for u in knn_nodes: for v in lcn[u]: # u's neighbours if v in knn_nodes: # v qualifies if u not in hccs: hccs.add_node(u, **lcn.nodes[u]) if v not in hccs: hccs.add_node(v, **lcn.nodes[v]) if not hccs.has_edge(u, v): hccs.add_edge(u, v, **lcn.edges[u, v]) return hccs
def test_sparse_sym(self): A = np.array([[0, 1, 1, 0, 1], [1, 0, 1, 1, 0], [1, 1, 0, 0, 0], [0, 1, 0, 0, 1], [1, 0, 0, 1, 0]]) A_nx = nx.convert_matrix.from_numpy_array(A) # sparse matrix conversion A = scipy.sparse.csr_matrix(A) rows, cols = A.nonzero() print(rows, cols) A[cols,rows] = A[rows, cols] k = sample.out_degree(A) knn_sample = sample.nearest_neighbour_degree_undirected(A) # knn_nx = nx.degree_assortativity_coefficient(A_nx) knn_nx = nx.k_nearest_neighbors(A_nx) # debug check """ print(k) print('\n') print(knn_sample) print(knn_nx) """ self.assertTrue(knn_sample == knn_nx)
def list_degree_average(G): davg_dic={} num_nodes=nx.number_of_nodes(G) degree=nx.k_nearest_neighbors(G, weight='weight') for i in range(num_nodes): if str(i) in degree.keys(): davg_dic[i]=degree[str(i)] return davg_dic
def gen_graph_stats (graph): G = nx.read_graphml(graph) stats = {} edges, nodes = 0,0 for e in G.edges_iter(): edges += 1 for n in G.nodes_iter(): nodes += 1 stats['Edges'] = (edges,'The number of edges within the Graph') stats['Nodes'] = (nodes, 'The number of nodes within the Graph') print "%i edges, %i nodes" % (edges, nodes) # Accessing the highest degree node center, degree = sorted(G.degree().items(), key=itemgetter(1), reverse=True)[0] stats['Center Node'] = ('%s: %0.5f' % (center,degree),'The center most node in the graph. Which has the highest degree') hairball = nx.subgraph(G, [x for x in nx.connected_components(G)][0]) print "Average shortest path: %0.4f" % nx.average_shortest_path_length(hairball) stats['Average Shortest Path Length'] = (nx.average_shortest_path_length(hairball), '') # print "Center: %s" % G[center] # print "Shortest Path to Center: %s" % p print "Degree: %0.5f" % degree stats['Degree'] = (degree,'The node degree is the number of edges adjacent to that node.') print "Order: %i" % G.number_of_nodes() stats['Order'] = (G.number_of_nodes(),'The number of nodes in the graph.') print "Size: %i" % G.number_of_edges() stats['Size'] = (G.number_of_edges(),'The number of edges in the graph.') print "Clustering: %0.5f" % nx.average_clustering(G) stats['Average Clustering'] = (nx.average_clustering(G),'The average clustering coefficient for the graph.') print "Transitivity: %0.5f" % nx.transitivity(G) stats['Transitivity'] = (nx.transitivity(G),'The fraction of all possible triangles present in the graph.') part = community.best_partition(G) # values = [part.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() mod = community.modularity(part,G) print "modularity: %0.5f" % mod stats['Modularity'] = (mod,'The modularity of a partition of a graph.') knn = nx.k_nearest_neighbors(G) print knn stats['K Nearest Neighbors'] = (knn,'the average degree connectivity of graph.\nThe average degree connectivity is the average nearest neighbor degree of nodes with degree k. For weighted graphs, an analogous measure can be computed using the weighted average neighbors degre') return G, stats
def test_degree_barrat(self): G = nx.star_graph(5) G.add_edges_from([(5, 6), (5, 7), (5, 8), (5, 9)]) G[0][5]["weight"] = 5 nd = nx.average_degree_connectivity(G)[5] assert nd == 1.8 nd = nx.average_degree_connectivity(G, weight="weight")[5] assert nd == pytest.approx(3.222222, abs=1e-5) nd = nx.k_nearest_neighbors(G, weight="weight")[5] assert nd == pytest.approx(3.222222, abs=1e-5)
def test_degree_barrat(self): G=nx.star_graph(5) G.add_edges_from([(5,6),(5,7),(5,8),(5,9)]) G[0][5]['weight']=5 nd = nx.average_degree_connectivity(G)[5] assert_equal(nd,1.8) nd = nx.average_degree_connectivity(G,weight='weight')[5] assert_almost_equal(nd,3.222222,places=5) nd = nx.k_nearest_neighbors(G,weight='weight')[5] assert_almost_equal(nd,3.222222,places=5)
def analyze_graphs(my_df, report_dict, layer): #G=nx.Graph() G = nx.from_pandas_edgelist(my_data, 'Source_Names', 'Destination_Names', edge_attr=None, create_using=None) report_dict['knearestscore'].append(nx.k_nearest_neighbors(G)) report_dict['knearestscore'].append(nx.average_degree_connectivity(G)) purchase = my_data.loc[my_data['Etype'] == 5] report_dict['Source_Names'].append(purchase['Source_Names'].iloc[0]) report_dict['Destination_Names'].append( purchase['Destination_Names'].iloc[0]) report_dict['full_date'].append(purchase['full_date'].iloc[0]) report_dict['layer'].append(layer)
def assortativity(self): result = {} result['average_degree_connectivity'] = nx.average_degree_connectivity( self.graph) result['k_nearest_neighbors'] = nx.k_nearest_neighbors(self.graph) # k degree distribution k_degree = [] for k in result['average_degree_connectivity'].keys(): k_degree.append((k, result['average_degree_connectivity'][k], result['k_nearest_neighbors'][k])) k_degree.insert( 0, ['degree k', 'average_degree_connectivity', 'k_nearest_neighbors']) return k_degree
def graph_stats(G): density = nx.density(G) try: corr = nx.degree_pearson_correlation_coefficient(G) except: corr = 0 avg_neighbor_degree = nx.average_neighbor_degree(G) #dict k_nearest_neighbors = nx.k_nearest_neighbors(G) #dict degree_centrality = nx.degree_centrality(G) #dict info = nx.info(G) return { 'density': density, 'corr': corr, 'avg_neighbor_degree': avg_neighbor_degree, 'k_nearest_neighbors': k_nearest_neighbors, 'degree_centrality': degree_centrality, 'info': info }
def assortativity(self): result = {} result[ 'degree_assortativity_coefficient'] = nx.degree_assortativity_coefficient( self.graph) if self.directed == 'undirected': result[ 'degree_pearson_correlation_coefficient'] = nx.degree_pearson_correlation_coefficient( self.graph) result['average_neighbor_degree'] = nx.average_neighbor_degree( self.graph) result['average_degree_connectivity'] = nx.average_degree_connectivity( self.graph) result['k_nearest_neighbors'] = nx.k_nearest_neighbors(self.graph) fname_assort = self.DIR + '/assortativity.json' with open(fname_assort, "w") as f: json.dump(result, f, cls=SetEncoder, indent=2) print(fname_assort)
def test_array_inin(self): A = np.array([[0, 0, 1, 0, 1], [1, 0, 0, 1, 0], [1, 1, 0, 0, 0], [0, 1, 1, 0, 1], [1, 0, 0, 1, 0]]) A_nx = nx.convert_matrix.from_numpy_array(A, create_using=nx.DiGraph()) k = sample.in_degree(A) knn_sample = sample.nearest_neighbour_degree_inin(A) # knn_nx = nx.degree_assortativity_coefficient(A_nx) knn_nx = nx.k_nearest_neighbors(A_nx, source='in', target='in') # debug check """ print(k) print('\n') print(knn_sample) print(knn_nx) """ self.assertTrue(knn_sample == knn_nx)
def test_array_sym(self): A = np.array([[0, 1, 1, 0, 1], [1, 0, 1, 1, 0], [1, 1, 0, 0, 0], [0, 1, 0, 0, 1], [1, 0, 0, 1, 0]]) A_nx = nx.convert_matrix.from_numpy_array(A) k = sample.out_degree(A) knn_sample = sample.nearest_neighbour_degree_undirected(A) # knn_nx = nx.degree_assortativity_coefficient(A_nx) knn_nx = nx.k_nearest_neighbors(A_nx) # debug check """ print(k) print('\n') print(knn_sample) print(knn_nx) """ self.assertTrue(knn_sample == knn_nx)
edge_list = os.path.join(input_data_folder, edgelist_filename) if not os.path.exists(edge_list): continue new_graph = nx.read_weighted_edgelist(edge_list) graph_dict[graph_name] = new_graph # %% knn_dict = {} degree_dict = {} for graph in graph_dict.keys(): print(graph) knn_dict[graph] = nx.k_nearest_neighbors(graph_dict[graph], weight='weight') degree_dict[graph] = {(x):y for (x,y) in graph_dict[graph].degree(weight='weight')} # %% # split dict to weekend vs weekday weekday_knn = {} weekend_knn = {} for key in knn_dict.keys(): day_type = key.split("_")[1] day_hour = int(key.split("_")[-1])
print('Calculating: clustering (this may take a while)') dict_clustering = nx.clustering(Gtc, weight='weight') nx.set_node_attributes(Gtc, name='clustering', values=dict_clustering) print('Calculating: average neighbor degree') dict_average_neighbor_degree = nx.average_neighbor_degree( Gtc, weight='weight') nx.set_node_attributes(Gtc, name='average_neighbor_degree', values=dict_average_neighbor_degree) print('Calculating: k nearest neighbors') dict_k_nearest_neighbors = nx.k_nearest_neighbors(Gtc, weight='weight') nx.set_node_attributes(Gtc, name='k_nearest_neighbors', values=dict_k_nearest_neighbors) print('Calculating: eccentricity') dict_eccentricity = nx.eccentricity(Gtc) nx.set_node_attributes(Gtc, name='eccentricity', values=dict_eccentricity) print('Calculating: core number') dict_core_number = nx.core_number(Gtc) nx.set_node_attributes(Gtc, name='core_number', values=dict_core_number)
def _compute_avg_degree_connectivity(G: nx.Graph) -> Dict[int, float]: """ Source: https://networkx.github.io/documentation/stable/reference/algorithms/generated/networkx.algorithms.assortativity.k_nearest_neighbors.html#networkx.algorithms.assortativity.k_nearest_neighbors """ return nx.k_nearest_neighbors(G)
def graphinfo(G): nodenum = G.number_of_nodes() edgenum = G.size() connectivity = approx.node_connectivity(G) avgdegree = nx.k_nearest_neighbors(G)
import networkx as nx import matplotlib.pyplot as plt import scipy as sp # GRAPH CO-EFFICIENT #G = nx.gnp_random_graph(1000,0.02) G = nx.read_edgelist("../../Data/SNAP/facebook_combined.txt") A = nx.to_scipy_sparse_matrix(G); fig=plt.figure() plt.spy(A) fig.show() r = nx.degree_assortativity_coefficient(G) print("Degree Assortativity Coefficient = ", r) n = nx.average_neighbor_degree(G) k = nx.k_nearest_neighbors(G)
def processa(nomeEntrada, toStdOut=False): """Processa arquivo da rede, pondo as saídas na pasta com o nome 'out/<rede>' Saídas: - ? """ pastaSaída = criaPastaSaída(nomeEntrada) with open(pastaSaída + '/stats.txt', 'w') as arq: def printa(*args): """Escreve a saída no arquivo de estatísticas, pliz""" if toStdOut: print(nomeEntrada, '\t', *args) else: arq.write(' '.join(map(str, args))) arq.write('\n') # lê a rede do arquivo de entrada G = nx.read_weighted_edgelist(nomeEntrada, nodetype=int, comments='%') # e acha o maior componente maiorComponente = max(nx.connected_component_subgraphs(G), key=len) distribuiçãoDeGraus = list(map(lambda t: t[1], G.degree())) # knn, assortatividade e talz knn = nx.k_nearest_neighbors(G) distribuiçãoKnn = list(knn.values()) ks = list(knn.keys()) assortatividade = nx.degree_assortativity_coefficient(G) printa("Assortatividade:", assortatividade) printa("Pearson:", stats.pearsonr(ks, distribuiçãoKnn)[0]) printa("Spearman:", stats.spearmanr(ks, distribuiçãoKnn)[0]) # Centralidades; TODO: descobrir se rola o 'G' ou o 'maiorComponente' nessas medidas betweenness = list(nx.betweenness_centrality(G).values()) eigenvector = list(nx.eigenvector_centrality_numpy(G).values()) closeness = list(nx.closeness_centrality(G).values()) pageRank = list(nx.pagerank_numpy(G).values()) caminhada = caminhadaleatoria(G) ## Plots ## def histograma(fig, distribuição, título): """Plota um histograma, pra todos ficarem do mesmo jeito =]""" plt.figure(fig) plt.clf() plt.title(título or fig) plt.hist(distribuição, bins=100, histtype='step', log=True) plt.xlabel('i') plt.ylabel('{}(i)'.format(fig)) plt.savefig('{}/{}.png'.format(pastaSaída, fig)) # plot dos histogramas histograma('k', distribuiçãoDeGraus, 'Distribuição de probabilidade do grau') histograma('bet', betweenness, 'Distribuição de probabilidade do Betweenness centrality') histograma('eig', eigenvector, 'Distribuição de probabilidade do Eigenvector centrality') histograma('CC', closeness, 'Distribuição de probabilidade do Closeness centrality') histograma('pagerank', pageRank, 'Distribuição de probabilidade do PageRank') # plot do 'k vs knn' plt.figure('k X knn(k)') plt.clf() plt.plot(distribuiçãoKnn, 'bo') plt.title('Distribuição do grau X Knn(k)') plt.xlabel('k') plt.ylabel('knn (k)') plt.savefig(pastaSaída + '/kXknn.png') # plot do k(i) vs bet(i) plt.figure('k(i) X betweenness(i)') plt.clf() pirso = stats.pearsonr(distribuiçãoDeGraus, betweenness)[0] plt.loglog(distribuiçãoDeGraus, betweenness, 'bo', label='Pearson: ' + str(pirso)) plt.legend(loc='lower right', scatterpoints=0) plt.title('Distribuição de grau X Betweenness centrality') plt.xlabel('k(i)') plt.ylabel('bet(i)') plt.savefig(pastaSaída + '/kXbet.png') # plot do eigenvector X pagerank plt.figure('eigen X pagerank') plt.clf() pirso = stats.pearsonr(eigenvector, pageRank)[0] plt.loglog(eigenvector, pageRank, 'bo', label='Pearson: ' + str(pirso)) plt.legend(loc='lower right', scatterpoints=0) plt.xlabel('eigenvector (i)') plt.ylabel('pagerank (i)') plt.title('Eigenvector centrality X Page rank') plt.savefig(pastaSaída + '/eigXpagerank.png') # plot do k vs caminhada plt.figure('k X caminhada aleatória') plt.clf() pirso = stats.pearsonr(distribuiçãoDeGraus, caminhada)[0] plt.plot(distribuiçãoDeGraus, caminhada, 'bo', label='Pearson: ' + str(pirso)) plt.legend(loc='lower right', scatterpoints=0) plt.title('Distribuição do grau X Caminhada aleatória') plt.xlabel('k (i)') plt.ylabel('caminhada (i)') plt.savefig(pastaSaída + '/kXcaminhada.png') # plot do eigenvector vs caminhada plt.figure('eigenvector X caminhada aleatória') plt.clf() pirso = stats.pearsonr(eigenvector, caminhada)[0] plt.plot(eigenvector, caminhada, 'bo', label='Pearson: ' + str(pirso)) plt.legend(loc='lower right', scatterpoints=0) plt.title('Eigenvector centrality X Caminhada aleatória') plt.xlabel('eigenvector (i)') plt.ylabel('caminhada (i)') plt.savefig(pastaSaída + '/eigXcaminhada.png')
def main(argv): mode=argv[1] path="net.net" G=nx.read_pajek(path) G=nx.Graph(G) #-------------1-------------------------- Nnodes = G.number_of_nodes() Nedges = G.number_of_edges() degree=list(G.degree().values()) meandeg=0 for x in degree: meandeg+=x meandeg=meandeg/float(Nnodes) if mode=="1": print "number of nodes: ", Nnodes print "number of links: ",Nedges print "average degree: ", meandeg plt.title("degree distribution") plt.hist(degree) #------------------------------------------------ #------------------2--------------------------- clustering=list(nx.clustering(G).values()) ave_cluster=nx.average_clustering(G) if mode=="2": print "average clustering: ",ave_cluster print "-------------------------" print "-----ER-Network--------------" print "average degree: ", 2*Nedges/float(Nnodes) print "-------------------------" plt.title("clustering distribution") plt.bar(np.linspace(0,18,19),clustering) cluster_degree=[] i=0 for x in degree: if x > 1: cluster_degree.append(x) else: clustering.pop(i) i+=1 if mode == "3": plt.title("degree over clustering coefficient") plt.plot(clustering,cluster_degree,'o') #-----------------4--------------------- neighbours=list(nx.k_nearest_neighbors(G).values()) if mode=="4": print("average neares neighbour degree: ",sum(neighbours)/float(Nnodes)) #------------------5--------------------------- r=nx.degree_pearson_correlation_coefficient(G) if mode=="5": print("r: ",r) #-------------------6------------------------- eig_cent=list(nx.eigenvector_centrality(G).values()) eig_top=sorted(range(len(eig_cent)), key=lambda i:eig_cent[i])[-7:] deg_top=sorted(range(len(degree)), key=lambda i:degree[i])[-7:] if mode=="6": print("degree top 7:",deg_top) print("eigenvector centrality top 7: ", eig_top) #-----------------7-------------------- pagerank_1=list(nx.pagerank(G,alpha=0.1).values()) pagerank_2=list(nx.pagerank(G,alpha=0.85).values()) pagerank_3=list(nx.pagerank(G,alpha=0.99).values()) if mode=="7": plt.plot(range(Nnodes),pagerank_1,'r') plt.plot(range(Nnodes),pagerank_2,'g') plt.plot(range(Nnodes),pagerank_3,'y') if mode=="8": Gcc=sorted(nx.connected_component_subgraphs(G), key = len, reverse=True)[0] pos=nx.spring_layout(Gcc) nx.draw_networkx_nodes(Gcc,pos,node_size=20) nx.draw_networkx_edges(Gcc,pos,alpha=0.4) plt.show()
import util import networkx as nx from networkx.algorithms import approximation from networkx.algorithms import connectivity state_ = 15 input_ = 4 output_ = 1 file_name = 'test.kiss2' repeated = 5 experiment = 10 util.create_fsm(state_, input_, output_, file_name) G, g_data = util.create_graph(file_name) print(nx.average_neighbor_degree(G)) print(approximation.max_clique(G)) print(nx.k_nearest_neighbors(G)) print(nx.min_edge_cover(G))
# # outdegree of node print(G.in_degree()) print(G.out_degree()) print(G.degree) # Kanten ausgeben for e in G.edges(data=True): print('Edge :', e) print(att_to_list(G, att="DOG")) # # Hier haben wir ein directory von allen ausgehenden Kanten von 208... mit den zugehoerigen Informationen print(G['208000000000000']) print(nx.degree_assortativity_coefficient(G, x='out', y='in')) # TODO: Change node name by degree # if you want to change all the keys: # d = {'x':1, 'y':2, 'z':3} # d1 = {'x':'a', 'y':'b', 'z':'c'} # In [10]: dict((d1[key], value) for (key, value) in d.items()) # Out[10]: {'a': 1, 'b': 2, 'c': 3} print(nx.average_neighbor_degree(G, target='in')) print(nx.k_nearest_neighbors(G, target='in')) # data = att_to_list(G, att="VOL") # sns.set_style('whitegrid') # sns.distplot(np.log10(np.array(data)), rug=True) # plt.show() # for e in G.edges(data=True): # s,t,att = e # if att.get("FREQ") > 1: # print(e)
# %% [markdown] # This is a fairly large network # %% # here we calculate some network-level statistics to describe the network # node / edge count node_count = len(G.nodes) edge_count = len(G.edges) # calculate network density graph_density = nx.density(G) # average clustering coefficient graph_avg_clustering_coef = nx.average_clustering(G) # average neighbour degree graph_avg_neighbour_deg = nx.average_neighbor_degree(G) # k-nearest-neighbour knn = nx.k_nearest_neighbors(G) # average shortest path graph_avg_shortest_path = nx.average_shortest_path_length(G) # %% print(f"The network has {node_count} nodes, {edge_count} edges, with average density of {graph_density}.\nAverage clustering coefficient = {graph_avg_clustering_coef}\nAverage shortest path length = {graph_avg_shortest_path}") # %% [markdown] # Many more network statistics are node-based or edge-based, i.e. the statistics describe individual node/edge in the network. For example, KNN, or average degree of nearest neighbours of k-degree nodes, is used to understand degree correlation and graph assortativity. By plotting KNN against k, we can understand if k-degree nodes tend to connect with nodes of similar degrees. # %% knn_df = pd.DataFrame.from_dict(knn,orient='index',columns=['KNN']) knn_df.sort_index(inplace=True) knn_df.head()
c = nx.clustering(G) print("Clustering co-efficient = ", c) a = nx.average_clustering(G) print("Average Clustering co-efficient = ", a) print("") print("------------------") print("Twitter - directed") print("------------------") #G2 = nx.read_edgelist(twitter,create_using=nx.DiGraph()) G2 = nx.read_edgelist(twitter) print("Nodes: ", len(G2)) # Draw the graph draw_graph(G2) r = nx.degree_assortativity_coefficient(G2) print("Degree Assortativity Coefficient = ", r) n = nx.average_neighbor_degree(G2) k = nx.k_nearest_neighbors(G2) c = nx.clustering(G2) print("Clustering co-efficient = ", c) a = nx.average_clustering(G2) print("Average Clustering co-efficient = ", a) print("") #print("Displaying the chart") #display_degseq.plot_degseq(G2, False) #print("Chart done")
# rates.plot.box(ylabel=r'Initial growth rate $(d^{-1})$') # final.plot.box(ylabel=r'Total affected population $(fraction)$', # positions=clust) # plt.violinplot(final, positions=clust) # %% # assortativity (NOT RELEVANT) sbpx = [221, 222, 223, 224] nets = [rando, watts, barab, holme] # nets = latti fig05 = plt.figure(figsize=(6.4, 4.8), dpi=300) for i in range(4): net = nets[i] sbp = sbpx[i] fig05.add_subplot(sbp) knn = nx.k_nearest_neighbors(net.G) net.G.knn = [knn[i] for i in np.unique(net.G.degree_sequence)] x = np.unique(net.G.degree_sequence) y = np.array(net.G.knn) R = nx.degree_assortativity_coefficient(net.G) plt.scatter(x, y, alpha=0.5) plt.xlabel('k') plt.ylabel(r'$\langle k_{nn} \rangle$') # plt.ylim([net.G.k_min, net.G.k_max]) plt.text(net.G.k_min, np.min(y), 'r = ' + str(np.round(R, 2)), color='red', alpha=0.7)
B=nx.Graph() B.add_weighted_edges_from(makenodes) labels1 = nx.get_edge_attributes(B,'weight') pos1=nx.bipartite_layout(B,iot_nodes) pos = nx.circular_layout(B) nx.draw_networkx_nodes(B ,pos1, node_size=2000, nodelist=edge_nodes, node_color='g') nx.draw_networkx_nodes(B, pos1, node_size=3000, nodelist=iot_nodes, node_color='b') nx.draw_networkx_edges(B,pos1, alpha=0.5, width=3) nx.draw_networkx_edge_labels(B,pos1,font_color='k',edge_labels=labels1) nx.draw_networkx_labels(B,pos1,font_color='w') plt.show() #nearest neibhour print(nx.k_nearest_neighbors(B,nodes=iot_nodes, weight='weight')) #complete bipartite between edge and iot and edge device clique initial_graph=nx.compose(B,ete) labels1 = nx.get_edge_attributes(initial_graph,'weight') pos1=nx.spring_layout(initial_graph) pos = nx.circular_layout(initial_graph) nx.draw_networkx_nodes(initial_graph ,pos1, node_size=2000, nodelist=edge_nodes, node_color='g') nx.draw_networkx_nodes(initial_graph, pos1, node_size=3000, nodelist=iot_nodes, node_color='b') nx.draw_networkx_edges(initial_graph,pos1, alpha=0.5, width=3) nx.draw_networkx_edge_labels(initial_graph,pos1,font_color='k',edge_labels=labels1)
print "degree_pearson_correlation_coefficient" print nx.degree_pearson_correlation_coefficient(G) #print nx.k_nearest_neighbors(G) print "bipartite.closeness_centrality" print bipartite.closeness_centrality(G,G.node) print "degree_centrality" print nx.degree_centrality(G) print "betweenness_centrality" print nx.betweenness_centrality(G) print "k_nearest_neighbors" print nx.k_nearest_neighbors(G) #print nx.current_flow_closeness_centrality(G, normalized=True, weight='weight', dtype='float', solver='lu') #centrality=nx.eigenvector_centrality(G) #print(['%s %0.2f'%(node,centrality[node]) for node in centrality]) #print nx.eigenvector_centrality(G, max_iter=100, tol=1e-02, nstart=None) #print nx.communicability(G) #print nx.triangles(G) #directed Graphでなくてはだめ #print(nx.clustering(G,0)) #print nx.average_clustering(G)
def knn(graph): knn = list(nx.k_nearest_neighbors(graph).values()) k = list(nx.k_nearest_neighbors(graph).keys()) return knn, k