def create_subspace(M, k): [size, images] = M.shape # calculate the mean mean = np.dot(M, np.ones((images, 1), dtype=np.int)) / images if images > size: covariance = np.dot((M - mean), (M - mean).T) [eigenvectors, eigenvalues] = la.eigh(covariance) # this should usually be the case since the number of pixels in a picture is probably # greater that the number of input pictures so instead of creating a huge Covariance # matrix which can be very large we instead calculate the eigenvectors of NxN matrix # and then use this to calculate the N eigenvectors of the DxD sized matrix else: L = np.dot((M - mean).T, (M - mean)) [eigenvalues, eigenvectors] = la.eigh(L) eigenvectors = np.dot((M - mean), eigenvectors) # wow python no scoping in loops, it's kinda hard to take you serious as a language sometimes # to make the eigenvectors unit length or orthonormal for i in range(images): eigenvectors[:, i] = eigenvectors[:, i] / la.norm(eigenvectors[:, i]) sorted_order = np.argsort(eigenvalues) sorted_order = np.flipud(sorted_order) eigenvalues = eigenvalues[sorted_order] eigenvectors = eigenvectors[:, sorted_order] principle_eigenvalues = eigenvalues[0:k] principle_eigenvectors = eigenvectors[:, 0:k] return principle_eigenvalues, principle_eigenvectors, mean
def get_msig_pos( self, sctx, eps_app_eng, *args, **kw ): ''' get biggest positive principle stress @param sctx: @param eps_app_eng: ''' sig_eng, D_mtx = self.get_corr_pred( sctx, eps_app_eng, 0, 0, 0 ) ms_vct = zeros( 3 ) shape = sig_eng.shape[0] if shape == 3: s_mtx = self.map_sig_eng_to_mtx( sig_eng ) m_sig, m_vct = linalg.eigh( s_mtx ) # @todo: - this must be written in a more readable way # if m_sig[-1] > 0: # multiply biggest positive stress with its vector ms_vct[:2] = m_sig[-1] * m_vct[-1] elif shape == 6: s_mtx = self.map_sig_eng_to_mtx( sig_eng ) m_sig = linalg.eigh( s_mtx ) if m_sig[0][-1] > 0: # multiply biggest positive stress with its vector ms_vct = m_sig[0][-1] * m_sig[1][-1] return ms_vct
def solve_kernel(self, regparam): self.regparam = regparam K1, K2 = self.K1, self.K2 Y = self.Y.reshape((K1.shape[0], K2.shape[0]), order='F') #assert self.Y.shape == (self.K1.shape[0], self.K2.shape[0]), 'Y.shape!=(K1.shape[0],K2.shape[0]). Y.shape=='+str(Y.shape)+', K1.shape=='+str(self.K1.shape)+', K2.shape=='+str(self.K2.shape) if not self.trained: self.trained = True evals1, V = la.eigh(K1) evals1 = mat(evals1).T V = mat(V) self.evals1 = evals1 self.V = V evals2, U = la.eigh(K2) evals2 = mat(evals2).T U = mat(U) self.evals2 = evals2 self.U = U self.VTYU = V.T * self.Y * U newevals = 1. / (self.evals1 * self.evals2.T + regparam) self.A = multiply(self.VTYU, newevals) self.A = self.V * self.A * self.U.T self.model = KernelPairwiseModel(self.A)
def get_red_rho_A(Sx,Sz,b,N): ''' Form the reduced ground state density matrix. Only defined when N >= 2. ''' if N < 2: raise Exception("N must be greater or equal to 2.") H = get_tran_ising_H(Sx,Sz,b,N) E,V = eigh(H.toarray()) rho_A_B = np.outer(V[:,0],V[:,0]) l,basis = eigh(Sz.toarray()) rho_A_k = rho_A_B for k in range(N-1,0,-1): rho_A_m = np.zeros([D**k,D**k]) for m in range(D): # Rewrite basis states in the full N space. basis_m = get_full_matrix(dok_matrix(basis)[m].transpose(),k,k) basis_m = np.kron(np.eye(D),basis_m.toarray()) # Trace the density matrix over the k-th particle. rho_A_m += np.dot(np.dot(np.transpose(basis_m),rho_A_k),basis_m) rho_A_k = rho_A_m rho_A = rho_A_k return rho_A
def chi1d(h,energies = [0.],t=0.0001,delta=0.01,q=0.001,nk=1000,U=None,adaptive=True,ks=None): hkgen = h.get_hk_gen() # get the generating hamiltonian n = len(h.geometry.x) # initialice response m = np.zeros((len(energies),n*n),dtype=np.complex) # initialice if not adaptive: # full algorithm if ks==None: ks = np.linspace(0.,1.,nk) # create klist for k in ks: # print "Doing k=",k hk = hkgen(k) # fist point e1,ev1 = lg.eigh(hk) # get eigenvalues hk = hkgen(k+q) # second point e2,ev2 = lg.eigh(hk) # get eigenvalues ct = calculate_xychi(ev1.T,e1,ev2.T,e2,energies,t,delta) # contribution m += ct m = m/nk # normalice by the number of kpoints ms = [m[i,:].reshape(n,n) for i in range(len(m))] # convert to matrices if adaptive: # adaptive algorithm from integration import integrate_matrix def get_chik(k): # function which returns a matrix """ Get response at a cetain energy""" hk = hkgen(k) # first point e1,ev1 = lg.eigh(hk) # get eigenvalues hk = hkgen(k+q) # second point e2,ev2 = lg.eigh(hk) # get eigenvalues ct = calculate_xychi(ev1.T,e1,ev2.T,e2,energies,t,delta) # contribution return ct # return response ms = [] m = integrate_matrix(get_chik,xlim=[0.,1.],eps=.1,only_imag=False) # add energy ms = [m[i,:].reshape(n,n) for i in range(len(m))] # convert to matrices if U==None: # raw calculation return ms else: # RPA calculation return rpachi(ms,U=U)
def HEG2(n,V): """\ Does the diagonalization in the discrete variable representation """ X = zeros((n,n),'d') for i in range(n): if i > 0: X[i,i-1] = X[i-1,i] = sqrt(i)/sqrt(2) # Eq 1 from HEG lam,T = eigh(X) KEho = zeros((n,n),'d') for i in range(n): KEho[i,i] = 0.25*(2*i+1) if i > 1: KEho[i,i-2] = KEho[i-2,i] = -0.25*sqrt(i-1)*sqrt(i) KEx = matmul(transpose(T),matmul(KEho,T)) #KEx = matmul(T,matmul(KEho,transpose(T))) # Form the potential matrix # Eq 2 from HEG Vx = diag([V(li) for li in lam]) Hx = KEx + Vx print "x\n",lam[:5] #from scipy.special.orthogonal import h_roots #print h_roots(n) matprint(KEx,label="T") matprint(Vx,label="V") matprint(Hx,label="H") E,U = eigh(Hx) return lam,E,U
def HEG(n,V): X = zeros((n,n),'d') for i in range(n): if i > 0: X[i,i-1] = X[i-1,i] = sqrt(i)/sqrt(2) # Eq 1 from HEG lam,T = eigh(X) print lam # Form the potential matrix # Eq 2 from HEG Vx = [V(li) for li in lam] Vho = matmul(T,matmul(diag(Vx),transpose(T))) KEho = zeros((n,n),'d') for i in range(n): KEho[i,i] = 0.25*(2*i+1) if i > 1: KEho[i,i-2] = KEho[i-2,i] = -0.25*sqrt(i-1)*sqrt(i) Hho = KEho+Vho Hx = matmul(transpose(T),matmul(Hho,T)) E,U = eigh(Hho) # The eigenvectors are in terms of the HO eigenvectors, so # we have to multiply by X before returning return lam,E,matmul(transpose(T),U)
def set(self,matrix): ''' Set the basis. Parameters ---------- matrix : callable The function to get the single particle matrix. ''' Eup,Uup,Edw,Udw=[],[],[],[] for k in [()] if self.BZ is None else self.BZ.mesh('k'): m=matrix(k) es,us=nl.eigh(m[:m.shape[0]//2,:m.shape[0]//2]) Edw.append(es) Udw.append(us) es,us=nl.eigh(m[m.shape[0]//2:,m.shape[0]//2:]) Eup.append(es) Uup.append(us) Eup,Uup=np.asarray(Eup),np.asarray(Uup).transpose((1,0,2)) Edw,Udw=np.asarray(Edw),np.asarray(Udw).transpose((1,0,2)) if self.polarization=='up': self._E1_=Edw self._E2_=Eup self._U1_=Udw self._U2_=Uup else: self._E1_=Eup self._E2_=Edw self._U1_=Uup self._U2_=Udw
def diag_H(self): '''Diagonalize the Hamiltonians of spin a and spin b. ''' e_a, w_a = nl.eigh(self.Ha) e_b, w_b = nl.eigh(self.Hb) e_gs = np.sum(e_a[:self.Na]) + np.sum(e_b[:self.Nb]) + self.C tmp_a = (w_a[:, :self.Na].dot(w_a.conj().T[:self.Na, :])).diagonal() print "tmpa:", tmp_a tmp_b = (w_b[:, :self.Nb].dot(w_b.conj().T[:self.Nb, :])).diagonal() print "tmpb:", tmp_b def vec_equal(v1, v2, Min = 10e-5): a = abs(v1-v2) a = (a < Min)*1. one = np.ones(len(v1)) return np.array_equal(a, one) not_conv = True if vec_equal(tmp_a, self.lattice_a) and vec_equal(tmp_b,\ self.lattice_b): not_conv = False return e_gs, not_conv self.lattice_a = tmp_a.copy() # update new density print "lattice a", self.lattice_a self.lattice_b = tmp_b.copy() print "lattice b", self.lattice_b return e_gs, not_conv #ground state energy
def __calcEigChan(self,A1,G2,Left,channels=10): # Calculate Eigenchannels using recipe from PRB # For right eigenchannels, A1=A2, G2=G1 !!! if isinstance(A1,MM.SpectralMatrix): ev, U = LA.eigh(MM.mm(A1.L,A1.R)) else: ev, U = LA.eigh(A1) # This small trick will remove all zero contribution vectors # and will diagonalize the tt matrix in the subspace where there # are values. idx = (ev > 0).nonzero()[0] ev = N.sqrt(ev[idx] / ( 2 * N.pi )) ev.shape = (1, -1) Utilde = ev * U[:, idx] nuo,nuoL,nuoR = self.nuo, self.nuoL, self.nuoR if Left: tt=MM.mm(MM.dagger(Utilde[nuo-nuoR:nuo,:]),2*N.pi*G2,Utilde[nuo-nuoR:nuo,:]) else: tt=MM.mm(MM.dagger(Utilde[:nuoL,:]),2*N.pi*G2,Utilde[:nuoL,:]) # Diagonalize (note that this is on a reduced tt matrix (no 0 contributing columns) evF, UF = LA.eigh(tt) EC = MM.mm(Utilde, UF[:,-channels:]).T return EC[::-1, :], evF[::-1] # reverse eigenvalues
def get_chik(k): # function which returns a matrix """ Get response at a cetain energy""" hk = hkgen(k) # first point e1,ev1 = lg.eigh(hk) # get eigenvalues hk = hkgen(k+q) # second point e2,ev2 = lg.eigh(hk) # get eigenvalues ct = calculate_xychi(ev1.T,e1,ev2.T,e2,energies,t,delta) # contribution return ct # return response
def linear_algebra(): """ Use the `numpy.linalg` library to do Linear Algebra For a reference on math, see 'Linear Algebra explained in four pages' http://minireference.com/static/tutorials/linear_algebra_in_4_pages.pdf """ ### Setup two vectors x = np.array([1, 2, 3, 4]) y = np.array([5, 6, 7, 8]) ### Vector Operations include addition, subtraction, scaling, norm (length), # dot product, and cross product print np.vdot(x, y) # Dot product of two vectors ### Setup two arrays / matrices a = np.array([[1, 2], [3, 9]]) b = np.array([[2, 4], [5, 6]]) ### Dot Product of two arrays print np.dot(a, b) ### Solving system of equations (i.e. 2 different equations with x and y) print LA.solve(a, b) ### Inverse of a matrix undoes the effects of the Matrix # The matrix multipled by the inverse matrix returns the # 'identity matrix' (ones on the diagonal and zeroes everywhere else); # identity matrix is useful for getting rid of the matrix in some equation print LA.inv(a) # return inverse of the matrix print "\n" ### Determinant of a matrix is a special way to combine the entries of a # matrix that serves to check if matrix is invertible (!=0) or not (=0) print LA.det(a) # returns the determinant of the array print "\n" # e.g. 3, means that it is invertible ### Eigenvectors is a special set of input vectors for which the action of # the matrix is described as simple 'scaling'. When a matrix is multiplied # by one of its eigenvectors, the output is the same eigenvector multipled # by a constant (that constant is the 'eigenvalue' of the matrix) print LA.eigvals(a) # comput the eigenvalues of a general matrix print "\n" print LA.eigvalsh(a) # Comput the eigenvalues of a Hermitian or real symmetric matrix print "\n" print LA.eig(a) # return the eigenvalues for a square matrix print "\n" print LA.eigh(a) # return the eigenvalues or eigenvectors of a Hermitian or symmetric matrix print "\n"
def get_chik(k): # function which returns a matrix """ Get response at a cetain energy""" hk = hkgen(k) # first point if collinear: hk = np.matrix([[hk[2*i,2*j] for i in range(len(hk)/2)] for j in range(len(hk)/2)]) # up component e1,ev1 = lg.eigh(hk) # get eigenvalues hk = hkgen(k+q) # second point if collinear: hk = np.matrix([[hk[2*i+1,2*j+1] for i in range(len(hk)/2)] for j in range(len(hk)/2)]) # down component e2,ev2 = lg.eigh(hk) # get eigenvalues ct = collinear_xychi(ev1.T,e1,ev2.T,e2,energies,t,delta) # contribution return ct # return response
def energy(s,n = None, scaleEnergy = 1): values = [] if n == None: for q in numpy.arange(0,1.+qstep,qstep): evalues, evectors = linalg.eigh(ham(q,s,scaleEnergy)) values.append(evalues[:5]) else: for q in numpy.arange(0,1.+qstep,qstep): evalues, evectors = linalg.eigh(ham(q,s,scaleEnergy)) values.append(evalues[n]) return values
def pca(X, d_prime): d,n = X.shape # mu: vector promedio mu = X.mean(axis=0) # Restamos la media for i in range(n): X[i] -= mu A = X.copy() if d>200 and n<3*d: if d_prime > n: d_prime = n # C: Matriz de covarianzas C_prime = 1.0/d * np.dot(A.T,A) #Delta=eigenvalues B=eigenvectors D_prime,B_prime = la.eigh(C_prime) #print "B prime: ", B_prime.shape, "- delta: ", D_prime.shape for i in xrange(n): B_prime[:,i] = B_prime[:,i]/np.linalg.norm(B_prime[:,i]) B = np.dot(A, B_prime) D = d/n * D_prime #print "B complete: ", B.shape, "- delta: ", D.shape # Ordenamos los vectores propios, primero los que más varianza recogen order = np.argsort(D, axis=0)[::-1] # Ordenamos los vectores propios & los valores propios B = B[:,order] D = D[order] else: C = 1.0/n * np.dot(A,A.T) D,B = la.eigh(C) # Ordenamos los vectores propios, primero los que más varianza recogen order = np.argsort(D)[::-1] # sorting the eigenvalues # Ordenamos los vectores propios & los valores propios B = B[:,order] D = D[order] # B_dprime (d'xn) #print "B: ", B.shape, " - ", B[:,:d_prime].shape #print "D: ", D.shape #print "X: ", X.shape #print "d': ",d_prime #print "mu: ", mu.shape #Proyectamos los datos en d' B_dprime = B[:,:d_prime] y = np.dot(B_dprime.T,X) #print y[0] #print #print #return ['B_dprime':B_dprime,D,B,mu,X] return {'B':B, 'B_dprime':B_dprime,'mu':mu,'y':y}, d_prime
def test_eig_vs_eigh_above_560(): # gh-6896 N = 560 A = np.arange(N*N).reshape(N, N) A = A + A.T w1 = np.sort(linalg.eig(A)[0]) w2 = np.sort(linalg.eigh(A, UPLO='U')[0]) w3 = np.sort(linalg.eigh(A, UPLO='L')[0]) assert_array_almost_equal(w1, w2) assert_array_almost_equal(w1, w3)
def eig_psd(K): """"Returns the reduced eigen decomposition of the kernel matrix K so that only the eigenvectors corresponding to the nonzero eigenvalues are returned. @param K: a positive semi-definite kernel matrix whose rows and columns are indexed by the datumns. @type K: numpy matrix of floats @return: the square roots of the nonzero eigenvalues and the corresponding eigenvectors of K. The square roots of the eigenvectors are contained in a r*1-matrix, where r is the number of nonzero eigenvalues. @rtype: a tuple of two numpy matrices""" try: evals, evecs = la.eigh(K) except LinAlgError, e: print 'Warning, caught a LinAlgError while eigen decomposing: ' + str(e) K = K + np.eye(K.shape[0]) * 0.0000000001 evals, evecs = la.eigh(K)
def get_chik(k): """Function to integrate""" hk = hkgen(k) # fist point if collinear: hk = np.matrix([[hk[2*i,2*j] for i in range(len(hk)/2)] for j in range(len(hk)/2)]) # up component e1,ev1 = lg.eigh(hk) # get eigenvalues hk = hkgen(k+q) # second point if collinear: hk = np.matrix([[hk[2*i+1,2*j+1] for i in range(len(hk)/2)] for j in range(len(hk)/2)]) # down component e2,ev2 = lg.eigh(hk) # get eigenvalues if collinear: ct = collinear_xychi(ev1.T,e1,ev2.T,e2,energies,t,delta) # contribution else: ct = calculate_xychi(ev1.T,e1,ev2.T,e2,energies,t,delta) # contribution return ct
def SVD(mat): matT = mat.transpose() matmatT = mat.dot(matT) matTmat = matT.dot(mat) egnvalU, egnvecU = LA.eigh(matmatT) egnvalV, egnvecV = LA.eigh(matTmat) V = np.fliplr(egnvecV) VT = V.transpose() egnvalV = egnvalV[::-1] S = np.zeros(mat.shape) for i in range(min(mat.shape)): S[i][i] = math.sqrt(egnvalV[i]) U = np.dot(np.dot(mat,np.transpose(VT)),LA.pinv(S)) return U, S, VT
def PCA(data_mat, p): 'reduce the data dimensionality to p, this function will substract the \ mean from the original data' d, N=data_mat.shape m=matlib.mean(data_mat, 1) data_mat-=m if d<N: AAT=data_mat*data_mat.T w, v=linalg.eigh(AAT) return v[:,-p:], m else: ATA=data_mat.T*data_mat w, v=linalg.eigh(ATA) return data_mat*v[:, -p:], m
def get_msig_pm( self, sctx, eps_app_eng, *args, **kw ): sig_eng, D_mtx = self.get_corr_pred( sctx, eps_app_eng, 0, 0, 0 ) t_field = zeros( 9 ) shape = sig_eng.shape[0] if shape == 3: s_mtx = self.map_sig_eng_to_mtx( sig_eng ) m_sig = linalg.eigh( s_mtx ) if m_sig[0][-1] > 0: t_field[0] = m_sig[0][-1]#biggest positive stress elif shape == 6: s_mtx = self.map_sig_eng_to_mtx( sig_eng ) m_sig = linalg.eigh( s_mtx ) if m_sig[0][-1] > 0: t_field[0] = m_sig[0][-1] return t_field
def calculate_edf(self, useibl=True): """Calculate the coefficients b_il in the expansion of the EDF. ``|phi_l> = sum_i b_il |f^u_i>``, in terms of ``|f^u_i> = P^u|f_i>``. To use the infinite band limit set useibl=True. N is the total number of bands to use. """ for k, L in enumerate(self.L_k): if L==0: assert L!=0, 'L_k=0 for k=%i. Not implemented' % k self.Vo_kni = [V_ni[:M] for V_ni, M in zip(self.V_kni, self.M_k)] self.Fo_kii = np.asarray([np.dot(dagger(Vo_ni), Vo_ni) for Vo_ni in self.Vo_kni]) if useibl: self.Fu_kii = self.s_lcao_kii - self.Fo_kii else: self.Vu_kni = [V_ni[M:self.N] for V_ni, M in zip(self.V_kni, self.M_k)] self.Fu_kii = np.asarray([np.dot(dagger(Vu_ni), Vu_ni) for Vu_ni in self.Vu_kni]) self.b_kil = [] for Fu_ii, L in zip(self.Fu_kii, self.L_k): b_i, b_ii = la.eigh(Fu_ii) ls = b_i.real.argsort()[-L:] b_il = b_ii[:, ls] #pick out the eigenvec with largest eigenvals. normalize2(b_il, Fu_ii) #normalize the EDF: <phi_l|phi_l> = 1 self.b_kil.append(b_il)
def get_vdw_potential_hessian(atoms, vdw, spectral=False): Bx = np.array([[1, 0, 0, -1, 0, 0], [0, 1, 0, 0, -1, 0], [0, 0, 1, 0, 0, -1]]) i = vdw.atomi j = vdw.atomj rij = rel_pos_pbc(atoms, i, j) dij = linalg.norm(rij) eij = rij / dij Pij = np.tensordot(eij, eij, axes=0) Qij = np.eye(3) - Pij Hr = (156.0 * vdw.Aij / dij ** 14 - 42.0 * vdw.Bij / dij ** 8) * Pij + ( -12.0 * vdw.Aij / dij ** 13 + 6.0 * vdw.Bij / dij ** 7 ) / dij * Qij Hx = np.dot(Bx.T, np.dot(Hr, Bx)) if spectral: eigvals, eigvecs = linalg.eigh(Hx) D = np.diag(np.abs(eigvals)) U = eigvecs Hx = np.dot(U, np.dot(D, np.transpose(U))) vdw.r = dij return i, j, Hx
def mpower(M, p): """ Matrix exponentiation, works for Hermitian matrices """ e,EV = linalg.eigh(M) return dot(transp(EV), dot(diag((e+0j)**p), EV))
def get_coulomb_potential_hessian(atoms, coulomb, spectral=False): Bx = np.array([[1, 0, 0, -1, 0, 0], [0, 1, 0, 0, -1, 0], [0, 0, 1, 0, 0, -1]]) i = coulomb.atomi j = coulomb.atomj rij = rel_pos_pbc(atoms, i, j) dij = linalg.norm(rij) eij = rij / dij Pij = np.tensordot(eij, eij, axes=0) Qij = np.eye(3) - Pij Hr = (2.0 * coulomb.chargeij / dij ** 3) * Pij + (-coulomb.chargeij / dij / dij) / dij * Qij Hx = np.dot(Bx.T, np.dot(Hr, Bx)) if spectral: eigvals, eigvecs = linalg.eigh(Hx) D = np.diag(np.abs(eigvals)) U = eigvecs Hx = np.dot(U, np.dot(D, np.transpose(U))) coulomb.r = dij return i, j, Hx
def music_3d(self,complexList, f): #Frequency, f in Hertz gamma = [-45, 45, 135, 225] v = 1500 lamda = v / f d = 0.015 r = math.sqrt(2 * math.pow(d / 2, 2)) A = zeros((4, 1), dtype=complex) pmusic = zeros((360, 90)) (eigval, eigvec) = LA.eigh(self.computeCovarianceMatrix(complexList)) Vn = eigvec[:, 0:3] for theta in range(90): #Theta is altitude for phi in range(360): #Phi is azimuth for i in range(4): #Hydrophone positions pd = 2*math.pi/lamda*r*math.sin(np.deg2rad(theta))*math.cos(np.deg2rad(phi - gamma[i])) A[i] = cmath.exp((1j)*pd) Ahat = np.matrix(A) num = Ahat.T.conj() * Ahat denom = (Ahat.T.conj() * Vn) * (Vn.T.conj() * Ahat) pmusic[phi, theta] = num.real / denom.real #plot(pmusic[:,theta],theta) #writeToFile('pmusic.txt',pmusic[:,theta],theta) [Music_phiCap,Music_thetaCap] = self.getMax(pmusic) rospy.loginfo("Music DOA calculated: " + str(Music_phiCap)) rospy.loginfo("Music elevation calculated: " + str(Music_thetaCap)) return [Music_phiCap,Music_thetaCap]
def get_morse_potential_hessian(atoms, morse, spectral=False): Mx = np.array([[1, 0, 0, -1, 0, 0], [0, 1, 0, 0, -1, 0], [0, 0, 1, 0, 0, -1]]) i = morse.atomi j = morse.atomj rij = rel_pos_pbc(atoms, i, j) dij = linalg.norm(rij) eij = rij / dij Pij = np.tensordot(eij, eij, axes=0) Qij = np.eye(3) - Pij exp = np.exp(-morse.alpha * (dij - morse.r0)) Hr = 2.0 * morse.D * morse.alpha * exp * (morse.alpha * (2.0 * exp - 1.0) * Pij + (1.0 - exp) / dij * Qij) Hx = np.dot(Mx.T, np.dot(Hr, Mx)) if spectral: eigvals, eigvecs = linalg.eigh(Hx) D = np.diag(np.abs(eigvals)) U = eigvecs Hx = np.dot(U, np.dot(D, np.transpose(U))) morse.r = dij return i, j, Hx
def whiten(df, epsilon=1E-5): """ Recibe una matrix de datos en filas de un pandas DataFrame. Se asume que los datos estan normalizados. """ from numpy import dot, sqrt, diag from numpy.linalg import eigh # covariance matrix Xcov = dot(df.T, df) / df.shape[1] # eigenvalue decomposition of the covariance matrix d, V = eigh(Xcov) # an epsilon factor can be used so that eigenvectors associated with # small eigenvalues do not get overamplified D = diag(1./sqrt(d + epsilon)) # whitening matrix W = dot(dot(V, D), V.T) # multiply by the whitening matrix X = dot(df, W) return X, W
def fit(self, X): if self.components==0: self.components=X.shape[0] self.X = X N = X.shape[0] K = np.zeros((N,N)) for row in range(N): for col in range(N): K[row,col] = self._kernel_func(X[row,:], X[col,:]) self._K_sum = np.sum(K) self._K_cached_sumcols = np.sum(K, axis=0) K_c = K - repmat(np.reshape(np.sum(K, axis=1), (N,1)), 1, N)/N - repmat(self._K_cached_sumcols, N, 1)/N + self._K_sum/N**2 # kernel matrix must be symmetric, so using symmetric matrix eigenvalue solver self._eigenvalues, self._eigenvectors = eigh(K_c) self._eigenvalues = np.real(self._eigenvalues) self._eigenvectors = np.real(self._eigenvectors) key = np.argsort(self._eigenvalues) key = key[::-1] self._eigenvalues = self._eigenvalues[key] self._eigenvectors = self._eigenvectors[:,key] self.X = self.X[key,:] self._K_cached_sumcols = self._K_cached_sumcols[key]
def _pca1 (X, verbose=False): """ Simple principal component decomposition (PCA) X as Npix by Nt matrix X should be normalized and centered beforehand returns: - EV (Nt by Nesq:esq>0), matrix of PC 'signals' (eigenvalues of temporal covariance matrix). Signals are in columns - esq, vector of eigenvalues """ print "Please don't use this, it's not ready" #return n_data, n_dimension = X.shape # (m x n) Y = X - X.mean(axis=0)[np.newaxis,:] # remove mean #C = dot(Y, Y.T) # (n x n) covariance matrix C = dot(Y.T, Y) print C.shape es, EV = eigh(C) # eigenvalues, eigenvectors ## take non-negative eigenvalues non_neg, = where(es>=0) neg = where(es<0) if len(neg)>0: if verbose: print "pca1: Warning, C have %d negative eigenvalues" %len(neg) es = es[non_neg] EV = EV[:,non_neg] #tmp = dot(Y.T, EV).T #V1 = tmp[::-1] #S1 = sqrt(es)[::-1] return EV
def svd_wrapper(matrix, mode, ncomp, debug, verbose, usv=False, random_state=None, to_numpy=True): """ Wrapper for different SVD libraries (CPU and GPU). Parameters ---------- matrix : array_like, 2d 2d input matrix. mode : {'lapack', 'arpack', 'eigen', 'randsvd', 'cupy', 'eigencupy', 'randcupy', 'pytorch', 'eigenpytorch', 'randpytorch'}, str optional Switch for the SVD method/library to be used. ``lapack`` uses the LAPACK linear algebra library through Numpy and it is the most conventional way of computing the SVD (deterministic result computed on CPU). ``arpack`` uses the ARPACK Fortran libraries accessible through Scipy (computation on CPU). ``eigen`` computes the singular vectors through the eigendecomposition of the covariance M.M' (computation on CPU). ``randsvd`` uses the randomized_svd algorithm implemented in Sklearn (computation on CPU). ``cupy`` uses the Cupy library for GPU computation of the SVD as in the LAPACK version. ``eigencupy`` offers the same method as with the ``eigen`` option but on GPU (through Cupy). ``randcupy`` is an adaptation of the randomized_svd algorithm, where all the computations are done on a GPU (through Cupy). ``pytorch`` uses the Pytorch library for GPU computation of the SVD. ``eigenpytorch`` offers the same method as with the ``eigen`` option but on GPU (through Pytorch). ``randpytorch`` is an adaptation of the randomized_svd algorithm, where all the linear algebra computations are done on a GPU (through Pytorch). ncomp : int Number of singular vectors to be obtained. In the cases when the full SVD is computed (LAPACK, ARPACK, EIGEN, CUPY), the matrix of singular vectors is truncated. debug : bool If True the explained variance ratio is computed and displayed. verbose: bool If True intermediate information is printed out. usv : bool optional If True the 3 terms of the SVD factorization are returned. random_state : int, RandomState instance or None, optional If int, random_state is the seed used by the random number generator. If RandomState instance, random_state is the random number generator. If None, the random number generator is the RandomState instance used by np.random. Used for ``randsvd`` mode. to_numpy : bool, optional If True (by default) the arrays computed in GPU are transferred from VRAM and converted to numpy ndarrays. Returns ------- V : array_like The right singular vectors of the input matrix. If ``usv`` is True it returns the left and right singular vectors and the singular values of the input matrix. References ---------- * For ``lapack`` SVD mode see: https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.linalg.svd.html http://www.netlib.org/lapack/ * For ``eigen`` mode see: https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.linalg.eigh.html * For ``arpack`` SVD mode see: https://docs.scipy.org/doc/scipy-0.19.1/reference/generated/scipy.sparse.linalg.svds.html http://www.caam.rice.edu/software/ARPACK/ * For ``randsvd`` SVD mode see: https://github.com/scikit-learn/scikit-learn/blob/master/sklearn/utils/extmath.py Finding structure with randomness: Stochastic algorithms for constructing approximate matrix decompositions Halko, et al., 2009 http://arxiv.org/abs/arXiv:0909.4061 * For ``cupy`` SVD mode see: https://docs-cupy.chainer.org/en/stable/reference/generated/cupy.linalg.svd.html * For ``eigencupy`` mode see: https://docs-cupy.chainer.org/en/master/reference/generated/cupy.linalg.eigh.html * For ``pytorch`` SVD mode see: http://pytorch.org/docs/master/torch.html#torch.svd * For ``eigenpytorch`` mode see: http://pytorch.org/docs/master/torch.html#torch.eig """ def reconstruction(ncomp, U, S, V, var=1): if mode == 'lapack': rec_matrix = np.dot(U[:, :ncomp], np.dot(np.diag(S[:ncomp]), V[:ncomp])) rec_matrix = rec_matrix.T print(' Matrix reconstruction with {} PCs:'.format(ncomp)) print(' Mean Absolute Error =', MAE(matrix, rec_matrix)) print(' Mean Squared Error =', MSE(matrix, rec_matrix)) # see https://github.com/scikit-learn/scikit-learn/blob/c3980bcbabd9d2527548820581725df2904e4a0d/sklearn/decomposition/pca.py exp_var = (S**2) / (S.shape[0] - 1) full_var = np.sum(exp_var) explained_variance_ratio = exp_var / full_var # % of variance explained by each PC ratio_cumsum = np.cumsum(explained_variance_ratio) elif mode == 'eigen': exp_var = (S**2) / (S.shape[0] - 1) full_var = np.sum(exp_var) explained_variance_ratio = exp_var / full_var # % of variance explained by each PC ratio_cumsum = np.cumsum(explained_variance_ratio) else: rec_matrix = np.dot(U, np.dot(np.diag(S), V)) print(' Matrix reconstruction MAE =', MAE(matrix, rec_matrix)) exp_var = (S**2) / (S.shape[0] - 1) full_var = np.var(matrix, axis=0).sum() explained_variance_ratio = exp_var / full_var # % of variance explained by each PC if var == 1: pass else: explained_variance_ratio = explained_variance_ratio[::-1] ratio_cumsum = np.cumsum(explained_variance_ratio) msg = ' This info makes sense when the matrix is mean centered ' msg += '(temp-mean scaling)' print(msg) lw = 2 alpha = 0.4 fig = plt.figure(figsize=vip_figsize) fig.subplots_adjust(wspace=0.4) ax1 = plt.subplot2grid((1, 3), (0, 0), colspan=2) ax1.step(range(explained_variance_ratio.shape[0]), explained_variance_ratio, alpha=alpha, where='mid', label='Individual EVR', lw=lw) ax1.plot(ratio_cumsum, '.-', alpha=alpha, label='Cumulative EVR', lw=lw) ax1.legend(loc='best', frameon=False, fontsize='medium') ax1.set_ylabel('Explained variance ratio (EVR)') ax1.set_xlabel('Principal components') ax1.grid(linestyle='solid', alpha=0.2) ax1.set_xlim(-10, explained_variance_ratio.shape[0] + 10) ax1.set_ylim(0, 1) trunc = 20 ax2 = plt.subplot2grid((1, 3), (0, 2), colspan=1) # plt.setp(ax2.get_yticklabels(), visible=False) ax2.step(range(trunc), explained_variance_ratio[:trunc], alpha=alpha, where='mid', lw=lw) ax2.plot(ratio_cumsum[:trunc], '.-', alpha=alpha, lw=lw) ax2.set_xlabel('Principal components') ax2.grid(linestyle='solid', alpha=0.2) ax2.set_xlim(-2, trunc + 2) ax2.set_ylim(0, 1) msg = ' Cumulative explained variance ratio for {} PCs = {:.5f}' # plt.savefig('figure.pdf', dpi=300, bbox_inches='tight') print(msg.format(ncomp, ratio_cumsum[ncomp - 1])) # -------------------------------------------------------------------------- if matrix.ndim != 2: raise TypeError('Input matrix is not a 2d array') if usv: if mode not in ('lapack', 'arpack', 'randsvd', 'cupy', 'randcupy', 'pytorch', 'randpytorch'): msg = "Returning USV is supported with modes lapack, arpack, " msg += "randsvd, cupy, randcupy, pytorch or randpytorch" raise ValueError(msg) if ncomp > min(matrix.shape[0], matrix.shape[1]): msg = '{} PCs cannot be obtained from a matrix with size [{},{}].' msg += ' Increase the size of the patches or request less PCs' raise RuntimeError(msg.format(ncomp, matrix.shape[0], matrix.shape[1])) if mode == 'eigen': # building the covariance as np.dot(matrix.T,matrix) is slower and takes more memory C = np.dot(matrix, matrix.T) # covariance matrix e, EV = linalg.eigh(C) # eigenvalues and eigenvectors pc = np.dot(EV.T, matrix) # PCs using a compact trick when cov is MM' V = pc[::-1] # reverse since last eigenvectors are the ones we want S = np.sqrt(e)[:: -1] # reverse since eigenvalues are in increasing order if debug: reconstruction(ncomp, None, S, None) for i in range(V.shape[1]): V[:, i] /= S # scaling by the square root of eigenvalues V = V[:ncomp] if verbose: print('Done PCA with numpy linalg eigh functions') elif mode == 'lapack': # n_frames is usually smaller than n_pixels. In this setting taking the SVD of M' # and keeping the left (transposed) SVs is faster than taking the SVD of M (right SVs) U, S, V = linalg.svd(matrix.T, full_matrices=False) if debug: reconstruction(ncomp, U, S, V) V = V[:ncomp] # we cut projection matrix according to the # of PCs U = U[:, :ncomp] S = S[:ncomp] if verbose: print('Done SVD/PCA with numpy SVD (LAPACK)') elif mode == 'arpack': U, S, V = svds(matrix, k=ncomp) if debug: reconstruction(ncomp, U, S, V, -1) if verbose: print('Done SVD/PCA with scipy sparse SVD (ARPACK)') elif mode == 'randsvd': U, S, V = randomized_svd(matrix, n_components=ncomp, n_iter=2, transpose='auto', random_state=random_state) if debug: reconstruction(ncomp, U, S, V) if verbose: print('Done SVD/PCA with randomized SVD') elif mode == 'cupy': if no_cupy: raise RuntimeError('Cupy is not installed') a_gpu = cupy.array(matrix) a_gpu = cupy.asarray(a_gpu) # move the data to the current device u_gpu, s_gpu, vh_gpu = cupy.linalg.svd(a_gpu, full_matrices=True, compute_uv=True) V = vh_gpu[:ncomp] if to_numpy: V = cupy.asnumpy(V) if usv: S = s_gpu[:ncomp] if to_numpy: S = cupy.asnumpy(S) U = u_gpu[:, :ncomp] if to_numpy: U = cupy.asnumpy(U) if verbose: print('Done SVD/PCA with cupy (GPU)') elif mode == 'randcupy': if no_cupy: raise RuntimeError('Cupy is not installed') U, S, V = randomized_svd_gpu(matrix, ncomp, n_iter=2, lib='cupy') if to_numpy: V = cupy.asnumpy(V) S = cupy.asnumpy(S) U = cupy.asnumpy(U) if debug: reconstruction(ncomp, U, S, V) if verbose: print('Done randomized SVD/PCA with cupy (GPU)') elif mode == 'eigencupy': if no_cupy: raise RuntimeError('Cupy is not installed') a_gpu = cupy.array(matrix) a_gpu = cupy.asarray(a_gpu) # move the data to the current device C = cupy.dot(a_gpu, a_gpu.T) # covariance matrix e, EV = cupy.linalg.eigh(C) # eigenvalues and eigenvectors pc = cupy.dot(EV.T, a_gpu) # PCs using a compact trick when cov is MM' V = pc[::-1] # reverse since last eigenvectors are the ones we want S = cupy.sqrt( e)[::-1] # reverse since eigenvalues are in increasing order if debug: reconstruction(ncomp, None, S, None) for i in range(V.shape[1]): V[:, i] /= S # scaling by the square root of eigenvalues V = V[:ncomp] if to_numpy: V = cupy.asnumpy(V) if verbose: print('Done PCA with cupy eigh function (GPU)') elif mode == 'pytorch': if no_torch: raise RuntimeError('Pytorch is not installed') a_gpu = torch.Tensor.cuda(torch.from_numpy(matrix.astype('float32').T)) u_gpu, s_gpu, vh_gpu = torch.svd(a_gpu) V = vh_gpu[:ncomp] S = s_gpu[:ncomp] U = torch.transpose(u_gpu, 0, 1)[:ncomp] if to_numpy: V = np.array(V) S = np.array(S) U = np.array(U) if verbose: print('Done SVD/PCA with pytorch (GPU)') elif mode == 'eigenpytorch': if no_torch: raise RuntimeError('Pytorch is not installed') a_gpu = torch.Tensor.cuda(torch.from_numpy(matrix.astype('float32'))) C = torch.mm(a_gpu, torch.transpose(a_gpu, 0, 1)) e, EV = torch.eig(C, eigenvectors=True) V = torch.mm(torch.transpose(EV, 0, 1), a_gpu) S = torch.sqrt(e[:, 0]) if debug: reconstruction(ncomp, None, S, None) for i in range(V.shape[1]): V[:, i] /= S V = V[:ncomp] if to_numpy: V = np.array(V) if verbose: print('Done PCA with pytorch eig function') elif mode == 'randpytorch': if no_torch: raise RuntimeError('Pytorch is not installed') U, S, V = randomized_svd_gpu(matrix, ncomp, n_iter=2, lib='pytorch') if to_numpy: V = np.array(V) S = np.array(S) U = np.array(U) if debug: reconstruction(ncomp, U, S, V) if verbose: print('Done randomized SVD/PCA with randomized pytorch (GPU)') else: raise ValueError('The SVD mode is not available') if usv: if mode == 'lapack': return V.T, S, U.T elif mode == 'pytorch': if to_numpy: return V.T, S, U.T else: return torch.transpose(V, 0, 1), S, torch.transpose(U, 0, 1) else: return U, S, V else: if mode == 'lapack': return U.T elif mode == 'pytorch': return U else: return V
-0.0000000, 0.0000000, 0.0000000, -0.0000000, 1.0000000, -0.0000000, -0.0000000 ], [ 0.0384056, 0.3861388, 0.2684382, 0.2097269, -0.0000000, 1.0000000, 0.1817599 ], [ 0.0384056, 0.3861388, -0.2684382, 0.2097269, -0.0000000, 0.1817599, 1.0000000 ]] w, v = LA.eig(mat) print(w) print_mat(v) w, v = LA.eigh(mat) print(w) print_mat(v) for i in range(len(w)): print(w[i]) print(v[i]) w, v = LA.eigh(mat) for i in range(len(w)): print(w[i]) print(v[i]) v2 = np.transpose(v) vv = np.matmul(v2, v) print_mat(vv) w3, v3 = LA.eig(vv) print(w3) print_mat(v3)
def getPCAVideo(I): ICov = I.dot(I.T) [lam, V] = linalg.eigh(ICov) lam[lam < 0] = 0 V = V * np.sqrt(lam[None, :]) return V
def AF_MUSIC2D(self, focusing_freq=-1, signals=1, xrange=(-50, 50), yrange=(-50, 50), xstep=False, ystep=False, colormap="gist_heat", shw=True, block_run=True, no_fig=False, chunks=10): """Displays a heatmap for visual inspection of AF-MUSIC-based location estimation. Generates a grid of provided dimension/resolution, and evaluates the AF-MUSIC algorithm at each point on the grid. Arguments: focusing_freq (float): The frequency (in Hz) at which to perform the calculation. If <0, will default to 0.9*(spatial Nyquist frequency) signals (int): The number of signals to locate. xrange (float, float): The lower and upper bound in the x-direction. yrange (float, float): The lower and upper bound in the y-direction. xstep (float): If given, determines the size of the steps in the x-direction. Otherwise defaults to 1000 steps. ystep (float): If given, determines the size of the steps in the y-direction. Otherwise defaults to 1000 steps. colormap (str): The colour map for the heatmap. See https://matplotlib.org/examples/color/colormaps_reference.html shw (bool): If False, return the axis object rather than display. block_run (bool): Pause execution of the file while the figure is open? Set to True for running in the command-line. no_fig (bool): If True, return the heatmap grid rather than plot it. Returns: np.array: Returns EITHER the current (filled) heatmap domain if no_fig == True, OR a handle to the displayed figure. """ raise NotImplementedError self.dataFFT = fft_pack.rfft(self.data, axis=0).T self.numbins = self.dataFFT.shape[1] pos = fft_pack.rfftfreq(self.data.shape[0]) * self.sample_rate if focusing_freq < 0: focusing_freq = self.spatial_nyquist_freq * 0.45 # focusing_freq = pos[np.argmax(self.dataFFT[0, :])] else: focusing_freq = 1000 idxs = np.array(np.arange(pos.shape[0])) refidx = np.argmin(abs(pos - focusing_freq)) Rcoh = np.zeros((self.dataFFT.shape[0], self.dataFFT.shape[0]), dtype='complex128') ul, self.Uf0 = la.eigh( dot(self.dataFFT[:, refidx:refidx + 1], self.dataFFT[:, refidx:refidx + 1].conj().T) / self.dataFFT.shape[0]) ul = ul.real self.Uf0 = self.Uf0[:, argsort(abs(ul))[::-1]] pool = Pool(processes=7) res = pool.map(self._UfitoRyy_, idxs) pool.close() for r in res: Rcoh += r if xstep and ystep: xdom = np.linspace(start=xrange[0], stop=xrange[1], num=int((xrange[1] - xrange[0]) // xstep)) ydom = np.linspace(start=yrange[0], stop=yrange[1], num=int((yrange[1] - yrange[0]) // ystep)) else: xdom = np.linspace(start=xrange[0], stop=xrange[1], num=1000) ydom = np.linspace(start=yrange[0], stop=yrange[1], num=1000) self._hm_domain_ = np.zeros((len(ydom), len(xdom))) xdom, ydom = np.meshgrid(xdom, ydom) self._hm_domain_ = self._MUSIC2D_((pos[refidx], refidx), xdom, ydom, numsignals=signals, SI=Rcoh) if no_fig: return self._hm_domain_ f = plt.figure() plt.imshow(self._hm_domain_, cmap=colormap, interpolation='none', origin='lower', extent=[xrange[0], xrange[1], yrange[0], yrange[1]]) plt.colorbar() plt.xlabel("Horiz. Dist. from Center of Array [m]") plt.ylabel("Vert. Dist. from Center of Array [m]") if shw: plt.show(block=block_run) return else: return f
# Do global fit on all data pg_1step = get_params_global(data) print " Parameters from 1 step global fitting (D0, K0, D1, K1)=\n",\ pg_1step # Likelihood of fits p1 = lnlike(pg_1step, data) p2 = lnlike(pg_2step, data) print " Likelihood for fits: 2step=", p2, " 1step=", p1 # Evaluate Hessian by FD FDH = FD_Hessian(lnlike, pg_2step, fcnargs=[data]) print "Hesssian: ", FDH Hinv = LA.inv(FDH) evals, evecs = LA.eigh(Hinv) print "evals:", evals print "evecs:", evecs samples = np.random.multivariate_normal(pg_2step, Hinv, 50000) fig = triangle.corner(samples, labels=["D0", "K0", "D1", "K1"]) plt.savefig("triangle_Hinv.png") plt.close() # Now reweight the samples taking into account the likelihood of exp. 3 F0 = np.zeros(len(samples)) F1 = np.zeros(len(samples)) w = np.zeros(len(samples)) #from scipy.stats import multivariate_normal #NOS = len(samples) #i = 0
def mmr_multic_label(ilabmode,Y,X,kk,lpar): ## It labels the outputs for multiclass classification ## Input: ilabmode labeling mode ## =0 indicators ## =1 class mean ## =2 class median ## =3 tetrahedron ## =31 weighted simplex ## Y output categories ## column vector with components =1,...,kk ## X corresponding input vectors, ## the rows contain the input vectors ## kk number of possible categories ## lpar optional parameter used by method 31 ## Output: YL label vectors in its rows to all sample items ## Y0 all possible labels, it has kk rows and in the rows the ## possible labels ## number of items and input dimension (m,nx)=X.shape if ilabmode==0: ## the indicator case for multiclass learning Y0=eye(kk) ## setting the label vectors YL=zeros((m,kk)) for i in range(m): YL[i,Y[i]]=1 elif ilabmode==1: ## class mean Y0=zeros((kk,nx)) xmm=zeros((kk,nx)) xnn=zeros(kk) for i in range(m): iy=Y[i] xmm[iy,:]=xmm[iy,:]+X[i,:] xnn[iy]+=1 for k in range(kk): if xnn[k]>0: Y0[k,:]=xmm[k,:]/xnn[k] YL=zeros((m,nx)) for i in range(m): YL[i,:]=Y0[Y[i],:] elif ilabmode==2: ## class median Y0=zeros((kk,nx)) for k in range(kk): inx=where(Y==k)[0] if len(inx)>0: xmm=median(X[inx,:],axis=0) Y0[k,:]=xmm/sqrt(sum(xmm**2)) YL=zeros((m,nx)) for i in range(m): YL[i,:]=Y0[Y[i],:] elif ilabmode==3: ## tetrahedron, minimum correlation Y0=eye(kk) Y0=Y0+Y0/(kk-1)-ones((kk,kk))/(kk-1) (S,U)=linalg.eigh(Y0) SS=dot(U,diag(sqrt(abs(S)))) ix=argmin(S) Y0=zeros((kk,kk-1)) j=0 for k in range(kk): if k!=ix: Y0[:,j]=SS[:,k] j+=1 YL=zeros((m,kk-1)) for i in range(m): YL[i,:]=Y0[Y[i],:] elif ilabmode==31: if kk>1: lpar=float(1)/(kk-1) else: lpar=1.0 Y0=(1+lpar)*eye(kk)-lpar*ones((kk,kk)) YL=zeros((m,kk)) for i in range(m): YL[i,:]=Y0[Y[i,0],:] else: pass return(YL,Y0)
def debug(coord1, coord2): natom = len(coord1) com1 = numpy.mean(coord1, 0) coord1 -= com1 com2 = numpy.mean(coord2, 0) coord2 -= com2 cormat = numpy.array([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]) for i in range(natom): cormat += numpy.outer(coord1[i], coord2[i]) #print cormat Fmat = [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]] Fmat[0][0] = cormat[0][0] + cormat[1][1] + cormat[2][2] Fmat[0][1] = cormat[1][2] - cormat[2][1] Fmat[0][2] = cormat[2][0] - cormat[0][2] Fmat[0][3] = cormat[0][1] - cormat[1][0] Fmat[1][1] = cormat[0][0] - cormat[1][1] - cormat[2][2] Fmat[1][2] = cormat[0][1] + cormat[1][0] Fmat[1][3] = cormat[0][2] + cormat[2][0] Fmat[2][2] = -cormat[0][0] + cormat[1][1] - cormat[2][2] Fmat[2][3] = cormat[1][2] + cormat[2][1] Fmat[3][3] = -cormat[0][0] - cormat[1][1] + cormat[2][2] for i in range(4): for j in range(i): Fmat[i][j] = Fmat[j][i] Fmat = numpy.array(Fmat) #print Fmat #print linalg.eigh(Fmat) (eigval, eigvec) = linalg.eigh(Fmat) #print eigvec[3] diag_error = numpy.dot(Fmat, eigvec[:, 3]) - eigval[3] * eigvec[:, 3] print diag_error quat = eigvec[:, 3] q0 = quat[0] q1 = quat[1] q2 = quat[2] q3 = quat[3] rot_mat = numpy.zeros((3, 3)) # Well, this format is used for atom coord as column, we need a transpose rot_mat[0][0] = q0**2 + q1**2 - q2**2 - q3**2 rot_mat[0][1] = 2.0 * (q1 * q2 - q0 * q3) rot_mat[0][2] = 2.0 * (q1 * q3 + q0 * q2) rot_mat[1][0] = 2.0 * (q1 * q2 + q0 * q3) rot_mat[1][1] = q0**2 - q1**2 + q2**2 - q3**2 rot_mat[1][2] = 2.0 * (q2 * q3 - q0 * q1) rot_mat[2][0] = 2.0 * (q1 * q3 - q0 * q2) rot_mat[2][1] = 2.0 * (q2 * q3 + q0 * q1) rot_mat[2][2] = q0**2 - q1**2 - q2**2 + q3**2 rot_mat = rot_mat.transpose() coord_rot = numpy.dot(coord1, rot_mat) print coord1 print coord2 print coord_rot print linalg.norm(coord1 - coord2) print linalg.norm(coord_rot - coord2)
G = snp_data.val K = G.dot(G.T) K /= K.diagonal().mean() else: K = snp_intersect.kernel(standardizer=standardizer, blocksize=blocksize) K /= K.diagonal().mean() t1 = time.time() print("done building kernel after %.4fs" % (t1 - t0)) if 0: print("computing Eigenvalue decomposition of K") t0 = time.time() S, U = la.eigh(K) t1 = time.time() print("done computing eigenvalue decomposition of kernel after %.4fs" % (t1 - t0)) if 1: print("running GWAS") t0 = time.time() if 1: #LMM with pre-built kernel K mygwas = GWAS(K=K, snps_K=None, snps_test=snp_intersect, phenotype=pheno, covariates=covariates, h2=None, interact_with_snp=None,
def wigner_distribution(x0, hess, masses, zero_threshold=1.0e-9, is_molecule=True): """ compute wigner distribution for quadratic potential. The hessian can have zero vibrational frequencies (translation and rotation) which whould result in a very broad wave packet along those zero modes. Therefore only the non-zero modes are transformed to the Wigner representation while the zero modes are constrained by delta functions: W(Q1,...,QN;P1,...,PN) ~ Prod(vib.modes i) exp(-Omega_i*Qi^2 - 1/Omega_i * Pi^2) *Prod(zero modes j) delta(Qj)*delta(Pj) Returns: ======== Aw, Bw """ # convert Hessian to mass-weighted coordinates hess_mwc = hess / np.sqrt(np.outer(masses, masses)) # mass weighted coordinates are now qi = sqrt(mi) dxi # compute eigen values of hess_mwc omega2, modes = la.eigh(hess_mwc) # modes that are zero within numerical accuracy zero_modes = np.where((omega2 < zero_threshold))[0] vib_modes = np.where((omega2 >= zero_threshold))[0] Nzero = len(zero_modes) if is_molecule == True: Nzero_expected = expected_zero_modes(x0, masses) if Nzero != Nzero_expected: print "WARNING: Expected %d modes with 0 frequency (translation + rotation) but got %d modes!" % ( Nzero_expected, Nzero) Ndim = len(masses) Aq = np.zeros(hess.shape) #, dtype=complex) Ap = np.zeros(hess.shape) #, dtype=complex) # vibrational modes Msq = np.sqrt(np.outer(masses, masses)) MsqInv = 1.0 / Msq Oi = np.sqrt(omega2[vib_modes]) Li = modes[:, vib_modes] print "Wigner distribution for vibrational modes" Oii = np.diag(Oi) OiiInv = np.diag(1.0 / Oi) Aq = 2 * np.dot(Li, np.dot(Oii, Li.transpose())) * Msq Ap = 2 * np.dot(Li, np.dot(OiiInv, Li.transpose())) * MsqInv # constrain zero modes by delta-functions # delta(Qi)*delta(Pi) ~ lim_(Oconstr->infty) exp(-Oconstr*(Qi^2 + Pi^2)) print "delta distribution for zero modes" Oconstr = 1.0e6 * np.eye(len(zero_modes)) # very large number, e.g. 1.0e10 Li = modes[:, zero_modes] Aq += np.dot(Li, np.dot(Oconstr, Li.transpose())) * Msq Ap += np.dot(Li, np.dot( Oconstr, Li.transpose())) * MsqInv * Msq.max() / MsqInv.max() Bq = np.dot(x0, Aq) Bp = np.zeros(x0.shape) Zo = np.zeros((Ndim, Ndim)) Aw = np.bmat([[Aq, Zo], [Zo, Ap]]) Aw = np.asarray(Aw) Bw = np.hstack([Bq, Bp]).transpose() return Aw, Bw
def sce(mu, N, k0, mg, k_step, wd, selection, ww): if selection == 1: k1 = np.arange(-np.pi, np.pi, k_step) k2 = 0. k3 = 1. * 0. mu_matrix = np.empty(shape=(0, 0)) for ii in range(N): mu_matrix = kronsum(mu_matrix, pm(0) * mu[ii]) kk = np.empty(shape=(1, 0)) for i, val in enumerate(k1): h1 = -(np.cos(k3) - 2. + np.cos(k1[i]) - np.cos(k0) - mg) * pm(1) - np.sin(k3) * pm(3) h3 = -pm(2) / (2. * 1j) - pm(1) / 2. h2 = pm(2) / (2. * 1j) - pm(1) / 2. H = tridiag(h1, h3, h2, N) H = H - mu_matrix hd = np.zeros((2 * N, 2 * N)) * 1j hd[0:2, 2 * N - 2:2 * N] = h2 * np.exp(+1j * k2) hd[2 * N - 2:2 * N, 0:2] = h3 * np.exp(-1j * k2) H = H + hd # print(H) # print('la') # print(LA.eig(pm(0))) w, U = LA.eigh( H ) # this calculates the eigen values aka energies of the system for given k_1 U = U[(w > -wd) & (w < wd), :] # print("la") # print(w) w = w[(w > -wd) & (w < wd)] if np.size(w) > 0: kk = np.append(kk, [[k1[i]]], 1) plt.plot(np.ones((np.size(w))) * k1[i], w, 'ko', markersize=0.8) plt.plot(k1[i], ww, 'ro', markersize=0.8) plt.plot(k1[i], -ww, 'ro', markersize=0.8) elif selection == 2: k3 = 0. k2 = 0. # mu=-3.*np.sin(np.pi*np.arange(0,N,1)/(N-1)) # mu=mu+np.max(-mu) # mu=np.ones((N,)) k1 = np.arange(-np.pi, np.pi, k_step) k2 = np.pi * 0. k3 = 0. deltam = np.empty(shape=(0, 0)) for ii in range(N): deltam = kronsum(deltam, pm(2) * 1j * 0.06) delta_up = deltam delta_down = delta_up.getH() delta_up = np.hstack( (np.zeros((2 * N, 2 * N)), delta_up) ) # this following three lines creates a block diagonal matrix one block is H and the other block is -H^t delta_down = np.hstack((delta_down, np.zeros((2 * N, 2 * N)))) delta_up = deltam delta_down = delta_up.getH() delta_up = np.hstack( (np.zeros((2 * N, 2 * N)), delta_up) ) # this following three lines creates a block diagonal matrix one block is H and the other block is -H^t delta_down = np.hstack((delta_down, np.zeros((2 * N, 2 * N)))) deltam = np.vstack((delta_up, delta_down)) mu_matrix = np.empty(shape=(0, 0)) for ii in range(N): mu_matrix = kronsum(mu_matrix, pm(0) * mu[ii]) for i, val in enumerate(k1): h1 = -(np.cos(k3) - 2. + np.cos(k1[i]) - np.cos(k0) - mg) * pm(1) - pm(3) * np.sin(k3) * pm(3) h3 = -pm(2) / (2. * 1j) - pm(1) / 2. h2 = pm(2) / (2. * 1j) - pm(1) / 2. H = tridiag(h1, h3, h2, N) H = H - mu_matrix hd = np.zeros((2 * N, 2 * N)) * 1j hd[0:2, int(2 * N - 2):2 * N] = h2 * np.exp(+1j * k2) hd[int(2 * N - 2):2 * N, 0:2] = h3 * np.exp(-1j * k2) H = H + hd h1m = -(np.cos(-k3) - 2. + np.cos(-k1[i]) - np.cos(k0) - mg) * pm(1) - pm(3) * np.sin(-k3) * pm(3) h3m = -pm(2) / (2. * 1j) - pm(1) / 2. h2m = pm(2) / (2. * 1j) - pm(1) / 2. Hm = tridiag(h1m, h3m, h2m, N) hdm = np.zeros((2 * N, 2 * N)) * 1j hdm[0:2, int(2 * N - 2):2 * N] = h2 * np.exp(-1j * k2) hdm[int(2 * N - 2):2 * N, 0:2] = h3 * np.exp(+1j * k2) Hm = Hm - mu_matrix + hdm h_up = np.hstack( (H, np.zeros((2 * N, 2 * N))) ) # this following three lines creates a block diagonal matrix one block is H and the other block is -H^t h_down = np.hstack((np.zeros((2 * N, 2 * N)), -np.transpose(Hm))) h_bog = np.vstack((h_up, h_down)) h_bog = deltam + h_bog w, U = LA.eigh(h_bog) wws = np.sqrt(ww**2 + 0.06**2) plt.plot(np.ones((np.size(w))) * k1[i] / np.pi, w, 'ko', markersize=0.3) plt.plot(k1[i], wws, 'ro', markersize=0.8) plt.plot(k1[i], -wws, 'ro', markersize=0.8) kk = 5 return kk
def network_deconvolution(mat, **kwargs): """Python implementation/translation of network deconvolution by MIT-KELLIS LAB. .. note:: code author:gidonro [Github username](https://github.com/gidonro/Network-Deconvolution) LICENSE: MIT-KELLIS LAB AUTHORS: Algorithm was programmed by Soheil Feizi. Paper authors are S. Feizi, D. Marbach, M. M?©dard and M. Kellis Python implementation: Gideon Rosenthal For more details, see the following paper: Network Deconvolution as a General Method to Distinguish Direct Dependencies over Networks By: Soheil Feizi, Daniel Marbach, Muriel Médard and Manolis Kellis Nature Biotechnology Args: mat (numpy.ndarray): matrix, if it is a square matrix, the program assumes it is a relevance matrix where mat(i,j) represents the similarity content between nodes i and j. Elements of matrix should be non-negative. beta (float): Scaling parameter, the program maps the largest absolute eigenvalue of the direct dependency matrix to beta. It should be between 0 and 1. alpha (float): fraction of edges of the observed dependency matrix to be kept in deconvolution process. control (int): if 0, displaying direct weights for observed interactions, if 1, displaying direct weights for both observed and non-observed interactions. Returns: numpy.ndarray: Output deconvolved matrix (direct dependency matrix). Its components represent direct edge weights of observed interactions. Choosing top direct interactions (a cut-off) depends on the application and is not implemented in this code. .. note:: To apply ND on regulatory networks, follow steps explained in Supplementary notes 1.4.1 and 2.1 and 2.3 of the paper. In this implementation, input matrices are made symmetric. """ alpha = kwargs.get('alpha', 1) beta = kwargs.get('beta', 0.99) control = kwargs.get('control', 0) # ToDO : ASSERTS try: assert beta < 1 or beta > 0 assert alpha <= 1 or alpha > 0 except AssertionError: raise ValueError("alpha must be in ]0, 1] and beta in [0, 1]") # Processing the input matrix, diagonal values are filtered np.fill_diagonal(mat, 0) # Thresholding the input matrix y = stat.mquantiles(mat[:], prob=[1 - alpha]) th = mat >= y mat_th = mat * th # Making the matrix symetric if already not mat_th = (mat_th + mat_th.T) / 2 # Eigen decomposition Dv, U = LA.eigh(mat_th) D = np.diag((Dv)) lam_n = np.abs(np.min(np.min(np.diag(D)), 0)) lam_p = np.abs(np.max(np.max(np.diag(D)), 0)) m1 = lam_p * (1 - beta) / beta m2 = lam_n * (1 + beta) / beta m = max(m1, m2) # network deconvolution for i in range(D.shape[0]): D[i, i] = (D[i, i]) / (m + D[i, i]) mat_new1 = np.dot(U, np.dot(D, LA.inv(U))) # Displying direct weights if control == 0: ind_edges = (mat_th > 0) * 1.0 ind_nonedges = (mat_th == 0) * 1.0 m1 = np.max(np.max(mat * ind_nonedges)) m2 = np.min(np.min(mat_new1)) mat_new2 = (mat_new1 + np.max(m1 - m2, 0)) * ind_edges + (mat * ind_nonedges) else: m2 = np.min(np.min(mat_new1)) mat_new2 = (mat_new1 + np.max(-m2, 0)) # linearly mapping the deconvolved matrix to be between 0 and 1 m1 = np.min(np.min(mat_new2)) m2 = np.max(np.max(mat_new2)) mat_nd = (mat_new2 - m1) / (m2 - m1) return mat_nd
def Heigenvectors(A): w, v = linalg.eigh(A) return w, transpose(v)
def feature_extraction(filename): #point_cloud = np.loadtxt(filename) orig_data = np.fromfile(filename, dtype=np.float32) point_cloud = orig_data.reshape((-1, 4)) new_ind = np.random.choice(point_cloud.shape[0], DOWN_SAMPLING) new_ind.sort() point_cloud = point_cloud[new_ind] features = np.zeros((NUM_FEATURES)) mod_cck = point_cloud.shape[0] # Histogram features features[0] = np.max(point_cloud[:, 3]) features[1] = np.mean(point_cloud[:, 3]) features[2] = np.var(point_cloud[:, 3]) l = np.max(point_cloud[:, 0]) - np.min(point_cloud[:, 0]) w = np.max(point_cloud[:, 1]) - np.min(point_cloud[:, 1]) h = np.max(point_cloud[:, 2]) - np.min(point_cloud[:, 2]) features[3] = l * w * h lalonde_features = np.zeros((DOWN_SAMPLING, 3)) # Lalonde features are computed here point_cloud = point_cloud[:, :3] # For each point in a component obtain the 20 nearest neighbors within radius 0.5m # perform eigen decomposition and normalize eigenvalues # Calculate L1 = d1, L2 = d1-d2, L3 = d2-d3, were d1>d2>d3 are eigen values tree = sklearn.neighbors.KDTree(point_cloud) for i in range(mod_cck): #print("Procssing point number {}".format(i)) dist, ind = tree.query([point_cloud[i]], k=21) dist = dist[0, 1:] ind = ind[0, 1:] ind = ind[(dist <= 0.5)[0]] if len(ind) > 0: ind = ind[0] cck = (point_cloud[ind, :]).transpose() cck[0, :] = cck[0, :] - np.mean(cck[0, :]) cck[1, :] = cck[1, :] - np.mean(cck[1, :]) cck[2, :] = cck[2, :] - np.mean(cck[2, :]) cck_trans = (cck).transpose() cov_mat = np.matmul(cck, cck_trans) / len(ind) e_vals, e_vecs = LA.eigh(cov_mat) d_mat = np.array([e_vals[2], e_vals[1], e_vals[0]]) dnorm = d_mat / np.sum(d_mat) l1 = dnorm[0] l2 = dnorm[0] - dnorm[1] l3 = dnorm[1] - dnorm[2] lalonde_features[i] = [l1, l2, l3] else: lalonde_features[i] = [0, 0, 0] # Calculate the normalized histogram with 4 bins for each Lalonde feature features[4] = sum(lalonde_features[:, 0] <= 0.25) / mod_cck features[5] = sum((lalonde_features[:, 0] > 0.25) & (lalonde_features[:, 0] <= 0.5)) / mod_cck features[6] = sum((lalonde_features[:, 0] > 0.5) & (lalonde_features[:, 0] <= 0.75)) / mod_cck features[7] = sum((lalonde_features[:, 0] > 0.75) & (lalonde_features[:, 0] <= 1)) / mod_cck features[8] = sum(lalonde_features[:, 1] <= 0.25) / mod_cck features[9] = sum((lalonde_features[:, 1] > 0.25) & (lalonde_features[:, 1] <= 0.5)) / mod_cck features[10] = sum((lalonde_features[:, 1] > 0.5) & (lalonde_features[:, 1] <= 0.75)) / mod_cck features[11] = sum((lalonde_features[:, 1] > 0.75) & (lalonde_features[:, 1] <= 1)) / mod_cck features[12] = sum(lalonde_features[:, 2] <= 0.25) / mod_cck features[13] = sum((lalonde_features[:, 2] > 0.25) & (lalonde_features[:, 2] <= 0.5)) / mod_cck features[14] = sum((lalonde_features[:, 2] > 0.5) & (lalonde_features[:, 2] <= 0.75)) / mod_cck features[15] = sum((lalonde_features[:, 2] > 0.75) & (lalonde_features[:, 2] <= 1)) / mod_cck # Anguelov features are computed here dist = sklearn.metrics.pairwise.pairwise_distances(point_cloud[:, :2]) print(np.shape(dist)) print(np.shape(point_cloud[:, :2])) # For each point, obtain a right cylindrical region on top of it with radius 0.1 and height 2 m # treat the point is in the lower axes of the cylinder. # Split the right circular region into 3 parts and calculate the sum of points in each part which # are the three Anguelov features A1, A2 and A3 anguelov_features = np.zeros((DOWN_SAMPLING, 3)) for pt in range(mod_cck): indexes_circ = np.where(dist[pt, :] < 0.1) z_values = point_cloud[indexes_circ[0], 2] height_diff = point_cloud[pt, 2] - z_values a1 = sum((height_diff >= 0) & (height_diff <= 0.6667)) / len(height_diff) a2 = sum((height_diff > 0.6667) & (height_diff <= 1.3334)) / len(height_diff) a3 = sum((height_diff > 1.3334) & (height_diff <= 2)) / len(height_diff) anguelov_features[pt] = [a1, a2, a3] # Calculate the normalized histogram with 4 bins for each Anguelov feature features[16] = sum(anguelov_features[:, 0] <= 0.25) / mod_cck features[17] = sum((anguelov_features[:, 0] > 0.25) & (anguelov_features[:, 0] <= 0.5)) / mod_cck features[18] = sum((anguelov_features[:, 0] > 0.5) & (anguelov_features[:, 0] <= 0.75)) / mod_cck features[19] = sum((anguelov_features[:, 0] > 0.75) & (anguelov_features[:, 0] <= 1)) / mod_cck features[20] = sum(anguelov_features[:, 1] <= 0.25) / mod_cck features[21] = sum((anguelov_features[:, 1] > 0.25) & (anguelov_features[:, 1] <= 0.5)) / mod_cck features[22] = sum((anguelov_features[:, 1] > 0.5) & (anguelov_features[:, 1] <= 0.75)) / mod_cck features[23] = sum((anguelov_features[:, 1] > 0.75) & (anguelov_features[:, 1] <= 1)) / mod_cck features[24] = sum(anguelov_features[:, 2] <= 0.25) / mod_cck features[25] = sum((anguelov_features[:, 2] > 0.25) & (anguelov_features[:, 2] <= 0.5)) / mod_cck features[26] = sum((anguelov_features[:, 2] > 0.5) & (anguelov_features[:, 2] <= 0.75)) / mod_cck features[27] = sum((anguelov_features[:, 2] > 0.75) & (anguelov_features[:, 2] <= 1)) / mod_cck return features
def mmr_normalization(ilocal,iscale,XTrain,XTest,ipar): ## function to normalize the input and the output data ## !!!! the localization happens before normalization if both given !!! ## input ## ilocal centralization ## =-1 no localization ## =0 mean ## =1 median ## =2 geometric median ## =3 shift by ipar ## =4 smallest enclosing ball ## =5 row mean row wise ## icenter ## =-1 no scaling ## =0 scale item wise by L2 norm ## =1 scale item wise by L1 norm ## =2 scale item wise by L_infty norm ## =3 scale items by stereographic projection relative to zero ## =4 scale variables by STD(standard deviation) ## =5 scale variables by MAD(median absolute deviation) ## =6 scale variables by absolute deviation ## =7 scale all variables by average STD ## =8 scale all variables by maximum STD ## =9 scale all variables by median MAD ## =10 scale item wise by Minkowski norm, power given by ipar ## =11 \sum_i||u-x_i||/m where u=0 ## =12 scale all variables by overall max ## =13 Mahalonobis scaling ## XTrain Data matrix which will be normalized. It assumed the ## rows are the sample vetors and the columns are variables ## XTest Data matrix which will be normalized. It assumed the ## rows are the sample vetors and the columns are ## variables. ## It herites the center and the scale in the variable wise ca## se from the XTrain, ## otherwise it is normalized independently ## ipar additional parameter ## output ## XTrain Data matrix which is the result of the normalization ## of input XTrain. It assumed the rows are the sample ## vetors and the columns are variables ## XTest Data matrix which is the result of the normalization ## of input XTest. It assumed the rows are the sample ## vetors and the columns are variables. ## opar the radius in case of ixnorm=2. ## if XTest is None: XTest=array([]) opar=0; (mtrain,n)=XTrain.shape if len(XTest.shape)>=2: mtest=XTest.shape[0] elif len(XTest.shape)==1: mtest=XTest.shape[0] XTest=XTest.reshape((1,mtest)) else: mtest=0 XTest=array([]) if ilocal==-1: pass elif ilocal==0: ## mean xcenter=mean(XTrain,axis=0) elif ilocal==1: ## median xcenter=median(XTrain,axis=0) elif ilocal==2: ## geometric median xcenter=mmr_geometricmedian(XTrain)[0] elif ilocal==3: ## shift by ipar xcenter=ipar elif ilocal==4: ## smallest comprising ball xalpha=mmr_outerball(0,XTrain) xcenter=dot(XTrain.T,xalpha) elif ilocal==5: ## row mean row wise xcenter=mean(XTrain,axis=1) if ilocal in (0,1,2,3,4): XTrain=XTrain-tile(xcenter,(mtrain,1)) if mtest>0: XTest=XTest-tile(xcenter,(mtest,1)) elif ilocal==5: XTrain=XTrain-outer(xcenter,ones(n)) if mtest>0: xcenter=mean(XTest,axis=1) XTest=XTest-outer(xcenter,ones(n)) ## itemwise normalizations if iscale==-1: pass elif iscale==0: ## scale items by L2 norm xscale_tra=sqrt(np_sum(XTrain**2,axis=1)) if mtest>0: xscale_tes=sqrt(np_sum(XTest**2,axis=1)) elif iscale==1: ## scale items by L1 norm xscale_tra=np_sum(abs(XTrain),axis=1) if mtest>0: xscale_tes=np_sum(abs(XTest),axis=1) elif iscale==2: ## scale items by L_infty norm xscale_tra=np_max(abs(XTrain),axis=1) if mtest>0: xscale_tes=np_max(abs(XTest),axis=1) elif iscale==10: ## scale items by Minowski with ipar xscale_tra=np_sum(abs(XTrain)**ipar,axis=1)**(1/ipar) if mtest>0: xscale_tes=np_sum(abs(XTest)**ipar,axis=1)**(1/ipar) if iscale in (0,1,2,10): xscale_tra=xscale_tra+(xscale_tra==0) XTrain=XTrain/tile(xscale_tra.reshape(mtrain,1),(1,n)) if mtest>0: xscale_tes=xscale_tes+(xscale_tes==0) XTest=XTest/tile(xscale_tes.reshape(mtest,1),(1,n)) if iscale==3: ## scale items by stereographic projection relative to zero xnorm2=np_sum(XTrain**2,axis=1) R=ipar xhom=ones(mtrain)/(xnorm2+R**2) xhom2=xnorm2-R**2 XTrain=concatenate((2*R**2*XTrain*outer(xhom,ones(n)),R*xhom2*xhom), \ axis=1) if mtest>0: xnorm2=np_sum(XTest**2,axis=1) xhom=ones(mtest)/(xnorm2+R**2) xhom2=xnorm2-R**2 XTest=concatenate((2*R**2*XTest*outer(xhom,ones(n)),R*xhom2*xhom), \ axis=1) ## variable wise normalization relative to zero ## test has to use of the training scale if iscale==-1: pass elif iscale==4: ## scale vars by std to zeros center xscale=std(XTrain,axis=0) ## xscale=sqrt(mean(XTrain**2,axis=0)) elif iscale==5: ## scale vars by mad xscale=median(abs(XTrain),axis=0) elif iscale==6: ## scale vars by absolut deviation xscale=mean(abs(XTrain),axis=0) if iscale in (4,5,6): xscale=xscale+(xscale==0) XTrain=XTrain/tile(xscale,(mtrain,1)) if mtest>0: XTest=XTest/tile(xscale,(mtest,1)) if iscale==-1: pass if iscale==7: ## scale vars by average std to zero center ## xscale=mean(std(XTrain,axis=0)) xscale=mean(sqrt(mean(XTrain**2,axis=0))) elif iscale==8: ## scale vars by max std to zero center ## xscale=np_max(std(XTrain,axis=0)) xscale=np_max(sqrt(mean(XTrain**2,axis=0))) elif iscale==9: ## scale vars by median mad xscale=median(median(abs(XTrain),axis=0)) elif iscale==11: ## \sum_i||u-x_i||/m where u=0 xscale=mean(sqrt(np_sum(XTrain**2,axis=1))) elif iscale==12: ## \sum_i||u-x_i||/m where u=0 xscale=XTrain.max() ## print(xscale) if iscale in (7,8,9,11,12): xscale=xscale+(xscale==0) XTrain=XTrain/xscale if mtest>0: XTest=XTest/xscale if iscale==13: ## scale by Mahalonobis xsigma=dot(XTrain.T,XTrain) ## covariance [w,v]=linalg.eigh(xsigma) iw=where(w<=10**(-10))[0] w[iw]=0.0 iw=where(w>0.0)[0] w_sqinv=zeros(XTrain.shape[1]) w_sqinv[iw]=1/sqrt(w[iw]) XTrain=dot(XTrain,v)*outer(ones(mtrain),w_sqinv) if mtest>0: XTest=dot(XTest,v)*outer(ones(mtest),w_sqinv) return(XTrain,XTest,opar)
def _solve_gs_preserve(self, A, f, mu, subsample_mapping, skip_gs=False): """ Code notes from Daniil Kitchaev ([email protected]) - 2018-09-10 This is a WORK IN PROGRESS based on Wenxuan's ground-state preservation fitting code. A, f, and mu as as in the other routines subsample mapping deals with the fact that weights change when fitting on a partial set (when figuring out mu) skin_gs gives the option of ignoring the constrained fitting part, which is helpful when figuring out mu In general, this code is really not production ready - the algorithm that serious numerical issues, and getting around them involved lots of fiddling with eigenvalue roundoffs, etc, as is commented below. There are also issues with the fact that constraints can be very difficult to satisfy, causing the solver to diverge (or just quit silently giving absurd results) - ths solution here appears to be to use MOSEK instead of cvxopt, and to iteratively remove constraints when they cause problems. Usually after cleaning up the data, everything can be fit though without removing constraints. At the end of the day, this algorithm seems to only be useful for niche applications because enforcing ground state preservation causes a giant bias in the fit and makes the error in E-above-hull highly correlated with the value of E-above-hull. The result is entropies are completely wrong, which is what you usually want out of a cluster expansion. So, use the code at your own risk. AFAIK, it works as described in Wenxuans paper, with various additions from me for numerical stability. It has not been extensively tested though or used in real projects due to the bias issue I described above. I think that unless the bias problem is resolved, this fitting scheme will not be of much practical use. """ if not subsample_mapping: assert A.shape[0] == self.feature_matrix.shape[0] subsample_mapping = {} for i in range(self.feature_matrix.shape[0]): subsample_mapping[i] = i from cvxopt import matrix from cvxopt import solvers from pymatgen.core.periodic_table import get_el_sp try: import mosek except: raise ValueError("GS preservation fitting is finicky and MOSEK solvers are typically required for numerical stability.") solvers.options['show_progress'] = False solvers.options['MOSEK'] = {mosek.dparam.check_convexity_rel_tol: 1e-6} ehull = list(self.e_above_hull_input) structure_index_at_hull = [i for (i,e) in enumerate(ehull) if e < 1e-5] reduce_composition_at_hull = [ self.structures[i].composition.element_composition.reduced_composition.element_composition for i in structure_index_at_hull] all_corr_in = np.array(self.feature_matrix) all_engr_in = np.array(self.normalized_energies) # Some structures can be degenerate in correlation space, even if they are distinct in reality. We can't # constrain their energies since as far as the CE is concerned, same correlation = same structure duplicated_correlation_set = [] for i in range(len(all_corr_in)): if i not in structure_index_at_hull: for j in structure_index_at_hull: if np.max(np.abs(all_corr_in[i] - all_corr_in[j])) < 1e-6: logging.info("Structure {} ({} - {}) has the same correlation as hull structure {} ({} {})".format(i, self.structures[i].composition.element_composition.reduced_formula, self.spacegroups[i], j, self.structures[j].composition.element_composition.reduced_formula, self.spacegroups[j])) duplicated_correlation_set.append(i) all_engr_in.shape = (len(all_engr_in), 1) f.shape = (f.shape[0], 1) # Adjust weights if subsample changed whats included and whats not weights_tmp = [] for i in range(A.shape[0]): weights_tmp.append(self.weights[subsample_mapping[i]]) subsample_mapping_inv = {} for i, j in subsample_mapping.items(): subsample_mapping_inv[j] = i for i in duplicated_correlation_set: if i in subsample_mapping_inv.keys(): weights_tmp[subsample_mapping_inv[i]] = 0 weight_vec = np.array(weights_tmp) weight_matrix = np.diag(weight_vec.transpose()) N_corr = A.shape[1] # Deal with roundoff error making P not positive semidefinite by using the SVD of A # At = USV* # At A = U S St Ut -> any negatives in S get squared # Unfortunately, this is usually not enough, so the next step is to explicitly add something small (1e-10) # to all eigenvalues so that eigenvalues close to zero are instead very slightly positive. # Otherwise, random numerical error makes the matrix not positive semidefinite, and the convex optimization # gets confused Aw = weight_matrix.dot(A) u, s, v = la.svd(Aw.transpose()) Ss = np.pad(np.diag(s), ((0, u.shape[0] - len(s)),(0,0)), mode='constant', constant_values=0) P_corr_part = 2 * u.dot((Ss.dot(Ss.transpose()))).dot(u.transpose()) P = np.lib.pad(P_corr_part, ((0, N_corr), (0, N_corr)), mode='constant', constant_values=0) P = 0.5 * (P + P.transpose()) ev, Q = la.eigh(P) Qi = la.inv(Q) P = Q.dot(np.diag(np.abs(ev)+1e-10)).dot(Qi) q_corr_part = -2 * ((weight_matrix.dot(A)).transpose()).dot(f) q_z_part = np.ones((N_corr, 1)) / mu q = np.concatenate((q_corr_part, q_z_part), axis=0) G_1 = np.concatenate((np.identity(N_corr), -np.identity(N_corr)), axis=1) G_2 = np.concatenate((-np.identity(N_corr), -np.identity(N_corr)), axis=1) G_3 = np.concatenate((G_1, G_2), axis=0) h_3 = np.zeros((2 * N_corr, 1)) # formulation is min 1/2 x'Px+ q'x s.t.: Gx<=h, Ax=b # P = 2 * A^T A # q = -2 * E^T A = q^T -> q = -2 * A^T E # See Wenxuan npjCompMat paper for derivation. All of the above mess is implementing this formula, plus dealing # with numerical issues with zero eigenvalues getting rounded off to something slightly negative init_vals = matrix(np.linalg.lstsq(self.feature_matrix, self.normalized_energies)[0]) input_entries = [] for s, e in zip(self.structures, self.energies): input_entries.append(PDEntry(s.composition.element_composition, e)) max_e = max(input_entries, key=lambda e: e.energy_per_atom).energy_per_atom + 1000 for el in self.ce.structure.composition.keys(): input_entries.append(PDEntry(Composition({el: 1}).element_composition, max_e)) pd_input = PhaseDiagram(input_entries) constraint_strings = [] # Uncomment to save various matrices for debugging purposes #np.save("A.npy", A) #np.save("f.npy", f) #np.save("w.npy", weight_vec) #np.save("P.npy", P) #np.save("q.npy", q) #np.save("G_noC.npy", G_3) #np.save("h_noC.npy", h_3) # The next part deals with adding constraints based on on-hull/off-hull compositions # Once again, there are numerical errors that arise when some structures are very close in correlation space # or in energy, such that the solver runs into either numerical issues or something else. The solution seems # to be to add constraints in batches, and try the increasingly constrained fit every once in a while. # When the fitting fails, roll back to find the problematic constraint and remove it. Usually there isnt more # than one or two bad constrains, and looking at them by hand is enough to figure out why they are causing # problems. BATCH_SIZE = int(np.sqrt(len(all_corr_in))) tot_constraints = 0 removed_constraints = 0 if not skip_gs: for i in range(len(all_corr_in)): if i not in structure_index_at_hull and i not in duplicated_correlation_set: reduced_comp = self.structures[i].composition.element_composition.reduced_composition.element_composition if reduced_comp in reduce_composition_at_hull: ## in hull composition hull_idx = reduce_composition_at_hull.index(reduced_comp) global_index = structure_index_at_hull[hull_idx] G_3_new_line = np.concatenate((all_corr_in[global_index] - all_corr_in[i], np.zeros((N_corr)))) G_3_new_line.shape = (1, 2 * N_corr) G_3 = np.concatenate((G_3, G_3_new_line), axis=0) small_error = np.array(-1e-3) # TODO: This tolerance is actually quite big, but it can be reduced as needed small_error.shape = (1, 1) h_3 = np.concatenate((h_3, small_error), axis=0) tot_constraints += 1 string = "{}|Added constraint from {}({} - {}) structure at hull comp".format(h_3.shape[0], reduced_comp, self.spacegroups[i], i) print(string) constraint_strings.append(string) else: # out of hull composition comp_now = self.structures[i].composition.element_composition.reduced_composition.element_composition decomposition_now = pd_input.get_decomposition(comp_now) new_vector = -1.0 * all_corr_in[i] for decompo_keys, decompo_values in decomposition_now.items(): reduced_decompo_keys = decompo_keys.composition.element_composition.reduced_composition.element_composition index_1 = reduce_composition_at_hull.index(reduced_decompo_keys) vertex_index_global = structure_index_at_hull[index_1] new_vector = new_vector + decompo_values * all_corr_in[vertex_index_global] G_3_new_line = np.concatenate((new_vector, np.zeros(N_corr))) G_3_new_line.shape = (1, 2 * N_corr) G_3 = np.concatenate((G_3, G_3_new_line), axis=0) small_error = np.array(-1e-3) small_error.shape = (1, 1) h_3 = np.concatenate((h_3, small_error), axis=0) tot_constraints += 1 string = "{}|Added constraint from {}({}) structure not at hull comp".format(h_3.shape[0], reduced_comp, i) print(string) constraint_strings.append(string) elif i in structure_index_at_hull: if self.structures[i].composition.element_composition.is_element: continue entries_new = [] for j in structure_index_at_hull: if not j == i: entries_new.append( PDEntry(self.structures[j].composition.element_composition, self.energies[j])) for el in self.ce.structure.composition.keys(): entries_new.append(PDEntry(Composition({el: 1}).element_composition, max(self.normalized_energies) + 1000)) pd_new = PhaseDiagram(entries_new) comp_now = self.structures[i].composition.element_composition.reduced_composition.element_composition decomposition_now = pd_new.get_decomposition(comp_now) new_vector = all_corr_in[i] abandon = False print("Constraining gs of {}({})".format(self.structures[i].composition, self.structures[i].composition)) for decompo_keys, decompo_values in decomposition_now.items(): reduced_decompo_keys = decompo_keys.composition.element_composition.reduced_composition.element_composition if not reduced_decompo_keys in reduce_composition_at_hull: abandon = True break index = reduce_composition_at_hull.index(reduced_decompo_keys) vertex_index_global = structure_index_at_hull[index] new_vector = new_vector - decompo_values * all_corr_in[vertex_index_global] if abandon: continue G_3_new_line = np.concatenate((new_vector, np.zeros(N_corr))) G_3_new_line.shape = (1, 2 * N_corr) G_3 = np.concatenate((G_3, G_3_new_line), axis=0) small_error = np.array(-1e-3) # TODO: Same tolerance as above small_error.shape = (1, 1) h_3 = np.concatenate((h_3, small_error), axis=0) tot_constraints += 1 string = "{}|Added constraint from {}({}) structure on hull, decomp".format(h_3.shape[0], comp_now, i) print(string) constraint_strings.append(string) if i % BATCH_SIZE == 0 or i == len(all_corr_in)-1: valid = False const_remove = 0 G_t = deepcopy(G_3) h_t = deepcopy(h_3) # Remove constraints until fit works while not valid: sol = solvers.qp(matrix(P), matrix(q), matrix(G_3), matrix(h_3), initvals=init_vals, solver='mosek') if sol['status'] == 'optimal': valid = True else: const_remove += 1 G_3 = G_t[:-1 * (const_remove),:] h_3 = h_t[:-1 * (const_remove)] removed_constraints += 1 if const_remove > 0: constraint_strings.append("{}|Removed".format(G_t.shape[0] - const_remove + 1)) # Add constraints back in one by one and remove if they cause problems for num_new in range(1, const_remove): G_new_line = G_t[-1 * (const_remove - num_new),:] h_new_line = h_t[-1 * (const_remove - num_new)] G_new_line.shape = (1, 2 * N_corr) h_new_line.shape = (1,1) G_3 = np.concatenate((G_3, G_new_line), axis=0) h_3 = np.concatenate((h_3, h_new_line), axis=0) sol = solvers.qp(matrix(P), matrix(q), matrix(G_3), matrix(h_3), initvals=init_vals, solver='mosek') removed_constraints -= 1 if sol['status'] != 'optimal': G_3 = G_3[:-1, :] h_3 = h_3[:-1] removed_constraints += 1 constraint_strings.append("{}|Removed".format(G_t.shape[0] - const_remove + num_new + 1)) # Uncomment for iterative saving matricex #np.save("G.npy", G_3) #np.save("h.npy", h_3) # Uncomment for debugging #np.save("G.npy", G_3) #np.save("h.npy", h_3) sol = solvers.qp(matrix(P), matrix(q), matrix(G_3), matrix(h_3), initvals=init_vals, solver='mosek') print("Final status: {}".format(sol['status'])) print("Mu: {}".format(mu)) print("Constrants: {}/{}".format(tot_constraints - removed_constraints, tot_constraints)) ecis = np.array(sol['x'])[:N_corr, 0] # Uncomment for some debugging info #print(ecis) #for string in constraint_strings: # print(string) return ecis
def _ladder_operators(basis, operator, sparsification=False, tol=1e-12, return_operators=True): # Alternative version of _ladder_operators(). basisA = basis # Liouvillian matrix between basisA and basisB. (L_A_B, basisB) = liouvillian_matrix(basisA, -operator, return_extended_basis=True) # The smallest basis that includes only operators from basisA and basisB. smallest_basisAB_opstrings = [os for os in basisA if os in basisB] smallest_basisAB = Basis(smallest_basisAB_opstrings) if len(smallest_basisAB) == 0: if return_operators: evecs_ladder_ops = [] else: evecs_ladder_ops = np.zeros((len(basisA), 0), dtype=complex) return (evecs_ladder_ops, np.zeros(0, dtype=complex)) # Find the relevant indices of operator strings in different bases. inds_os_AB_in_A = [] inds_os_AB_in_B = [] inds_os_notAB_in_A = [] inds_os_notAB_in_B = [] ind_os_B = 0 for os in basisB: if os in basisA: inds_os_AB_in_A.append(basisA.index(os)) inds_os_AB_in_B.append(ind_os_B) else: inds_os_notAB_in_B.append(ind_os_B) ind_os_B += 1 ind_os_A = 0 for os in basisA: if os not in basisB: inds_os_notAB_in_A.append(ind_os_A) ind_os_A += 1 # The full Liouvillian matrix. L = L_A_B #.toarray() # The original Liouvillian matrix projected into the smallest # basis made of operators in both basisA and basisB. # L_AB: A \intersect B -> A \intersect B L_AB = L[inds_os_AB_in_B, :] L_AB = L_AB[:, inds_os_AB_in_A].toarray() print('basisA = \n{}'.format(basisA)) print('basisB = \n{}'.format(basisB)) print('smallest_basisAB = \n{}'.format(smallest_basisAB)) if len(inds_os_notAB_in_B) > 0: # The Liouvillian matrix whose output is projected out of basisAB. # L_notAB: A \intersect B -> B/(A \intersect B) = B/A L_notAB = L[inds_os_notAB_in_B, :] L_notAB = L_notAB[:, inds_os_AB_in_A].toarray() # Perform SVD on the L_notAB to determine the right null vectors. # These are the vectors we care about: they stay in basisAB after # applying the Liouvillian matrix. (left_svecs, svals, right_svecsH) = nla.svd(L_notAB) inds_zero_svals = np.where(np.abs(svals) < tol)[0] print('inds_zero_svals = {}'.format(inds_zero_svals)) valid_vecs = np.conj(np.transpose(right_svecsH))[:, inds_zero_svals] print('svals = {}'.format(svals)) #print('valid_vecs = {}'.format(valid_vecs)) # The L_A matrix projected onto the valid vectors that stay in basisA. projected_L = np.dot(np.conj(np.transpose(valid_vecs)), np.dot(L_AB, valid_vecs)) else: projected_L = L_AB print('projected_L = {}'.format(projected_L)) check_hermitian = np.allclose(np.conj(np.transpose(projected_L))-projected_L, np.zeros(projected_L.shape)) print('projected_L is Hermitian: {}'.format(check_hermitian)) # Perform eigendecomposition on the projected L matrix. (evals, evecs) = nla.eigh(0.5*(projected_L + np.conj(np.transpose(projected_L)))) print('evals = {}'.format(evals)) #print('evecs = {}'.format(evecs)) # Find all of the positive eigenvalues that # come paired with a negative eigenvalue partner. inds_pos = np.where(np.logical_and(np.imag(evals) < tol, np.real(evals) > tol))[0] inds_pos_partnered = [] for ind_pos_ev in inds_pos: inds_neg_ev = np.where(np.abs(evals[ind_pos_ev] + evals) < tol)[0] if len(inds_neg_ev) > 0: inds_pos_partnered.append(ind_pos_ev) print('inds_pos = {}'.format(inds_pos)) print('inds_pos_partnered = {}'.format(inds_pos_partnered)) ladder_evals = np.real(evals[inds_pos_partnered]) if len(inds_os_notAB_in_B) > 0: ladder_evecsAB = np.dot(valid_vecs, evecs[:, inds_pos_partnered]) else: ladder_evecsAB = evecs[:, inds_pos_partnered] ladder_evecs = np.zeros((len(basisA), len(ladder_evals)), dtype=complex) ladder_evecs[inds_os_AB_in_A, :] = ladder_evecsAB # Post-process the eigenvalues and eigenvectors. inds_sort = np.argsort(ladder_evals) evals_ladder_ops = ladder_evals[inds_sort] evecs_ladder_ops = ladder_evecs[:, inds_sort] num_ladder_ops = len(evals_ladder_ops) if num_ladder_ops == 0: if return_operators: evecs_ladder_ops = [] return (evecs_ladder_ops, evals_ladder_ops) """ # Perform SVD on the Liouvillian matrix. (left_svecsB, svals, right_svecsAH) = nla.svd(L) right_svecsA = np.conj(np.transpose(right_svecsAH)) # Identify the degenerate positive singular values subspaces. degenerate_subspace_inds = [] degenerate_subspace_sval = [] visited_inds = set() for ind_sv in range(len(svals)): subspace_inds = [] inds_deg = np.where(np.logical_and(np.abs(svals[ind_sv]-svals) < tol, np.abs(svals) > tol))[0] for ind_deg in inds_deg: if ind_deg not in visited_inds: subspace_inds.append(ind_deg) visited_inds.add(ind_deg) if len(subspace_inds) > 0: degenerate_subspace_inds.append(subspace_inds) degenerate_subspace_sval.append(svals[ind_sv]) projector_B_to_A = np.zeros((len(basisA), len(basisB)), dtype=complex) for ind_os_b in range(len(basisB)): os_b = basisB.op_strings[ind_os_b] if os_b in basisA: ind_os_a = basisA.index(os_b) projector_B_to_A[ind_os_a, ind_os_b] = 1.0 projected_L = np.dot(projector_B_to_A, L) # For each degenerate subspace, project onto the right # singular vectors with singular value s and see if # the eigenvalues of the projected matrix are +/- s. # If they are, then the projection preserved the # singular vectors as eigenvectors of the projected # matrix. num_ladder_ops = 0 evecs_ladder_ops = [] evals_ladder_ops = [] for (subspace_inds, subspace_sval) in zip(degenerate_subspace_inds, degenerate_subspace_sval): if len(subspace_inds) > 1: right_vecs = right_svecsA[:, subspace_inds] subspace_L = np.dot(np.conj(np.transpose(right_vecs)), np.dot(projected_L, right_vecs)) (evals_sub, evecs_sub) = nla.eig(subspace_L) inds_eval_matches_sval = np.where(np.abs(evals_sub - subspace_sval) < tol)[0] inds_eval_matches_msval = np.where(np.abs(evals_sub + subspace_sval) < tol)[0] assert(len(inds_eval_matches_sval) == len(inds_eval_matches_msval)) if len(inds_eval_matches_sval) > 0: evals_ladder_ops.append(evals_sub[inds_eval_matches_sval]) evecs_ladder_ops.append(evecs_sub[inds_eval_matches_sval]) num_ladder_ops += len(inds_eval_matches_sval) if num_ladder_ops == 0: if return_operators: evecs_ladder_ops = [] else: evecs_ladder_ops = np.zeros((len(basisA), 0), dtype=complex) return (evecs_ladder_ops, np.zeros(0, dtype=complex)) evals_ladder_ops = np.concatenate(tuple(evals_ladder_ops)) evecs_ladder_ops = np.hstack(tuple(evecs_ladder_ops)) """ # Go through each degenerate subspace and sparsify the basis of that subspace. if sparsification: inds_sort = np.argsort(np.real(evals_ladder_ops)) evals_ladder_ops = evals_ladder_ops[inds_sort] evecs_ladder_ops = evecs_ladder_ops[:, inds_sort] ind_ev = 0 while ind_ev < len(evals_ladder_ops): inds_jump = np.where(np.abs(evals_ladder_ops[ind_ev:] - evals_ladder_ops[ind_ev]) > 1e-10)[0] if len(inds_jump) == 0: ind_jump = 0 else: ind_jump = inds_jump[0] inds_degenerate_eval = np.arange(ind_ev, ind_ev+ind_jump) if ind_jump > 1: evecs_ladder_ops[:,inds_degenerate_eval] = sparsify(evecs_ladder_ops[:,inds_degenerate_eval]) ind_ev += ind_jump else: ind_ev += 1 if not return_operators: return (evecs_ladder_ops, evals_ladder_ops) else: ladder_ops = [] if isinstance(basis, Basis): for ind_ev in range(num_ladder_ops): ladder_op = Operator(evecs_ladder_ops[:, ind_ev], basisA.op_strings) ladder_ops.append(ladder_op) #print('Ladder operators:') #for op in ladder_ops: # print(op) elif isinstance(basis, list) and isinstance(basis[0], Operator): raise NotImplementedError('A basis made of a list of Operators is not supported yet.') else: raise ValueError('Invalid basis of type: {}'.format(type(basis))) return (ladder_ops, evals_ladder_ops)
from math import * from pylab import plot, show from numpy import * from numpy.linalg import eigh A = array([[1, 2], [2, 4]]) print(A) print(eigh(A)) E = [] hbar = 6.6 * (10**-34) / (2 * pi) m_e = 9.1 * (10**-31) L = 5 * (10**-10) e = 1.6 * (10**-19) for i in range(1, 11): E.append(i * i * pi * pi * (hbar**2) / (2 * m_e * (L**2))) print(E) def V_x(x): return (10 * e * x / L) def Hphi(x, n, m): total = ((hbar**2) * (1 / (2 * m_e)) * ((n * pi / L)**2) * (sin(n * pi * x / L))) total += sin(n * pi * x / L) * V_x(x) total *= (2 / L) * sin(m * pi * x / L) return total
print("Degree Matrix: \n", Degree) # In[293]: print("4(d)") Lmatrix = Degree - Adjacency print("Laplace Matrix: \n", Lmatrix, "\n") # In[294]: print("4(d)") #Eigen values and Eigenvectors from numpy import linalg as LA evals, evecs = LA.eigh(Lmatrix) print("Eigenvalues of Laplace Matrix = \n", evals, "\n") print("Eigenvectors of Laplace Matrix = \n", evecs, "\n") # In[295]: print("4(d)") # Series plot of the smallest ten eigenvalues to determine the number of clusters plt.figure(figsize=(8, 6)) plt.scatter(np.arange(0, 9, 1), evals[0:9, ]) plt.xlabel('Sequence') plt.ylabel('Eigenvalue') plt.grid() plt.show()
def solve(self, regparam): """Re-trains KronRLS for the given regparam Parameters ---------- regparam : float, optional regularization parameter, regparam > 0 Notes ----- Computational complexity of re-training: m = n_samples1, n = n_samples2, d = n_features1, e = n_features2 O(ed^2 + de^2) Linear version (assumption: d < m, e < n) O(m^3 + n^3) Kernel version """ self.regparam = regparam if self.kernelmode: K1, K2 = self.K1, self.K2 #assert self.Y.shape == (self.K1.shape[0], self.K2.shape[0]), 'Y.shape!=(K1.shape[0],K2.shape[0]). Y.shape=='+str(Y.shape)+', K1.shape=='+str(self.K1.shape)+', K2.shape=='+str(self.K2.shape) if not self.trained: self.trained = True evals1, V = la.eigh(K1) evals1 = np.mat(evals1).T V = np.mat(V) self.evals1 = evals1 self.V = V evals2, U = la.eigh(K2) evals2 = np.mat(evals2).T U = np.mat(U) self.evals2 = evals2 self.U = U self.VTYU = V.T * self.Y * U newevals = 1. / (self.evals1 * self.evals2.T + regparam) self.A = np.multiply(self.VTYU, newevals) self.A = self.V * self.A * self.U.T self.A = np.asarray(self.A) label_row_inds, label_col_inds = np.unravel_index( np.arange(K1.shape[0] * K2.shape[0]), (K1.shape[0], K2.shape[0])) label_row_inds = np.array(label_row_inds, dtype=np.int32) label_col_inds = np.array(label_col_inds, dtype=np.int32) self.predictor = KernelPairwisePredictor(self.A.ravel(), label_row_inds, label_col_inds) else: X1, X2 = self.X1, self.X2 Y = self.Y.reshape((X1.shape[0], X2.shape[0]), order='F') if not self.trained: self.trained = True V, svals1, rsvecs1 = linalg.svd_economy_sized(X1) svals1 = np.mat(svals1) self.svals1 = svals1.T self.evals1 = np.multiply(self.svals1, self.svals1) self.V = V self.rsvecs1 = np.mat(rsvecs1) if X1.shape == X2.shape and (X1 == X2).all(): svals2, U, rsvecs2 = svals1, V, rsvecs1 else: U, svals2, rsvecs2 = linalg.svd_economy_sized(X2) svals2 = np.mat(svals2) self.svals2 = svals2.T self.evals2 = np.multiply(self.svals2, self.svals2) self.U = U self.rsvecs2 = np.mat(rsvecs2) self.VTYU = V.T * Y * U kronsvals = self.svals1 * self.svals2.T newevals = np.divide(kronsvals, np.multiply(kronsvals, kronsvals) + regparam) self.W = np.multiply(self.VTYU, newevals) self.W = self.rsvecs1.T * self.W * self.rsvecs2 self.predictor = LinearPairwisePredictor( np.array(self.W).ravel(order='F'))
def sorted_eig(m): evals, evects = eigh(m) sort_order = evals.argsort()[::-1] evals = np.sort(evals)[::-1] evects = evects[:, sort_order] return evals, evects
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()
ay = 2 for i in range(0, len(N)): Nx = N[i] #incrementing size of lattice Ny = N[i] #incrementing size of lattice coor = shps.square(Nx, Ny) #creating coordinate array NN = nbrs.NN_Arr(coor) #nearest neighbor array NNb = nbrs.Bound_Arr(coor) #boundary array H_sparse = spop.H0(coor, ax, ay, NN) #creating sparse hamiltonian start = time.time() #Time start for numpy H_dense = dpop.H0(coor, ax, ay, NN) #creating dense hamiltonian eigs, vecs = LA.eigh(H_dense) #diagonalizing end = time.time() #Time end for numpy t_dense[i] = end-start #append time taken to diagonalize start = time.time() #Time start for scipy H_sparse = spop.H0(coor, ax, ay, NN) #creating sparse hamiltonian num = int(H_sparse.shape[0]/2) #Number of eigenvalues and eigenvectors you want sigma = 0 #This is the eigenvalue we search around which = 'LM' #Largest magnitude eigenvalues spLA.eigsh(H_sparse, k = num, sigma = sigma, which = which) #diagonlizing end = time.time() #time end for scipy t_sparse[i] = end-start #append time to sparse time array
def write_op2(self, op2, op2_ascii, itable, date, is_mag_phase=False, endian='>'): #if self.nnodes != 9: #return import inspect frame = inspect.currentframe() call_frame = inspect.getouterframes(frame, 2) op2_ascii.write('%s.write_op2: %s\n' % (self.__class__.__name__, call_frame[1][3])) if itable == -1: self._write_table_header(op2, op2_ascii, date) itable = -3 #if isinstance(self.nonlinear_factor, float): #op2_format = '%sif' % (7 * self.ntimes) #raise NotImplementedError() #else: #op2_format = 'i21f' #s = Struct(op2_format) nnodes_expected = self.nnodes eids2 = self.element_node[:, 0] nodes = self.element_node[:, 1] eids3 = self.element_cid[:, 0] cids3 = self.element_cid[:, 1] # table 4 info #ntimes = self.data.shape[0] nnodes = self.data.shape[1] nelements = len(eids2) # 21 = 1 node, 3 principal, 6 components, 9 vectors, 2 p/ovm #ntotal = ((nnodes * 21) + 1) + (nelements * 4) ntotal = 4 + 21 * nnodes_expected #print('shape = %s' % str(self.data.shape)) assert nnodes > 1, nnodes assert self.ntimes == 1, self.ntimes device_code = self.device_code op2_ascii.write(' ntimes = %s\n' % self.ntimes) #fmt = '%2i %6f' #print('ntotal=%s' % (ntotal)) #assert ntotal == 193, ntotal struct1 = Struct(b(endian + 'ii4si')) struct2 = Struct(b(endian + 'i20f')) cen = b'GRID' for itime in range(self.ntimes): self._write_table_3(op2, op2_ascii, itable, itime) # record 4 header = [4, -4, 4, 4, 1, 4, 4, 0, 4, 4, ntotal, 4, 4 * ntotal] op2.write(pack('%ii' % len(header), *header)) op2_ascii.write('r4 [4, 0, 4]\n') op2_ascii.write('r4 [4, %s, 4]\n' % (itable - 1)) op2_ascii.write('r4 [4, %i, 4]\n' % (4 * ntotal)) oxx = self.data[itime, :, 0] oyy = self.data[itime, :, 1] ozz = self.data[itime, :, 2] txy = self.data[itime, :, 3] tyz = self.data[itime, :, 4] txz = self.data[itime, :, 5] o1 = self.data[itime, :, 6] o2 = self.data[itime, :, 7] o3 = self.data[itime, :, 8] ovm = self.data[itime, :, 9] p = (o1 + o2 + o3) / -3. #print('eids3', eids3) cnnodes = nnodes_expected + 1 for i, deid, node_id, doxx, doyy, dozz, dtxy, dtyz, dtxz, do1, do2, do3, dp, dovm in zip( count(), eids2, nodes, oxx, oyy, ozz, txy, tyz, txz, o1, o2, o3, p, ovm): #print(' eid =', deid, node_id) j = where(eids3 == deid)[0] assert len(j) > 0, j cid = cids3[j][0] A = [[doxx, dtxy, dtxz], [dtxy, doyy, dtyz], [dtxz, dtyz, dozz]] (Lambda, v) = eigh(A) # a hermitian matrix is a symmetric-real matrix #node_id, oxxi, txyi, o1i, v[0, 1], v[0, 2], v[0, 0], pi, ovmi, #'', oyyi, tyzi, o2i, v[1, 1], v[1, 2], v[1, 0], #'', ozzi, txzi, o3i, v[2, 1], v[2, 2], v[2, 0] #(grid_device, sxx, sxy, s1, a1, a2, a3, pressure, svm, #syy, syz, s2, b1, b2, b3, #szz, sxz, s3, c1, c2, c3) if i % cnnodes == 0: data = [ deid * 10 + self.device_code, cid, cen, nnodes_expected ] op2_ascii.write(' eid=%s cid=%s cen=%s nnodes = %s\n' % tuple(data)) op2.write(struct1.pack(*data) #pack(b'2i 4s i', *data) ) #else: op2_ascii.write(' nid=%i\n' % node_id) data = [ node_id, doxx, dtxy, do1, v[0, 1], v[0, 2], v[0, 0], dp, dovm, doyy, dtyz, do2, v[1, 1], v[1, 2], v[1, 0], dozz, dtxz, do3, v[2, 1], v[2, 2], v[2, 0], ] op2_ascii.write( ' oxx, txy, o1, v01, v02, v00, p, ovm = %s\n' % data[1:8]) op2_ascii.write( ' oyy, tyz, o2, v11, v12, v10 = %s\n' % data[8:14]) op2_ascii.write( ' ozz, txz, o3, v21, v22, v20 = %s\n' % data[14:]) op2.write(struct2.pack(*data)) i += 1 itable -= 2 header = [ 4 * ntotal, ] op2.write(pack('i', *header)) op2_ascii.write('footer = %s' % header) header = [ 4, itable, 4, 4, 1, 4, 4, 0, 4, ] op2.write(pack('%ii' % len(header), *header))
def sortedEigenValuesAndVectors(sigma): eigenValues, eigenVectors = LA.eigh(sigma) sorted_indices = np.argsort( eigenValues) #Returns the indices that would sort an array. return eigenValues[sorted_indices], eigenVectors[:, sorted_indices]
chan_3d1_3s1 = potential.load(2, 3, 'EM420new', '12010', 50, 'np') chan_3d1 = potential.load(2, 3, 'EM420new', '12210', 50, 'np') # Compute reference Hamiltonian hamiltonian_ref = _get_coupled_channel_hamiltonian( [chan_3s1, chan_3s1_3d1, chan_3d1_3s1, chan_3d1]) # Create coupled channel potential from channels c_potential = potential.CoupledPotential( [chan_3s1, chan_3s1_3d1, chan_3d1_3s1, chan_3d1]) # Compute alternate Hamiltonian hamiltonian_coupled = c_potential.with_weights() + c_potential.kinetic_energy() # Compute bound state eigenvalues ev_ref = np.amin(eigh(hamiltonian_ref)[0]) ev = np.amin(eigh(hamiltonian_coupled)[0]) # Print unevolved results print('Unevolved') print('E_ref = E_srg = {} MeV'.format(hbarc**2 / (2 * red_mass) * ev_ref)) print('E_alt = {} MeV\n'.format(hbarc**2 / (2 * red_mass) * ev)) # Set up SRG evolution v_mask = np.array([[0 for _ in range(len(c_potential.nodes))] for _ in range(len(c_potential.nodes))]) k_mask = np.array([[1 for _ in range(len(c_potential.nodes))] for _ in range(len(c_potential.nodes))]) srg_obj = srg.SRG(c_potential, v_mask, k_mask)
def write_f06(self, f06, header=None, page_stamp='PAGE %s', page_num=1, is_mag_phase=False, is_sort1=True): if header is None: header = [] nnodes, msg_temp = _get_f06_header_nnodes(self, is_mag_phase) # write the f06 ntimes = self.data.shape[0] eids2 = self.element_node[:, 0] nodes = self.element_node[:, 1] eids3 = self.element_cid[:, 0] cids3 = self.element_cid[:, 1] for itime in range(ntimes): dt = self._times[itime] header = _eigenvalue_header(self, header, itime, ntimes, dt) f06.write(''.join(header + msg_temp)) #print("self.data.shape=%s itime=%s ieids=%s" % (str(self.data.shape), itime, str(ieids))) oxx = self.data[itime, :, 0] oyy = self.data[itime, :, 1] ozz = self.data[itime, :, 2] txy = self.data[itime, :, 3] tyz = self.data[itime, :, 4] txz = self.data[itime, :, 5] o1 = self.data[itime, :, 6] o2 = self.data[itime, :, 7] o3 = self.data[itime, :, 8] ovm = self.data[itime, :, 9] p = (o1 + o2 + o3) / -3. cnnodes = nnodes + 1 for i, deid, node_id, doxx, doyy, dozz, dtxy, dtyz, dtxz, do1, do2, do3, dp, dovm in zip( count(), eids2, nodes, oxx, oyy, ozz, txy, tyz, txz, o1, o2, o3, p, ovm): j = where(eids3 == deid)[0] cid = cids3[j] A = [[doxx, dtxy, dtxz], [dtxy, doyy, dtyz], [dtxz, dtyz, dozz]] (Lambda, v) = eigh(A) # a hermitian matrix is a symmetric-real matrix # o1-max # o2-mid # o3-min assert do1 >= do2 >= do3, 'o1 >= o2 >= o3; eid=%s o1=%e o2=%e o3=%e' % ( deid, do1, do2, do3) [oxxi, oyyi, ozzi, txyi, tyzi, txzi, o1i, o2i, o3i, pi, ovmi] = write_floats_13e([ doxx, doyy, dozz, dtxy, dtyz, dtxz, do1, do2, do3, dp, dovm ]) if i % cnnodes == 0: f06.write('0 %8s %8iGRID CS %i GP\n' % (deid, cid, nnodes)) f06.write( '0 %8s X %-13s XY %-13s A %-13s LX%5.2f%5.2f%5.2f %-13s %s\n' ' %8s Y %-13s YZ %-13s B %-13s LY%5.2f%5.2f%5.2f\n' ' %8s Z %-13s ZX %-13s C %-13s LZ%5.2f%5.2f%5.2f\n' % ('CENTER', oxxi, txyi, o1i, v[0, 1], v[0, 2], v[0, 0], pi, ovmi, '', oyyi, tyzi, o2i, v[1, 1], v[1, 2], v[1, 0], '', ozzi, txzi, o3i, v[2, 1], v[2, 2], v[2, 0])) else: f06.write( '0 %8s X %-13s XY %-13s A %-13s LX%5.2f%5.2f%5.2f %-13s %s\n' ' %8s Y %-13s YZ %-13s B %-13s LY%5.2f%5.2f%5.2f\n' ' %8s Z %-13s ZX %-13s C %-13s LZ%5.2f%5.2f%5.2f\n' % (node_id, oxxi, txyi, o1i, v[0, 1], v[0, 2], v[0, 0], pi, ovmi, '', oyyi, tyzi, o2i, v[1, 1], v[1, 2], v[1, 0], '', ozzi, txzi, o3i, v[2, 1], v[2, 2], v[2, 0])) i += 1 f06.write(page_stamp % page_num) page_num += 1 return page_num - 1
def steady_state(lindblad, *, sparse=None, method="ed", rho0=None, **kwargs): r"""Computes the numerically exact steady-state of a lindblad master equation. The computation is performed either through the exact diagonalization of the hermitian :math:`L^\dagger L` matrix, or by means of an iterative solver (bicgstabl) targeting the solution of the non-hermitian system :math:`L\rho = 0` and :math:`\mathrm{Tr}[\rho] = 1`. Note that for systems with 7 or more sites it is usually computationally impossible to build the full lindblad operator and therefore only `iterative` will work. Note that for systems with hilbert spaces with dimensions above 40k, tol should be set to a lower value if the steady state has non-trivial correlations. Args: lindblad: The lindbladian encoding the master equation. sparse: Whever to use sparse matrices (default: False for ed, True for iterative) method: 'ed' (exact diagonalization) or 'iterative' (iterative bicgstabl) rho0: starting density matrix for the iterative diagonalization (default: None) kwargs...: additional kwargs passed to bicgstabl For full docs please consult SciPy documentation at https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.linalg.bicgstab.html Keyword Args: maxiter: maximum number of iterations for the iterative solver (default: None) tol: The precision for the calculation (default: 1e-05) callback: User-supplied function to call after each iteration. It is called as callback(xk), where xk is the current solution vector Returns: The steady-state density matrix. """ from numpy import sqrt, array if sparse is None: sparse = True M = lindblad.hilbert.physical.n_states if method == "ed": if not sparse: from numpy.linalg import eigh from warnings import warn warn( """For reasons unknown to me, using dense diagonalisation on this matrix results in very low precision of the resulting steady-state since the update to numpy 1.9. We suggest using sparse=True, however, if you wish not to, you have been warned. Your digits are your reponsability now.""") lind_mat = lindblad.to_dense() ldagl = lind_mat.H * lind_mat w, v = eigh(ldagl) else: from scipy.sparse.linalg import eigsh lind_mat = lindblad.to_sparse() ldagl = lind_mat.H * lind_mat w, v = eigsh(ldagl, which="SM", k=2) print("Minimum eigenvalue is: ", w[0]) rho = v[:, 0].reshape((M, M)) rho = rho / rho.trace() elif method == "iterative": # An extra row is added at the bottom of the therefore M^2+1 long array, # with the trace of the density matrix. This is needed to enforce the # trace-1 condition. L = lindblad.to_linear_operator(sparse=sparse, append_trace=True) # Initial density matrix ( + trace condition) Lrho_start = np.zeros((M**2 + 1), dtype=L.dtype) if rho0 is None: Lrho_start[0] = 1.0 Lrho_start[-1] = 1.0 else: Lrho_start[:-1] = rho0.reshape(-1) Lrho_start[-1] = rho0.trace() # Target residual (everything 0 and trace 1) Lrho_target = np.zeros((M**2 + 1), dtype=L.dtype) Lrho_target[-1] = 1.0 # Iterative solver print("Starting iterative solver...") res, info = bicgstab(L, Lrho_target, x0=Lrho_start, **kwargs) rho = res[:-1].reshape((M, M)) if info == 0: print("Converged trace is ", rho.trace()) elif info > 0: print("Failed to converge after ", info, " ( trace is ", rho.trace(), " )") elif info < 0: print("An error occured: ", info) else: raise ValueError("method must be 'ed' or 'iterative'") return rho
def layoutDisplay(self, display): nodes = [] edges = [] for visibles in display.visibles.itervalues(): for visible in visibles: if visible.isPath(): edges.append(visible) elif visible.parent is None: nodes.append(visible) n=len(nodes) if n > 1: # Build the adjacency matrix A = zeros((n, n)) for edge in edges: (pathStart, pathEnd) = edge.pathEndPoints() n1 = nodes.index(pathStart.rootVisible()) n2 = nodes.index(pathEnd.rootVisible()) if self.weightingFunction is None: weight = 1.0 else: weight = self.weightingFunction(edge) if edge.flowTo() is None or edge.flowTo(): A[n1, n2] = A[n1, n2] + weight if edge.flowFrom() is None or edge.flowFrom(): A[n2, n1] = A[n2, n1] + weight #print A.tolist() # This is equivalent to the MATLAB code from <http://mit.edu/lrv/www/elegans/>: # c=full((A+A')/2); # d=diag(sum(c)); # l=d-c; # b=sum(c.*sign(full(A-A')),2); # z=pinv(l)*b; # q=d^(-1/2)*l*d^(-1/2); # [vx,lambda]=eig(q); # x=d^(-1/2)*vx(:,2); # y=d^(-1/2)*vx(:,3); A_prime = A.T c = (A + A_prime) / 2.0 d = diag(c.sum(0)) l = mat(d - c) print c, d if display.viewDimensions == 2: z = zeros((n, 1)) else: b = (c * sign(A - A_prime)).sum(1).reshape(1, n) z = inner(pinv(l), b) d2 = mat(d**-0.5) d2[isinf(d2)] = 0 q = d2 * l * d2 eVec = eigh(q)[1] x = d2 * mat(eVec[:,1]) y = d2 * mat(eVec[:,2]) xMin, xMax = x.min(), x.max() xOff = (xMax + xMin) / 2.0 xSize = xMax - xMin if self.autoScale else 1.0 yMin, yMax = y.min(), y.max() yOff = (yMax + yMin) / 2.0 ySize = yMax - yMin if self.autoScale else 1.0 zMin, zMax = z.min(), z.max() zOff = (zMax + zMin) / 2.0 zSize = zMax - zMin if self.autoScale and zMax != zMin else 1.0 for i in range(n): nodes[i].setPosition((0.0 if xSize == 0 else (x[i,0] - xOff) / xSize * self.scaling[0], \ 0.0 if ySize == 0 else (y[i,0] - yOff) / ySize * self.scaling[1], \ 0.0 if zSize == 0 else (z[i,0] - zOff) / zSize * self.scaling[2]))
G = nx.grid_graph([5, 5]) n = 25 AM = nx.adjacency_matrix(G) NLM = (nx.normalized_laplacian_matrix(G)).todense() LM = (nx.laplacian_matrix(G)).todense() ''' Labels = [G.nodes[i]['club'] != 'Mr. Hi' for i in G.nodes()] plt.figure() plt.title("Data Labels") nx.draw(G, node_color=Labels ) plt.show() ''' #scipy.linalg.eigh(NLM,eigvals=1)#replace with this for speed NLMva, NLMve = LA.eigh(NLM) LMva, LMve = LA.eigh(LM) Fv = LMve[:, 1] xFv = [Fv.item(x) for x in range(n)] NFv = NLMve[:, 1] xNFv = [NFv.item(x) for x in range(n)] plt.figure() plt.title("Laplacian Eigenvalues") nx.draw(G, node_color=xFv) plt.show() plt.figure() plt.title("Normalized Laplacian Eigenvalues")
print("""\n Loading results from step 1 \n """) beta_file_name = output_dir + "beta.mat" mat = loadmat(beta_file_name) b_0 = mat['beta'] sigma_file_name = output_dir + "sigma.mat" mat = loadmat(sigma_file_name) sigma_eta = mat['sigma_eta'] omega_eps = mat['omega_eps'] res_y = y_data * 0 for j in range(m): res_y[:, :, j] = y_data[:, :, j] - np.dot(x_data, b_0[:, :, j]) inv_s = np.zeros(shape=(n_v, m, m)) for l in range(n_v): if m > 1: inv_s2 = inv(sigma_eta[l, :, :]+omega_eps[l, :, :]) w, v = eigh(np.squeeze(inv_s2)) w = np.real(w) w[w < 0] = 0 w_diag = np.diag(w ** (1 / 2)) inv_s_tp = np.dot(np.dot(v, w_diag), v.T) inv_s[l, :, :] = np.real(inv_s_tp) else: inv_s[l, :, :] = (sigma_eta[l, :, :]+omega_eps[l, :, :])**(-0.5) """++++++++++++++++++++++++++++++++++++""" print("""\n Threshold on the difference of images to get initial disease regions and effects\n""") y1 = y_data[np.nonzero(z == 1)[0], :, :] x1 = x_data[np.nonzero(z == 1)[0], :] n1 = int(sum(z)) res_y1 = res_y[np.nonzero(z == 1)[0], :, :] # threshold = np.percentile(np.squeeze(res_y1[:, :, 0]), 5, axis=1)