def SwapNodes(self, swapNodes): for (nodeX, nodeY) in swapNodes: self.amends += 1 self.partition[0].remove(nodeX) self.partition[0].append(nodeY) self.partition[1].remove(nodeY) self.partition[1].append(nodeX) #print(self.partition) #time.sleep(20) #self.G=nx.relabel_nodes(self.G, #mapping={nodeX:nodeY,nodeY:nodeX}) self.components[0] = self.G.subgraph(self.partition[0]).copy() self.components[1] = self.G.subgraph(self.partition[1]).copy() self.spectrum = nx.laplacian_spectrum(self.G) self.algebraic_connectivity = nx.algebraic_connectivity(self.G) self.components_spectrum[0] = nx.laplacian_spectrum( self.components[0]) self.components_spectrum[1] = nx.laplacian_spectrum( self.components[1]) self.components_ac[0] = nx.algebraic_connectivity( self.components[0]) self.components_ac[1] = nx.algebraic_connectivity( self.components[1]) self.history.append([ self.algebraic_connectivity, self.components_ac[0], self.components_ac[1] ]) logging.info("Changes appended to history succesfully.")
def graph_sim(g1, g2, tol): """ determine subgraph similarity """ spec1 = nx.laplacian_spectrum(g1) spec2 = nx.laplacian_spectrum(g2) D, p_val = ks_2samp(spec1, spec2) return p_val >= tol
def specSimScore(self, subgraphA, subgraphB, centerType=None): self.defSub(subgraphA, subgraphB) self.extractSub(centerType) specA = nx.laplacian_spectrum(self.extA, weight=None) specB = nx.laplacian_spectrum(self.extB, weight=None) D, p_val = stat.ks_2samp(specA, specB) return p_val
def getSimilarity(self): laplacian1 = nx.laplacian_spectrum(self.graph1) laplacian2 = nx.laplacian_spectrum(self.graph2) k1 = select_k(laplacian1) k2 = select_k(laplacian2) k = min(k1, k2) similarity = sum((laplacian1[:k] - laplacian2[:k]) ** 2) if similarity == 0: similarity = 1 return similarity
def test_laplacian_spectrum(self): "Laplacian eigenvalues" evals=numpy.array([0, 0, 1, 3, 4]) e=sorted(nx.laplacian_spectrum(self.G)) assert_almost_equal(e,evals) e=sorted(nx.laplacian_spectrum(self.WG,weight=None)) assert_almost_equal(e,evals) e=sorted(nx.laplacian_spectrum(self.WG)) assert_almost_equal(e,0.5*evals) e=sorted(nx.laplacian_spectrum(self.WG,weight='other')) assert_almost_equal(e,0.3*evals)
def test_laplacian_spectrum(self): "Laplacian eigenvalues" evals = numpy.array([0, 0, 1, 3, 4]) e = sorted(nx.laplacian_spectrum(self.G)) npt.assert_almost_equal(e, evals) e = sorted(nx.laplacian_spectrum(self.WG, weight=None)) npt.assert_almost_equal(e, evals) e = sorted(nx.laplacian_spectrum(self.WG)) npt.assert_almost_equal(e, 0.5 * evals) e = sorted(nx.laplacian_spectrum(self.WG, weight='other')) npt.assert_almost_equal(e, 0.3 * evals)
def get_laplacian(graph, graph_name): """ Graph laplacian maxtrix eigen values와 normalizaed 된 값을 구한다. """ eigen_values = nx.laplacian_spectrum(graph) print('eigen values of ' + graph_name + ' ' + ', '.join(["{0:0.4f}".format(i) for i in eigen_values[:10]]) + " min eigenvalue {0:0.4f}, max eigenvalue {1:0.4f}".format( min(eigen_values), max(eigen_values))) nor_lapla_mx = nx.normalized_laplacian_matrix(graph) n_eigen_values = np.sort(np.linalg.eigvals(nor_lapla_mx.A)) print('nor eigen values of ' + graph_name + ' ' + ', '.join(["{0.real:.4f}".format(i) for i in n_eigen_values[:10]]) + " min eigenvalue {0.real:.4f}, max eigenvalue {1.real:.4f}".format( min(n_eigen_values), max(n_eigen_values))) print("Clustering Coefficient " + graph_name + ' ' + ": {0}".format(nx.clustering(graph))) print("Avg. Clustering Coefficient " + graph_name + ' ' + ": {0:.4f}".format(nx.average_clustering(graph))) print("Transivity of " + graph_name + ' ' + "{0:.4f} : ".format(nx.transitivity(graph))) print("####################################")
def graph_laplacian_spectrum_fun(graph, **kwargs): # first eigenvalue is 0 spectrum = nx.laplacian_spectrum(graph.G)[1:] feature_dim = kwargs['feature_dim'] if len(spectrum) > feature_dim: spectrum = spectrum[:feature_dim] return torch.tensor(spectrum)
def get_laplacian_spectrum(graph, k=np.inf, which='SM', tol=1E-2, eigvals_only=True, use_gpu=False): """ Gets the bottom k eigenpairs of the Laplacian matrix :param graph: undirected NetworkX graph :param k: number of bottom k eigenpairs to obtain :param which: he type of k eigenvectors and eigenvalues to find :param tol: the precision at which to stop computing the eigenpairs :param eigvals_only: get only the eigenvalues i.e., no eigenvectors :return: the eigenpair information """ if use_gpu: print('Warning: GPU requested, but not available for Laplacian measures') # get all eigenvalues for small graphs if len(graph) < 100: lam = nx.laplacian_spectrum(graph) else: L = get_laplacian(graph) lam = eigsh(L, k=min(k, len(graph) - 1), which=which, tol=tol, return_eigenvectors=not eigvals_only) lam = np.sort(lam) # sort ascending return lam
def computeFeatures(self, G, features_nx, features_nk): if("effective_graph_resistance" in features_nx or "nb_spanning_trees" in features_nx or "algebraic_connectivity" in features_nx): if(self.params["verbose"]): print("Computing laplacian_eigenvalues") s = time.time() self.eigenvalues["laplacian"] = np.real(nx.laplacian_spectrum(G)) if(self.params["verbose"]): print("Finish laplacian_eigenvalues (%s)" % (timeFormat(time.time()-s))) if("largest_eigenvalue" in features_nx or "symmetry_ratio" in features_nx or "natural_connectivity" in features_nx): if(self.params["verbose"]): print("Computing adjacency_eigenvalues") s = time.time() self.eigenvalues["adjacency"] = np.real(nx.adjacency_spectrum(G)) if(self.params["verbose"]): print("Finish adjacency_eigenvalues (%s)" % (timeFormat(time.time()-s))) if("weighted_spectrum_3" in features_nx or "weighted_spectrum_4" in features_nx): if(self.params["verbose"]): print("Computing normalized_laplacian_eigenvalues") s = time.time() self.eigenvalues["normalized_laplacian"] = np.real(nx.normalized_laplacian_spectrum(G)) if(self.params["verbose"]): print("Finish normalized_laplacian_eigenvalues (%s)" % (timeFormat(time.time()-s))) return(NodesFeatures.computeFeatures(self, G, features_nx, features_nk))
def create_graph(self): g = nx.Graph() duplicated_nodes_list = self.only_nodes.iloc[:,0].append(self.only_nodes.iloc[:,1]).reset_index(drop=True) nodes_list = duplicated_nodes_list.values.tolist() No_duplicate_nodes = set(nodes_list) # print(len(No_duplicate_nodes))#327 g.add_nodes_from(No_duplicate_nodes) g.add_edges_from(self.No_duplicate_links) # nx.draw(g,node_size = 1.5)#with_labels=True # plt.draw() # plt.show() link_density = nx.density(g) # print(link_density)#0.109 average_degree = nx.average_neighbor_degree(g) # numbers degreeede= [average_degree[key] for key in average_degree] # mean = statistics.mean(numbers) # var = statistics.variance(numbers) # print(var) degree_correlation = nx.degree_pearson_correlation_coefficient(g) # print(degree_correlation)#0.033175769936049336 average_clustering = nx.average_clustering(g) # print(average_clustering)#0.5035048191728447 average_hopcount = nx.average_shortest_path_length(g) # print(average_hopcount)#2.1594341569576554 diameter = nx.diameter(g) # print(diameter)#4 # A = nx.adjacency_matrix(g) A_eigenvalue = nx.adjacency_spectrum(g) # print(max(A_eigenvalue))#(41.231605032525835+0j) G_eigenvalue = nx.laplacian_spectrum(g) # print(sorted(G_eigenvalue))#1.9300488624481513 return g, nodes_list, No_duplicate_nodes, link_density, average_degree
def spectralgapscore(subgraphs): sum = 0 for g in subgraphs: S = nx.laplacian_spectrum(g) gap = (S[len(S) - 1] - S[len(S) - 2])/ S[len(S) - 1] sum = sum + gap return sum
def get_statistics(graph, matrix): plt.figure() d = matrix.sum(axis=1) e = np.sum(d) / graph.order() print("Average degree: ", e) hist = nx.degree_histogram(graph) entropy = 0 for i in range(len(hist)): if hist[i] != 0: entropy -= hist[i] * np.log2(hist[i]) print("Entropy: ", entropy) # average_sp = nx.average_shortest_path_length(graph) # print("Average shortest path length: ", average_sp) average_c = nx.average_clustering(graph) print("Network Clustering: ", average_c) a_s = nx.degree_assortativity_coefficient(graph) print("Assortativeness: ", a_s) density = nx.density(graph) print("Density:", density) plt.bar(range(len(hist)), hist) plt.title("Degree Distribution") plt.xlabel("Degree") plt.ylabel("Number of nodes") plt.show() autovalores = nx.laplacian_spectrum(graph) plt.bar(range(len(autovalores)), autovalores) plt.title("Autovalues")
def compute_graph(graph, nodePositions, mask): """Compute graph properties. Parameters ---------- graph : original graph nodePositions : node positions mask : binary array of cellular region of interest Returns ------- properties : list of graph properties """ nodeNumber = graph.number_of_nodes() edgeNumber = graph.number_of_edges() connectedComponents = connected_components(graph) connectedComponentsNumber = len(connectedComponents) edgeCapacity = 1.0 * np.array([property['capa'] for node1, node2, property in graph.edges(data=True)]) bundling = np.nanmean(edgeCapacity) assortativity = nx.degree_pearson_correlation_coefficient(graph, weight='capa') shortestPathLength = path_lengths(graph) reachability = np.nanmean(shortestPathLength) shortestPathLengthSD = np.nanstd(shortestPathLength) shortestPathLengthCV = 1.0 * shortestPathLengthSD / reachability algebraicConnectivity = np.sort(nx.laplacian_spectrum(graph, weight='capa'))[1] edgeAngles = edge_angles(graph, nodePositions, mask) edgeAnglesMean = np.nanmean(edgeAngles) edgeAnglesSD = np.nanstd(edgeAngles) edgeAnglesCV = 1.0 * edgeAnglesSD / edgeAnglesMean edgeCrossings = crossing_number(graph, nodePositions) edgeCrossingsMean = np.nanmean(edgeCrossings) properties = [nodeNumber, edgeNumber, connectedComponentsNumber, bundling, assortativity, reachability, shortestPathLengthCV, algebraicConnectivity, edgeAnglesCV, edgeCrossingsMean] return(properties)
def get_laplacian_spectrum(graph, k=np.inf, which='SM', tol=1E-2, eigvals_only=True): """ Gets the bottom k eigenpairs of the Laplacian matrix :param graph: sparse matrix :param k: number of bottom k eigenpairs to obtain :param which: he type of k eigenvectors and eigenvalues to find :param tol: the precision at which to stop computing the eigenpairs :param eigvals_only: get only the eigenvalues i.e., no eigenvectors :return: the eigenpair information """ # get all eigenvalues for small graphs if len(graph) < 100: lam = nx.laplacian_spectrum(graph) else: L = get_laplacian(graph) lam = eigsh(L, k=min(k, len(graph) - 1), which=which, tol=tol, return_eigenvectors=not eigvals_only) lam = np.sort(lam) # sort ascending return lam
def data_analysis(self, graph): data_vec = [0] * 13 num_vertex = nx.number_of_nodes(graph) data_vec[0] = nx.average_clustering(graph) sq_values = list(nx.square_clustering(graph).values()) data_vec[1] = sum(sq_values) / len(sq_values) g = nx.path_graph(num_vertex) data_vec[2] = nx.average_shortest_path_length( graph) / nx.average_shortest_path_length(g) data_vec[3] = nx.degree_pearson_correlation_coefficient(graph) if math.isnan(data_vec[3]) is True: data_vec[3] = 0 data_vec[4] = nx.diameter(graph) / (num_vertex - 1) data_vec[5] = nx.density(graph) data_vec[6] = nx.edge_connectivity(graph) / (num_vertex - 1) g = nx.star_graph(num_vertex - 1) Freeman_degree_norm = self.freeman_centralization( nx.degree_centrality(g)) Freeman_close_norm = self.freeman_centralization( nx.closeness_centrality(g)) Freeman_between_norm = self.freeman_centralization( nx.betweenness_centrality(g)) # need to change Freeman_eigen_norm = self.freeman_centralization( nx.eigenvector_centrality_numpy(g)) data_vec[7] = self.freeman_centralization( nx.degree_centrality(graph)) / Freeman_degree_norm data_vec[8] = self.freeman_centralization( nx.closeness_centrality(graph)) / Freeman_close_norm data_vec[9] = self.freeman_centralization( nx.betweenness_centrality(graph)) / Freeman_between_norm # warning, the way it normalized may not correct data_vec[10] = self.freeman_centralization( nx.eigenvector_centrality_numpy(graph)) / Freeman_eigen_norm egvl_lap = nx.laplacian_spectrum(graph) egvl_lap = np.sort(egvl_lap) egvl_lap = np.delete(egvl_lap, 0, 0) summ = 0 for mu in egvl_lap: summ += (1 / mu) summ = summ * num_vertex data_vec[11] = (num_vertex - 1) / summ # for simple graph(adj matrix is symmetric), eigenvalue must be real number. egvl_adj = np.real(nx.adjacency_spectrum(graph)) data_vec[12] = max(egvl_adj) / (num_vertex - 1) return data_vec
def calculateSpectrum(self): self.components_spectrum = {} self.components_ac = {} self.spectrum = None self.algebraic_connectivity = 0 self.spectrum = nx.laplacian_spectrum(self.G) self.algebraic_connectivity = nx.algebraic_connectivity(self.G) self.components_spectrum[0] = nx.laplacian_spectrum(self.components[0]) self.components_spectrum[1] = nx.laplacian_spectrum(self.components[1]) self.components_ac[0] = nx.algebraic_connectivity(self.components[0]) self.components_ac[1] = nx.algebraic_connectivity(self.components[1]) logging.info("Spectrum and algebraic connectivity values calculated.") self.history.append([ self.algebraic_connectivity, self.components_ac[0], self.components_ac[1] ]) logging.info("Appened to history succesfully.")
def algebraic_connectivity_of_graph(graph): if not graph: return 0.0 ls = sorted(nx.laplacian_spectrum(graph)) # Is the graph connected? if (ls[1] - ls[0]) > 1e-10: return ls[1] else: return 0.0
def LapSpectrum(G): """ Calculate the eigenvalues of the Laplacian matrix of a network :param G: [networkx graph object] this is a networkx graph object :return: [list] Returns a list of the real part of the eigenvalues of the Laplacian matrix of G """ eig_temp = nx.laplacian_spectrum(G) eig = [x.real for x in eig_temp] return eig
def test_bethe_hessian_spectrum(self): "Bethe Hessian eigenvalues" evals = np.array([0.5 * (9 - np.sqrt(33)), 4, 0.5 * (9 + np.sqrt(33))]) e = sorted(nx.bethe_hessian_spectrum(self.P, r=2)) npt.assert_almost_equal(e, evals) # Collapses back to Laplacian: e1 = sorted(nx.bethe_hessian_spectrum(self.P, r=1)) e2 = sorted(nx.laplacian_spectrum(self.P)) npt.assert_almost_equal(e1, e2)
def algebraic_connectivity(G, nodes, eigenvalues=None): laplacian_eigenvalues = None if(not eigenvalues is None): laplacian_eigenvalues = eigenvalues["laplacian"] if(laplacian_eigenvalues is None): laplacian_eigenvalues = np.real(nx.laplacian_spectrum(G)) laplacian_eigenvalues = np.delete(laplacian_eigenvalues, laplacian_eigenvalues.argmin()) v = np.min(laplacian_eigenvalues) return(np.float64(v))
def effective_graph_resistance(G, nodes, eigenvalues=None): laplacian_eigenvalues = None if(not eigenvalues is None): laplacian_eigenvalues = eigenvalues["laplacian"] if(laplacian_eigenvalues is None): laplacian_eigenvalues = np.real(nx.laplacian_spectrum(G)) laplacian_eigenvalues = np.delete(laplacian_eigenvalues, laplacian_eigenvalues.argmin()) nonzero_eigenvalues = laplacian_eigenvalues[np.nonzero(laplacian_eigenvalues)] nst = len(G)*np.sum(1/nonzero_eigenvalues) return(np.float64(nst))
def nb_spanning_trees(G, nodes, eigenvalues=None): laplacian_eigenvalues = None if(not eigenvalues is None): laplacian_eigenvalues = eigenvalues["laplacian"] if(laplacian_eigenvalues is None): laplacian_eigenvalues = np.real(nx.laplacian_spectrum(G)) laplacian_eigenvalues = np.delete(laplacian_eigenvalues, laplacian_eigenvalues.argmin()) nonzero_eigenvalues = laplacian_eigenvalues[np.nonzero(laplacian_eigenvalues)] nst = np.prod(nonzero_eigenvalues/len(G)) return(np.float64(nst))
def draw_laplacian_spectrum(orig_g, new_g, g1_label, ax): """ The set of all N Laplacian eigenvalues is called the Laplacian spectrum of a graph G. The second smallest eigenvalue is lamdaN >= 1, but equal to zero only if a graph is disconnected. Thus, the multiplicity of 0 as an eigenvalue of Q is equal to the number of components of G [8]. """ import matplotlib.patches as mpatches es = nx.laplacian_spectrum(new_g) ax.plot(range(new_g.number_of_nodes()), es, 'k-o', alpha=0.2) es = nx.laplacian_spectrum(orig_g) ax.plot(range(orig_g.number_of_nodes()), es, 'r-o') ax.set_title("Laplacian Spectrum") blue_patch = mpatches.Patch(color='r', label=g1_label) green_patch = mpatches.Patch(color='black', label="Synthetic") ax.legend(handles=[blue_patch, green_patch]) # set plot to log log scale ax.set_yscale('log') ax.set_xscale('log')
def draw_laplacian_spectrum_conf_bands(orig_g, synth_graphs, graph_name, ax): """ ax = axis handle for a given figure Reference: http://stackoverflow.com/questions/27164114/show-confidence-limits-and-prediction-limits-in-scatter-plot """ import matplotlib.patches as mpatches import pandas as pd eigs = [nx.laplacian_spectrum(g) for g in synth_graphs] df = pd.DataFrame(eigs) es = nx.laplacian_spectrum(orig_g) ax.plot(df.min(), 'k:') ax.plot(df.max(), 'k:') ax.fill_between(df.columns, df.mean()-df.quantile(.05), df.mean()+df.quantile(.95), color='b', alpha=0.2) if nx.__version__ == '1.10': ax.fill_between(df.columns, df.mean()-df.sem(), df.mean()+df.sem(), color='r', alpha=0.2) ax.plot(range(orig_g.number_of_nodes()), es, 'ko',alpha=0.5 ) # ax.plot(df.quantile(.95),'r--',alpha=0.5) # ax.plot(df.quantile(.05),'r--',alpha=0.5) # ax.fill_between(df.columns, df.mean()-2*df.std(), df.mean()+2*df.std(), color='b', alpha=0.2) # # ax.set_title("Laplacian Spectrum") # blue_patch = mpatches.Patch(color='r', label=g1_label) # green_patch = mpatches.Patch(color='black', label="Synthetic") # ax.legend(handles=[blue_patch, green_patch]) #### AXES LABELS # set plot to log log scale # ax.set_yscale('log') # ax.set_xscale('log') ## Set ax.set_ylabel('Eigenvalues') ax.set_xlabel('Node Count') # ax.yaxis.set_label_coords(0.05, 0.85) return
def run(self): while not self.kill_received: # Get a task try: ndumpName = self.work_queue.get_nowait() network = readLeda('{0}.gw'.format(ndumpName)) spectrum = sorted(nx.laplacian_spectrum(network), reverse=True) self.result_queue.put((ndumpName, spectrum)) except Queue.Empty: pass
def plot_spectral_laplacian(graph, filename, label, outpath): """ plot spectral distribution of laplacian matrix""" if not graph: graph = nx.read_edgelist(filename) spectrals = nx.laplacian_spectrum(graph) spectrals_unique = np.unique(spectrals, return_counts=True) fig = plt.figure() ax = fig.add_subplot(1, 1, 1) ax.bar(spectrals_unique[0], spectrals_unique[1]) ax.set_title('spectral distribution of laplacian matrix') ax.set_xlabel('eigenvalue') ax.set_ylabel('frequency') plt.savefig(outpath + label + '-spectral-laplacian.svg')
def algebraic_connectivity(self): """ Algebraic connectivity. Second smallest eigenvalue of the normalized Laplacian matrix of a network. Uses an undirected graph. Returns ------- alg_con : float Algebraic connectivity """ eig = nx.laplacian_spectrum(self.to_undirected()) eig = np.sort(eig) alg_con = eig[1] return alg_con
def lapSpec (graphDic): t_list=np.array([]) eigenval_list=np.array([]) #for each t all its eigenvalus (eg) in a parallel list for T in graphDic.keys(): graph=(graphDic[T]).to_undirected() for ev in np.nditer(nx.laplacian_spectrum(graph)): t_list=np.append(t_list, T) eigenval_list=np.append( eigenval_list , ev) #draw plt.plot(t_list, eigenval_list,'ro') plt.show() return 1
def laplacian_eigenvalues(self) -> np.array: """ Returns eigenvalues of the Laplacian :return: """ CP.print_none('Calculating Laplacian Eigenvalues') if self.graph.order() == 0 or self.graph.size() == 0: CP.print_orange( f'Graph has {self.graph.order()} nodes and {self.graph.size()} edges!' ) laplacian_eigs = [] else: laplacian_eigs = nx.laplacian_spectrum(self.graph) self.stats['laplacian_eigenvalues'] = laplacian_eigs return laplacian_eigs
def investigate_laplacian(graph): """ Compute Laplacian """ w = nx.laplacian_spectrum(graph) pairs = [] for i, w in enumerate(sorted(w)): if abs(w) < 1e-5: continue inv_w = 1 / w pairs.append((inv_w, i)) fig = plt.figure() plt.scatter(*zip(*pairs)) plt.xlabel(r'$\frac{1}{\lambda_i}$') plt.ylabel(r'rank index') save(fig, 'laplacian_spectrum')
def eigenvalueAttributes(graph): return_values = [] #Compute eigenvalues on L as ndarray object #L = nx.normalized_laplacian_matrix(graph) #numpy matrix #e = numpy.linalg.eigvals(L.A) #takes matrix and returns eigenvalues e = nx.laplacian_spectrum(graph) #numPy array; uses unnormalized laplcian matrix #e = nx.adjacency_spectrum(graph) #numPy array eig_sum = 0 largest = 0 second_largest = 0 unique_values = [] inverse_product = 1 for i in e: if i < 0: abs_i = i * -1 else: abs_i = i #woods midterm paper - use squared sum of abs value eig_sum += abs_i #eigenvalue distriminants paper - use inverse of product of sqrt(|eigval|) inverse_product *= math.sqrt(abs_i) if i not in unique_values: unique_values.append(i) #energy: squared sum of eigenvalues return_values.append(eig_sum*eig_sum) largest = max(e) l_index = numpy.argmax(e) e = numpy.delete(e, l_index) #Second largest eigenvalue (actual value, not magnitude) second_largest = max(e) return_values.append(second_largest) #Number distict eigenvalues return_values.append(len(unique_values)) #Spectral Radius: largest eigenvalue (actual value, not magnitude) return_values.append(largest) #Inverse product [1/(sqrt|eig1| * sqrt|eig2| * ... * sqrt|eign|)] if(inverse_product > 0): return_values.append(1/inverse_product) else: return_values.append(0) return return_values
def test_laplacian_spectrum(self): "Laplacian eigenvalues" evals=numpy.array([0, 0, 1, 3, 4]) e=sorted(nx.laplacian_spectrum(self.G)) assert_almost_equal(e,evals)
import networkx as nx import numpy as np import matplotlib.pyplot as plt G = nx.Graph() G.add_edges_from([(1, 2), (1, 3), (2, 3), (1, 4), (4, 5)]) G2 = nx.generators.random_graphs.fast_gnp_random_graph(10, .3) # nx.adjacency_matrix(G) L = nx.laplacian(G) # L=D-A # np.linalg.eigvals(L) np.linalg.eig(L) res = nx.laplacian_spectrum(G) print res print nx.normalized_laplacian(G) c = nx.communicability(G) # drawing nx.draw(G) # default using spring_layout: force-directed # same as: # pos = nx.spring_layout(G) # nx.draw(G, pos) nx.draw_random(G) nx.draw_spectral(G) plt.show() plt.savefig('path.png') plt.cla() # random graph G = nx.generators.random_graphs.random_regular_graph(6, 50)
print "assortativity.average_degree_connectivity",'\t\t', nx.assortativity.average_degree_connectivity(graphs[g]) #print "degree_pearson_correlation_coefficient",'\t\t', nx.degree_pearson_correlation_coefficient(graphs[g]) print "node closeness_centrality",'\t\t\t', get_avg(nx.closeness_centrality(graphs[g])) print "clustering",'\t\t\t', get_avg(nx.clustering(graphs[g])) print "node betweeness",'\t\t\t', get_avg(nx.betweenness_centrality(graphs[g],normalized=False,endpoints=False)) print "edge betweeness",'\t\t\t', get_avg(nx.edge_betweenness_centrality(graphs[g],normalized=False)) #print "spectral_bipartivity",'\t\t', bipartite.spectral_bipartivity(graphs[g]) #print "node betweeness normalized",'\t\t\t', get_avg(nx.betweenness_centrality(graphs[g],normalized=True,endpoints=False)) #print "edge betweeness normalized",'\t\t\t', get_avg(nx.edge_betweenness_centrality(graphs[g],normalized=True)) #print "node closeness_vitality",'\t\t\t', get_avg(nx.closeness_vitality(graphs[g])) #print "communicability_centrality",'\t\t', get_avg(nx.communicability_centrality(graphs[g])) #print "communicability_betweenness_centrality",'\t\t', get_avg(nx.communicability_betweenness_centrality(graphs[g])) #print "transitivity",'\t\t\t', round(nx.transitivity(graphs[g]),4) #print "laplacian_spectrum",'\t\t\n:', nx.laplacian_spectrum(graphs[g]) print "adjacency_spectrum",'\t\tMin 5 :', get_min(nx.adjacency_spectrum(graphs[g])) , "\t\tMax 5 :",get_max(nx.adjacency_spectrum(graphs[g])) print "laplacian_spectrum",'\t\tMin 5 :', get_min(nx.laplacian_spectrum(graphs[g])) , "\t\tMax 5 :",get_max(nx.laplacian_spectrum(graphs[g])) #print "normalized_laplacian_spectrum",'\t\tMin 5 :', get_min(numpy.real(normalized_laplacian_spectrum(graphs[g]))) , "\t\tMax 5 :",get_max(normalized_laplacian_spectrum(graphs[g])) #print "adjacency_spectrum",'\t\t\n', nx.adjacency_spectrum(graphs[g]) #print "laplacian_spectrum",'\t\t\n', nx.laplacian_spectrum(graphs[g]) #print "normalized_laplacian_spectrum",'\t\t\n', normalized_laplacian_spectrum(graphs[g]) ####print "adjacency_spectrum",'\t\t\n', numpy.around(numpy.real(nx.adjacency_spectrum(graphs[g])), decimals=4) ####print "laplacian_spectrum",'\t\t\n', numpy.around(numpy.real(nx.laplacian_spectrum(graphs[g])), decimals=4) ####print "normalized_laplacian_spectrum",'\t\t\n', numpy.around(numpy.real(normalized_laplacian_spectrum(graphs[g])), decimals=4) #statistics.pdf_to_textfile(numpy.real(numpy.around(nx.adjacency_spectrum(graphs[g]), decimals=2)).tolist(),g+"_adj_pdf.txt") # Write to a file #statistics.to_textfile(numpy.real(numpy.around(nx.adjacency_spectrum(graphs[g]), decimals=2)).tolist(),g+"_adj_pdf.txt") #statistics.pdf_to_textfile(numpy.real(numpy.around(nx.laplacian_spectrum(graphs[g]), decimals=2)).tolist(),g+"_pdf.txt") #statistics.cdf_to_textfile(numpy.real(numpy.around(nx.laplacian_spectrum(graphs[g]), decimals=2)).tolist(),g+"_cdf.txt") #statistics.pdf_to_textfile(numpy.real(numpy.around(normalized_laplacian_spectrum(graphs[g]), decimals=4)).tolist(),g+"_pdf.txt") #statistics.cdf_to_textfile(numpy.real(numpy.around(normalized_laplacian_spectrum(graphs[g]), decimals=4)).tolist(),g+"_cdf.txt") #print "adjacency_matrix",'\t\t\t\n', nx.adjacency_matrix(graphs[g])
# but for the 2010 connection algorithm there shouldn't be any # multiedge in the graph for k, cell_pair_list in enumerate(cell_pair_lol): assert len(cell_pair_list)==len(ordered_edge_lists[k]) graphs = [nx.empty_graph(n_cells, create_using=nx.Graph()) for each in cell_pair_lol] for k,g in enumerate(graphs): g.add_edges_from(cell_pair_lol[k]) nx.write_graphml(g, '../dataSets/graphs/graph_2010_ncells{0}_trial{1:02}.graphml'.format(n_cells, k)) average_clustering_coefficients = np.array([nx.average_clustering(g) for g in graphs]) print("Average clustering: {0} ± {1}".format(average_clustering_coefficients.mean(), np.sqrt(average_clustering_coefficients.var()))) average_shortest_path_lengths = np.array([nx.average_shortest_path_length(g) for g in graphs]) print("Average shortest path length: {0} ± {1}".format(average_shortest_path_lengths.mean(), np.sqrt(average_shortest_path_lengths.var()))) laplacian_spectra = [np.sort(nx.laplacian_spectrum(g)) for g in graphs] eigenratios = np.array([s[-1]/(s[2]) for s in laplacian_spectra]) print("Average eigenratio: {0} ± {1}".format(eigenratios.mean(), np.sqrt(eigenratios.var()))) # for each trial, calculate the degree sequence of the # network. Note that the degree of a cell is defined as the number # of unique cells it's connected to; the number of gap junctions # on a cell is an obvious upper bound for the cell's degree. degree_sequences = np.array([[len([pair for pair in l if any((pair[0]==k, pair[1]==k))]) for k in range(n_cells)] for l in cell_pair_lol]) # for each trial, for each connected pair, calculate the distance # between somata edge_lengths = [] for trial, cell_pair_list in enumerate(cell_pair_lol): lengths = np.array([distances_squareform[trial][tuple(e)] for e in cell_pair_list]) edge_lengths.append(lengths)
def _compute(self, graph): s = nx.laplacian_spectrum(graph) return s
def ComputeLaplacianMatrixEigenvalues(self): self.laplacianSpectrum = np.around(np.array(nx.laplacian_spectrum(self.G)),decimals=4) self.laplacianSpectrum.sort()
def creationVecteur (G): v={} # Adding nodes nn = nx.number_of_nodes(G) v["numNodes"]=nn # Adding edges ne = nx.number_of_edges(G) v["numEdges"]=ne # Adding cyclomatic number c=nx.number_connected_components(G) cyclo = ne-nn+c v["numCycles"]=cyclo # Adding link density if nn==1: linkdensity="?" else: linkdensity = 2*ne/((nn-1)*nn) v["linkDensity"]=linkdensity # Adding average degree avgdegree = 2*ne/nn v["avgDegree"]=avgdegree # Adding number of leaves nl = numberLeaves(G) v["numLeafs"]=nl # Adding histogram of the nodes degree v["histDegree0"]=0 v["histDegree1"]=0 v["histDegree2"]=0 v["histDegree3"]=0 v["histDegree4"]=0 histDegree=nx.degree_histogram(G) v["histDegree0"]=histDegree[0] if len(histDegree)>1: v["histDegree1"]=histDegree[1] if len(histDegree)>2: v["histDegree2"]=histDegree[2] if len(histDegree)>3: v["histDegree3"]=histDegree[3] if len(histDegree)>4: v["histDegree4"]=histDegree[4] # Adding sMetric v["sMetric"]= metric(G) # Adding graph energy energ = graphEnergy (G) v["graphEnergy"]=energ # Adding average of the average neighboring degrees of all nodes av = averageNeighDegree(G) v["averageNeighDegree"]=av # Adding average of closeness over all nodes v["averageCloseness"]=average_closeness(G) # Adding pearson coefficient for the degree sequence of all edges of the graph pearson = nx.degree_pearson_correlation_coefficient(G) if np.isnan(pearson): pearson = 0 v["pearson"]=pearson # Adding rich club metric for all nodes with a degree larger than 1 rc=richClub(G) v["richClub"]=rc # Adding algebraic connectivity, i.e. the second smallest eigenvalue of the Laplacian algConnect = nx.laplacian_spectrum(G) algConnect = list(algConnect) algConnect = sorted(algConnect) v["algConnect"]=algConnect[1] # Adding diameter of the graph if nx.is_connected(G): diam = nx.diameter(G) else: diam="?" v["diameter"]=diam # Adding average shortest path if nx.is_connected(G): avgShortestPath=nx.average_shortest_path_length(G) else: avgShortestPath="?" v["avgShortPath"]=avgShortestPath # Adding graph radius if nx.is_connected(G): rad = nx.radius(G) else: rad="?" v["graphRadius"]=rad return v
def lapl_spect(net): spec = nx.laplacian_spectrum(net) connec = sorted(spec)[1] _,b,c,d = spectrum(spec,'laplacian') return b,c,d,(connec,'algebraic_connectivity')
''' Theorem 3 of Mahadevan, S., & Maggioni, M. (2007). Proto-value functions: A Laplacian framework for learning representation and control in Markov decision processes. Journal of Machine Learning Research, 8 states that the eigenvalues of the Laplacian of graph G that is the cartesian product of two graphs G1 and G2, are the sums of all the combination of the eigenvalues of G1 and G2. This program illustrates this by generating a grid as the cartesian product of two paths. ''' from itertools import product import networkx as nx n = 5 P = nx.path_graph(n) G = nx.cartesian_product(P, P) ev_P = nx.laplacian_spectrum(P) ev_G = nx.laplacian_spectrum(G).real ev = [] for i,j in product(range(n), repeat=2): ev.append(ev_P[i] + ev_P[j])