def generate_grid_graph(): """Generates k cuts for grid graphs""" k = int(input("k for grid graph:")) trials = int(input("number of trials:")) gridfname = input("output file:") gridfname = "hard_instances/" + gridfname gridfile = open(gridfname, "wb", 0) n = int(input("Number of dimensions: ")) d = [] for i in range(0, n): tmp = int(input("Size of dimension " + str(i + 1) + ": ")) d.append(tmp) G = nx.grid_graph(dim=d) A = nx.adjacency_matrix(G).toarray() L = nx.normalized_laplacian_matrix(G).toarray() (tmpw, tmpv) = la.eigh(L, eigvals=(0, 1)) tmp = 2 * math.sqrt(tmpw[1]) print("cheeger upperbound:" + str(tmp)) (w, v) = spectral_projection(L, k) lambda_k = w[k - 1] k_cuts_list = lrtv(A, v, k, lambda_k, trials, gridfile) plotname = gridfname + "plot" plot(k_cuts_list, plotname) tmp_str = "Grid graph of dimension: " + str(d) + "\n" tmp_str += "k = " + str(k) + ", " tmp_str += "trials = " + str(trials) + "\n\n\n" tmp_str = tmp_str.encode("utf-8") gridfile.write(tmp_str) for i in range(len(k_cuts_list)): k_cuts = k_cuts_list[i] tmp_str = list(map(str, k_cuts)) tmp_str = " ".join(tmp_str) tmp_str += "\n\n" tmp_str = tmp_str.encode("utf-8") gridfile.write(tmp_str)
def generate_dyn_heat(G, s, jump, n): Fs = [] L = networkx.normalized_laplacian_matrix(G) L = L.todense() F0s = [] seeds = [] for i in range(s): F0 = numpy.zeros(len(G.nodes())) v = random.randint(0, len(G.nodes())-1) seeds.append(v) F0[v] = len(G.nodes()) F0s.append(F0) Fs.append(numpy.sum(F0s, axis=0)) for j in range(n): FIs = [] for i in range(s): FI = numpy.multiply(linalg.expm(-j*jump*L), F0s[i])[:,seeds[i]] FIs.append(FI) Fs.append(numpy.sum(FIs, axis=0)) return numpy.array(Fs)[1:]
def spectral_clustering(graph, n_cluster): """ return the prediction of kmeans model of the spectral clustering """ Lap_nom = nx.normalized_laplacian_matrix(graph).todense() eig_val, eig_vec = np.linalg.eig(Lap_nom) k = 10 selected_vec = np.zeros([len(eig_val),k]) thr = sorted(eig_val)[k-1] eig_val, eig_vec = np.linalg.eig(Lap_nom) ind = 0 for i in range(len(eig_val)): if eig_val[i]<=thr: selected_vec[:,ind] = np.array(eig_vec)[:,i] ind += 1 # X = selected_vec cluster_km = KMeans(n_clusters = n_cluster,max_iter = 10000,tol = 0.00001) features_spectre = selected_vec cluster_km.fit(features_spectre) pred = cluster_km.predict(selected_vec) dict_predict = {} for i in range(len(graph.nodes())): dict_predict.update( { graph.nodes()[i] : int(pred[i]) }) return dict_predict
def normalized_laplacian_spectrum(G, weight='weight'): """Return eigenvalues of the Laplacian of G Parameters ---------- G : graph A NetworkX graph weight : string or None, optional (default='weight') The edge data key used to compute each value in the matrix. If None, then each edge has weight 1. Returns ------- evals : NumPy array Eigenvalues Notes ----- For MultiGraph/MultiDiGraph, the edges weights are summed. See to_numpy_matrix for other options. See Also -------- laplacian_matrix """ from scipy.linalg import eigvalsh #return eigvalsh(nx.normalized_laplacian_matrix(G,weight=weight).todense()) import scipy.sparse as sparse w , v = sparse.linalg.eigsh(nx.normalized_laplacian_matrix(G,weight=weight), which='SM') return w
def test_normalized_laplacian(self): "Generalized Graph Laplacian" GL=numpy.array([[ 1.00, -0.408, -0.408, -0.577, 0.00], [-0.408, 1.00, -0.50, 0.00 , 0.00], [-0.408, -0.50, 1.00, 0.00, 0.00], [-0.577, 0.00, 0.00, 1.00, 0.00], [ 0.00, 0.00, 0.00, 0.00, 0.00]]) Lsl = numpy.array([[ 0.75 , -0.2887, -0.2887, -0.3536, 0.], [-0.2887, 0.6667, -0.3333, 0. , 0.], [-0.2887, -0.3333, 0.6667, 0. , 0.], [-0.3536, 0. , 0. , 0.5 , 0.], [ 0. , 0. , 0. , 0. , 0.]]) assert_almost_equal(nx.normalized_laplacian_matrix(self.G),GL,decimal=3) assert_almost_equal(nx.normalized_laplacian_matrix(self.MG),GL,decimal=3) assert_almost_equal(nx.normalized_laplacian_matrix(self.WG),GL,decimal=3) assert_almost_equal(nx.normalized_laplacian_matrix(self.WG,weight='other'),GL,decimal=3) assert_almost_equal(nx.normalized_laplacian_matrix(self.Gsl), Lsl, decimal=3)
def my_algebraic_connectivity(graph, normalise=False): if normalise: eigvals, eigvecs = sp.sparse.linalg.eigsh(nx.normalized_laplacian_matrix(graph).asfptype(), 2, which='SA') a = eigvals[1] else: eigvals, eigvecs = sp.sparse.linalg.eigsh(nx.laplacian_matrix(graph).asfptype(), 2, which='SA') a = eigvals[1] if a < MACHINE_EPSILON: a = 0.0 return a
def find_nonzero_eigenvalues_magnitudes(g, edge_weight='weight'): print ' Calculating normalized laplacian ...' L = nx.normalized_laplacian_matrix(g, weight=edge_weight) print ' Calculating eigenvalues of laplacian ...' ev_i = np.absolute(np.linalg.eigvals(L.A.astype(np.float64))) nz_ix = ev_i != 0 if np.sum(nz_ix) <= 0: raise RuntimeError('All eigenvalues zero for the Laplacian of supplied graph') return ev_i[nz_ix]
def transform(self, _F): """ """ (self.G, self.F) = build_stacked_graph_dense(self.G_unstacked, _F) L = networkx.normalized_laplacian_matrix(self.G) L = L.todense() self.U, self.lamb_str = compute_eigenvectors_and_eigenvalues(L) return graph_fourier(self.F, self.U)
def generate_product_graph(): """Generates k cuts for cartesian product of a path and a double tree""" k = int(input("k for product of tree & path:")) trials = int(input("number of trials:")) prodfname = input("output file:") prodfname = "hard_instances/" + prodfname prodfile = open(prodfname, "wb", 0) h = int(input("height of the tree: ")) H1 = nx.balanced_tree(2, h) H2 = nx.balanced_tree(2, h) H = nx.disjoint_union(H1, H2) n = H.number_of_nodes() p = math.pow(2, h + 1) - 1 H.add_edge(0, p) n = 4 * math.sqrt(n) n = math.floor(n) print("Length of path graph: " + str(n)) G = nx.path_graph(n) tmpL = nx.normalized_laplacian_matrix(G).toarray() T = nx.cartesian_product(G, H) A = nx.adjacency_matrix(T).toarray() L = nx.normalized_laplacian_matrix(T).toarray() (tmpw, tmpv) = la.eigh(L) tmp = 2 * math.sqrt(tmpw[1]) print("cheeger upperbound:" + str(tmp)) (w, v) = spectral_projection(L, k) lambda_k = w[k - 1] tmp_str = "Cartesian product of balanced tree of height " + str(h) tmp_str += " and path of length " + str(n - 1) + "\n" tmp_str += "k = " + str(k) + ", " tmp_str += "trials = " + str(trials) + "\n\n\n" tmp_str = tmp_str.encode("utf-8") prodfile.write(tmp_str) k_cuts_list = lrtv(A, v, k, lambda_k, trials, prodfile) plotname = prodfname + "plot" plot(k_cuts_list, plotname) for i in range(len(k_cuts_list)): k_cuts = k_cuts_list[i] tmp_str = list(map(str, k_cuts)) tmp_str = " ".join(tmp_str) tmp_str += "\n\n" tmp_str = tmp_str.encode("utf-8") prodfile.write(tmp_str)
def write_adj_mat(G, fileobj=sys.stdout): """Write G to a sparse matrix format that Julia and Matlab can read.""" lapmatrix = nx.laplacian_matrix(G) norm_lapl = nx.normalized_laplacian_matrix(G) adjmatrix = nx.adjacency_matrix(G) mdict = {'laplacian': lapmatrix, 'norm_lapl': norm_lapl, 'adjacency': adjmatrix} sio.savemat(fileobj, mdict) return mdict
def do(self): logger.info("SPECTRAL Eigenvalues %i" % (self.spectral_eigenvalues, )) logger.info("SPECTRAL Dimensions %i" % (self.spectral_dimensions,)) logger.info("SPECTRAL Laplacian %i" % (self.spectral_laplacian,)) logger.info("SPECTRAL Eigenvector %i" % (self.spectral_eigenvector,)) logger.info("SPECTRAL Compute Neuron Graph") neuron_graph = self.database.db2graph() logger.info("SPECTRAL Compute Laplacian Matrix") if self.spectral_laplacian == Config.SPECTRAL_LAPLACIAN_DIRECTED: neuron_graph_laplacian = networkx.directed_laplacian_matrix(neuron_graph, weight=None, walk_type='pagerank', alpha=0.95) elif self.spectral_laplacian == Config.SPECTRAL_LAPLACIAN_UNDIRECTED: neuron_graph = neuron_graph.to_undirected() neuron_graph_laplacian = networkx.normalized_laplacian_matrix(neuron_graph, weight=None) else: logger.critical("SPECTRAL Laplacian Method not supported") raise RuntimeError() logger.info("SPECTRAL Compute Lapalcian Eigenvectors") if self.spectral_eigenvector == Config.EIGENVECTOR_LEFT: eigenvalues, eigenvectors = scipy.sparse.linalg.eigen.arpack.eigs(neuron_graph_laplacian, self.spectral_eigenvalues, sigma=0, which='LM') elif self.spectral_eigenvector == Config.EIGENVECTOR_RIGHT: eigenvalues, eigenvectors = scipy.sparse.linalg.eigen.arpack.eigs(neuron_graph_laplacian, self.spectral_eigenvalues) else: logger.critical("SPECTRAL Eigenvector direction not supported") raise RuntimeError() points = eigenvectors.real[:, :self.spectral_dimensions] database_session = self.database.new_session() db_populations = {p.id: p for p in database_session.query(orm.population.Population).filter_by(shadow=False).all()} self.data = dict() for neuron, neuron_data in neuron_graph.nodes_iter(data=True): pop_id = neuron_data['p'] if pop_id not in self.data .keys(): self.data[pop_id] = dict() self.data[pop_id]['label'] = db_populations[pop_id].label self.data[pop_id]['neurons'] = db_populations[pop_id].neurons self.data[pop_id]['neurons_core'] = db_populations[pop_id].neurons_core self.data[pop_id]['space'] = dict() self.data[pop_id]['clusters'] = dict() self.data[pop_id]['nodes'] = dict() pop_neuron_id = neuron_data['n'] self.data[pop_id]['space'][pop_neuron_id] = points[neuron_graph.nodes().index(neuron)] return self.data
def eigenvalues(graph): try: import numpy.linalg as linal eigenvalues = linal.eigvals except ImportError: raise ImportError("numpy can not be imported.") L = nx.normalized_laplacian_matrix(graph) eigen_values = eigenvalues(L.A) return sorted(eigen_values, reverse=True)[:25]
def largest_eigenvector(G): """Return the largest eigenvector of a graph G.""" L = nx.normalized_laplacian_matrix(G) eigenvalues, eigenvectors = np.linalg.eig(L) # highest eigenvalue index and ... ind = np.argmax(eigenvalues) # ... its corresponding eigenvector. largest = eigenvectors[:, ind] return dict(zip(G, largest))
def set_graph(self, _G): self.G = _G L = networkx.normalized_laplacian_matrix(self.G) L = L.todense() self.U, self.lamb_str = compute_eigenvectors_and_eigenvalues(L) lamb_max = max(self.lamb_str.real) K = 10 J = 10 gamma = comp_gamma() self.T = comp_scales(lamb_max, K, J) self.w = graph_wavelets(self.lamb_str.real, self.U.real, range(len(self.G.nodes())), self.T) self.s = graph_low_pass(self.lamb_str.real, self.U.real, range(len(self.G.nodes())), self.T, gamma, lamb_max, K)
def transform(self, _F): """ """ (self.G, self.F) = build_stacked_graph_dense(self.G_unstacked, _F) L = networkx.normalized_laplacian_matrix(self.G) L = L.todense() self.U, self.lamb_str = compute_eigenvectors_and_eigenvalues(L) lamb_max = max(self.lamb_str) gamma = comp_gamma() K = 10 J = 10 self.T = comp_scales(lamb_max, K, J) self.w = graph_wavelets(self.lamb_str, self.U, range(len(self.G.nodes())), self.T) self.s = graph_low_pass(self.lamb_str, self.U, range(len(self.G.nodes())), self.T, gamma, lamb_max, K) return hammond_wavelet_transform(self.w, self.s, self.T, self.F)
def calc_laplacian_matrix(g): """ calc_laplacian_matrix(g) calculate directed Laplacian matrix of G = (V, E) (directed) L = D - A where A is the adjacency matrix and D is the diagonal matrix of node degrees.. :param g: graph for processing :return: eigen_values """ logging.info(cs_ref, 'laplacian_matrix') g2 = cv.convert_to_directed(g) laplacian = nx.normalized_laplacian_matrix(g) eigen_values= lg.eigvals(laplacian.A) eigen_info = "\tLaplacian : \n\tLargest eigen-value :" + str(max(eigen_values)) + "\n\tSmallest eigen-value : " \ + str(min(eigen_values)) with open(dest_file, "a") as dat_file: dat_file.write("\n" + eigen_info) print(eigen_info) return eigen_values
def generate_noisy_hypercube(): """Generates n dimensional noisy hypercube graph, with epsilon noise""" k = int(input("k for noisy hypercube: ")) trials = int(input("number of trials: ")) cubefname = input("output file:") cubefname = "hard_instances/" + cubefname cubefile = open(cubefname, "wb", 0) n = int(input("dimension of hypercube: ")) nodes = 2 ** n epsilon = float(input("noise:")) G = nx.empty_graph(nodes) for u in G.nodes(): for v in G.nodes(): if u == v: continue else: d = hamming_dist(u, v, n) w = epsilon ** d G.add_edge(u, v, weight=w) A = nx.adjacency_matrix(G).toarray() L = nx.normalized_laplacian_matrix(G).toarray() (tmpw, tmpv) = la.eigh(L, eigvals=(0, 1)) tmp = 2 * math.sqrt(tmpw[1]) print("cheeger upperbound:" + str(tmp)) (w, v) = spectral_projection(L, k) lambda_k = w[k - 1] tmp_str = "Noisy hypercube of dimension " + str(n) tmp_str += " with noise parameter " + str(epsilon) + "\n" tmp_str += "k = " + str(k) + ", " tmp_str += "trials = " + str(trials) + "\n\n\n" tmp_str = tmp_str.encode("utf-8") cubefile.write(tmp_str) k_cuts_list = lrtv(A, v, k, lambda_k, trials, cubefile) plotname = cubefname + "plot" plot(k_cuts_list, plotname) for i in range(len(k_cuts_list)): k_cuts = k_cuts_list[i] tmp_str = list(map(str, k_cuts)) tmp_str = " ".join(tmp_str) tmp_str += "\n\n" tmp_str = tmp_str.encode("utf-8") cubefile.write(tmp_str)
def __init__(self, graph, feature_list=[]): self.no_feature = 39 self.G = graph self.nodes = nx.number_of_nodes(self.G) self.edges = nx.number_of_edges(self.G) self.Lap = nx.normalized_laplacian_matrix(self.G) # ??? how to check whether comparable, addable? self.eigvals = numpy.linalg.eigvals(self.Lap.A).tolist() try: self.radius = nx.radius(self.G) except nx.exception.NetworkXError: self.radius = "ND" try: self.ecc_dic = nx.eccentricity(self.G) except nx.exception.NetworkXError: self.ecc_dic = {} self.degree_dic = nx.average_neighbor_degree(self.G) self.pagerank = nx.pagerank(self.G).values() if feature_list == []: self.feature_list = list(range(1, self.no_feature + 1)) else: self.feature_list = feature_list self.feature_vector = [] self.feature_time = []
def test_buckminsterfullerene(self): G = nx.Graph( [(1, 10), (1, 41), (1, 59), (2, 12), (2, 42), (2, 60), (3, 6), (3, 43), (3, 57), (4, 8), (4, 44), (4, 58), (5, 13), (5, 56), (5, 57), (6, 10), (6, 31), (7, 14), (7, 56), (7, 58), (8, 12), (8, 32), (9, 23), (9, 53), (9, 59), (10, 15), (11, 24), (11, 53), (11, 60), (12, 16), (13, 14), (13, 25), (14, 26), (15, 27), (15, 49), (16, 28), (16, 50), (17, 18), (17, 19), (17, 54), (18, 20), (18, 55), (19, 23), (19, 41), (20, 24), (20, 42), (21, 31), (21, 33), (21, 57), (22, 32), (22, 34), (22, 58), (23, 24), (25, 35), (25, 43), (26, 36), (26, 44), (27, 51), (27, 59), (28, 52), (28, 60), (29, 33), (29, 34), (29, 56), (30, 51), (30, 52), (30, 53), (31, 47), (32, 48), (33, 45), (34, 46), (35, 36), (35, 37), (36, 38), (37, 39), (37, 49), (38, 40), (38, 50), (39, 40), (39, 51), (40, 52), (41, 47), (42, 48), (43, 49), (44, 50), (45, 46), (45, 54), (46, 55), (47, 54), (48, 55)]) for normalized in (False, True): if not normalized: A = nx.laplacian_matrix(G) sigma = 0.2434017461399311 else: A = nx.normalized_laplacian_matrix(G) sigma = 0.08113391537997749 for method in methods: try: assert_almost_equal(nx.algebraic_connectivity( G, normalized=normalized, tol=1e-12, method=method), sigma) x = nx.fiedler_vector(G, normalized=normalized, tol=1e-12, method=method) check_eigenvector(A, sigma, x) except nx.NetworkXError as e: if e.args not in (('Cholesky solver unavailable.',), ('LU solver unavailable.',)): raise
def test_normalized_laplacian(self): "Generalized Graph Laplacian" # fmt: off G = np.array([[1., -0.408, -0.408, -0.577, 0.], [-0.408, 1., -0.5, 0., 0.], [-0.408, -0.5, 1., 0., 0.], [-0.577, 0., 0., 1., 0.], [0., 0., 0., 0., 0.]]) GL = np.array([[1., -0.408, -0.408, -0.577, 0.], [-0.408, 1., -0.5, 0., 0.], [-0.408, -0.5, 1., 0., 0.], [-0.577, 0., 0., 1., 0.], [0., 0., 0., 0., 0.]]) Lsl = np.array([[0.75, -0.2887, -0.2887, -0.3536, 0.], [-0.2887, 0.6667, -0.3333, 0., 0.], [-0.2887, -0.3333, 0.6667, 0., 0.], [-0.3536, 0., 0., 0.5, 0.], [0., 0., 0., 0., 0.]]) # fmt: on np.testing.assert_almost_equal( nx.normalized_laplacian_matrix(self.G, nodelist=range(5)).todense(), G, decimal=3, ) np.testing.assert_almost_equal(nx.normalized_laplacian_matrix( self.G).todense(), GL, decimal=3) np.testing.assert_almost_equal(nx.normalized_laplacian_matrix( self.MG).todense(), GL, decimal=3) np.testing.assert_almost_equal(nx.normalized_laplacian_matrix( self.WG).todense(), GL, decimal=3) np.testing.assert_almost_equal( nx.normalized_laplacian_matrix(self.WG, weight="other").todense(), GL, decimal=3, ) np.testing.assert_almost_equal(nx.normalized_laplacian_matrix( self.Gsl).todense(), Lsl, decimal=3)
def compute_metrics(fs, outdir, atlas, verb=False): """ Given a set of files and a directory to put things, loads graphs and performs set of analyses on them, storing derivatives in a pickle format in the desired output location. Required parameters: fs: - Dictionary of lists of files in each dataset outdir: - Path to derivative save location atlas: - Name of atlas of interest as it appears in the directory titles Optional parameters: verb: - Toggles verbose output statements """ graphs = loadGraphs(fs, verb=verb) nodes = nx.number_of_nodes(graphs.values()[0]) # Number of non-zero edges (i.e. binary edge count) print("Computing: NNZ") nnz = OrderedDict((subj, len(nx.edges(graphs[subj]))) for subj in graphs) write(outdir, 'number_non_zeros', nnz, atlas) print("Sample Mean: %.2f" % np.mean(nnz.values())) # Degree sequence print("Computing: Degree Seuqence") temp_deg = OrderedDict((subj, np.array(nx.degree(graphs[subj]).values())) for subj in graphs) deg = density(temp_deg, nbins=nodes) write(outdir, 'degree_distribution', deg, atlas) show_means(temp_deg) # Edge Weights print("Computing: Edge Weight Sequence") temp_ew = OrderedDict((s, [graphs[s].get_edge_data(e[0], e[1])['weight'] for e in graphs[s].edges()]) for s in graphs) ew = density(temp_ew, nbins=2*nodes) write(outdir, 'edge_weight_distribution', ew, atlas) show_means(temp_ew) # Clustering Coefficients print("Computing: Clustering Coefficient Sequence") temp_cc = OrderedDict((subj, nx.clustering(graphs[subj]).values()) for subj in graphs) ccoefs = density(temp_cc, nbins=2*nodes) write(outdir, 'clustering_coefficients', ccoefs, atlas) show_means(temp_cc) # Scan Statistic-1 print("Computing: Max Local Statistic Sequence") temp_ss1 = scan_statistic(graphs, 1) ss1 = density(temp_ss1, nbins=2*nodes) write(outdir, 'scan_statistic_1', ss1, atlas) show_means(temp_ss1) # Eigen Values print("Computing: Eigen Value Sequence") laplac = OrderedDict((subj, nx.normalized_laplacian_matrix(graphs[subj])) for subj in graphs) eigs = OrderedDict((subj, np.sort(np.linalg.eigvals(laplac[subj].A))[::-1]) for subj in graphs) write(outdir, 'eigen_sequence', eigs, atlas) print("Subject Maxes: " + ", ".join(["%.2f" % np.max(eigs[key]) for key in eigs.keys()])) scree = OrderedDict((subj, np.cumsum(eigs[subj])/np.sum(eigs[subj])) for subj in eigs) write(outdir, 'scree_eigen', scree, atlas) # Betweenness Centrality print("Computing: Betweenness Centrality Sequence") nxbc = nx.algorithms.betweenness_centrality # For PEP8 line length... temp_bc = OrderedDict((subj, nxbc(graphs[subj]).values()) for subj in graphs) centrality = density(temp_bc, nbins=2*nodes) write(outdir, 'betweenness_centrality', centrality, atlas) show_means(temp_bc) outf = outdir + '/' + atlas + '_summary.png'
def plot_graph(graph, label=None, cache=False, max_id=None): val_map = [ 'cyan', 'red', 'blue', 'magenta', 'gray', 'purple', 'orange', 'yellow', 'green', 'black', 'pink' ] if label is not None: if len(np.shape(label)) > 1: values = [val_map[_] for _ in np.where(label == 1)[1].tolist()] else: values = [val_map[int(_)] for _ in label] else: values = None # if graph.name == 'Zachary\'s Karate Club': # vals = {'Mr. Hi': 0, 'Officer': 1} # values = [vals[__['club']] for _, __ in graph._node.items()] if cache: pos = pk.load(open('./pos.pk', 'rb')) else: pos = nx.fruchterman_reingold_layout(graph, k=0.1, iterations=50) pk.dump(pos, open('./pos.pk', 'wb')) # pos = nx.circular_layout(graph,scale=1) # pos = nx.random_layout(graph) # pos = nx.shell_layout(graph) # pos = nx.spectral_layout(graph) if nx.bipartite.is_bipartite(graph): l, r = nx.bipartite.sets(graph) pos = {} pos.update((node, (1, index)) for index, node in enumerate(l)) pos.update((node, (2, index)) for index, node in enumerate(r)) print("\nPlotting a graph...") # plot graph plt.axis('off') plt.figure(1, figsize=(10, 10)) gs = gridspec.GridSpec(2, 1, height_ratios=[1, 3]) ax0 = plt.subplot(gs[0]) # plot eigenvalues norm_lap = nx.normalized_laplacian_matrix(graph) eigval, eigvec = LA.eigh(norm_lap.A) ax0.plot(eigval, 'ro') ax1 = plt.subplot(gs[1]) # nx.draw(graph, pos=pos, node_color=values, node_size=15, width=0.1) nx.draw(graph, pos, node_color=label[:0], node_size=20, width=0.1, cmap=plt.cm.rainbow, with_labels=False) # color bar sm = plt.cm.ScalarMappable(cmap=plt.cm.rainbow, norm=plt.Normalize(vmin=np.min(label), vmax=np.max(label))) sm._A = [] divider = make_axes_locatable(ax1) cax = divider.append_axes("bottom", size="5%") cbar = plt.colorbar(sm, cax=cax, ticks=[-1, -.5, -.25, -.1, 0, .1, .25, .5, 1], orientation='horizontal') cbar.ax.tick_params(labelsize=8) cbar.ax.set_xlabel('node text in graph is index=val', rotation=360) plt.title('original networks w/ eigenvalues') plt.show() # visualize eigen vectors # for _ in range(3): # len(graph._node)): for _ in list(range(3)) + max_id.flatten().tolist(): # len(graph._node)): plt.figure(1, figsize=(7, 8)) fig, ax = plt.subplots(2, 1, num=1) gs = gridspec.GridSpec(2, 1, height_ratios=[1, 3]) # plot eigen vector values ax0 = plt.subplot(gs[0]) cur_eigv = eigvec[:, _] print("{}:{:.4f}".format(_, eigval[_])) print(["{}:{:.4f}".format(k, v) for k, v in enumerate(cur_eigv)]) ax0.plot(range(cur_eigv.shape[0]), cur_eigv, 'b--') for i, txt in enumerate(cur_eigv): ax0.annotate(i, (range(cur_eigv.shape[0])[i], cur_eigv[i])) # ax0.set_ylabel('scale') ax0.set_xlabel('eigenvector of i={}'.format(_)) # plot eigen vector as labels on graph ax1 = plt.subplot(gs[1]) nx.draw(graph, pos, node_color=cur_eigv, node_size=20, width=0.1, cmap=plt.cm.rainbow, with_labels=False) # label draw labels = { k: "{}={:.3f}".format(k, v) for k, v in enumerate(cur_eigv.tolist()) } pos_higher = {} for k, v in pos.items(): pos_higher[k] = (v[0], v[1] + (1 if random.random() < 0.5 else -1) * random.uniform(0.02, 0.03)) # nx.draw_networkx_labels(graph, pos_higher, labels, font_size=6) # color bar sm = plt.cm.ScalarMappable(cmap=plt.cm.rainbow, norm=plt.Normalize(vmin=np.min(cur_eigv), vmax=np.max(cur_eigv))) sm._A = [] divider = make_axes_locatable(ax1) cax = divider.append_axes("bottom", size="5%") cbar = plt.colorbar(sm, cax=cax, ticks=[-1, -.5, -.25, -.1, 0, .1, .25, .5, 1], orientation='horizontal') cbar.ax.tick_params(labelsize=8) cbar.ax.set_xlabel('node text in graph is index=val', rotation=360) plt.show()
def create_er_graph(self): self.er_prob = 0.2 self.er_graph = nx.fast_gnp_random_graph(self.num_vertices, self.er_prob) self.er_normL = nx.normalized_laplacian_matrix(self.er_graph) return
def f(graph: nx.Graph): es1, _ = np.linalg.eigh(nx.laplacian_matrix(graph).todense()) es2, _ = np.linalg.eigh(nx.normalized_laplacian_matrix(graph).todense()) print(es1) print(es2) return
def spectral_clustering(self): print("\tSpectral Clustering Data Precomputing ...") from sklearn.cluster import KMeans from scipy.stats import halfnorm for graph, prefix in [ (self.__drugtarget, "drug_target"), (self.__drugdrug, "drug_projection"), (self.__targettarget, "target_projection"), ]: maj = graph.subgraph( max(list(nx.connected_components(graph)), key=len)) L = nx.normalized_laplacian_matrix(graph).toarray() evals, evects = np.linalg.eigh(L) relevant = [ n for n, dif in enumerate(np.diff(evals)) if dif > halfnorm.ppf(0.99, *halfnorm.fit(np.diff(evals))) ] relevant = [ relevant[n] for n in range(len(relevant) - 1) if relevant[n] + 1 != relevant[n + 1] ] + [ relevant[-1] ] # keeps only the highest value if there are consecutive ones n_clusters = (relevant[0] + 1 if ( relevant[0] > 1 and relevant[0] + 1 != nx.number_connected_components(graph)) else relevant[1] + 1) km = KMeans(n_clusters=n_clusters, n_init=100) clusters = km.fit_predict(evects[:, :n_clusters]) L_maj = nx.normalized_laplacian_matrix(maj).toarray() evals_maj, evects_maj = np.linalg.eigh(L_maj) relevant_maj = [ n for n, dif in enumerate(np.diff(evals_maj)) if dif > halfnorm.ppf(0.99, *halfnorm.fit(np.diff(evals_maj))) ] relevant_maj = [ relevant_maj[n] for n in range(len(relevant_maj) - 1) if relevant_maj[n] + 1 != relevant_maj[n + 1] ] + [ relevant_maj[-1] ] # keeps only the highest value if there are consecutive ones n_clusters_maj = (relevant_maj[0] + 1 if ( relevant_maj[0] > 1 and relevant_maj[0] + 1 != nx.number_connected_components(maj)) else relevant_maj[1] + 1) km_maj = KMeans(n_clusters=n_clusters_maj, n_init=100) clusters_maj = km_maj.fit_predict(evects_maj[:, :n_clusters_maj]) name = "data/groups/" + prefix + "_spectral.pickle" with open(name, "wb") as bkp: pickle.dump( [ L, evals, evects, n_clusters, clusters, L_maj, evals_maj, evects_maj, n_clusters_maj, clusters_maj, ], bkp, ) if os.path.isfile(name + ".bkp"): os.remove(name + ".bkp")
# Whether use GAE embedding debuginfoStr('Start Graph Autoencoder training') if args.useGAEembedding or args.useBothembedding: zDiscret = zOut > np.mean(zOut, axis=0) zDiscret = 1.0 * zDiscret if args.useGAEembedding: zOut = GAEembedding(zDiscret, adj, args) elif args.useBothembedding: zEmbedding = GAEembedding(zDiscret, adj, args) zOut = np.concatenate((zOut, zEmbedding), axis=1) debuginfoStr('Graph Autoencoder training finished') # For iteration studies G0 = nx.Graph() G0.add_weighted_edges_from(edgeList) nlG0 = nx.normalized_laplacian_matrix(G0) # set iteration criteria for converge adjOld = nlG0 # set celltype criteria for converge listResultOld = [1 for i in range(zOut.shape[0])] # Fill the zeros before EM iteration # TODO: better implementation later, now we don't filling zeros for now if args.zerofillFlag: for nz_index in range(len(scData.nz_i)): # tmp = scipy.sparse.lil_matrix.todense(scData.features[scData.nz_i[nz_index], scData.nz_j[nz_index]]) # tmp = np.asarray(tmp).reshape(-1)[0] tmp = scData.features[scData.nz_i[nz_index], scData.nz_j[nz_index]] reconOut[scData.nz_i[nz_index], scData.nz_j[nz_index]] = tmp recon = reconOut
for i in nodelist: features.append([ pagerank[i], triangles[i], deg_centrality[i], core_number[i], color_number[i] ]) features_dict[i] = np.array([ pagerank[i], triangles[i], deg_centrality[i], core_number[i], color_number[i] ]) features = np.array(features) nx.set_node_attributes(G, name='x', values=features_dict) print('Normalizing Laplacian') ## Peut-être que la normalisation n'est pas bonne adj = nx.normalized_laplacian_matrix(G, nodelist=nodelist).tocoo() values = adj.data indices = np.vstack((adj.row, adj.col)) # Yields indices to split data into training, validation and test sets features = torch.FloatTensor(features) idx = np.random.permutation(n_train_host) idx_train = idx[:int(0.8 * n_train_host)] idx_val = idx[int(0.8 * n_train_host):] idx_test = np.arange(n_train_host, n) # Transform the numpy matrices/vectors to torch tensors y = torch.LongTensor(np.argmax(labels, axis=1)) i = torch.LongTensor(indices) v = torch.FloatTensor(values) # .todense(?)
def make_laplacian_matrix(G): a = nx.normalized_laplacian_matrix(G) # print(a.todense()) return a.todense()
degrees = [] for (_, d) in G.degree(): degrees.append(d) # plot degree distribution degree_sequence = sorted([d for n, d in G.degree()], reverse=True) dmax = max(degree_sequence) plt.loglog(degree_sequence, "b-", marker="o") plt.title("Degree rank plot") plt.ylabel("degree") plt.xlabel("rank") plt.savefig(os.path.join(out_dir, 'degree_distribution.png')) plt.close() plt.matshow(nx.normalized_laplacian_matrix(G).A, cmap='prism') plt.savefig(os.path.join(out_dir, 'laplacian_norm.png')) plt.close() # dict for storing results (will be converted to DataFrame) metrics = {'method': [], 'precision': [], 'recall': [], 'F1': [], 'Sn': [], 'PPV': [], 'Acc': [], 'use_GO': []} for method_name, method in zip(['TENE', 'TADW', 'FSCNMF', 'ASNE', 'SINE', 'BANE', 'AE', 'MUSAE'], # the name of the embedding/community detection method [TENE, TADW, FSCNMF, ASNE, SINE, BANE, AE, MUSAE]): # the model class for use_go in [True, False]: if use_go: attr_m = coo_matrix(A) dataset = dset_file + '_GO' else: attr_m = coo_matrix(np.ones_like(A)) dataset = dset_file out_dir = 'plots/%s' % dataset
k=16 #降维后的向量长度 ft=open("E:\\node2vec\\node2vec\\graph\\Les.edgelist",'r') edges=ft.readlines() g=nx.Graph() for i in edges: edge=i.split() g.add_edge(int(edge[0]),int(edge[1]),weight=int(edge[2])) print(g.edges()) #标准化的拉普拉斯矩阵 L=nx.adjacency_matrix(g) # print(L.todense()) L1=np.array(L.todense()) #聚类 # spectral=SpectralClustering(n_clusters=k,affinity='nearest_neighbors',n_neighbors=4,eigen_solver='arpack',n_jobs=20) # pre=spectral.fit(L1) L_new=nx.normalized_laplacian_matrix(g) a,b=np.linalg.eig(np.array(L_new.todense())) print(a) print(b) eig_vec_dic={} eig_vec_dic=dict(zip(a,b)) result=list(sorted(eig_vec_dic.items(),key=lambda x:x[0])) coll=[] for i in range(k): coll.append(result[i][1]) #coll中的每一列存放的是一个节点降维后的向量 coll1=np.array(coll) print(coll1.shape) A=coll1.transpose() #降维后的样本 #聚类
def main_operation(): #Loading gene interactions JSON file into a variable with open('JSON rows/gene_interactions.json') as json_data: interactions = json.load(json_data) #Information about Graph Connectivity graph_info = interactions["results"] #Creating NetworkX instance graph = nx.Graph() i = 0 #Extracting the edge relationships for edge in graph_info: #Adding the edge in NetworkX graph.add_edge(edge[0],edge[2]) if i == 1000: break i += 1 #Converting into numpy array adjacency_matrix = nx.to_numpy_matrix(graph) #Normalized Laplacian Matrix normalized_laplacian = nx.normalized_laplacian_matrix(graph) #Normal Laplacian Matrix laplacian = nx.laplacian_matrix(graph) #Conversion to dense matrix dense_laplacian = laplacian.todense() #Conversion into Dense Matrix normalized_laplacian_dense = normalized_laplacian.todense() #The number of eigen vectors to be obtained for K-means clustering eigen_number = 100 #Function Call for Spectral Clustering cluster_labels = spectral_clustering(normalized_laplacian_dense,eigen_number) #List of Nodes nodes = graph.nodes() #Cluster consisting of similar nodes clusters = {} #Initializing the clusters for num in range(0,eigen_number): clusters[num] = [] i = 0 #Populating with the actual node names in the cluster for cluster_number in cluster_labels: clusters[cluster_number].append(nodes[i]) i+=1 #Cluster Mappings for color cluster_dict = create_color_mappings(clusters) #Drawing the Graph values = [cluster_dict.get(node,0.25) for node in graph.nodes()] nx.draw(graph,cmap=plt.get_cmap('jet'),node_color = values) plt.show()
def main(): parser = get_parser() args = vars(parser.parse_args()) print args ''' draw a graph of citing-users and their follower count output: figures/outfig.pdf ''' if args['do_fcount'] == True: print '-'*4, 'draw a graph of citing-users and their follower count' draw_citing_users_follower_count() exit() infname = 'Results/procjson.tsv' infname = "Results/clustered_relevant_users.tsv" with open(infname) as f: lines = f.readlines() edges = [] sourc = [] for j,l in enumerate(lines): l = l.rstrip('\r\n') lparts = l.split('\t') edgesLst= [np.int64(p.lstrip('[').rstrip(']')) for p in lparts] edges.append(tuple(edgesLst)) sourc.append(edgesLst[0]) # Add the twitter users' follower network # processes this file: twtrs_follower_network.tsv plusEdgesLst = convert_follower_network_2edgelist() fllwrsEdges =[] for x,y in plusEdgesLst: x = np.int64(x) y = np.int64(x) fllwrsEdges.append((x,y)) #### #### Builds the basic graph #### g = nx.Graph() g.add_edges_from(edges) print nx.info(g) print '-'*4,'draw basic network' draw_basic_network(g,sourc) g.add_edges_from(plusEdgesLst) print nx.info(g) if args ['do_metrics'] == True: print '-'*4,'compute network metrics and write to disk' ## \ / ## \/ isualization # deg distrib snm.get_degree_dist([g],"citeplus", 'orig') # write to disk clustering coeffs for this graph snm.get_clust_coeff([g], 'orig', 'citeplus') # write to disk egienvalue snm.network_value_distribution([g], [], 'citeplus') if 0: L = nx.normalized_laplacian_matrix(g) e = np.linalg.eigvals(L.A) print("Largest eigenvalue:", max(e)) print("Smallest eigenvalue:", min(e))
def create_sparse_matrix(self, network, normalize=False): if normalize: return csc_matrix(networkx.normalized_laplacian_matrix(network)) else: return csc_matrix(networkx.laplacian_matrix(network))
def driver(names, fs, outdir, atlas, verb=False): """ Given a set of files and a directory to put things, loads graphs and performs set of analyses on them, storing derivatives in a pickle format in the desired output location. Required parameters: names: - List of names of the datasets fs: - Dictionary of lists of files in each dataset outdir: - Path to derivative save location atlas: - Name of atlas of interest as it appears in the directory titles Optional parameters: verb: - Toggles verbose output statements """ graphs = constructGraphDict(names, fs, verb=verb) # Number of non-zero edges (i.e. binary edge count) print "Computing: NNZ" nnz = OrderedDict() for idx, name in enumerate(names): nnz[name] = OrderedDict((subj, len(nx.edges(graphs[name][subj]))) for subj in graphs[name]) write(outdir, 'nnz', nnz, atlas) # Degree sequence print "Computing: Degree Seuqence" deg = OrderedDict() for idx, name in enumerate(names): temp_deg = OrderedDict((subj, np.array(nx.degree(graphs[name][subj]).values())) for subj in graphs[name]) deg[name] = density(temp_deg) write(outdir, 'degree', deg, atlas) # Edge Weights print "Computing: Edge Weight Sequence" ew = OrderedDict() for idx, name in enumerate(names): temp_ew = OrderedDict((subj, [graphs[name][subj].get_edge_data(e[0], e[1])['weight'] for e in graphs[name][subj].edges()]) for subj in graphs[name]) ew[name] = density(temp_ew) write(outdir, 'edgeweight', ew, atlas) # Clustering Coefficients print "Computing: Clustering Coefficient Sequence" ccoefs = OrderedDict() nxc = nx.clustering # For PEP8 line length... for idx, name in enumerate(names): temp_cc = OrderedDict((subj, nxc(graphs[name][subj]).values()) for subj in graphs[name]) ccoefs[name] = density(temp_cc) write(outdir, 'ccoefs', ccoefs, atlas) # Scan Statistic-1 print "Computing: Scan Statistic-1 Sequence" ss1 = OrderedDict() for idx, name in enumerate(names): temp_ss1 = scan_statistic(graphs[name], 1) ss1[name] = density(temp_ss1) write(outdir, 'ss1', ss1, atlas) # Eigen Values print "Computing: Eigen Value Sequence" laplacian = OrderedDict() eigs = OrderedDict() for idx, name in enumerate(names): laplacian[name] = OrderedDict((subj, nx.normalized_laplacian_matrix(graphs[name][subj])) for subj in graphs[name]) eigs[name] = OrderedDict((subj, np.sort(np.linalg.eigvals(laplacian[name][subj].A))[::-1]) for subj in graphs[name]) write(outdir, 'eigs', eigs, atlas) # Betweenness Centrality print "Computing: Betweenness Centrality Sequence" centrality = OrderedDict() nxbc = nx.algorithms.betweenness_centrality # For PEP8 line length... for idx, name in enumerate(names): temp_bc = OrderedDict((subj, nxbc(graphs[name][subj]).values()) for subj in graphs[name]) centrality[name] = density(temp_bc) write(outdir, 'centrality', centrality, atlas)
def create_ba_graph(self): self.ba_graph = nx.barabasi_albert_graph(self.num_vertices, 1) self.ba_normL = nx.normalized_laplacian_matrix(self.ba_graph)
weight_total += G_u[edge[0]][edge[1]]['weight'] # Adds the number fo nodes, edges, total weigths and max eigenvalue to their respective lists node_count = G_u.number_of_nodes() # Gets number of nodes in the egonet # TODO: # Only computes the eigenvalue when the egonet has more than one node # If the ego net only has one node it dose not have an edge and thus no Adjacency matrix to use to compute the eigenvalue # selects the max eigenvalue if edges exstis, otherwise sets the eigenvalue to 0 # I am not sure if this method is correct or not if node_count > 1: node_counts.append(node_count) edge_counts.append(G_u.number_of_edges()) weight_totals.append(weight_total) L = nx.normalized_laplacian_matrix( G_u) # Computes the adjacency matrix e = np.linalg.eigvals( L.A) # Gets the egienvalues of the adjacency matrix # Gets the max eginvalue of the Adjaceny matrix # Adds it to the eigenvalues list eigenvalues.append(sum(e)) ##################################################################################### # Plot on a log-log scale: # # (i) E_u versus V_u for every egonet G_u # # (ii) the least squares fit on the median values for each bucket of points after # # applying logairthmic binning on the x-axis # # (iii) two lines of slope 1 and 2, the correspond to the stars and cliques # # respectivly. # # Additionally, plot (on a separate figure) the value of lamda_wu versus W_u for #
def eigenvalue_n(g, n=0): L = nx.normalized_laplacian_matrix(g) e = np.linalg.eigvals(L.A) return np.real(e[n])
def perform_split( self, character_matrix: pd.DataFrame, samples: List[int], weights: Optional[Dict[int, Dict[int, float]]] = None, missing_state_indicator: int = -1, ) -> Tuple[List[str], List[str]]: """Partitions the samples using the spectral algorithm. First, a similarity graph is generated with samples as nodes such that edges between a pair of nodes is some provided function on the number of character/state mutations shared. Then, Fiedler's algorithm is used to generate a partition on this graph that minimizes a modified normalized cut: weight of edges across cut/ min(weight of edges within each side of cut). It does this efficiently by first calculating the 2nd eigenvector of the normalized Laplacian of the similarity matrix. Then, it orders the nodes in a graph by the eigenvector values and finds an index such that partitioning the ordered nodes on that index minimizes the normalized cut ratio. As the optimal partition can be determined using the 2nd eigenvector, this greatly reduces the space of cuts needed to be explored. Args: character_matrix: Character matrix samples: A list of samples to partition weights: Weighting of each (character, state) pair. Typically a transformation of the priors. missing_state_indicator: Character representing missing data. Returns: A tuple of lists, representing the left and right partition groups """ G = graph_utilities.construct_similarity_graph( character_matrix, missing_state_indicator, samples, similarity_function=self.similarity_function, threshold=self.threshold, weights=weights, ) L = nx.normalized_laplacian_matrix(G).todense() diag = sp.linalg.eig(L) second_eigenvector = diag[1][:, 1] nodes_to_eigenvector = {} vertices = list(G.nodes()) for i in range(len(vertices)): nodes_to_eigenvector[vertices[i]] = second_eigenvector[i] vertices.sort(key=lambda v: nodes_to_eigenvector[v]) total_weight = 2 * sum([G[e[0]][e[1]]["weight"] for e in G.edges()]) # If the similarity graph is empty and there are no meaningful splits, # return a polytomy over the remaining samples if total_weight == 0: return samples, [] cut = set() numerator = 0 denominator = 0 prev_numerator = -1 best_score = np.inf best_index = 0 for i in range(len(vertices) - 1): v = vertices[i] cut.add(v) cut_edges = 0 neighbor_weight = 0 for w in G.neighbors(v): neighbor_weight += G[v][w]["weight"] if w in cut: cut_edges += G[v][w]["weight"] denominator += neighbor_weight if i > 0: prev_numerator = numerator numerator += neighbor_weight - 2 * cut_edges # Avoids naively taking the first zero-weight cut. If more samples # can be added without changing the cut weight, those samples do not # share any similarity with the other side of the partition. if numerator != 0 and prev_numerator == 0: best_index = i - 1 break if min(denominator, total_weight - denominator) != 0: if (numerator / min(denominator, total_weight - denominator) < best_score): best_score = numerator / min(denominator, total_weight - denominator) best_index = i else: best_score = 0 best_index = i improved_left_set = graph_utilities.spectral_improve_cut( G, vertices[:best_index + 1]) improved_right_set = [] for i in samples: if i not in improved_left_set: improved_right_set.append(i) return improved_left_set, improved_right_set
def gen_laplacian(G, _MODE_): if _MODE_ == 1: return nx.laplacian_matrix(G) else: return nx.normalized_laplacian_matrix(G)
'''If original graph is BA graph''' G_1 = nx.generators.random_graphs.barabasi_albert_graph(N,5,100) G_2 = nx.generators.random_graphs.barabasi_albert_graph(N,5,100) '''If original graph is small world graph''' #G_1 = nx.generators.random_graphs.watts_strogatz_graph(N,4,0.3,100) #G_2 = nx.generators.random_graphs.watts_strogatz_graph(N,4,0.3,100) laplacian_mat_original = nx.laplacian_matrix(G_1) laplacian_mat_original = laplacian_mat_original.todense() adj_original = nx.adjacency_matrix(G_1) adj_original = adj_original.todense() norm_laplacian_original = nx.normalized_laplacian_matrix(G_1) norm_laplacian_original = norm_laplacian_original.todense() deg,cnt = deg_count(G_1) for batch in range(num_batch): for i in range(edges_per_batch): G1 = preferential_add(G_1) G2 = small_world_add(G_2) #if i%200 == 0 and i!=0: # print('%d edges added'%i) edges_added = (batch+1)*edges_per_batch print('%d edges added'%edges_added) print('{} edges added'.format(edges_added),file=output) laplacian_mat_1 = nx.laplacian_matrix(G_1)
import operator from sklearn.cluster import KMeans from matplotlib.pyplot import figure #### Extracting Data from gml File dolphins_data = nx.read_gml("../data/dolphins/dolphins.gml") #### Nodes nodes = np.array(dolphins_data.node) ### Normalized Laplacian Matrix normalized_laplacian = nx.normalized_laplacian_matrix(dolphins_data, nodelist=None, weight='weight') normalized_laplacian = np.array(normalized_laplacian.todense()) #print(normalized_laplacian) #### Eigen Value and eigen Vector eigen_value, eigen_vector = np.linalg.eigh(normalized_laplacian) eigen_vector = eigen_vector.T #### Eigen Value Sorting dict = {} sorted_dict = {} for i in range(len(eigen_value)): dict[eigen_value[i]] = eigen_vector[i] sorted_dict = sorted(dict.items(), key=operator.itemgetter(0))
def spectral_analysis(G, k=None, normalize=True): """Given an input graph (G), number of clusters (k), and whether the graph Laplacian is to be normalized (True) or not (False) runs spectral clustering on the graph Laplacian using hierarchial method. Clusters are returned as a list of sets, where the contents of the first set are the nodes that belong to "cluster 1" Returns Partitions (list of sets of ints) """ EIGEN_GAP = 0.1 if normalize: # get_mat = lambda G : nx.normalized_laplacian_matrix(G).todense() get_mat = lambda G: nx.normalized_laplacian_matrix(G).asfptype() else: # get_mat = lambda G : nx.laplacian_matrix(G).todense() get_mat = lambda G: nx.laplacian_matrix(G).asfptype() partitions = [G] while True: second_least_eigenvalues = [] min_partition_eigenvalue = None best_partition = None partition_eigenvector = None for i, partition in enumerate(partitions): if len(partition.nodes) > 1: mat = get_mat(partition) # in the case of having 2 nodes, the 2nd least eigenvalue is the largest eigenvalue if len(partition.nodes) == 2: U, s, _ = svds(mat, k=1, which='LM', return_singular_vectors="u") cur_eigenvector = U[:, 0] partition_eigenvalue = s[0] # else we can just use the smallest two eigenvalues else: U, s, _ = svds(mat, k=2, which='SM', return_singular_vectors="u") cur_eigenvector = U[:, 1] partition_eigenvalue = s[1] # _, s, _ = np.linalg.svd(get_mat(partition)) if min_partition_eigenvalue is None or partition_eigenvalue < min_partition_eigenvalue: best_partition = i partition_eigenvector = cur_eigenvector min_partition_eigenvalue = partition_eigenvalue _plot_eigenvalues(s, "eigen/eigenvalues_{}.png".format(len(partitions))) _plot_eigenvector(partition_eigenvector, "eigen/eigenvector_{}.png".format(len(partitions))) if k is None: smallest_eigenvalues = np.array(s[::-1][:10]) eigen_steps = [ (smallest_eigenvalues[i] - smallest_eigenvalues[i - 1]) for i in range(1, len(smallest_eigenvalues)) ] _plot_eigenvalues(smallest_eigenvalues, "smallest_eigenvalues.png") _plot_eigenvalues(eigen_steps, "eigen_step.png") for i, eigen_step in enumerate(eigen_steps): if eigen_step > EIGEN_GAP: k = i + 1 if k is None: k = 1 print("Partitioning into {} clusters".format(k)) if len(partitions) >= k: break new_partitions = _partition_graph(partitions[best_partition], partition_eigenvector) del partitions[best_partition] if len(partitions + new_partitions) > k: new_partitions = [ nx.compose(new_partitions[0], new_partitions[1]), new_partitions[2] ] partitions += new_partitions print("Completed partitioning w/ {} partitions".format(k)) # return partitions partitions = [set(partition.nodes()) for partition in partitions] return partitions
def __init__(self, G, n=2000, portion=0.02, vectors=[13], spectrum_disp=False, cut_disp=False, vectors_disp=False, k_means_disp=False): iters = [] spectrum = [] accs = [] number_of_edges = [] n = G.number_of_nodes() laplacian_matrix = nx.normalized_laplacian_matrix(G) vals, vecs = sparse.linalg.eigs(laplacian_matrix.asfptype(), k=int(portion * (G.n_1 + G.n_2)), which='SM') ground_labels = nx.get_node_attributes(G, 'ground_label') optimal_val = 2 * G.b / (G.a + G.b) step = 2 * (G.a**2 + G.b**2) * np.log(n) / (G.a + G.b) / n if len(vectors) <= 0: vec_idxs = [ i for i in range(int(n * portion)) if vals[i] > optimal_val - 2 * step and vals[i] < optimal_val + 3 * step ] else: vec_idxs = vectors if spectrum_disp: sns.set() plt.rcParams['figure.figsize'] = [14, 7] plt.scatter(vals, [1 for i in range(len(vals))], marker='o', facecolors='none', edgecolors='b') plt.axvline(x=optimal_val, linewidth=2, color='black') plt.xlabel(r"spectrum") plt.ylabel(r"iterations") plt.show() if cut_disp: for i in vec_idxs: vector = vecs[:, i] vector = vector.astype('float64') labels_pred_spectral = checkSign(vector) accuracy = max( accuracy_score(labels_pred_spectral, G.ground_labels), 1 - accuracy_score(labels_pred_spectral, G.ground_labels)) accs += [accuracy] labels_dict = dict(zip(list(G.nodes), labels_pred_spectral)) nx.set_node_attributes(G, labels_dict, "label") sns.distplot(vector, kde=False, bins=50) plt.show() sns.distplot([ G.nodes[node]["coordinate"] for node in G.nodes if G.nodes[node]['label'] == 0 ], label="Cluster 0", kde=False, bins=50) sns.distplot([ G.nodes[node]["coordinate"] for node in G.nodes if G.nodes[node]['label'] == 1 ], label="Cluster 1", kde=False, bins=50) plt.title("i = " + str(i) + ", eigenvalue = " + str(vals[i]) + ", accuracy = " + str(accuracy)) plt.show() coordinates0 = [ G.nodes[node]["coordinate"] for node in G if G.nodes[node]['ground_label'] == 0 ] coordinates1 = [ G.nodes[node]["coordinate"] for node in G if G.nodes[node]['ground_label'] == 1 ] plt.scatter(coordinates0, vector[:int(n / 2)]) plt.scatter(coordinates1, vector[int(n / 2):]) plt.title("i = " + str(i) + ", eigenvalue = " + str(vals[i]) + ", accuracy = " + str(accuracy)) plt.show() dist_dict = nx.shortest_path_length(G, source=0) dist = [dist_dict[x] for x in sorted(dist_dict)] plt.scatter(dist[1:int(n / 2)], vector[1:int(n / 2)]) plt.scatter(dist[int(n / 2):], vector[int(n / 2):]) plt.title("i = " + str(i) + ", eigenvalue = " + str(vals[i]) + ", accuracy = " + str(accuracy)) plt.show() if vectors_disp: accs = [] c_norms = [] spectra = [] for i in vec_idxs: vector = vecs[:, i] vector = vector.astype('float64') km = k_means([vector], n) labels_pred = dict(zip(list(G.nodes), km['labels'])) accuracy = G.GetAccuracy(labels_pred) accs += [accuracy] spectra += [vals[i]] c_norms += [np.linalg.norm(sum(km['centers']))] sns.set() plt.plot(vec_idxs, accs, marker='o', label='Iteration ' + str(i)) plt.xlabel("Order of eigenvector") plt.ylabel("Accuracy") plt.show() # plt.plot(vec_idxs, c_norms, marker='o', label = 'Iteration ' + str(i)) # plt.show() plt.plot(vec_idxs, spectra, marker='o') plt.axhline(y=optimal_val, linewidth=2, color='black') plt.show() if k_means_disp: k = len(vec_idxs) accs = [] c_norms = [] inerts = [] min_dists = [] sum_dists = [] balances = [] for j in range(1, k + 1): # print([vec_idxs[i] for i in range(j)]) # km_vectors = [vecs[:,vectors[1]], vecs[:,vectors[j]]] km_vectors = [vecs[:, vec_idxs[i]] for i in range(j)] km = k_means(km_vectors, n) accuracy = max( accuracy_score(km['labels'], G.ground_labels), 1 - accuracy_score(km['labels'], G.ground_labels)) accs += [accuracy] c_norms += [np.linalg.norm(sum(km['centers']), ord=2)] inerts += [km['inertia'] / j] min_dists += [min(km['dists'])] sum_dists += [sum(km['dists'])] balances += [abs(sum(km['labels']) - n / 2)] plt.plot(vec_idxs[:k], accs, marker='o') plt.show() plt.plot(vec_idxs[:k], c_norms, marker='o', color='red') plt.show() # plt.plot(vec_idxs[:k], min_dists, marker='o', color = 'red') # plt.show() # plt.plot(vec_idxs[:k], sum_dists, marker='o', color = 'green') # plt.show() plt.plot(vec_idxs[:k], balances, marker='o', color='orange') plt.show() # k_means_vectors = [vecs[:,i] for i in vec_idxs] # labels_k_means = k_means(k_means_vectors, n)['labels'] # print(k_means(k_means_vectors, n)['labels'][:100]) # accuracy = max(accuracy_score(labels_k_means, G.ground_labels), 1 - accuracy_score(labels_k_means, G.ground_labels)) # print("Total accuracy after k-means = %.3f" % accuracy) self.n_edges = number_of_edges self.spectrum = vals self.accs = accs self.accuracy = accuracy
def erdos_renyi_lap( G ): #ER build graphs based on individual proteins, so number of nodes and probability of those edges being created lap_test = [] lap_test1 = [] lap_test2 = [] N = nx.number_of_nodes(G) E = nx.number_of_edges(G) prob_edges = (( (N * (N - 1)) / 2) / E) / 100 #divide by 100 float not percentage #print prob_edges '''start_time = time.time() for i in range(500): er_graph = nx.gnp_random_graph(N,prob_edges,seed=None) #number of nodes, probability for edge creation lap = nx.normalized_laplacian_matrix(er_graph, weight='weight') lap = np.eye(lap.shape[0])-lap eigenvalues,eigenvectors = scipy.sparse.linalg.eigsh(lap,k=2) lap_sum = (eigenvalues[1]-eigenvalues[0]) lap_test1.append(lap_sum) print lap_test1 print ("--- %s seconds ---" % (time.time() - start_time)) start_time = time.time() for i in range(500): er_graph = nx.fast_gnp_random_graph(N,prob_edges,seed=None) #number of nodes, probability for edge creation lap = nx.normalized_laplacian_matrix(er_graph, weight='weight') lap = np.eye(lap.shape[0])-lap eigenvalues,eigenvectors = scipy.sparse.linalg.eigsh(lap,k=2) lap_sum = (eigenvalues[1]-eigenvalues[0]) lap_test2.append(lap_sum) print lap_test2 print ("--- %s seconds ---" % (time.time() - start_time))''' start_time = time.time() for i in range(500): er_graph = nx.erdos_renyi_graph( N, prob_edges, seed=None) #number of nodes, probability for edge creation lap = nx.normalized_laplacian_matrix(er_graph, weight='weight') lap = np.eye(lap.shape[0]) - lap eigenvalues, eigenvectors = scipy.sparse.linalg.eigsh(lap, k=2) lap_sum = (eigenvalues[1] - eigenvalues[0]) lap_test.append(lap_sum) print lap_test print("--- %s seconds ---" % (time.time() - start_time)) start_time = time.time() for i in range(500): er_graph = nx.erdos_renyi_graph( N, prob_edges, seed=None) #number of nodes, probability for edge creation lap = nx.normalized_laplacian_matrix(er_graph, weight='weight') lap = np.eye(lap.shape[0]) - lap eigenvalues, eigenvectors = np.linalg.eigh(lap) lap_sum = (eigenvalues[1] - eigenvalues[0]) lap_test1.append(eigenvalues) print lap_test1 print("--- %s seconds ---" % (time.time() - start_time)) # using IGRAPH start_time = time.time() for i in range(500): er_graph = Graph.Erdos_Renyi( n=N, p=prob_edges, directed=True, loops=False) #number of nodes, probability for edge creation lap = er_graph.laplacian(normalized=True) e = np.linalg.eigvals(lap) lap_test2.append(e) print lap_test2 print("--- %s seconds ---" % (time.time() - start_time)) start_time = time.time() for i in range(500): er_graph = nx.gnp_random_graph( N, prob_edges, seed=None) #number of nodes, probability for edge creation '''lap = nx.normalized_laplacian_matrix(er_graph, weight='weight') lap = np.eye(lap.shape[0])-lap eigenvalues,eigenvectors = scipy.sparse.linalg.eigsh(lap,k=2) lap_sum = (eigenvalues[1]-eigenvalues[0]) lap_test1.append(lap_sum)''' print er_graph print("--- %s seconds ---" % (time.time() - start_time)) start_time = time.time() for i in range(500): er_graph = nx.fast_gnp_random_graph( N, prob_edges, seed=None) #number of nodes, probability for edge creation '''lap = nx.normalized_laplacian_matrix(er_graph, weight='weight') lap = np.eye(lap.shape[0])-lap eigenvalues,eigenvectors = scipy.sparse.linalg.eigsh(lap,k=2) lap_sum = (eigenvalues[1]-eigenvalues[0]) lap_test2.append(lap_sum)''' print er_graph print("--- %s seconds ---" % (time.time() - start_time)) start_time = time.time() for i in range(500): er_graph = nx.erdos_renyi_graph( N, prob_edges, seed=None) #number of nodes, probability for edge creation '''lap = nx.normalized_laplacian_matrix(er_graph, weight='weight') lap = np.eye(lap.shape[0])-lap eigenvalues,eigenvectors = scipy.sparse.linalg.eigsh(lap,k=2) lap_sum = (eigenvalues[1]-eigenvalues[0]) lap_test.append(lap_sum)''' print er_graph print("--- %s seconds ---" % (time.time() - start_time))
degree = list() for i in range(len(non_isolated)): degree.append(assembly_graph.degree[non_isolated[i]]) assembly_graph_degree = np.diag(degree) assembly_graph_adjacent = nx.adjacency_matrix(assembly_graph, nodelist=non_isolated).A degree = list() for i in range(len(non_isolated)): degree.append(PE_graph.degree[non_isolated[i]]) PE_graph_degree = np.diag(degree) PE_graph_adjacent = nx.adjacency_matrix(PE_graph, nodelist=non_isolated).A F = np.zeros([len(non_isolated), n_bins]) for i in range(len(non_isolated)): if non_isolated[i] in contigs_bin: F[i, contigs_bin[non_isolated[i]]] = 1 F_l = F[:binned_cnt,] assembly_graph_L = nx.normalized_laplacian_matrix(assembly_graph, nodelist=non_isolated).A PE_graph_L = nx.normalized_laplacian_matrix(PE_graph, nodelist=non_isolated).A Obj_fun = list() alpha = np.array([0.5, 0.5], dtype=np.float64) for i in range(max_iter): all_degree = alpha[0]*assembly_graph_degree + alpha[1]*PE_graph_degree all_adjacant = alpha[0]*assembly_graph_adjacent + alpha[1]*PE_graph_adjacent all_trans = np.dot(np.linalg.inv(all_degree), all_adjacant) all_trans_uu = all_trans[binned_cnt:, binned_cnt:] all_trans_ul = all_trans[binned_cnt:, :binned_cnt] F_u = np.dot(np.dot(np.linalg.inv(np.eye(all_trans_uu.shape[0]) - all_trans_uu), all_trans_ul), F_l) F = np.concatenate((F_l, F_u), axis=0) alpha[0] = 0.5/math.sqrt(np.trace(np.dot(np.dot(F.T,assembly_graph_L),F))) alpha[1] = 0.5/math.sqrt(np.trace(np.dot(np.dot(F.T,PE_graph_L),F))) obj = math.sqrt(np.trace(np.dot(np.dot(F.T,assembly_graph_L),F)))
def compute_metrics(fs, outdir, atlas, verb=False): """ Given a set of files and a directory to put things, loads graphs and performs set of analyses on them, storing derivatives in a pickle format in the desired output location. Required parameters: fs: - Dictionary of lists of files in each dataset outdir: - Path to derivative save location atlas: - Name of atlas of interest as it appears in the directory titles Optional parameters: verb: - Toggles verbose output statements """ graphs = loadGraphs(fs, verb=verb) # Number of non-zero edges (i.e. binary edge count) print("Computing: NNZ") nnz = OrderedDict((subj, len(nx.edges(graphs[subj]))) for subj in graphs) write(outdir, 'number_non_zeros', nnz, atlas) print("Sample Mean: %.2f" % np.mean(nnz.values())) # Degree sequence print("Computing: Degree Seuqence") temp_deg = OrderedDict( (subj, np.array(nx.degree(graphs[subj]).values())) for subj in graphs) deg = density(temp_deg) write(outdir, 'degree_distribution', deg, atlas) show_means(temp_deg) # Edge Weights print("Computing: Edge Weight Sequence") temp_ew = OrderedDict((s, [ graphs[s].get_edge_data(e[0], e[1])['weight'] for e in graphs[s].edges() ]) for s in graphs) ew = density(temp_ew) write(outdir, 'edge_weight_distribution', ew, atlas) show_means(temp_ew) # Clustering Coefficients print("Computing: Clustering Coefficient Sequence") temp_cc = OrderedDict( (subj, nx.clustering(graphs[subj]).values()) for subj in graphs) ccoefs = density(temp_cc) write(outdir, 'clustering_coefficients', ccoefs, atlas) show_means(temp_cc) # Scan Statistic-1 print("Computing: Max Local Statistic Sequence") temp_ss1 = scan_statistic(graphs, 1) ss1 = density(temp_ss1) write(outdir, 'scan_statistic_1', ss1, atlas) show_means(temp_ss1) # Eigen Values print("Computing: Eigen Value Sequence") laplac = OrderedDict((subj, nx.normalized_laplacian_matrix(graphs[subj])) for subj in graphs) eigs = OrderedDict((subj, np.sort(np.linalg.eigvals(laplac[subj].A))[::-1]) for subj in graphs) write(outdir, 'eigen_sequence', eigs, atlas) print("Subject Maxes: " + ", ".join(["%.2f" % np.max(eigs[key]) for key in eigs.keys()])) scree = OrderedDict( (subj, np.cumsum(eigs[subj]) / np.sum(eigs[subj])) for subj in eigs) write(outdir, 'scree_eigen', scree, atlas) # Betweenness Centrality print("Computing: Betweenness Centrality Sequence") nxbc = nx.algorithms.betweenness_centrality # For PEP8 line length... temp_bc = OrderedDict( (subj, nxbc(graphs[subj]).values()) for subj in graphs) centrality = density(temp_bc) write(outdir, 'betweenness_centrality', centrality, atlas) show_means(temp_bc) outf = outdir + '/' + atlas + '_summary.png'
edges=np.arange(0,max(nx.degree(G).values())+2) axD.hist(sorted(nx.degree(G).values()), edges) axD.set_xlabel('Node degree') axD.set_ylabel('Frequency') axD.title.set_text('Node degree distribution of A') A=nx.to_numpy_matrix(G) axA.plot(np.sort(np.linalg.eigvals( A ) ) ) axA.set_xlim(0,np.shape(A)[0]) axA.set_xlabel('eigenvector index') axA.set_ylabel('eigenvalue') axA.title.set_text('Eigenvalue spectrum of A') L=nx.normalized_laplacian_matrix(G) axL.plot(np.sort(np.linalg.eigvals( L.todense() ) ) ) axL.set_xlim(0,np.shape(L)[0]) axL.set_xlabel('eigenvector') axL.set_ylabel('eigenvalue') axL.title.set_text('Eigenvalue spectrum of L_n') #plt.show() C=nx.degree_centrality(G) axC.plot(np.sort(C.values()) ) axC.set_xlim(0,np.shape(L)[0]) axC.set_xlabel('node index') axC.set_ylabel('centrality') axC.title.set_text('Degree centrality spectrum') plt.tight_layout()
def get_lap_torch(self): return torch.from_numpy( nx.normalized_laplacian_matrix( self.nx_graph).toarray()).unsqueeze(0)
def _layout_laplacian(self, graph): nlm = nx.normalized_laplacian_matrix(graph) eigvals, eigvects = eigs(nlm, k=self.n_eigenvectors, which='SR') eigvals, eigvects = np.real(eigvals), np.real(eigvects) return scale(eigvects)
def min_eigenvalue(g): L = nx.normalized_laplacian_matrix(g) e = np.linalg.eigvals(L.A) return np.real(min(e))
def set_graph(self, _G): self.G = _G L = networkx.normalized_laplacian_matrix(self.G) L = L.todense() self.U, self.lamb_str = compute_eigenvectors_and_eigenvalues(L)
W1 = img_to_graph(f, return_as=np.ndarray) # gradient weighted W1 = np.exp(-W1 / W1.std()) W2 = im2graph(f) # spatial location and intensity-based weighted """## 3. Calculate Laplacian""" ## 1. Using csgraph Lapl_1 = csgraph.laplacian(W1, normed=True) print(Lapl_1.shape) ## 2. Using networkx G = nx.from_numpy_matrix(W1) Lapl_2 = nx.normalized_laplacian_matrix(G) Lapl_2b = nx.laplacian_matrix(G) print(Lapl_2.shape) ## 3. Doing the math --> https://en.wikipedia.org/wiki/Laplacian_matrix D = (np.diag(np.power(W1.sum(axis=1), -0.5))) k = re_size*re_size Lapl_3 = np.ones(k) - np.matmul(np.matmul(D, W1), D) Lapl_4 = D - W1 print(Lapl_3.shape) print(np.sum(Lapl_1-Lapl_2)) # both works great! print(np.sum(Lapl_1-Lapl_3))
def create_celegans(location): # load data data = scipy.io.loadmat(location + 'celegans.mat') A = data['A_combined'] G = nx.DiGraph(A) #set labels labels = {} for i in G: G.node[i]['labels'] = data['Labels'][i][0][0] labels[i] = data['Labels'][i][0][0] #set neuron types neuron_tpe = np.loadtxt(location + 'neuron_type.txt', dtype=str) neuron_type = {} colors = [] for i in range(len(neuron_tpe)): for il, l in enumerate(labels): if neuron_tpe[i][1] == labels[il]: if neuron_tpe[i][2] == 'M': G.node[il]['type'] = 0 neuron_type[il] = 0 colors.append('C0') elif neuron_tpe[i][2] == 'I': G.node[il]['type'] = 1 neuron_type[il] = 1 colors.append('C1') elif neuron_tpe[i][2] == 'S': G.node[il]['type'] = 2 neuron_type[il] = 2 colors.append('C2') #set positions of nodes, following SI of Varshney et al 2011 A = np.array(nx.to_numpy_matrix(G)) W = 0.5 * (A + A.T) D = np.diag(np.array(W.sum(1)).flatten()) b = np.array((W * np.sign(A - A.T)).sum(0)).flatten() L = D - W L = (nx.laplacian_matrix(nx.Graph(W))).toarray() z = np.array(np.linalg.pinv(L).dot(b)).flatten() #z = sc.sparse.linalg.spsolve(L,b) L_norm = nx.normalized_laplacian_matrix(nx.Graph(W)) vs = sc.sparse.linalg.eigs(L_norm, which='SM', k=3)[1][:, 1:] D_sqrt_inv = np.diag(1 / np.sqrt(np.diag(D))) v2 = D_sqrt_inv.dot(vs[:, 0]) v3 = D_sqrt_inv.dot(vs[:, 1]) pos = {} for i in G: #pos[i] = (-np.real(v2[i]), np.real(v3[i])) pos[i] = (-np.real(v2[i]), -z[i]) return G, pos, labels, neuron_type, colors
from data_process import create_graph, yield_data_time from utils import MSE, normalize import pickle as pk batch_size = 768 seq_len = 10 nodes_nums = 450 encode_dim = 100 load_name = 'result/rnn_new/encode2_seqlen/finfull_e47' graph_data = np.load('data/new/result_fin.npy') G = create_graph(graph_data[:nodes_nums, :nodes_nums]) adj = np.array(nx.normalized_laplacian_matrix(G).todense()) data = np.load('data/new/data2.npy').T[:, :nodes_nums] data = normalize(data) device = torch.device("cpu") if torch.cuda.is_available(): device = torch.device("cuda") with open(load_name+'.model', 'rb') as f: trainer = torch.load(f).to(device) encoder = trainer.encoder decoder = trainer.decoder
def gen_nor_laplacian(G): lap_nor_matrix = nx.normalized_laplacian_matrix(G) return lap_nor_matrix
#A_full = _A_obs.todense() A_matrix = np.loadtxt('plots/three_cluster_line_training.txt') A_full = np.loadtxt('plots/three_cluster_line.txt') N = A_full.shape[0] valid_edges = np.loadtxt('plots/three_cluster_line_val_edges.txt').tolist() valid_nonEdges = np.loadtxt( 'plots/three_cluster_line_val_non_edges.txt').tolist() valid = valid_edges + valid_nonEdges test_edges = np.loadtxt('plots/three_cluster_line_test_edges.txt').tolist() test_nonEdges = np.loadtxt( 'plots/three_cluster_line_test_non_edges.txt').tolist() test = test_edges + test_nonEdges G = nx.from_numpy_matrix(A_full) L = nx.normalized_laplacian_matrix(G).todense() eig_vals, eig_vecs = linalg.eig(L) eig_list = zip(eig_vals, np.transpose(eig_vecs)) eig_list.sort(key=lambda x: x[0]) u = np.asarray([u_i.real for u_i in eig_list[-2][1]])[0][0] truth = utils.compute_graph_statistics(np.asarray(A_full)) f = open('plots/truth.txt', "w") f.write(str(truth)) f.close() truth_spec = utils.specGap(A_full) #train_spec = utils.specGap(A_matrix)
def compute_metrics(fs, outdir, atlas, verb=False): """ Given a set of files and a directory to put things, loads graphs and performs set of analyses on them, storing derivatives in a pickle format in the desired output location. Required parameters: fs: - Dictionary of lists of files in each dataset outdir: - Path to derivative save location atlas: - Name of atlas of interest as it appears in the directory titles Optional parameters: verb: - Toggles verbose output statements """ graphs = loadGraphs(fs, verb=verb) nodes = nx.number_of_nodes(graphs.values()[0]) # Number of non-zero edges (i.e. binary edge count) print("Computing: NNZ") nnz = OrderedDict((subj, len(nx.edges(graphs[subj]))) for subj in graphs) write(outdir, 'number_non_zeros', nnz, atlas) print("Sample Mean: %.2f" % np.mean(nnz.values())) # Degree sequence print("Computing: Degree Sequence") total_deg = OrderedDict((subj, np.array(nx.degree(graphs[subj]).values())) for subj in graphs) ipso_deg = OrderedDict() contra_deg = OrderedDict() for subj in graphs: # TODO GK: remove forloop and use comprehension maybe? g = graphs[subj] N = len(g.nodes()) LLnodes = g.nodes()[0:N/2] # TODO GK: don't assume hemispheres LL = g.subgraph(LLnodes) LLdegs = [LL.degree()[n] for n in LLnodes] RRnodes = g.nodes()[N/2:N] # TODO GK: don't assume hemispheres RR = g.subgraph(RRnodes) RRdegs = [RR.degree()[n] for n in RRnodes] LRnodes = g.nodes() ipso_list = LLdegs + RRdegs degs = [g.degree()[n] for n in LRnodes] contra_deg[subj] = [a_i - b_i for a_i, b_i in zip(degs, ipso_list)] ipso_deg[subj] = ipso_list # import pdb; pdb.set_trace() deg = {'total_deg': total_deg, 'ipso_deg': ipso_deg, 'contra_deg': contra_deg} write(outdir, 'degree_distribution', deg, atlas) show_means(total_deg) # Edge Weights print("Computing: Edge Weight Sequence") temp_ew = OrderedDict((s, [graphs[s].get_edge_data(e[0], e[1])['weight'] for e in graphs[s].edges()]) for s in graphs) ew = temp_ew write(outdir, 'edge_weight', ew, atlas) show_means(temp_ew) # Clustering Coefficients print("Computing: Clustering Coefficient Sequence") temp_cc = OrderedDict((subj, nx.clustering(graphs[subj]).values()) for subj in graphs) ccoefs = temp_cc write(outdir, 'clustering_coefficients', ccoefs, atlas) show_means(temp_cc) # Scan Statistic-1 print("Computing: Max Local Statistic Sequence") temp_ss1 = scan_statistic(graphs, 1) ss1 = temp_ss1 write(outdir, 'locality_statistic', ss1, atlas) show_means(temp_ss1) # Eigen Values print("Computing: Eigen Value Sequence") laplac = OrderedDict((subj, nx.normalized_laplacian_matrix(graphs[subj])) for subj in graphs) eigs = OrderedDict((subj, np.sort(np.linalg.eigvals(laplac[subj].A))[::-1]) for subj in graphs) write(outdir, 'eigen_sequence', eigs, atlas) print("Subject Maxes: " + ", ".join(["%.2f" % np.max(eigs[key]) for key in eigs.keys()])) # Betweenness Centrality print("Computing: Betweenness Centrality Sequence") nxbc = nx.algorithms.betweenness_centrality # For PEP8 line length... temp_bc = OrderedDict((subj, nxbc(graphs[subj]).values()) for subj in graphs) centrality = temp_bc write(outdir, 'betweenness_centrality', centrality, atlas) show_means(temp_bc) # Mean connectome print("Computing: Mean Connectome") adj = OrderedDict((subj, nx.adj_matrix(graphs[subj]).todense()) for subj in graphs) mat = np.zeros(adj.values()[0].shape) for subj in adj: mat += adj[subj] mat = mat/len(adj.keys()) write(outdir, 'study_mean_connectome', mat, atlas)