def regularized_eigenvectors(A, d, K, alpha): import numpy as np import math as math from scipy.sparse.linalg.eigen.arpack import eigsh as largest_eigsh d = np.array(d) n = len(A[:, 1]) # Compute the degrees and other related metrics dalpha = np.power(d, -alpha) d1alpha = np.power(d, (alpha - 1)) invDalpha = np.diag(dalpha[:, 0]) invD1alpha = np.diag(d1alpha[:, 0]) # Compute the affinity matrix L_alpha B = (A - d.dot(np.transpose(d)) / (np.transpose(d).dot((np.ones( (n, 1)))))) / math.sqrt(n) L_alpha = (invDalpha.dot(B)).dot(invDalpha) # Compute the dominant eigenvectors of L_alpha evals_large_sparse, evecs_large_sparse = largest_eigsh(L_alpha, K - 1, which='LM') #Normalize the dominant eigenvectors normalized_evecs = invD1alpha.dot(evecs_large_sparse) return normalized_evecs
def sample_dual_dpp(L, q, k=None): ''' Wrapper function for the sample_dual_dpp Matlab code written by Alex Kulesza Given a kernel matrix L, returns a sample from a k-DPP. L is the kernel matrix q is the number of used eigenvalues k is the number of elements in the sample from the DPP ''' # Matlab link global mtb if mtb == None: import matlab_wrapper mtb = matlab_wrapper.MatlabSession() # Extract the feature matrix from the kernel evals, evecs = largest_eigsh(L, q, which='LM') B = np.dot(evecs, np.diag(evals)) # load values in Matlab and get sample mtb.put('B', B) if k != None: k = np.array([[k]]) # matlab only undernstand matrices mtb.put('k', k) mtb.eval("dpp_sample = sample_dual_dpp(B,decompose_kernel(B'*B),k)") else: mtb.eval("dpp_sample = sample_dual_dpp(B,decompose_kernel(B'*B))") dpp_sample = mtb.get('dpp_sample') return dpp_sample.astype(int)
def sample_dual_dpp(L, q, k=None): ''' Wrapper function for the sample_dual_dpp Matlab code written by Alex Kulesza Given a kernel matrix L, returns a sample from a k-DPP. L is the kernel matrix q is the number of used eigenvalues k is the number of elements in the sample from the DPP ''' # Matlab link global mtb if mtb == None: mtb = initialize_mtb() # Extract the feature matrix from the kernel evals, evecs = largest_eigsh(L, q, which='LM') B = np.dot(evecs, np.diag(evals)) # load values in Matlab and get sample mtb.put('B', B) print("sampling {} items from a dual DPP of size {}...".format(k, len(L))), start_time = time.time() sys.stdout.flush() if k != None: k = np.array([[k]]) # matlab only undernstand matrices mtb.put('k', k) mtb.eval("dpp_sample = sample_dual_dpp(B,decompose_kernel(B'*B),k)") else: mtb.eval("dpp_sample = sample_dual_dpp(B,decompose_kernel(B'*B))") dpp_sample = mtb.get('dpp_sample') print("done! took {} seconds".format(round(time.time() - start_time, 2))) sys.stdout.flush() return dpp_sample.astype(int)
def subgrad(z, mu, k, gamma_t): nx = len(z) uns_index = [i for i in range(nx) if mu[i] < T[i]] val = 0.0 for i in uns_index: val = val + (1 - mu[i] / T[i]) * S[i] a, b = largest_eigsh(val, 1) # compute the largest eigenvalue val = 0.0 subg = [0.0] * nx for i in range(nx): subg[i] = math.pow(float(b.T * V[i].T), 2.0) for i in range(nx): subg[i] = z[i] - subg[i] / float(T[i]) #supgradient at mu musol = np.array(mu) - gamma_t * np.array(subg) # compute projection and find mu_{t+1} musol[musol < 0] = 0 for i in range(nx): if musol[i] > T[i]: musol[i] = T[i] zsol = np.array(z) + gamma_t * np.array(mu) zsol = proj(zsol, nx, k) # compute projection and find z_{t+1} lb = a[0] + np.dot(mu, z) # lower bound zub = [0] * nx index = np.argsort(-np.array(mu)) for i in range(k): ind = index[i] zub[ind] = 1 ub = a[0] + np.dot(mu, zub) # upper bound return lb, ub, a, musol, zsol
def truncation(n, k): start = datetime.datetime.now() LB = [0] * n for i in range(n): a = A[i] a = abs(a) sindex = np.argsort(-a) b = [0] * n for j in range(k): b[sindex[0, j]] = a[0, sindex[0, j]] bnorm = np.linalg.norm(b, 2) b = b / bnorm b = np.matrix(b) LB[i] = (b * A * b.T)[0, 0] LB1 = max(max(LB), max(np.diag(A))) a, b = largest_eigsh(A, 1) b = b[:, 0] b = abs(b) sindex = np.argsort(-b) x = [0] * n for j in range(k): x[sindex[j]] = b[sindex[j]] xnorm = np.linalg.norm(x, 2) x = x / xnorm x = np.matrix(x) LB2 = (x * A * x.T)[0, 0] end = datetime.datetime.now() time = (end - start).seconds return time, max(LB1, LB2)
def EDC(w,Ares,k): wadj = np.tensordot(w,Ares,axes=1); v,u = largest_eigsh(wadj,k+1,which='LM'); v_abs = abs(v); u = np.real(u[:,v_abs.argsort()]); v = v[v_abs.argsort()]; return v,u
def SC(matrix,k): evals, evecs = largest_eigsh(matrix,k,which='LM') evals_abs = abs(evals) evecs = evecs[:,evals_abs.argsort()] evals = evals[evals_abs.argsort()] model = KMeans(n_clusters=k).fit(np.real(evecs)) label = model.predict(np.real(evecs)) return label
def K(self, X): n = len(X) H = self.H(X) D = self.GeoDesicMatrix(X) K = -0.5 * np.matmul(np.matmul(H, D), H) M = np.block([[np.zeros([n, n]), 2 * K], [np.eye(n), -4 * K]]) evals_large_sparse, evec = largest_eigsh(M, 1, which='LM') c = evals_large_sparse[0] return K + 2 * c * K + 0.5 * c * c * H
def calc_eigenvalues(graph, num_ev=100): num_ev = min(100, num_ev) print_f("Extracting adjacency matrix!") adj_mat = adjacency(graph, weight=None) print_f("Starting calculation of {} Eigenvalues".format(num_ev)) evals_large_sparse, evecs_large_sparse = largest_eigsh(adj_mat, num_ev * 2, which='LM') print_f("Finished calculating Eigenvalues") weights = sorted([float(x) for x in evals_large_sparse], reverse=True)[:num_ev] graph.gp["top_eigenvalues"] = graph.new_graph_property("vector<float>", weights) return graph
def calc_eigenvalues(self, num_ev=100): num_ev = min(100, num_ev) self.debug_msg("Extracting adjacency matrix!") A = adjacency(self.graph, weight=None) self.debug_msg("Starting calculation of {} Eigenvalues".format(num_ev)) evals_large_sparse, evecs_large_sparse = largest_eigsh(A, num_ev * 2, which='LM') self.debug_msg("Finished calculating Eigenvalues") evs = sorted([float(x) for x in evals_large_sparse], reverse=True)[:num_ev] self.graph.graph_properties[ "top_eigenvalues"] = self.graph.new_graph_property("object", evs)
def wam(self,w,n_init=10): evals, evecs = largest_eigsh(np.tensordot(w,self.Alist,axes=1),self.k, which='LM') evals_abs = abs(evals) evecs = evecs[:,evals_abs.argsort()] evals = evals[evals_abs.argsort()] if self.method =='gmm': evecs_mean = np.zeros((self.k,self.k)) label = GaussianMixture(n_components=self.k,n_init=n_init).fit_predict(np.real(evecs[:,:])) else: label = KMeans(n_clusters=self.k,n_init=n_init).fit_predict(np.real(evecs[:,:])) return label
def compute_egiv(P, al, ga): n = int(P.max()) v = np.ones(n) print("Computing the super-spacey random surfer vector") x = sf.shift_fix(P, v, al, ga, n) xT = x.T print("Generating Transition Matrix: P[x]") RT = tc.tran_matrix(P, x) #A = mymult(output, b, RT, xT) # check accuracy of this. A = np.ones((n, n)) print("Solving the eigenvector problem for P[x]") eigenvalue, eigenvector = largest_eigsh(A, 2, which='LM') return (eigenvector, RT, x)
def computeLmaxes_Thresh(self, nSteps): self.LM = np.zeros(nSteps) self.LM_vect = {} for n_i in range(nSteps): print("computing step " + str(n_i)) self.setThresholdMask(nSteps=nSteps, step_i=n_i) self.computeNewAreaFromThresholdMask(n_i) self.computeFitnessFromThreshold(n_i) self.computeLandscapeMatrix() evals_large_sparse, evecs_large_sparse = largest_eigsh(self.M, 1, which='LA') self.LM[n_i] = evals_large_sparse self.LM_vect[n_i] = evecs_large_sparse
def getmainEig(dim,X): print "Computing means of data set" means = mean(X.T, axis=1) print "Computing covariance matrix" X_ = (X.T- dot(ones((X.shape[0],1)),matrix(means.T)).T)/std(X.T) covmat = cov(X_) print "Computing eigenvalues" eigvalues, eigvectors = largest_eigsh(covmat,k=754) #Sort the eigvalues and eigvectors indices = eigvalues[::-1].argsort() eigvalues = eigvalues[indices] eigvectors = eigvectors[:,indices].T error = abs(sum(eigvalues[dim:]))/abs(sum(eigvalues)) print "With ", dim," dimensions , information loss is approximately ", (error)*100, "%" display_patches(eigvectors[0:dim]) return eigvectors, eigvalues
def validcut(z, n): nu = 0 mu = [0] * n sel_index = [i for i in range(n) if z[i] == 1] uns_index = [i for i in range(n) if z[i] == 0] val = 0 for i in sel_index: val = val + S[i] a, b = largest_eigsh(val, 1) # compute the largest eigenvalue nu = max(a) mu = [0] * n for i in uns_index: mu[i] = T[i] return nu, mu
def K(self, X): self.nbrs_ = NearestNeighbors(self.n_neighbors, algorithm=self.neighbors_algorithm, n_jobs=self.n_jobs) random_state = check_random_state(self.random_state) X = check_array(X, dtype=float) self.nbrs_.fit(X) n=len(X) M= locally_linear_embedding( self.nbrs_, self.n_neighbors, eigen_solver=self.eigen_solver, max_iter=self.max_iter, random_state=random_state, reg=self.reg, n_jobs=self.n_jobs) lambdamax, evec = largest_eigsh(M, 1, which='LM') L=lambdamax*np.eye(n)-M """ Center L m=len(L) e=1/np.sqrt(m)*np.ones([m,1]) S=np.eye(len(L))-np.matmul(e.T,e) L=np.matmul(S,L,S) """ return L
def weight_multi(self,init = False,label=[],n_init=10): w = np.empty(self.L) for i in range(len(self.Alist)): if init: evals, evecs = largest_eigsh(self.Alist[i].astype(float),self.k, which='LM') evals_abs = abs(evals) evecs = evecs[:,evals_abs.argsort()] evals = evals[evals_abs.argsort()] if self.method == 'gmm': evecs_mean = np.zeros((self.k,self.k)) label = GaussianMixture(n_components=self.k,n_init=n_init).fit_predict(np.real(evecs[:,:])) else: label = KMeans(n_clusters=self.k,n_init=n_init).fit_predict(np.real(evecs[:,:])) w[i] = self.weight_single(self.Alist[i],label) w = np.maximum(w,np.zeros(self.L)) if np.sum(w)==0: w = np.random.randint(low=1,high=10,size=self.L) return w/np.sum(w)
# 0 and we can chnage it to many other things like. let sy to value 2 or we can implement for loop # to iterate the function and get required values. N=5000 k=10 X = np.random.random((N,N)) - 2.5 X = np.dot(X, X.T) #create a symmetric matrix # Benchmark the dense routine start = clock() evals_large, evecs_large = largest_eigh(X, eigvals=(N-k,N-1)) elapsed = (clock() - start) print("eigh elapsed time: ", elapsed) print(X) # Benchmark the sparse routine start = clock() evals_large_sparse, evecs_large_sparse = largest_eigsh(X, k, which='LM') elapsed = (clock() - start) print("eigsh elapsed time: ", elapsed) #################333 # approach 2 Numpy universial functions import numpy as np import time import sys # library to see the memoray occupied by list and numpy array. N = int(input('Please enter the diemention you want (N*N):')) N = (N) d = np.random.random((N,N)) -0.5 print(d) start = time.time()
def select(rule, x, A, b, loss, args, iteration): if rule is None: return None, args """ Adaptive selection rules """ n_params = x.size block_size = args["block_size"] it = iteration lipschitz = loss.lipschitz if "Tree" not in rule: assert block_size > 0 else: assert block_size == -1 g_func = loss.g_func if rule == "all": """ select all coordinates """ block = np.arange(n_params) elif rule == "Random": """ randomly select a coordinate""" all_block = np.random.permutation(n_params) block = all_block[:block_size] #block = np.unravel_index(block, (n_features, n_classes)) elif rule in ["Perm", "Cyclic"]: """Select next coordinate""" if iteration % n_params == 0: args["perm_coors"] = np.random.permutation(n_params) emod = it % int((n_params/block_size)) block = args["perm_coors"][emod*block_size: (emod + 1)*block_size] #block = np.unravel_index(block, (n_features, n_classes)) elif rule == "Lipschitz": """non-uniform sample based on lipschitz values""" L = lipschitz block = np.random.choice(x.size, block_size, replace=False, p=L/L.sum()) elif rule in ["GS"]: """ select coordinates based on largest gradients""" g = g_func(x, A, b, block=None) s = np.abs(g) block = np.argsort(s, axis=None)[-block_size:] elif rule in ["GSDLi", "GSD"]: """ select coordinates based on largest individual lipschitz""" L = lipschitz g = g_func(x, A, b, block=None) s = np.abs(g) / np.sqrt(L) block = np.argsort(s, axis=None)[-block_size:] elif rule in ["GSDHb"]: """ select coordinates based on the uper bound of the hessian""" g = g_func(x, A, b, block=None) if "GSD_L" not in args: Hb = loss.Hb_func(x, A, b, block=None) args["GSD_L"] = np.sum(np.abs(Hb), 1) s = np.abs(g) / np.sqrt(args["GSD_L"]) block = np.argsort(s, axis=None)[-block_size:] elif rule in ["GSQ-IHT", "IHT"]: """ select coordinates based on largest individual lipschitz""" L = lipschitz if "Hb_IHT" not in args: args["Hb_IHT"] = loss.Hb_func(x, A, b, block=None) #args["mu_IHT"] = 1. / np.max(np.linalg.eigh(args["Hb_IHT"])[0]) args["mu_IHT"] = 1. / largest_eigsh(args["Hb_IHT"], 1, which='LM')[0] Hb = args["Hb_IHT"] mu = args["mu_IHT"] G = g_func(x, A, b, block=None) d = G / np.sqrt(L) d_old = d.copy() for i in range(10): d = d - mu*(G + Hb.dot(d)) ind = np.argsort(np.abs(d)) d[ind[:-block_size]]= 0 if np.linalg.norm(d_old - d) < 1e-10: block = ind[-block_size:] break #print "norm diff: %.3f" % np.linalg.norm(d_old - d) d_old = d.copy() block = ind[-block_size:] #block = np.where(d != 0) return np.array(block), args elif rule == "gsq-nn": """ select coordinates based on largest individual lipschitz""" g = g_func(x, A, b, block=None) L = lipschitz d = -g / L x_new = x + d neg = x_new < 0 pos = (1 - neg).astype(bool) # SANITY CHECK assert x.size == (neg.sum() + pos.sum()) s = np.zeros(x.size) d = -g[pos] / L[pos] s[pos] = g[pos] * d + (L[pos]/2.) * d**2 d = - x[neg] s[neg] = g[neg] * d + (L[neg]/2.) * d**2 block = np.argsort(s, axis=None)[:block_size] elif rule in ["GSDTree", "GSTree","RTree", "GSLTree"]: """ select coordinates that form a forest based on BGS or BGSC """ g_func = loss.g_func if "GSDTree" == rule: lipschitz = np.sum(np.abs(A), 1) score_list = np.abs(g_func(x, A, b, None)) / np.sqrt(lipschitz) sorted_indices = np.argsort(score_list)[::-1] elif "GSLTree" == rule: lipschitz = lipschitz score_list = np.abs(g_func(x, A, b, None)) / np.sqrt(lipschitz) sorted_indices = np.argsort(score_list)[::-1] elif "GSTree" == rule: score_list = np.abs(g_func(x, A, b, None)) sorted_indices = np.argsort(score_list)[::-1] elif "RTree" == rule: sorted_indices = np.random.permutation(np.arange(A.shape[0])) block = ta.get_tree_slow(sorted_indices, adj=A) if iteration == 0: xr = np.random.randn(*x.shape) xE, _ = ur.update("bpExact", xr.copy(), A, b, loss, copy.deepcopy(args), block, iteration=iteration) xG, _ = ur.update("bpGabp", xr.copy(), A, b, loss, copy.deepcopy(args) , block, iteration=iteration) np.testing.assert_array_almost_equal(xE, xG, 3) print("Exact vs GaBP Test passed...") elif rule == "GSExactTree": """ select coordinates based on largest individual lipschitz""" g = g_func(x, A, b, block=None) s = np.abs(g) block_size = int(loss.n_params**(1./3)) block = np.argsort(s, axis=None)[-block_size:] elif rule == "GSLExactTree": """ select coordinates based on largest individual lipschitz""" l = lipschitz g = g_func(x, A, b, block=None) s = np.abs(g) / np.sqrt(l) block_size = int(loss.n_params**(1./3)) block = np.argsort(s, axis=None)[-block_size:] elif rule in ["TreePartitions", "RedBlackTree", "TreePartitionsRandom", "RedBlackTreeRandom"]: """ select coordinates that form a forest based on BGS or BGSC """ g_func = loss.g_func if "graph_blocks" not in args: yb = args["data_y"] unlabeled = np.where(yb == 0)[0] Wb = args["data_W"][unlabeled][:, unlabeled] #################### GET GRAPH BLOCKS if args["data_lattice"] == False: if rule == "RedBlackTree": graph_blocks = ta.get_rb_general_graph(Wb, L=lipschitz) elif rule == "TreePartitions": graph_blocks = ta.get_tp_general_graph(Wb, L=lipschitz) elif rule == "RedBlackTreeRandom": graph_blocks = ta.get_rb_general_graph(Wb, L=np.ones(lipschitz.size)) elif rule == "TreePartitionsRandom": graph_blocks = ta.get_tp_general_graph(Wb, L=np.ones(lipschitz.size)) else: raise ValueError("%s - No" % rule) if args["data_lattice"] == True: if rule == "RedBlackTree": graph_blocks = ta.get_rb_indices(args["data_nrows"], args["data_ncols"]) elif rule == "TreePartitions": graph_blocks = ta.get_tp_indices(args["data_nrows"], args["data_ncols"]) else: raise ValueError("%s - No" % rule) graph_blocks = ta.remove_labeled_nodes(graph_blocks, args["data_y"]) #################### SANITY CHECK if rule in ["RedBlackTree", "RedBlackTreeRandom"]: # Assert all blocks have diagonal dependencies for tmp_block in graph_blocks: tmp = A[tmp_block][:, tmp_block] assert np.all(tmp == np.diag(np.diag(tmp))) elif rule in ["TreePartitions","TreePartitionsRandom"]: # Assert all blocks are forests/acyclic for tmp_block in graph_blocks: W_tmp = (Wb[tmp_block][:, tmp_block] != 0).astype(int) assert ta.isForest(W_tmp) else: raise ValueError("%s - No" % rule) args["graph_blocks"] = cycle(graph_blocks) block = next(args["graph_blocks"]) block.sort() # check if block is diag # tmp = A[block][:, block] # assert np.all(tmp == np.diag(np.diag(tmp))) if iteration == 0: x = np.random.randn(A.shape[1]) xr = np.random.randn(*x.shape) xE, _ = ur.update("bpExact", xr.copy(), A, b, loss, copy.deepcopy(args), block, iteration) xG, _ = ur.update("bpGabp", xr.copy(), A, b, loss, copy.deepcopy(args) , block, iteration) np.testing.assert_array_almost_equal(xE, xG, 3) print("Exact vs GaBP Test passed...") else: raise ValueError("selection rule %s doesn't exist" % rule) if "Tree" not in rule: assert block_size == block.size assert np.unique(block).size == block.size block.sort() return block, args
n = i conv = 1 times[i-2][0] = i # Benchmark the dense routine start = clock() evals_large, evecs_large = largest_eigh(H[0:n,0:n], eigvals=(n-k,n-1)) elapsed = (clock() - start) times[i-2][1] = elapsed # print "eigh elapsed time: ", elapsed # Benchmark the sparse routine start = clock() evals_large_sparse, evecs_large_sparse = largest_eigsh(H[0:n,0:n], k, which='LM') elapsed = (clock() - start) times[i-2][2] = elapsed # print "eigsh elapsed time: ", elapsed start = clock() phi0 = np.random.rand(n) # print la.eig(H)[1].T CayleyN = (np.identity(n)-0.5*H[0:n,0:n]) CayleyP = (np.identity(n)+0.5*H[0:n,0:n]) while(conv > eps): phi1 = la.solve(CayleyP,CayleyN.dot(phi0)) mu = math.sqrt(phi1.dot(phi1)) phi1 = phi1/mu
inSize = U.shape[0] outSize = inSize resSize = 1000 a = 0.9 # leaking rate K = 0.99 # spectial radius reg = 1e-6 # regularization coefficient input_scaling = 1 N_c = 100 # generation of random weights Win = (np.random.rand(resSize,1+inSize)-0.5) * input_scaling W = np.random.rand(resSize,resSize)-0.5 largest_eigvals, _ = largest_eigsh(W @ W.T, 1, which='LM') rhoW = np.sqrt(largest_eigvals[0]) W = W/rhoW*(K-1+a)/a X = np.zeros((resSize,U.shape[1])) x = np.zeros([resSize,1]) for t in range(U.shape[1]): u = U[:,t:t+1] x = (1-a) * x + a * np.tanh( Win @ np.vstack((1,u)) + W @ x ) X[:,t:t+1] = x # offline train U_train = U[:,train_start : train_start + num_train] X_train = X[:,train_start : train_start + num_train] Y_train = U[:,train_start + 1 : train_start + num_train + 1]
def generateEmbeddedCoordinates(self, distanceMatrix, numCoords=0): """ Computes the diffusion coordinates from the distance matrix supplied. The diffusion kernel is $k(x,y) = exp{ distance(x,y)^2 / epsilon } SVD is used to compuet the singular values of a matrix that is conjugated to the kernel. Then the corrsponding vectors are rescaled to get the eigen vectors. (Original version: Miro Kramar, 2013, in MATLAB) NOTES: - The first eigenvalue is always +1, so it is not returned. Rachel Levanger, 2014.""" if numCoords==0: numCoords=distanceMatrix.shape[0] - 2 min_coords = min(numCoords, distanceMatrix.shape[1] - 2) if min_coords < numCoords: w.warn('Number of coordinates truncated to max value of [ndim(distmat)-2].') numCoords = min_coords numCoords = numCoords + 1 # Make up for zero-based indexing matrix_size = distanceMatrix.shape K = np.zeros(matrix_size) # Construct the kernel for i in range(0,matrix_size[0]): for j in range(0,matrix_size[1]): K[i,j] = np.exp(-((distanceMatrix[i,j])/self.epsilon)) # Construct the symmetric conjugate (by \sqrt(pi) ) of the kernel dx = sum(K) dx_square_root = np.sqrt(dx) P = np.zeros(matrix_size) for i in range(0,matrix_size[0]): for j in range(0,matrix_size[1]): P[i,j] = np.divide(K[i,j], dx_square_root[i] * dx_square_root[j] ) # Get the largest eigenvalues and corresponding eigenvectors EigenValues, EigenVectors = largest_eigsh(P, numCoords, which="LM") # Transform the eigen vectors to get the (right) eigenvectors of # k(x,y)/dx(x) d = sum(dx) pi_sqrt = np.sqrt(np.divide(dx, d)) for i in range(0,numCoords): for j in range(0,EigenVectors.shape[0]): EigenVectors[j,i] = np.divide(EigenVectors[j,i], pi_sqrt[j]) # Sort by eigenvalue descending I = EigenValues.argsort()[::-1] EigenValues = EigenValues[I] EigenVectors = EigenVectors[:,I] # Account for sign changes in eigenvectors and scale by eigenvalues for i in range(0,EigenValues.shape[0]): EigenVectors[:,i] = EigenVectors[:,i]*EigenValues[i] if EigenVectors[0,i] < 0: EigenVectors[:,i] = EigenVectors[:,i]*(-1) return EigenVectors[:,1:], EigenValues[1:]
def run(self): L = nx.normalized_laplacian_matrix(self.graph) evalues, evectors = a,b = largest_eigsh(L, k=self.parameters['dim']) self.embeddings = {str(n):v for n,v in zip(self.graph.nodes, evectors)}
import numpy as np from time import clock from scipy.linalg import eigh as largest_eigh from scipy.sparse.linalg.eigen.arpack import eigsh as largest_eigsh np.set_printoptions(suppress=True) np.random.seed(0) N=500 k=10 X = np.random.random((N,N)) - 0.5 X = np.dot(X, X.T) #create a symmetric matrix # Benchmark the dense routine start = clock() evals_large, evecs_large = largest_eigh(X, eigvals=(N-k,N-1)) elapsed = (clock() - start) v # Benchmark the sparse routine start = clock() evals_large_sparse, evecs_large_sparse = largest_eigsh(X, k, which='LM') elapsed = (clock() - start) print "eigsh elapsed time: ", elapsed
def compute_eigen_functions(self, domain, num_eigens): X = self.compute_k_matrix(domain) return largest_eigsh(X, num_eigens, which='LM')