def __init__(self, pos, neg, k=5): self.k = k pos = pos.T neg = neg.T totals = pos.sum(axis=1) popular = numpy.argsort(totals, axis=0)[::-1, :][1 : 1 + k, :] popular = numpy.array(popular.T)[0] self.popular = popular pos = pos[popular, :].todense() neg = neg[popular, :].todense() self.posmu = pos.mean(axis=1) self.negmu = neg.mean(axis=1) p = pos - self.posmu n = neg - self.negmu self.pcov = p * p.T / p.shape[1] self.ncov = n * n.T / n.shape[1] self.pdet = dlinalg.det(self.pcov) self.ndet = dlinalg.det(self.ncov) assert self.pdet != 0 assert self.ndet != 0 self.picov = dlinalg.inv(self.pcov) self.nicov = dlinalg.inv(self.ncov)
def lnmixgaussian(x, params): """ NAME: lnmixgaussian PURPOSE: returns the log of a mixture of two two-dimensional gaussian INPUT: x - 2D point to evaluate the Gaussian at params - mean and variances ([mean_array,inverse variance matrix, mean_array, inverse variance, amp1]) OUTPUT: log N(mean,var) HISTORY: 2009-10-30 - Written - Bovy (NYU) """ return sc.log( params[4] / 2.0 / sc.pi * sc.sqrt(linalg.det(params[1])) * sc.exp(-0.5 * sc.dot(x - params[0], sc.dot(params[1], x - params[0]))) + (1.0 - params[4]) / 2.0 / sc.pi * sc.sqrt(linalg.det(params[3])) * sc.exp(-0.5 * sc.dot(x - params[2], sc.dot(params[3], x - params[2]))) )
def testQuaternion(): dtheta = 30.0 quat = Quaternion() print quat.q print quat.toRot() print det(quat.toRot()) figm = mlab.figure(bgcolor=(1,1,1)) for i in range(100): print quat.sampleUnif(0.5*np.pi) k,theta = quat.toAxisAngle() print theta*180.0/np.pi plotCosy(figm, quat.toRot()) figm = mlab.figure(bgcolor=(1,1,1)) for i in range(100): print quat.sample(dtheta) k,theta = quat.toAxisAngle() print theta*180.0/np.pi plotCosy(figm, quat.toRot()) figm1 = mlab.figure(bgcolor=(1,1,0.0)) for i in range(100): # sample rotation axis k = np.random.rand(3)-0.5 # sample uiniformly from +- 5 degrees theta = (np.asscalar(np.random.rand(1)) + dtheta - 0.5) *np.pi/180.0 # (np.a sscalar(np.random.rand(1))-0.5)*np.pi/(180.0/(2.0*dtheta)) print 'perturbation: {} theta={}'.format(k/norm(k),theta*180.0/np.pi) dR = RodriguesRotation(k/norm(k),theta) plotCosy(figm1, dR) mlab.show()
def LL(self,h,X=None,stack=True,REML=False): """ Computes the log-likelihood for a given heritability (h). If X==None, then the default X0t will be used. If X is set and stack=True, then X0t will be matrix concatenated with the input X. If stack is false, then X is used in place of X0t in the LL calculation. REML is computed by adding additional terms to the standard LL and can be computed by setting REML=True. """ if X is None: X = self.X0t elif stack: self.X0t_stack[:,(self.q)] = matrixMult(self.Kve.T,X)[:,0] X = self.X0t_stack n = float(self.N) q = float(X.shape[1]) beta,sigma,Q,XX_i,XX = self.getMLSoln(h,X) LL = n*np.log(2*np.pi) + np.log(h*self.Kva + (1.0-h)).sum() + n + n*np.log(1.0/n * Q) LL = -0.5 * LL if REML: LL_REML_part = q*np.log(2.0*np.pi*sigma) + np.log(det(matrixMult(X.T,X))) - np.log(det(XX)) LL = LL + 0.5*LL_REML_part LL = LL.sum() return LL,beta,sigma,XX_i
def __init__(self,n, dimz = 2, dimx = 3): self.n = n self.W = RS.normal(0,1, size = (dimx,dimz)) self.sigx = 0.000000000001#RS.normal(0,1) self.dimz = dimz self.dimx = dimx data = util.generate_data(n, self.W, self.sigx, dimx, dimz) self.observed = data[0] self.latent = data[1] self.prec = (1/self.sigx)*np.dot(self.W.transpose(), self.W) self.cov = np.linalg.inv(self.prec) ''' values for normalisation computation-- messy! ''' temp1 = (2*np.pi)**(dimz/2.0)*np.sqrt(det(self.cov)) temp2 = det(2*np.pi*self.sigx*np.identity(dimz)) self.pc_norm1 = temp1/temp2 temp3 = np.linalg.inv(np.dot(self.W.transpose(), self.W)) self.wtwinv = temp3 temp3 = np.dot(self.W, temp3) self.pc_norm2 = np.dot(temp3, self.W.transpose())
def find_best_rotation(q1, q2): """ This function calculates the best rotation between two srvfs using procustes rigid alignment :param q1: numpy ndarray of shape (2,M) of M samples :param q2: numpy ndarray of shape (2,M) of M samples :rtype: numpy ndarray :return q2new: optimal rotated q2 to q1 :return R: rotation matrix """ eps = finfo(double).eps n, T = q1.shape A = q1.dot(q2.T) U, s, V = svd(A) if (abs(det(U) * det(V) - 1) < 10 * eps): S = eye(n) else: S = eye(n) S[:, -1] = -S[:, -1] R = U.dot(S).dot(V.T) q2new = R.dot(q2) return (q2new, R)
def __init__(self,n, dimz = 2, dimx = 3): self.n = n self.W = RS.normal(0,1, size = (dimx,dimz)) self.sigx = 0.000000000001#RS.normal(0,1) self.dimz = dimz self.dimx = dimx data = self.generate_data(n) self.observed = data[0] #we keep this to test self.latent = data[1] self.prec = (1/self.sigx)*np.dot(self.W.transpose(), self.W) self.cov = np.linalg.inv(self.prec) ''' values for normalisation computation ''' temp1 = (2*np.pi)**(dimz/2.0)*np.sqrt(det(self.cov)) temp2 = det(2*np.pi*self.sigx*np.identity(dimz)) self.pc_norm1 = temp1/temp2 temp3 = np.linalg.inv(np.dot(self.W.transpose(), self.W)) self.wtwinv = temp3 temp3 = np.dot(self.W, temp3) self.pc_norm2 = np.dot(temp3, self.W.transpose()) ''' prior for n factors will be product of n priors~ N(0,I) ''' #I = np.identity(dimz) #product_priors = MVN(0, n*I) '''
def matrix_normal_density(X, M, U, V): """Sample from a matrix normal distribution""" norm = - 0.5*np.log(la.det(2*np.pi*U)) - 0.5*np.log(la.det(2*np.pi*V)) XM = X-M pptn = -0.5*np.trace( np.dot(la.solve(U,XM),la.solve(V,XM.T)) ) pdf = norm + pptn return pdf
def from_matrix44(self, aff): """ Convert a 4x4 matrix describing an affine transform into a 12-sized vector of natural affine parameters: translation, rotation, log-scale, pre-rotation (to allow for shearing when combined with non-unitary scales). In case the transform has a negative determinant, set the `_direct` attribute to False. """ vec12 = np.zeros((12,)) vec12[0:3] = aff[:3, 3] # Use SVD to find orthogonal and diagonal matrices such that # aff[0:3,0:3] == R*S*Q R, s, Q = spl.svd(aff[0:3, 0:3]) if spl.det(R) < 0: R = -R Q = -Q r = rotation_mat2vec(R) if spl.det(Q) < 0: Q = -Q self._direct = False q = rotation_mat2vec(Q) vec12[3:6] = r vec12[6:9] = np.log(np.maximum(s, TINY)) vec12[9:12] = q self._vec12 = vec12
def _update_precisions(self): """Update the variational distributions for the precisions""" if self.cvtype == 'spherical': self._a = 0.5 * self.n_features * np.sum(self._z, axis=0) for k in xrange(self.n_components): # XXX: how to avoid this huge temporary matrix in memory dif = (self._X - self._means[k]) self._b[k] = 1. d = np.sum(dif * dif, axis=1) self._b[k] += 0.5 * np.sum( self._z.T[k] * (d + self.n_features)) self._bound_prec[k] = ( 0.5 * self.n_features * ( digamma(self._a[k]) - np.log(self._b[k]))) self._precs = self._a / self._b elif self.cvtype == 'diag': for k in xrange(self.n_components): self._a[k].fill(1. + 0.5 * np.sum(self._z.T[k], axis=0)) ddif = (self._X - self._means[k]) # see comment above for d in xrange(self.n_features): self._b[k, d] = 1. dd = ddif.T[d] * ddif.T[d] self._b[k, d] += 0.5 * np.sum(self._z.T[k] * (dd + 1)) self._precs[k] = self._a[k] / self._b[k] self._bound_prec[k] = 0.5 * np.sum(digamma(self._a[k]) - np.log(self._b[k])) self._bound_prec[k] -= 0.5 * np.sum(self._precs[k]) elif self.cvtype == 'tied': self._a = 2 + self._X.shape[0] + self.n_features self._B = (self._X.shape[0] + 1) * np.identity(self.n_features) for i in xrange(self._X.shape[0]): for k in xrange(self.n_components): dif = self._X[i] - self._means[k] self._B += self._z[i, k] * np.dot(dif.reshape((-1, 1)), dif.reshape((1, -1))) self._B = linalg.pinv(self._B) self._precs = self._a * self._B self._detB = linalg.det(self._B) self._bound_prec = 0.5 * detlog_wishart( self._a, self._B, self._detB, self.n_features) self._bound_prec -= 0.5 * self._a * np.trace(self._B) elif self.cvtype == 'full': for k in xrange(self.n_components): T = np.sum(self._z.T[k]) self._a[k] = 2 + T + self.n_features self._B[k] = (T + 1) * np.identity(self.n_features) dx = self._X - self._means[k] self._B[k] += np.dot((self._z[:, k] * dx.T), dx) self._B[k] = linalg.inv(self._B[k]) self._precs[k] = self._a[k] * self._B[k] self._detB[k] = linalg.det(self._B[k]) self._bound_prec[k] = 0.5 * detlog_wishart(self._a[k], self._B[k], self._detB[k], self.n_features) self._bound_prec[k] -= 0.5 * self._a[k] * np.trace(self._B[k])
def KL_normal(m1, sigma1, m2, sigma2): """ Calculates the KL divergence between two normal distributions specified by N(``mu1``, ``sigma1``), N(``mu2``, ``sigma2``) """ return 1. / 2. * (math.log(det(sigma2) / det(sigma1)) - len(m1) + trace(mdot(inv(sigma2), sigma1)) + \ mdot((m2 - m1).T, inv(sigma2) , m2- m1))
def Matusita_kernel(cov_1, cov_2): p = np.shape(cov_1)[0] det_1 = la.det(cov_1) det_2 = la.det(cov_2) det_sum = la.det(cov_1 + cov_2) return ((2 ** (p/2.0)) * (det_1 ** 0.25) * (det_2 ** 0.25))/(det_sum ** 0.5)
def _ar_model_select(R, m, ne, p_range): """model order selection :Parameters: R : ndarray upper triangular mx from QR m : int state vector dimension ne : int number of bock equations of size m used in the estimation p_range : list list of model order to select from """ # inits p_max = max(p_range) p_len = len(p_range) sbc = N.zeros(p_len) fpe = N.zeros(p_len) ldp = N.zeros(p_len) np = N.zeros(p_len) np[-1] = m * p_max # get lower right triangle of R # # | R11 R12 | # R = | | # | 0 R22 | # R22 = R[np[-1]:np[-1] + m, :][:, np[-1]:np[-1] + m] invR22 = NL.inv(R22) Mp = N.dot(invR22, invR22.T) # model selection ldp[-1] = 2.0 * N.log(NL.det(R22)) for i in reversed(xrange(p_len)): np[i] = m * p_range[i] if p_range[i] < p_max: # downdated part of R Rp = R[np[i]:np[i] + m, :][:, np[-1]:np[-1] + m] # woodbury formular L = NL.cholesky(N.eye(m) + N.dot(N.dot(Rp, Mp), Rp.T), lower=True) Np = N.dot(N.dot(NL.inv(L), Rp), Mp) Mp = Mp - N.dot(Np.T, Np) ldp[i] = ldp[i + 1] + 2.0 * N.log(NL.det(L)) # selector metrics sbc[i] = ldp[i] / m - N.log(ne) * (ne - np[i]) / ne fpe[i] = ldp[i] / m - N.log(ne * (ne - np[i]) / (ne + np[i])) # return return sbc, fpe, ldp, np
def main1(): N = 4 # Число срезов во времени n = 1 r = 1 p = 1 m = 1 s = 2 q = 1 # Число точек плана solver = IMFSolver(n=n, r=r, p=p, m=m, s=s, N=N) theta = [1.0, 1.0] solver.set_Phi([[theta[0]]]) solver.set_diff_Phi_theta([[1.0]], 0) solver.set_diff_Phi_theta([[0.0]], 1) solver.set_Psi([[theta[1]]]) solver.set_diff_Psi_theta([[0.0]], 0) solver.set_diff_Psi_theta([[1.0]], 1) solver.set_Gamma([[1.0]]) solver.set_diff_Gamma_theta([[0.0]], 0) solver.set_diff_Gamma_theta([[0.0]], 1) solver.set_H([[1.0]]) solver.set_diff_H_theta([[0.0]], 0) solver.set_diff_H_theta([[0.0]], 1) solver.set_Q([[0.1]]) solver.set_diff_Q_theta([[0.0]], 0) solver.set_diff_Q_theta([[0.0]], 1) solver.set_R([[0.3]]) solver.set_diff_R_theta([[0.0]], 0) solver.set_diff_R_theta([[0.0]], 1) solver.set_x0([[0.0]]) solver.set_diff_x0_theta([[0.0]], 0) solver.set_diff_x0_theta([[0.0]], 1) solver.set_P0([[0.1]]) solver.set_diff_P0_theta([[0.0]], 0) solver.set_diff_P0_theta([[0.0]], 1) solver.set_u([[1.0]], 0) solver.set_u([[1.0]], 1) solver.set_u([[1.0]], 2) solver.set_u([[2.0]], 3) M = solver.get_inf_matrix() print "M" print M print "la.det(M) = ", la.det(M) print "-np.log(la.det(M)) = ", -np.log(la.det(M))
def give_me_an_array(A, B, C): output = np.zeros((2,2)) ### START YOUR CODE HERE ### output[0,0] = linalg.det(A+B.dot(linalg.inv(C))) output[0,1] = linalg.det(B-C.dot(linalg.inv(A))) output[1,0] = linalg.det(B-A.dot(linalg.inv(C))) output[1,1] = linalg.det(A+C.dot(linalg.inv(B))) #### END YOUR CODE HERE #### return output
def _update_precisions(self, X, z): """Update the variational distributions for the precisions""" n_features = X.shape[1] if self.covariance_type == 'spherical': self.dof_ = 0.5 * n_features * np.sum(z, axis=0) for k in xrange(self.n_components): # could be more memory efficient ? sq_diff = np.sum((X - self.means_[k]) ** 2, axis=1) self.scale_[k] = 1. self.scale_[k] += 0.5 * np.sum(z.T[k] * (sq_diff + n_features)) self.bound_prec_[k] = ( 0.5 * n_features * ( digamma(self.dof_[k]) - np.log(self.scale_[k]))) self.precs_ = np.tile(self.dof_ / self.scale_, [n_features, 1]).T elif self.covariance_type == 'diag': for k in xrange(self.n_components): self.dof_[k].fill(1. + 0.5 * np.sum(z.T[k], axis=0)) sq_diff = (X - self.means_[k]) ** 2 # see comment above self.scale_[k] = np.ones(n_features) + 0.5 * np.dot( z.T[k], (sq_diff + 1)) self.precs_[k] = self.dof_[k] / self.scale_[k] self.bound_prec_[k] = 0.5 * np.sum(digamma(self.dof_[k]) - np.log(self.scale_[k])) self.bound_prec_[k] -= 0.5 * np.sum(self.precs_[k]) elif self.covariance_type == 'tied': self.dof_ = 2 + X.shape[0] + n_features self.scale_ = (X.shape[0] + 1) * np.identity(n_features) for k in xrange(self.n_components): diff = X - self.means_[k] self.scale_ += np.dot(diff.T, z[:, k:k + 1] * diff) self.scale_ = linalg.pinv(self.scale_) self.precs_ = self.dof_ * self.scale_ self.det_scale_ = linalg.det(self.scale_) self.bound_prec_ = 0.5 * wishart_log_det( self.dof_, self.scale_, self.det_scale_, n_features) self.bound_prec_ -= 0.5 * self.dof_ * np.trace(self.scale_) elif self.covariance_type == 'full': for k in xrange(self.n_components): sum_resp = np.sum(z.T[k]) self.dof_[k] = 2 + sum_resp + n_features self.scale_[k] = (sum_resp + 1) * np.identity(n_features) diff = X - self.means_[k] self.scale_[k] += np.dot(diff.T, z[:, k:k + 1] * diff) self.scale_[k] = linalg.pinv(self.scale_[k]) self.precs_[k] = self.dof_[k] * self.scale_[k] self.det_scale_[k] = linalg.det(self.scale_[k]) self.bound_prec_[k] = 0.5 * wishart_log_det(self.dof_[k], self.scale_[k], self.det_scale_[k], n_features) self.bound_prec_[k] -= 0.5 * self.dof_[k] * np.trace( self.scale_[k])
def INsc1(A): X = np.copy(A) E = 0.5*(np.eye(A.shape[0])-A) dA = spl.det(A)**(0.5) for i in range (1,5): print i detX = spl.det(X) uk = np.abs(detX/dA)**(-1.0/i) Etk = (E + (0.5*X))/uk - (0.5)*uk*X X = uk*X + Etk print X E = (-0.5)*(Etk.dot(spl.inv(X))).dot(Etk) return X
def NWsc(M, object=False): X = np.copy(M) dM = spl.det(M)**(1.0/2) ras = result() for i in range(1,31): print i uk = np.abs(spl.det(X)/dM)**(-1.0/i) X = (0.5)*(uk*X + (uk**(-1))*spl.inv(X).dot(M)) print spl.norm(X.dot(X)-M)/spl.norm(M) ras.res.append((spl.norm(X.dot(X)-M)/spl.norm(M))) ras.iter = i ras.ris = X return (ras if object else X)
def _produceSamples(self): """ Append batchsize new samples and evaluate them. """ if self.numLearningSteps == 0 or not self.importanceMixing: for _ in range(self.batchSize): self._produceNewSample() self.allGenerated.append(self.batchSize + self.allGenerated[-1]) else: olds = len(self.allSamples) oldDetFactorSigma = det(self.allFactorSigmas[-2]) newDetFactorSigma = det(self.factorSigma) invA = inv(self.factorSigma) # All pdfs computed here are off by a coefficient of 1/power(2.0*pi, self.numDistrParams/2.) # but as only their relative values matter, we ignore it. # stochastically reuse old samples, according to the change in distribution for s in range(olds - self.batchSize, olds): oldPdf = exp(-0.5 * dot(self.allPs[s], self.allPs[s])) / oldDetFactorSigma sample = self.allSamples[s] newPs = dot(invA.T, (sample - self.x)) newPdf = exp(-0.5 * dot(newPs, newPs)) / newDetFactorSigma r = rand() if r < (1 - self.forcedRefresh) * newPdf / oldPdf: self.allSamples.append(sample) self.allFitnesses.append(self.allFitnesses[s]) self.allPs.append(newPs) # never use only old samples if (olds + self.batchSize) - len(self.allSamples) < self.batchSize * self.forcedRefresh: break self.allGenerated.append(self.batchSize - (len(self.allSamples) - olds) + self.allGenerated[-1]) # add the remaining ones oldInvA = inv(self.allFactorSigmas[-2]) while len(self.allSamples) < olds + self.batchSize: r = rand() if r < self.forcedRefresh: self._produceNewSample() else: while True: p = randn(self.numParameters) newPdf = exp(-0.5 * dot(p, p)) / newDetFactorSigma sample = dot(self.factorSigma.T, p) + self.x sample = array(map(float,sample[:lt.Dsize-1])+map(degree_bound,sample[lt.Dsize-1:])) if useNearest: sample = array(nearestPoint(sample[:lt.Dsize-1])+map(float,sample[lt.Dsize-1:])) if validDist(sample): break oldPs = dot(oldInvA.T, (sample - self.allCenters[-2])) oldPdf = exp(-0.5 * dot(oldPs, oldPs)) / oldDetFactorSigma if r < 1 - oldPdf / newPdf: self._produceNewSample(sample, p)
def NWsc(M, object=False): W = np.array(MPDBsc((mp.matrix(M))).tolist(),dtype=np.float64) X = np.copy(M) dM = spl.det(M)**(1.0/2) ras = result() for i in range(1,31): uk = np.abs(spl.det(X)/dM)**(-1.0/i) X = (0.5)*(uk*X + (uk**(-1))*spl.inv(X).dot(M)) print (spl.norm(X-W)/spl.norm(W)) ras.res.append((spl.norm(X-W)/spl.norm(W))) ras.iter = i ras.ris = X return (ras if object else X)
def _getBetaT(self,XStar,Ap,D,Yt): P = [] for i in range(self.M): P += (self.Kva + D[i]).tolist() P = np.array(P) L = np.kron(Ap,XStar) A = L.T * 1.0/(P+1.0) B = np.dot(A,L) Bi = linalg.inv(B) beta = np.dot(np.dot(Bi,A),Yt) _REML_part = np.log(linalg.det(np.dot(L.T,L))) + np.log(linalg.det(B)) mu = np.dot(L,beta) return beta,mu,Bi,_REML_part
def main(): N = 20 solver = IMFSolver(n=2, r=1, p=2, m=1, s=2, N=N) theta = [0.56, 0.48] solver.set_Phi([[1.0, 1.0], [-0.5, 0.0]]) solver.set_diff_Phi_theta([[0.0, 0.0], [0.0, 0.0]], 0) solver.set_diff_Phi_theta([[0.0, 0.0], [0.0, 0.0]], 1) solver.set_Psi([[theta[0]], [theta[1]]]) solver.set_diff_Psi_theta([[1.0], [0.0]], 0) solver.set_diff_Psi_theta([[0.0], [1.0]], 1) solver.set_Gamma([[1.0, 0.0], [0.0, 1.0]]) solver.set_diff_Gamma_theta([[0.0, 0.0], [0.0, 0.0]], 0) solver.set_diff_Gamma_theta([[0.0, 0.0], [0.0, 0.0]], 1) solver.set_H([[1.0, 0.0]]) solver.set_diff_H_theta([[0.0, 0.0]], 0) solver.set_diff_H_theta([[0.0, 0.0]], 1) solver.set_Q([[0.07, 0.0], [0.0, 0.07]]) solver.set_diff_Q_theta([[0.0, 0.0], [0.0, 0.0]], 0) solver.set_diff_Q_theta([[0.0, 0.0], [0.0, 0.0]], 1) solver.set_R([[0.02]]) solver.set_diff_R_theta([[0.0]], 0) solver.set_diff_R_theta([[0.0]], 1) solver.set_x0([[0.0], [0.0]]) solver.set_diff_x0_theta([[0.0], [0.0]], 0) solver.set_diff_x0_theta([[0.0], [0.0]], 1) solver.set_P0([[0.1, 0.0], [0.0, 0.1]]) solver.set_diff_P0_theta([[0.0, 0.0], [0.0, 0.0]], 0) solver.set_diff_P0_theta([[0.0, 0.0], [0.0, 0.0]], 1) for i in xrange(N): solver.set_u([[1.0]], i) M = solver.get_inf_matrix() print M print la.det(M) print -np.log(la.det(M)) dM = solver.get_diff_inf_matrix_u(0, 10) print dM print np.trace(np.dot(la.inv(M), dM))
def _debug_with_bound (itr, var_value, var_name, data, K, topicMean, topicCov, outDocCov, inDocCov, vocab, dtype, outMeans, outVarcs, inMeans, inVarcs, A, n): if np.isnan(var_value).any(): printStderr ("WARNING: " + var_name + " contains NaNs") if np.isinf(var_value).any(): printStderr ("WARNING: " + var_name + " contains INFs") if "dtype" in dir(var_value) and var_value.dtype != dtype: printStderr ("WARNING: dtype(" + var_name + ") = " + str(var_value.dtype)) model = ModelState(K, topicMean, topicCov, outDocCov, vocab, A, False, dtype, MODEL_NAME) query = QueryState(outMeans, outVarcs, inMeans, inVarcs, inDocCov, n) old_bound = _debug_with_bound.old_bound bound = var_bound(data, model, query) diff = "" if old_bound == 0 else "%15.4f" % (bound - old_bound) _debug_with_bound.old_bound = bound addendum = "" if var_name == "topicCov": try: addendum = "log det(topicCov) = %g" % (np.log(la.det(topicCov))) except: addendum = "log det(topicCov) = <undefined>" if isnan(bound): printStderr ("Bound is NaN") else: perp = perplexity_from_like(log_likelihood(data, model, query), data.word_count) if int(bound - old_bound) < 0: printStderr ("Iter %3d Update %-15s Bound %22f (%15s) (%5.0f) %s" % (itr, var_name, bound, diff, perp, addendum)) else: print ("Iter %3d Update %-15s Bound %22f (%15s) (%5.0f) %s" % (itr, var_name, bound, diff, perp, addendum))
def pdf(self, data=None): """Probability density function (PDF). Parameters ---------- data : array_like Grid of point to evaluate PDF at. (k,) - one observation, k dimensions (T, k) - T observations, k dimensions Returns ------- (T, ) array PDF values """ ndim = self.lam.size if data is None: raise ValueError('No data given!') self.data = np.atleast_2d(data) # (T, k) array diff = self.data - self.const_mu() # (k, T) array diff_norm = scl.solve(self.const_sigma(), diff.T) # (T, ) array diff_sandwich = (diff.T * diff_norm).sum(0) term1 = ((np.pi * self.eta) ** ndim * scl.det(self.const_sigma())) **(-.5) term2 = np.exp(gammaln((self.eta + self.ndim) / 2) - gammaln(self.eta / 2)) term3 = (1 + diff_sandwich / self.eta) ** (- (self.eta + ndim) / 2) return term1 * term2 * term3
def multivariateNormalPdf(z, x, sigma): """ The pdf of a multivariate normal distribution (not in scipy). The sample z and the mean x should be 1-dim-arrays, and sigma a square 2-dim-array. """ assert len(z.shape) == 1 and len(x.shape) == 1 and len(x) == len(z) and sigma.shape == (len(x), len(z)) tmp = -0.5 * dot(dot((z - x), inv(sigma)), (z - x)) res = (1. / power(2.0 * pi, len(z) / 2.)) * (1. / sqrt(det(sigma))) * exp(tmp) return res
def in_cirumcircle( a, b, c, test ): ax, ay = points[a]; bx, by = points[b] cx, cy = points[c]; dx, dy = points[test] l1 = [ ax-dx, ay-dy, (ax**2-dx**2) + (ay**2-dy**2) ] l2 = [ bx-dx, by-dy, (bx**2-dx**2) + (by**2-dy**2) ] l3 = [ cx-dx, cy-dy, (cx**2-dx**2) + (cy**2-dy**2) ] return linalg.det( c_[l1, l2, l3] ) > 0
def test_for_simetric_indefinite_matrix(self): # Define test matrix A. # Note that the leading 5x5 submatrix is indefinite. A = np.asarray([[1, 2, 3, 7, 8], [2, 5, 5, 9, 0], [3, 5, 11, 1, 2], [7, 9, 1, 7, 5], [8, 0, 2, 5, 8]]) # Get Cholesky from lapack functions cholesky, = get_lapack_funcs(('potrf',), (A,)) # Compute Cholesky Decomposition c, k = cholesky(A, lower=False, overwrite_a=False, clean=True) delta, v = singular_leading_submatrix(A, c, k) A[k-1, k-1] += delta # Check if the leading submatrix is singular. assert_array_almost_equal(det(A[:k, :k]), 0) # Check if `v` fullfil the specified properties quadratic_term = np.dot(v, np.dot(A, v)) assert_array_almost_equal(quadratic_term, 0)
def eigen(energy, rot, mx, V, R, mu): """ determine eigen energy solution based. Parameters ---------- energy : float energy (eV) of the attempted solution rot : int rotational quantum number mx : int matching point index, for inward and outward solutions V : numpy 3d array potential energy curve and coupling matrix R : numpy 1d array internuclear distance grid mu : float reduced mass in kg Returns ------- eigenvalue : float energy of the solution """ WI = WImat(energy, rot, V, R, mu) RI = RImat(WI, mx) # | R_mx - R^-1_mx+1 | return linalg.det(linalg.inv(RI[mx])-RI[mx+1])
def DBsc(M, object=False): ras = result() Xk = np.copy(M) Yk = np.eye(M.shape[0]) dA = spl.det(M)**(1.0/2) for i in range(1,31): uk = np.abs(spl.det(Xk)/dA)**(-1.0/i) Xk1 = (Xk*uk + (uk**-1)*np.linalg.inv(Yk))/2 Yk1 = (Yk*uk + (uk**-1)*np.linalg.inv(Xk))/2 Xk = Xk1 Yk = Yk1 ras.res.append((spl.norm(Xk.dot(Xk)-M)/spl.norm(M))) ras.iter = i ras.ris = Xk return (ras if object else Xk)
def KF(y, XF0, VF0, F, H, G, Q, R, limy, ISW, OSW, m, N): if OSW == 1: XPS = np.zeros((N,m),dtype=np.float); XFS = np.zeros((N,m),dtype=np.float) VPS = np.zeros((N,m,m),dtype=np.float); VFS = np.zeros((N,m,m),dtype=np.float) XF = XF0; VF = VF0; NSUM = 0.0; SIG2 = 0.0; LDET = 0.0 for n in xrange(N): # 1期先予測 XP = np.ndarray.flatten( np.dot(F, XF.T) ) #2週目から縦ベクトルになってしまうので、常に横ベクトルに変換 VP = np.dot( np.dot(F, VF), F.T ) + np.dot( np.dot(G, Q), G.T) # フィルタ # Rは操作しなければ縦ベクトル。pythonは横ベクトルになるので注意! if y[n] < limy: NSUM = NSUM + 1 B = np.dot( np.dot(H, VP), H.T) + R # Hは数学的には横ベクトル B1 = inverse(B) # nvar次元の縦ベクトル K = np.matrix(np.dot(VP, H.T)) * np.matrix(B1) # Kは縦ベクトルになる(matrix) e = np.array(y[n]).T - np.dot(H, XP.T) # nvar次元の縦ベクトル XF = np.array(XP) + np.array( K * np.matrix(e) ).T # 横ベクトル VF = np.array(VP) - np.array( K* np.matrix(H) * VP) SIG2 = SIG2 + np.ndarray.flatten(np.array( np.matrix(e) * np.matrix(B1) * np.matrix(e).T ))[0] # 1次元でも計算できるようにmatrixにする LDET = LDET + math.log(linalg.det(B)) else: XF = XP; VF = VP if OSW == 1: XPS[n,:] = XP; XFS[n,:] = XF; VPS[n,:,:] = VP; VFS[n,:,:] = VF SIG2 = SIG2 / NSUM if ISW == 0: FF = -0.5 * (NSUM * (math.log(2 * np.pi * SIG2) + 1) + LDET) else: FF = -0.5 * (NSUM * (math.log(2 * np.pi) + SIG2) + LDET) if OSW == 0: return {'LLF':FF, 'Ovar':SIG2} if OSW == 1: return {'XPS':XPS, 'XFS':XFS, 'VPS':VPS, 'VFS':VFS, 'LLF':FF, 'Ovar':SIG2}
print(i) a=np.arange(10) #[ 0 1 4 9 16 25 36 49 64 81] print(a**2) ### ###scipy的使用 ### from scipy import linalg a=np.array([[1,2],[30,4]]) print(a) #二阶方阵行列式 #注意:推荐用scipy.linalg代替numpy.linalg #-56.0 print(linalg.det(a)) ### ###Pandas的使用,数据结构:Series和DataFrame ### import pandas as pd s=pd.Series([2,4,5,np.nan,8,9]) print(s) #DatetimeIndex(['2017-12-01', '2017-12-02', '2017-12-03', '2017-12-04', # '2017-12-05', '2017-12-06', '2017-12-07'], # dtype='datetime64[ns]', freq='D') dates=pd.date_range('20171201',periods=7) print(dates)
from scipy import linalg import numpy as np mat = np.array([ [2, 3, 1], [4, 9, 10], [10, 5, 6], ]) print(mat) det = linalg.det(mat) inv = linalg.inv(mat) print("determinant of the matrix", det) print("inverse of matrix\n", inv) # singular value decomposition comp1, comp2, comp3 = linalg.svd(mat) print('perform svd') print(comp1) print(comp2) print(comp3) # stats module from scipy import stats # normal distribution with mean 3 and standard deviation 5 rvs_20 = stats.norm.rvs(3, 5, size=20) print(rvs_20) cdf_ = stats.beta.cdf(0.42, a=100, b=50)
def calcComplexGradient(S, H1, v2, Psi, Wg, Rg): Bra = Psi.copy() Ket = Psi.copy() #denominator and numerator of energy D = 0.0 N = 0.0 #gradient with respect to a,b orbital parameter of the denominator and numerator of energy Dab = np.zeros(Psi.shape, dtype = complex) Nab = np.zeros(Psi.shape, dtype = complex) #gradient with respect to a,b* orbital parameter of the denominator and numerator of energy Dab_bar = np.zeros(Psi.shape, dtype = complex) Nab_bar = np.zeros(Psi.shape, dtype = complex) for i in range(len(Wg)): Ketg = Rg[i].dot(Ket) #overlap quantities O = Bra.conj().T.dot(S).dot(Ketg) invO = lalg.inv(O) detO = lalg.det(O) #derivative of detO with respect to a,b orbital parameter detOab = detO * np.einsum('bi,ji,ja,a->ab', invO, Psi.conj(), S, np.diag(Rg[i]), dtype = complex, optimize = True) detOab_bar = detO * np.einsum('ai,i,ij,jb->ab', S, np.diag(Rg[i]), Psi, invO, dtype = complex, optimize = True) #density matrix dm1 = Ketg.dot(invO).dot(Bra.conj().T) #hamiltonian quantities G1 = contractEri(v2, dm1) F1 = H1 + 0.5 * G1 H = np.einsum('pq,qp->', F1, dm1, dtype = complex, optimize = True) #drivative of H with respect to a,b orbital parameter M = H1 + G1 Aab = np.einsum('bi,pi,pa,a->ab', invO, Psi.conj(), M, np.diag(Rg[i]), dtype = complex, optimize = True) Baj = np.einsum('jk,lk,la,a->aj', invO, Psi.conj(), S, np.diag(Rg[i]), dtype = complex, optimize = True) Hab = Aab - np.einsum('qb,qj,aj->ab', Aab, Psi, Baj, dtype = complex, optimize = True) Aab_bar = np.einsum('aq,q,qi,ib->ab', M, np.diag(Rg[i]), Psi, invO, dtype = complex, optimize = True) Bak_bar = np.einsum('ai,i,ij,jk->ak', S, np.diag(Rg[i]), Psi, invO, dtype = complex, optimize = True) Hab_bar = Aab_bar - np.einsum('ak,pk,pb->ab', Bak_bar, Psi.conj(), Aab_bar, dtype = complex, optimize = True) #averages with symmetry weights D += Wg[i] * detO Dab += Wg[i] * detOab Dab_bar += Wg[i] * detOab_bar N += Wg[i] * detO * H Nab += Wg[i] * (detOab * H + detO * Hab) Nab_bar += Wg[i] * (detOab_bar * H + detO * Hab_bar) #for complex conjugation projection, calculate overlaps with the conjugate of the ket, note that the only nonzero derivatives are with respect to a,b* parameters for i in range(len(Wg)): Ketg = Rg[i].dot(Ket.conj()) #overlap quantities O = Bra.conj().T.dot(S).dot(Ketg) invO = lalg.inv(O) detO = lalg.det(O) #derivative of detO with respect to a,b orbital parameter detOab_bar = detO * np.einsum('ai,i,ij,jb->ab', S, np.diag(Rg[i]), Psi.conj(), invO, dtype = complex, optimize = True) #detOab_bar += detO * np.einsum('bi,ji,ja,a->ab', invO, Psi.conj(), S, np.diag(Rg[i]), dtype = complex, optimize = True) detOab_bar = detOab_bar + detOab_bar #density matrix dm1 = Ketg.dot(invO).dot(Bra.conj().T) #hamiltonian quantities G1 = contractEri(v2, dm1) F1 = H1 + 0.5 * G1 H = np.einsum('pq,qp->', F1, dm1, dtype = complex, optimize = True) #drivative of H with respect to a,b orbital parameter M = H1 + G1 A1ab_bar = np.einsum('bi,pi,pa,a->ab', invO, Psi.conj(), M, np.diag(Rg[i]), dtype = complex, optimize = True) #A2ab_bar = np.einsum('aq,q,qi,ib->ab', M, np.diag(Rg[i]), Psi.conj(), invO, dtype = complex, optimize = True) A2ab_bar = A1ab_bar C1ak_bar = np.einsum('ai,i,ij,jk->ak', S, np.diag(Rg[i]), Psi.conj(), invO, dtype = complex, optimize = True) #D1pb_bar = np.einsum('pq,q,ql,lb->pb', M, np.diag(Rg[i]), Psi.conj(), invO, dtype = complex, optimize = True) D1pb_bar = A1ab_bar B1ab_bar = - np.einsum('ak,pk,pb->ab', C1ak_bar, Psi.conj(), D1pb_bar, optimize = True) #C2bq_bar = np.einsum('bi,pi,pq,q->bq', invO, Psi.conj(), M, np.diag(Rg[i]), dtype = complex, optimize = True) #D2ja_bar = np.einsum('jk,lk,la,a->ja', invO, Psi.conj(), S, np.diag(Rg[i]), dtype = complex, optimize = True) #B2ab_bar = - np.einsum('bq,qj,ja->ab', C2bq_bar, Psi.conj(), D2ja_bar, dtype = complex, optimize = True) B2ab_bar = B1ab_bar Hab_bar = A1ab_bar + A2ab_bar + B1ab_bar + B2ab_bar #averages with symmetry weights D += Wg[i] * detO Dab_bar += Wg[i] * detOab_bar N += Wg[i] * detO * H Nab_bar += Wg[i] * (detOab_bar * H + detO * Hab_bar) E = N / D J = Nab / D - E * (Dab / D) J_bar = Nab_bar / D - E * (Dab_bar / D) return J, J_bar
def test_simple(self): a = [[1, 2], [3, 4]] a_det = det(a) assert_almost_equal(a_det, -2.0)
#!/usr/bin/python # coding=utf8 import numpy as np from scipy import linalg __author__ = 'Jam' __date__ = '2019/7/17 13:29' print("-" * 70) a = np.array([[3, 2, 0], [1, -1, 0], [0, 5, 1]]) b = np.array([2, 4, -2]) res1 = linalg.solve(a, b) print(res1) print("-" * 70) A = np.array([[1, 2], [3, 4]]) res2 = linalg.det(A) print(res2) print("-" * 70) A = np.array([[1, 2], [3, 4]]) l, v = linalg.eig(A) print(l, v) print("-" * 70) a = np.random.randn(2, 3) + 1.j * np.random.randn(2, 3) U, s, Vh = linalg.svd(a) print(U, Vh, s)
def zonotope_sampler(A_zono, **params): """ MCMC based sampler for projection DPPs. The similarity matrix is the orthogonal projection matrix onto the row span of the feature vector matrix. Samples are of size equal to the ransampl_size of the projection matrix also equal to the rank of the feature matrix (assumed to be full row rank). :param A_zono: Feature vector matrix, feature vectors are stacked columnwise. It is assumed to be full row rank. :type A_zono: array_like :param params: Dictionary containing the parameters - ``'lin_obj'`` (list): Linear objective (:math:`c`) of the linear program used to identify the tile in which a point lies. Default is a random Gaussian vector. - ``'x_0'` (list): Initial point. - ``'nb_iter'`` (int): Number of iterations of the MCMC chain. Default is 10. - ``'T_max'`` (float): Maximum running time of the algorithm (in seconds). Default is None. - ``'random_state`` (default None) :type params: dict :return: MCMC chain of approximate samples (stacked row_wise i.e. nb_iter rows). :rtype: array_like .. seealso:: Algorithm 5 in :cite:`GaBaVa17` - :func:`extract_basis <extract_basis>` - :func:`basis_exchange_sampler <basis_exchange_sampler>` """ # For zonotope sampler try: from cvxopt import matrix, spmatrix, solvers except ImportError: raise ValueError( 'The cvxopt package is required to use the zonotype sampler (see setup.py).' ) solvers.options['show_progress'] = params.get('show_progress', False) solvers.options['glpk'] = { 'msg_lev': params.get('show_progress', 'GLP_MSG_OFF') } rng = check_random_state(params.get('random_state', None)) r, N = A_zono.shape # Sizes of r=samples=rank(A_zono), N=ground set # Linear objective c = matrix(params.get('lin_obj', rng.randn(N))) # Initial point x0 = A*u, u~U[0,1]^n x0 = matrix(params.get('x_0', A_zono.dot(rng.rand(N)))) nb_iter = params.get('nb_iter', 10) T_max = params.get('T_max', None) ################### # Linear problems # ################### # Canonical form # min c.T*x min c.T*x # s.t. G*x <= h <=> s.t. G*x + s = h # A*x = b A*x = b # s >= 0 # CVXOPT # =====> solvers.lp(c, G, h, A, b, solver='glpk') ################################################# # To access the tile Z(B_x) # Solve P_x(A,c) ###################################################### # y^* = # argmin c.T*y argmin c.T*y # s.t. A*y = x <=> s.t. A *y = x # 0 <= y <= 1 [ I_n] *y <= [1^n] # [-I_n] [0^n] ###################################################### # Then B_x = \{ i ; y_i^* \in ]0,1[ \} A = spmatrix(0.0, [], [], (r, N)) A[:, :] = A_zono G = spmatrix(0.0, [], [], (2 * N, N)) G[:N, :] = spmatrix(1.0, range(N), range(N)) G[N:, :] = spmatrix(-1.0, range(N), range(N)) # Endpoints of segment # D_x \cap Z(A) = [x+alpha_m*d, x-alpha_M*d] ########################################################################### # alpha_m/_M = argmin +/-alpha argmin [+/-1 0^N].T * [alpha,lambda] # s.t. x + alpha d = A lambda <=> s.t. [-d A] *[alpha, lambda] = x # 0 <= lambda <= 1 [0^N I_N] *[alpha, lambda] <= [1^N] # [0^N -I_N] [0^N] ########################################################################## c_mM = matrix(0.0, (N + 1, 1)) c_mM[0] = 1.0 A_mM = spmatrix(0.0, [], [], (r, N + 1)) A_mM[:, 1:] = A G_mM = spmatrix(0.0, [], [], (2 * N, N + 1)) G_mM[:, 1:] = G # Common h to both kind of LP # cf. 0 <= y <= 1 and 0 <= lambda <= 1 h = matrix(0.0, (2 * N, 1)) h[:N, :] = 1.0 ################## # Initialization # ################## B_x0 = [] while len(B_x0) != r: # Initial tile B_x0 # Solve P_x0(A,c) y_star = solvers.lp(c, G, h, A, x0, solver='glpk')['x'] # Get the tile B_x0 = extract_basis(np.asarray(y_star)) # Initialize sequence of sample chain = np.zeros((nb_iter, r), dtype=int) chain[0] = B_x0 # Compute the det of the tile (Vol(B)=abs(det(B))) det_B_x0 = la.det(A_zono[:, B_x0]) t_start = time.time() if T_max else 0 for it in range(1, nb_iter): # Take uniform direction d defining D_x0 d = matrix(rng.randn(r, 1)) # Define D_x0 \cap Z(A) = [x0 + alpha_m*d, x0 - alpha_M*d] # Update the constraint [-d A] * [alpha,lambda] = x A_mM[:, 0] = -d # Find alpha_m/M alpha_m = solvers.lp(c_mM, G_mM, h, A_mM, x0, solver='glpk')['x'][0] alpha_M = solvers.lp(-c_mM, G_mM, h, A_mM, x0, solver='glpk')['x'][0] # Propose x1 ~ U_{[x0+alpha_m*d, x0-alpha_M*d]} x1 = x0 + (alpha_m + (alpha_M - alpha_m) * rng.rand()) * d # Proposed tile B_x1 # Solve P_x1(A,c) y_star = solvers.lp(c, G, h, A, x1, solver='glpk')['x'] # Get the tile B_x1 = extract_basis(np.asarray(y_star)) # Accept/Reject the move with proba Vol(B1)/Vol(B0) if len(B_x1) != r: # if extract_basis returned smtg ill conditioned chain[it] = B_x0 else: det_B_x1 = la.det(A_zono[:, B_x1]) if rng.rand() < abs(det_B_x1 / det_B_x0): x0, B_x0, det_B_x0 = x1, B_x1, det_B_x1 chain[it] = B_x1 else: chain[it] = B_x0 if T_max: if time.time() - t_start < T_max: break return chain.tolist()
def func5(n): n = int(1.25*n) A = np.random.rand(n, n) la.det(A)
B[j, j + 1] = -1 B[j, j - 1] = -1 B[0, :] = [2, -1, 0, 0] B[3, :] = [0, 0, -1, 2] print 'A = ' print A print ' ' print 'B = ' print B print ' ' print '|A| = ' print la.det(A) print ' ' print 'AB = ' print dot(A, B) print ' ' print '*Element-wise* A*B = ' print A * B print ' ' print 'A^T = ' print A.T print ' ' print 'A^{-1} = '
def nedelecBasisIterative(eleNodes, points, eleVol, lengthEdges, edgeOrder): ''' Compute the basis Nedelec functions in an iterative way for a set of points in a given element. :param ndarray eleNodes: nodal spatial coordinates of the element :param ndarray points: spatial coordinates of the evaluation points :param float eleVol: element's volume :param ndarray lengthEdges: element's edges defined by their length :param int edgeOrder: order of tetrahedral edge element :return: values of Nedelec functions. :rtype: ndarray. .. note: References:\n Jin, Jian-Ming. The finite element method in electromagnetics. John Wiley & Sons, 2002. ''' # Coefficients computation. Running in a cycling way a = np.zeros([4], dtype=np.float64) b = np.zeros([4], dtype=np.float64) c = np.zeros([4], dtype=np.float64) d = np.zeros([4], dtype=np.float64) tmp = np.array([0, 1, 2, 3, 0, 1, 2], dtype=np.int) temp_ones = np.ones([3], dtype=np.float64) for iCoeff in np.arange(4): a[iCoeff] = det([[ eleNodes[tmp[iCoeff + 1], 0], eleNodes[tmp[iCoeff + 2], 0], eleNodes[tmp[iCoeff + 3], 0] ], [ eleNodes[tmp[iCoeff + 1], 1], eleNodes[tmp[iCoeff + 2], 1], eleNodes[tmp[iCoeff + 3], 1] ], [ eleNodes[tmp[iCoeff + 1], 2], eleNodes[tmp[iCoeff + 2], 2], eleNodes[tmp[iCoeff + 3], 2] ]]) b[iCoeff] = det([ temp_ones, [ eleNodes[tmp[iCoeff + 1], 1], eleNodes[tmp[iCoeff + 2], 1], eleNodes[tmp[iCoeff + 3], 1] ], [ eleNodes[tmp[iCoeff + 1], 2], eleNodes[tmp[iCoeff + 2], 2], eleNodes[tmp[iCoeff + 3], 2] ] ]) c[iCoeff] = det([ temp_ones, [ eleNodes[tmp[iCoeff + 1], 0], eleNodes[tmp[iCoeff + 2], 0], eleNodes[tmp[iCoeff + 3], 0] ], [ eleNodes[tmp[iCoeff + 1], 2], eleNodes[tmp[iCoeff + 2], 2], eleNodes[tmp[iCoeff + 3], 2] ] ]) d[iCoeff] = det([ temp_ones, [ eleNodes[tmp[iCoeff + 1], 0], eleNodes[tmp[iCoeff + 2], 0], eleNodes[tmp[iCoeff + 3], 0] ], [ eleNodes[tmp[iCoeff + 1], 1], eleNodes[tmp[iCoeff + 2], 1], eleNodes[tmp[iCoeff + 3], 1] ] ]) # Add signs sign = np.float64(-1.0) a[1] = a[1] * sign a[3] = a[3] * sign b[0] = b[0] * sign b[2] = b[2] * sign c[1] = c[1] * sign c[3] = c[3] * sign d[0] = d[0] * sign d[2] = d[2] * sign # Number of points if points.ndim == 1: nPoints = 1 else: nPoints = points.shape[0] # Nedelec basis for all points if nPoints == 1: AA = np.float64(1.0) / ((np.float64(6.0) * eleVol)**2) # To reduce number of multiplications b1x = b[0] * points[0] b2x = b[1] * points[0] b3x = b[2] * points[0] b4x = b[3] * points[0] c1y = c[0] * points[1] c2y = c[1] * points[1] c3y = c[2] * points[1] c4y = c[3] * points[1] d1z = d[0] * points[2] d2z = d[1] * points[2] d3z = d[2] * points[2] d4z = d[3] * points[2] A1 = a[0] + b1x + c1y + d1z A2 = a[1] + b2x + c2y + d2z A3 = a[2] + b3x + c3y + d3z A4 = a[3] + b4x + c4y + d4z # Basis 1 b1 = np.multiply([(b[1] * A1) - (b[0] * A2), (c[1] * A1) - (c[0] * A2), (d[1] * A1) - (d[0] * A2)], lengthEdges[0]) # Basis 2 b2 = np.multiply([ b[2] * A1 - b[0] * A3, c[2] * A1 - c[0] * A3, d[2] * A1 - d[0] * A3 ], lengthEdges[1]) # Basis 3 b3 = np.multiply([ b[3] * A1 - b[0] * A4, c[3] * A1 - c[0] * A4, d[3] * A1 - d[0] * A4 ], lengthEdges[2]) # Basis 4 b4 = np.multiply([ b[2] * A2 - b[1] * A3, c[2] * A2 - c[1] * A3, d[2] * A2 - d[1] * A3 ], lengthEdges[3]) # Basis 5 b5 = np.multiply([ b[1] * A4 - b[3] * A2, c[1] * A4 - c[3] * A2, d[1] * A4 - d[3] * A2 ], lengthEdges[4]) # Basis 6 b6 = np.multiply([ b[3] * A3 - b[2] * A4, c[3] * A3 - c[2] * A4, d[3] * A3 - d[2] * A4 ], lengthEdges[5]) basis = np.array(np.vstack((b1, b2, b3, b4, b5, b6)) * AA, dtype=np.float64) # If not else: basis = np.zeros((edgeOrder, 3, nPoints), dtype=np.float64) AA = np.float64(1.0) / ((np.float64(6.0) * eleVol)**2) # Compute basis for each point for iP in np.arange(nPoints): # To reduce number of multiplications b1x = b[0] * points[iP, 0] b2x = b[1] * points[iP, 0] b3x = b[2] * points[iP, 0] b4x = b[3] * points[iP, 0] c1y = c[0] * points[iP, 1] c2y = c[1] * points[iP, 1] c3y = c[2] * points[iP, 1] c4y = c[3] * points[iP, 1] d1z = d[0] * points[iP, 2] d2z = d[1] * points[iP, 2] d3z = d[2] * points[iP, 2] d4z = d[3] * points[iP, 2] A1 = a[0] + b1x + c1y + d1z A2 = a[1] + b2x + c2y + d2z A3 = a[2] + b3x + c3y + d3z A4 = a[3] + b4x + c4y + d4z # Basis 1 b1 = np.multiply([(b[1] * A1) - (b[0] * A2), (c[1] * A1) - (c[0] * A2), (d[1] * A1) - (d[0] * A2)], lengthEdges[0]) # Basis 2 b2 = np.multiply([ b[2] * A1 - b[0] * A3, c[2] * A1 - c[0] * A3, d[2] * A1 - d[0] * A3 ], lengthEdges[1]) # Basis 3 b3 = np.multiply([ b[3] * A1 - b[0] * A4, c[3] * A1 - c[0] * A4, d[3] * A1 - d[0] * A4 ], lengthEdges[2]) # Basis 4 b4 = np.multiply([ b[2] * A2 - b[1] * A3, c[2] * A2 - c[1] * A3, d[2] * A2 - d[1] * A3 ], lengthEdges[3]) # Basis 5 b5 = np.multiply([ b[1] * A4 - b[3] * A2, c[1] * A4 - c[3] * A2, d[1] * A4 - d[3] * A2 ], lengthEdges[4]) # Basis 6 b6 = np.multiply([ b[3] * A3 - b[2] * A4, c[3] * A3 - c[2] * A4, d[3] * A3 - d[2] * A4 ], lengthEdges[5]) basis[:, :, iP] = np.vstack((b1, b2, b3, b4, b5, b6)) * AA return basis
def mlogdet(self): return np.log(linalg.det(self.m))
def mdet(self): return linalg.det(self.m)
def do_nsd(self, row, col): r"""Evaluates by numerical steepest descent the integral :math:`\langle \Phi_i | f | \Phi^\prime_j \rangle` for a polynomial function :math:`f(x)` with :math:`x \in \mathbb{R}^D`. :param row: The index :math:`i` of the component :math:`\Phi_i` of :math:`\Psi`. :param row: The index :math:`j` of the component :math:`\Phi^\prime_j` of :math:`\Psi^\prime`. :return: A complex valued matrix of shape :math:`|\mathfrak{K}_i| \times |\mathfrak{K}^\prime_j|`. """ D = self._packet.get_dimension() N = self._packet.get_number_components() eps = self._packet.get_eps() Pibra = self._pacbra.get_parameters(component=row) Piket = self._packet.get_parameters(component=col) Pimix = self.mix_parameters(Pibra[:4], Piket[:4]) # Combine oscillators A, b, c = self.build_bilinear(Pibra[:4], Piket[:4]) # Schur decomposition of A = U^H T U T, U = schur(A, output="complex") U = conjugate(transpose(U)) # Oscillator updates for i in range(1, D): if T[i - 1, i - 1] == 0: # TODO: Prove that this never happens or handle it correctly! print("Warning: 'update_oscillator' encountered a RESIDUE situation!") # Diagonal Elements for j in range(i, D): T[j, j] = T[j, j] - T[i - 1, j]**2 / (4.0 * T[i - 1, i - 1]) # Others for rowi in range(i, D): for coli in range(rowi + 1, D): T[rowi, coli] = T[rowi, coli] - T[i - 1, rowi] * T[i - 1, coli] / (2 * T[i - 1, i - 1]) # Compute remaining parts X = inv(A + transpose(A)) ctilde = c - 0.5 * dot(transpose(b), dot(X, b)) # Prefactor originating from constant term c eps = self._packet.get_eps() w = 1.0 / eps**2 prefactor = exp(1.0j * w * ctilde) # Take out diagonals of T Dk = diag(T).reshape((D, 1)) # Tau (path parametrization variable) tk = self._nodes / sqrt(w) # Path Precomposition Tu = 0.5 * triu(T, 1) / Dk paths = (sqrt(1.0j / Dk) * tk).astype(complexfloating) for i in reversed(range(D)): paths[i, :] = paths[i, :] - dot(Tu[i, :], paths) # Path derivatives pathderivs = sqrt(1.0j / Dk) pdp = product(pathderivs, axis=0) # Backtransformation of paths pathst = dot(conjugate(transpose(U)), paths) - dot(X, b) # Another normalization prefactor # This is what differs the constant part of phi_0 from 1. # We loose it when dividing by phi_0 hence manually add it again. # TODO: Do we need mixing parameters here? # Preliminary answer: no fr = (pi * eps**2)**(-0.25 * D) * 1.0 / sqrt(det(Pibra[2])) fc = (pi * eps**2)**(-0.25 * D) * 1.0 / sqrt(det(Piket[2])) normfactor = conjugate(fr) * fc # Compute global phase difference phase = exp(1.0j / eps**2 * (Piket[4] - conjugate(Pibra[4]))) # Non-oscillatory parts # Wavepacket # TODO: This is a huge hack: division by phi_0 not stable? basisr = self._pacbra.evaluate_basis_at(conjugate(pathst), row, prefactor=False) basisr = basisr / basisr[0, :] basisc = self._packet.evaluate_basis_at(pathst, col, prefactor=False) basisc = basisc / basisc[0, :] # Basis division by phi0 may introduce NaNs #basisr = nan_to_num(basisr) #basisc = nan_to_num(basisc) # Operator should support the component notation for efficiency if self._eval_at_once is True: # TODO: Sure, this is inefficient, but we can not do better right now. opath = self._operator(pathst, Pimix[0])[row * N + col] else: opath = self._operator(pathst, Pimix[0], entry=(row, col)) # Do the quadrature quadrand = (opath * pdp * self._weights).reshape((-1,)) # Sum up matrices over all quadrature nodes M = einsum("k,ik,jk", quadrand, conjugate(basisr), basisc) return phase * normfactor * prefactor * M / sqrt(w)**D
def lndetC(sij, x, hessian=False): ''' f = ln det C = ln det F^{-1} = -ln det F where F = \sum_m^M x_m v_m.v_m^t By Jacob's formula df/dx_m = -tr(F^{-1}.(v_m.v_m^t)) The second derivative is d^2 f/dx_a dx_b = -tr( dC/dx_b.v_a.v_a^t) = tr( C.dF/dx_b.C.v_a.v_a^t) = tr( C.v_b.v_b^t.C.v_a.v_a^t) Return: tuple (f, d/dx f) if hessian is false tuple (f, d/dx f, d^2/dx^2 f) if hessian is true. ''' if not isinstance(sij, matrix): sij = matrix(sij) K = sij.size[0] M = K * (K + 1) / 2 F = matrix(0., (K, K)) for i in xrange(K): # n_{ii}*v_{ii}.v_{ii}^t F[i, i] += x[i] / (sij[i, i] * sij[i, i]) for j in xrange(i + 1, K): m = measurement_index(i, j, K) v2 = x[m] / (sij[i, j] * sij[i, j]) F[i, i] += v2 F[j, j] += v2 F[i, j] = F[j, i] = -v2 C = linalg.inv(F) fval = -np.log(linalg.det(F)) df = matrix(0., (1, M)) for i in xrange(K): df[i] = -C[i, i] / (sij[i, i] * sij[i, i]) for j in xrange(i + 1, K): m = measurement_index(i, j, K) df[m] = (2 * C[i, j] - C[i, i] - C[j, j]) / (sij[i, j] * sij[i, j]) if not hessian: return (fval, df) # Compute the Hessian d2f = matrix(0., (M, M)) for i in xrange(K): for j in xrange(i, K): # d^2/dx_i dx_j = C_{ij}^2/(s_{ii}^2 s_{jj}^2) d2f[i, j] = C[i, j] * C[i, j] / (sij[i, i] * sij[i, i] * sij[j, j] * sij[j, j]) d2f[j, i] = d2f[i, j] for i2 in xrange(K): for j2 in xrange(i2 + 1, K): m2 = measurement_index(i2, j2, K) # d^2/dx_id_x(i',j') = (C_{ii'}-C_{ji'})^2/(s_{i'i'}^2 s_{ij}^2) dC = C[i2, i] - C[j2, i] d2f[i, m2] = dC * dC / (sij[i, i] * sij[i, i] * sij[i2, j2] * sij[i2, j2]) d2f[m2, i] = d2f[i, m2] for j in xrange(i + 1, K): m = measurement_index(i, j, K) invs2 = 1 / (sij[i, j] * sij[i, j]) for i2 in xrange(i, K): for j2 in xrange(i2 + 1, K): m2 = measurement_index(i2, j2, K) # d^2/dx_{ij}dx_{i'j'} = # (C_{ii'}+C_{jj'}-C_{ji'}-C_{ij'})^2/(s_{i'j'}^2 s_{ij}^2) dC = C[i, i2] + C[j, j2] - C[j, i2] - C[i, j2] d2f[m, m2] = dC * dC * invs2 / (sij[i2, j2] * sij[i2, j2]) d2f[m2, m] = d2f[m, m2] return (fval, df, d2f)
import numpy as np from scipy import linalg A = np.array([[1, 8, -9, 7, 5], [0, 1, 0, 4, 4], [0, 0, 1, 2, 5], [0, 0, 0, 1, -5], [0, 0, 0, 0, 1]]) det_A = linalg.det(A) print("Determinant of the matrix\n") print(det_A) inv_A = linalg.pinv(A) print("\nInverse of the matrix\n") print(inv_A) print("\nTranspose of the matrix\n") transpose = np.matrix.transpose(A) print(transpose) eig_A = linalg.eig(A) print("\nEigen pairs of the matrix\n") print(eig_A)
def align_wahba(dt, theta, dv, lat, VE=None, VN=None): """Estimate attitude matrix by solving Wahba's problem. This method is based on solving a least-squares problem for a direction cosine matrix A (originally formulated in [1]_):: L = sum(||A r_i - b_i||^2, i=1, ..., m) -> min A, s. t. A being a right orthogonal matrix. Here ``(r_i, b_i)`` are measurements of the same unit vectors in two frames. The application of this method to self alignment of INS is explained in [2]_. In this problem the vectors ``(r_i, b_i)`` are normalized velocity increments due to gravity. It is applicable to dynamic conditions as well, but in this case a full accuracy can be achieved only if velocity is provided. The optimization problem is solved using the most straightforward method based on SVD [3]_. Parameters ---------- dt : double Sensors sampling period. theta, dv : array_like, shape (n_samples, 3) Rotation vectors and velocity increments computed from gyro and accelerometer readings after applying coning and sculling corrections. lat : float Latitude of the place. VE, VN : array_like with shape (n_samples + 1, 3) or None East and North velocity of the target. If None (default), it is assumed to be 0. See Notes for further details. Returns ------- hpr : tuple of 3 floats Estimated heading, pitch and roll at the end of the alignment. P_align : ndarray, shape (3, 3) Covariance matrix of misalignment angles, commonly known as "phi-angle" in INS literature. Its values are measured in degrees squared. This matrix is estimated in a rather ad-hoc fashion, see Notes. Notes ----- If the alignment takes place in dynamic conditions but velocities `VE` and `VN` are not provided, the alignment accuracy will be decreased (to some extent it will be reflected in `P_align`). Note that `VE` and `VN` are required with the same rate as inertial readings (and contain 1 more sample). It means that you usually have to do some sort of interpolation. In on-board implementation you just provide the last available velocity data from GPS and it will work fine. The paper [3]_ contains a recipe of computing the covariance matrix given that errors in measurements are independent, small and follow a statistical distribution with zero mean and known variance. In our case we estimate measurement error variance from the optimal value of the optimized function (see above). But as our errors are not independent and necessary small (nor they follow any reasonable distribution) we don't scale their variance by the number of observations (which is commonly done for the variance of an average value). Some experiments show that this approach gives reasonable values of `P_align`. Also note, that `P_align` accounts only for misalignment errors due to non-perfect alignment conditions. In addition to that, azimuth accuracy is always limited by gyro drifts and level accuracy is limited by the accelerometer biases. You should add these systematic uncertainties to the diagonal of `P_align`. References ---------- .. [1] G. Wahba, "Problem 65–1: A Least Squares Estimate of Spacecraft Attitude", SIAM Review, 1965, 7(3), 409. .. [2] P. M. G. Silson, "Coarse Alignment of a Ship’s Strapdown Inertial Attitude Reference System Using Velocity Loci", IEEE Trans. Instrum. Meas., vol. 60, pp. 1930-1941, Jun. 2011. .. [3] F. L. Markley, "Attitude Determination using Vector Observations and the Singular Value Decomposition", The Journal of the Astronautical Sciences, Vol. 36, No. 3, pp. 245-258, Jul.-Sept. 1988. """ n_samples = theta.shape[0] Vg = np.zeros((n_samples + 1, 3)) if VE is not None: Vg[:, 0] = VE if VN is not None: Vg[:, 1] = VN lat = np.deg2rad(lat) slat, clat = np.sin(lat), np.cos(lat) tlat = slat / clat re, rn = earth.principal_radii(lat) u = earth.RATE * np.array([0, clat, slat]) g = np.array([0, 0, -earth.gravity(slat)]) Cb0b = np.empty((n_samples + 1, 3, 3)) Cg0g = np.empty((n_samples + 1, 3, 3)) Cb0b[0] = np.identity(3) Cg0g[0] = np.identity(3) Vg_m = 0.5 * (Vg[1:] + Vg[:-1]) rho = np.empty_like(Vg_m) rho[:, 0] = -Vg_m[:, 1] / rn rho[:, 1] = Vg_m[:, 0] / re rho[:, 2] = Vg_m[:, 0] / re * tlat for i in range(n_samples): Cg0g[i + 1] = Cg0g[i].dot(dcm.from_rv((rho[i] + u) * dt)) Cb0b[i + 1] = Cb0b[i].dot(dcm.from_rv(theta[i])) f_g = np.cross(u, Vg) - g f_g0 = util.mv_prod(Cg0g, f_g) f_g0 = 0.5 * (f_g0[1:] + f_g0[:-1]) f_g0 = np.vstack((np.zeros(3), f_g0)) V_g0 = util.mv_prod(Cg0g, Vg) + dt * np.cumsum(f_g0, axis=0) V_b0 = np.cumsum(util.mv_prod(Cb0b[:-1], dv), axis=0) V_b0 = np.vstack((np.zeros(3), V_b0)) k = n_samples // 2 b = V_g0[k:2 * k] - V_g0[:k] b /= np.linalg.norm(b, axis=1)[:, None] r = V_b0[k:2 * k] - V_b0[:k] r /= np.linalg.norm(r, axis=1)[:, None] B = np.zeros((3, 3)) for bi, ri in zip(b, r): B += np.outer(bi, ri) n_obs = b.shape[0] B /= n_obs U, s, VT = svd(B, overwrite_a=True) d = det(U) * det(VT) Cg0b0 = U.dot(np.diag([1, 1, d])).dot(VT) Cgb = Cg0g[-1].T.dot(Cg0b0).dot(Cb0b[-1]) s[-1] *= d trace_s = np.sum(s) L = 1 - trace_s D = trace_s - s M = np.identity(3) - np.diag(s) if L < 0 or np.any(M < 0): L = max(L, 0) M[M < 0] = 0 warn("Negative values encountered when estimating the covariance, " "they were set to zeros.") R = (L * M / n_obs)**0.5 / D R = U.dot(R) R = Cg0g[-1].T.dot(R) R = np.rad2deg(R) return dcm.to_hpr(Cgb), R.dot(R.T)
def evaluate_basis_at(self, grid, component, prefactor=False): r"""Evaluate the basis functions :math:`\phi_k` recursively at the given nodes :math:`\gamma`. :param grid: The grid :math:\Gamma` containing the nodes :math:`\gamma`. :type grid: A class having a :py:meth:`get_nodes(...)` method. :param component: The index :math:`i` of a single component :math:`\Phi_i` to evaluate. :param prefactor: Whether to include a factor of :math:`\frac{1}{\sqrt{\det(Q)}}`. :type prefactor: bool, default is ``False``. :return: A two-dimensional ndarray :math:`H` of shape :math:`(|\mathcal{K}_i|, |\Gamma|)` where the entry :math:`H[\mu(k), i]` is the value of :math:`\phi_k(\gamma_i)`. """ D = self._dimension bas = self._basis_shapes[component] bs = self._basis_sizes[component] # TODO: Consider putting this into the Grid class as 2nd level API # Allow ndarrays for the 'grid' argument if isinstance(grid, Grid): # The overall number of nodes nn = grid.get_number_nodes(overall=True) # The grid nodes nodes = grid.get_nodes() else: # The overall number of nodes nn = prod(grid.shape[1:]) # The grid nodes nodes = grid # Allocate the storage array phi = zeros((bs, nn), dtype=complexfloating) # Precompute some constants q, p, Q, P, S = self._Pis[component] Qinv = inv(Q) Qbar = conj(Q) QQ = dot(Qinv, Qbar) # Compute the ground state phi_0 via direct evaluation mu0 = bas[tuple(D * [0])] phi[mu0, :] = self._evaluate_phi0(self._Pis[component], nodes, prefactor=False) # Compute all higher order states phi_k via recursion for d in xrange(D): # Iterator for all valid index vectors k indices = bas.get_node_iterator(mode="chain", direction=d) for k in indices: # Current index vector ki = vstack(k) # Access predecessors phim = zeros((D, nn), dtype=complexfloating) for j, kpj in bas.get_neighbours(k, selection="backward"): mukpj = bas[kpj] phim[j, :] = phi[mukpj, :] # Compute 3-term recursion p1 = (nodes - q) * phi[bas[k], :] p2 = sqrt(ki) * phim t1 = sqrt(2.0 / self._eps**2) * dot(Qinv[d, :], p1) t2 = dot(QQ[d, :], p2) # Find multi-index where to store the result kped = bas.get_neighbours(k, selection="forward", direction=d) # Did we find this k? if len(kped) > 0: kped = kped[0] # Store computed value phi[bas[kped[1]], :] = (t1 - t2) / sqrt(ki[d] + 1.0) if prefactor is True: phi = phi / self._sqrt[component](det(Q)) return phi
def LinApp_Solve(AA, BB, CC, DD, FF, GG, HH, JJ, KK, LL, MM, WWW, TT, NN, Z0, Sylv): """ This code takes Uhlig's original code and puts it in the form of a function. This version outputs the policy function coefficients: PP, QQ and UU for X, and RR, SS and VV for Y. Inputs overview: The matrices of derivatives: AA - TT. The autoregression coefficient matrix NN from the law of motion for Z. Z0 is the Z-point about which the linearization is taken. For linearizing about the steady state this is Zbar and normally Zbar = 0. Sylv is an indicator variable telling the program to use the built-in function sylvester() to solve for QQ and SS, if possible. Default is to use Sylv=1. Parameters ---------- AA : array_like, dtype=float, shape=(ny, nx) The matrix represented above by :math:`A`. It is the matrix of derivatives of the Y equations with repsect to :math:`X_t` BB : array_like, dtype=float, shape=(ny, nx) The matrix represented above by :math:`B`. It is the matrix of derivatives of the Y equations with repsect to :math:`X_{t-1}`. CC : array_like, dtype=float, shape=(ny, ny) The matrix represented above by :math:`C`. It is the matrix of derivatives of the Y equations with repsect to :math:`Y_t` DD : array_like, dtype=float, shape=(ny, nz) The matrix represented above by :math:`C`. It is the matrix of derivatives of the Y equations with repsect to :math:`Z_t` FF : array_like, dtype=float, shape=(nx, nx) The matrix represetned above by :math:`F`. It is the matrix of derivatives of the model's characterizing equations with respect to :math:`X_{t+1}` GG : array_like, dtype=float, shape=(nx, nx) The matrix represetned above by :math:`G`. It is the matrix of derivatives of the model's characterizing equations with respect to :math:`X_t` HH : array_like, dtype=float, shape=(nx, nx) The matrix represetned above by :math:`H`. It is the matrix of derivatives of the model's characterizing equations with respect to :math:`X_{t-1}` JJ : array_like, dtype=float, shape=(nx, ny) The matrix represetned above by :math:`J`. It is the matrix of derivatives of the model's characterizing equations with respect to :math:`Y_{t+1}` KK : array_like, dtype=float, shape=(nx, ny) The matrix represetned above by :math:`K`. It is the matrix of derivatives of the model's characterizing equations with respect to :math:`Y_t` LL : array_like, dtype=float, shape=(nx, nz) The matrix represetned above by :math:`L`. It is the matrix of derivatives of the model's characterizing equations with respect to :math:`Z_{t+1}` MM : array_like, dtype=float, shape=(nx, nz) The matrix represetned above by :math:`M`. It is the matrix of derivatives of the model's characterizing equations with respect to :math:`Z_t` WWW : array, dtype=float, shape=(ny,) The vector of the numberial errors of first ny characterizing equations TT : array, dtype=float, shape=(nx,) The vector of the numberial errors of the next nx characterizing equations following the first ny equations NN : array_like, dtype=float, shape=(nz, nz) The autocorrelation matrix for the exogenous state vector z. Z0 : array, dtype=float, shape=(nz,) the Z-point about which the linearization is taken. For linearizing about the steady state this is Zbar and normally Zbar = 0. QQ if true. Sylv: binary, dtype=int an indicator variable telling the program to use the built-in function sylvester() to solve for QQ and SS, if possible. Default is to use Sylv=1. Returns ------- P : 2D-array, dtype=float, shape=(nx, nx) The matrix :math:`P` in the law of motion for endogenous state variables described above. Q : 2D-array, dtype=float, shape=(nx, nz) The matrix :math:`Q` in the law of motion for exogenous state variables described above. U : array, dtype=float, shape=(nx,) ?????????? R : 2D-array, dtype=float, shape=(ny, nx) The matrix :math:`R` in the law of motion for endogenous state variables described above. S : 2D-array, dtype=float, shape=(ny, nz) The matrix :math:`S` in the law of motion for exogenous state variables described above. V : array, dtype=float, shape=(ny,) ??????????? References ---------- .. [1] Uhlig, H. (1999): "A toolkit for analyzing nonlinear dynamic stochastic models easily," in Computational Methods for the Study of Dynamic Economies, ed. by R. Marimon, pp. 30-61. Oxford University Press. """ #The original coding we did used the np.matrix form for our matrices so we #make sure to set our inputs to numpy matrices. AA = np.matrix(AA) BB = np.matrix(BB) CC = np.matrix(CC) DD = np.matrix(DD) FF = np.matrix(FF) GG = np.matrix(GG) HH = np.matrix(HH) JJ = np.matrix(JJ) KK = np.matrix(KK) LL = np.matrix(LL) MM = np.matrix(MM) NN = np.matrix(NN) WWW = np.array(WWW) TT = np.array(TT) Z0 = np.array(Z0) #Tolerance level to use TOL = .000001 # Here we use matrices to get pertinent dimensions. nx = FF.shape[1] l_equ = CC.shape[0] ny = CC.shape[1] nz = min(NN.shape) # The following if and else blocks form the # Psi, Gamma, Theta Xi, Delta mats if l_equ == 0: if CC.any(): # This blcok makes sure you don't throw an error with an empty CC. CC_plus = la.pinv(CC) CC_0 = _nullSpaceBasis(CC.T) else: CC_plus = np.mat([]) CC_0 = np.mat([]) Psi_mat = FF Gamma_mat = -GG Theta_mat = -HH Xi_mat = np.mat( vstack((hstack( (Gamma_mat, Theta_mat)), hstack((eye(nx), zeros((nx, nx))))))) Delta_mat = np.mat( vstack((hstack((Psi_mat, zeros( (nx, nx)))), hstack((zeros((nx, nx)), eye(nx)))))) else: CC_plus = la.pinv(CC) CC_0 = _nullSpaceBasis(CC.T) if l_equ != ny: Psi_mat = vstack((zeros((l_equ - ny, nx)), FF \ - dot(dot(JJ, CC_plus), AA))) Gamma_mat = vstack((dot(CC_0, AA), dot(dot(JJ, CC_plus), BB) \ - GG + dot(dot(KK, CC_plus), AA))) Theta_mat = vstack((dot(CC_0, BB), dot(dot(KK, CC_plus), BB) - HH)) else: CC_inv = la.inv(CC) Psi_mat = FF - dot(JJ.dot(CC_inv), AA) Gamma_mat = dot(JJ.dot(CC_inv), BB) - GG + dot(dot(KK, CC_inv), AA) Theta_mat = dot(KK.dot(CC_inv), BB) - HH Xi_mat = vstack((hstack((Gamma_mat, Theta_mat)), \ hstack((eye(nx), zeros((nx, nx)))))) Delta_mat = vstack((hstack((Psi_mat, np.mat(zeros((nx, nx))))),\ hstack((zeros((nx, nx)), eye(nx))))) # Now we need the generalized eigenvalues/vectors for Xi with respect to # Delta. That is eVals and eVecs below. eVals, eVecs = la.eig(Xi_mat, Delta_mat) if npla.matrix_rank(eVecs) < nx: print("Error: Xi is not diagonalizable, stopping...") # From here to line 158 we Diagonalize Xi, form Lambda/Omega and find P. else: Xi_sortabs = np.sort(abs(eVals)) Xi_sortindex = np.argsort(abs(eVals)) Xi_sortedVec = np.array([eVecs[:, i] for i in Xi_sortindex]).T Xi_sortval = eVals[Xi_sortindex] Xi_select = np.arange(0, nx) if np.imag(Xi_sortval[nx - 1]).any(): if (abs(Xi_sortval[nx - 1] - sp.conj(Xi_sortval[nx])) < TOL): drop_index = 1 cond_1 = (abs(np.imag(Xi_sortval[drop_index - 1])) > TOL) cond_2 = drop_index < nx while cond_1 and cond_2: drop_index += 1 if drop_index >= nx: print("There is an error. Too many complex eigenvalues." + " Quitting...") else: print("Droping the lowest real eigenvalue. Beware of" + " sunspots!") Xi_select = np.array([np.arange(0, drop_index - 1),\ np.arange(drop_index, nx + 1)]) # Here Uhlig computes stuff if user chose "Manual roots" I skip it. if max(abs(Xi_sortval[Xi_select])) > 1 + TOL: print( "It looks like we have unstable roots. This might not work...") if abs(max(abs(Xi_sortval[Xi_select])) - 1) < TOL: print("Check the model to make sure you have a unique steady" + " state we are having problems with convergence.") Lambda_mat = np.diag(Xi_sortval[Xi_select]) Omega_mat = Xi_sortedVec[nx:2 * nx, Xi_select] if npla.matrix_rank(Omega_mat) < nx: print("Omega matrix is not invertible, Can't solve for P; we" + " proceed with QZ-method instead.") #~~~~~~~~~ QZ-method codes from SOLVE_QZ ~~~~~~~~# Delta_up, Xi_up, UUU, VVV = la.qz(Delta_mat, Xi_mat, output='complex') UUU = UUU.T Xi_eigval = np.diag( np.diag(Xi_up) / np.maximum(np.diag(Delta_up), TOL)) Xi_sortabs = np.sort(abs(np.diag(Xi_eigval))) Xi_sortindex = np.argsort(abs(np.diag(Xi_eigval))) Xi_sortval = Xi_eigval[Xi_sortindex, Xi_sortindex] Xi_select = np.arange(0, nx) stake = max(abs(Xi_sortval[Xi_select])) + TOL Delta_up, Xi_up, UUU, VVV = qzdiv(stake, Delta_up, Xi_up, UUU, VVV) #Check conditions from line 49-109 if np.imag(Xi_sortval[nx - 1]).any(): if (abs(Xi_sortval[nx - 1] - sp.conj(Xi_sortval[nx])) < TOL): print( "Problem: You have complex eigenvalues! And this means" + " PP matrix will contain complex numbers by this method." ) drop_index = 1 cond_1 = (abs(np.imag(Xi_sortval[drop_index - 1])) > TOL) cond_2 = drop_index < nx while cond_1 and cond_2: drop_index += 1 if drop_index >= nx: print("There is an error. Too many complex eigenvalues." + " Quitting...") else: print("Dropping the lowest real eigenvalue. Beware of" + " sunspots!") for i in range(drop_index, nx + 1): Delta_up, Xi_up, UUU, VVV = qzswitch( i, Delta_up, Xi_up, UUU, VVV) Xi_select1 = np.arange(0, drop_index - 1) Xi_select = np.append(Xi_select1, np.arange(drop_index, nx + 1)) if Xi_sortval[max(Xi_select)] < 1 - TOL: print('There are stable roots NOT used. Proceeding with the' + ' smallest root.') if max(abs(Xi_sortval[Xi_select])) > 1 + TOL: print( "It looks like we have unstable roots. This might not work..." ) if abs(max(abs(Xi_sortval[Xi_select])) - 1) < TOL: print("Check the model to make sure you have a unique steady" + " state we are having problems with convergence.") #End of checking conditions #Lambda_mat = np.diag(Xi_sortval[Xi_select]) # to help sol_out.m VVV = VVV.conj().T VVV_2_1 = VVV[nx:2 * nx, 0:nx] VVV_2_2 = VVV[nx:2 * nx, nx:2 * nx] UUU_2_1 = UUU[nx:2 * nx, 0:nx] VVV = VVV.conj().T if abs(la.det(UUU_2_1)) < TOL: print( "One necessary condition for computing P is NOT satisfied," + " but we proceed anyways...") if abs(la.det(VVV_2_1)) < TOL: print( "VVV_2_1 matrix, used to compute for P, is not invertible; we" + " are in trouble but we proceed anyways...") PP = np.matrix(la.solve(-VVV_2_1, VVV_2_2)) PP_imag = np.imag(PP) PP = np.real(PP) if (sum(sum(abs(PP_imag))) / sum(sum(abs(PP))) > .000001).any(): print( "A lot of P is complex. We will continue with the" + " real part and hope we don't lose too much information.") #~~~~~~~~~ End of QZ-method ~~~~~~~~~# #This follows the original uhlig.py file else: PP = dot(dot(Omega_mat, Lambda_mat), la.inv(Omega_mat)) PP_imag = np.imag(PP) PP = np.real(PP) if (sum(sum(abs(PP_imag))) / sum(sum(abs(PP))) > .000001).any(): print( "A lot of P is complex. We will continue with the" + " real part and hope we don't lose too much information.") # The code from here to the end was from he Uhlig file calc_qrs.m. # I think for python it fits better here than in a separate file. # The if and else below make RR and VV depending on our model's setup. if l_equ == 0: RR = zeros((0, nx)) VV = hstack((kron(NN.T, FF) + kron(eye(nz), \ (dot(FF, PP) + GG)), kron(NN.T, JJ) + kron(eye(nz), KK))) else: RR = -dot(CC_plus, (dot(AA, PP) + BB)) VV = sp.vstack((hstack((kron(eye(nz), AA), \ kron(eye(nz), CC))), hstack((kron(NN.T, FF) +\ kron(eye(nz), dot(FF, PP) + dot(JJ, RR) + GG),\ kron(NN.T, JJ) + kron(eye(nz), KK))))) # Now we use LL, NN, RR, VV to get the QQ, RR, SS, VV matrices. # first try using Sylvester equation solver if Sylv: if ny > 0: PM = (FF - la.solve(JJ.dot(CC), AA)) if npla.matrix_rank(PM) < nx + ny: Sylv = 0 print("Sylvester equation solver condition is not satisfied;"\ +" proceed with the original method...") else: if npla.matrix_rank(FF) < nx: Sylv = 0 print("Sylvester equation solver condition is not satisfied;"\ +" proceed with the original method...") print("Using Sylvester equation solver...") if ny > 0: Anew = la.solve(PM, (FF.dot(PP)+GG+JJ.dot(RR)-\ la.solve(KK.dot(CC), AA)) ) Bnew = NN Cnew1 = la.solve(JJ.dot(CC),DD.dot(NN))+la.solve(KK.dot(CC), DD)-\ LL.dot(NN)-MM Cnew = la.solve(PM, Cnew1) QQ = la.solve_sylvester(Anew, Bnew, Cnew) SS = la.solve(-CC, (AA.dot(QQ) + DD)) else: Anew = la.solve(FF, (FF.dot(PP) + GG)) Bnew = NN Cnew = la.solve(FF, (-LL.dot(NN) - MM)) QQ = la.solve_sylvester(Anew, Bnew, Cnew) SS = np.zeros((0, nz)) #empty matrix # then the Uhlig's way else: if (npla.matrix_rank(VV) < nz * (nx + ny)): print("Sorry but V is not invertible. Can't solve for Q and S;" + " but we proceed anyways...") LL = sp.mat(LL) NN = sp.mat(NN) LLNN_plus_MM = dot(LL, NN) + MM if DD.any(): impvec = vstack([DD, LLNN_plus_MM]) else: impvec = LLNN_plus_MM impvec = np.reshape(impvec, ((nx + ny) * nz, 1), 'F') QQSS_vec = np.matrix(la.solve(-VV, impvec)) if (max(abs(QQSS_vec)) == sp.inf).any(): print("We have issues with Q and S. Entries are undefined." + " Probably because V is no inverible.") #Build QQ SS QQ = np.reshape(np.matrix(QQSS_vec[0:nx * nz, 0]), (nx, nz), 'F') SS = np.reshape(QQSS_vec[(nx * nz):((nx + ny) * nz), 0],\ (ny, nz), 'F') #Build WW - WW has the property [x(t)',y(t)',z(t)']=WW [x(t)',z(t)']. WW = sp.vstack( (hstack((eye(nx), zeros((nx, nz)))), hstack((dot(RR, la.pinv(PP)), (SS - dot(dot(RR, la.pinv(PP)), QQ)))), hstack((zeros((nz, nx)), eye(nz))))) # find constant terms # redefine matrix to be 2D-array for generating vectors UU and VVV AA = np.array(AA) CC = np.array(CC) FF = np.array(FF) GG = np.array(GG) JJ = np.array(JJ) KK = np.array(KK) LL = np.array(LL) NN = np.array(NN) RR = np.array(RR) QQ = np.array(QQ) SS = np.array(SS) if ny > 0: UU1 = -(FF.dot(PP) + GG + JJ.dot(RR) + FF - (JJ + KK).dot(la.solve(CC, AA))) UU2 = (TT+(FF.dot(QQ)+JJ.dot(SS)+LL).dot(NN.dot(Z0)-Z0)- \ (JJ+KK).dot(la.solve(CC,WWW))) UU = la.solve(UU1, UU2) VVV = la.solve(-CC, (WWW + AA.dot(UU))) else: UU = la.solve(-(FF.dot(PP) + FF + GG), (TT + (FF.dot(QQ) + LL).dot(NN.dot(Z0) - Z0))) VVV = np.array([]) return np.array(PP), np.array(QQ), np.array(UU), np.array(RR), np.array(SS),\ np.array(VVV)
def __init__(self, bounds, fit, A=None, npop=None, eta_mu=1.0, eta_sigma=None, eta_Bmat=None, adapt_sampling=False, ncores=1, seed=None): if seed: random.seed(seed) np.random.seed(seed) self.seed = seed patience = 100 self.fitness_hom = -np.inf self.f = fit self.eta_mu = eta_mu self.use_adasam = adapt_sampling self.ncores = ncores self.bounds = bounds dim = len(bounds) A = np.eye(dim) if A is None else A sigma = abs(det(A))**(1.0 / dim) bmat = A * (1.0 / sigma) self.dim = dim self.sigma = sigma self.bmat = bmat # default population size and learning rates npop = int(4 + 3 * log(dim)) if npop is None else npop eta_sigma = 3 * (3 + log(dim)) * ( 1.0 / (5 * dim * sqrt(dim))) if eta_sigma is None else eta_sigma eta_Bmat = 3 * (3 + log(dim)) * ( 1.0 / (5 * dim * sqrt(dim))) if eta_Bmat is None else eta_Bmat self.npop = npop self.eta_sigma = eta_sigma self.eta_bmat = eta_Bmat use_fshape = True # compute utilities if using fitness shaping if use_fshape: a = log(1 + 0.5 * npop) utilities = array([max(0, a - log(k)) for k in range(1, npop + 1)]) utilities /= sum(utilities) utilities -= 1.0 / npop # broadcast utilities = utilities[::-1] # ascending order else: utilities = None self.use_fshape = use_fshape self.utilities = utilities # stuff for adasam self.eta_sigma_init = eta_sigma self.sigma_old = None # logging self.fitness_best = -np.inf self.mu_best = None self.done = False self.counter = 0 self.patience = patience self.history = {'eta_sigma': [], 'sigma': [], 'fitness': []} # do not use options below when one individual in population is used if npop == 1: self.use_fshape = False self.use_adasam = False
sol=root(fun,0.1) print("ROOT:",sol.x,sol.fun) #3----Interpolation插值 x=np.linspace(0,1,10) y=np.sin(2*np.pi*x) from scipy.interpolate import interp1d li=interp1d(x,y,kind="cubic") x_new=np.linspace(0,1,50) y_new=li(x_new) figure() plot(x,y,"r") plot(x_new,y_new,"k") show() print(y_new) #4 linear from scipy import linalg as lg arr=np.array([[1,2],[3,4]]) print("Det:",lg.det(arr)) print("Inv:",lg.inv(arr)) b=np.array([6,14]) print("Sol:",lg.solve(arr,b)) print("Eig:",lg.eig(arr)) print("LU:",lg.lu(arr)) print("QR:",lg.qr(arr)) print("SVD:",lg.svd(arr)) print("Schur:",lg.schur(arr)) #others
def __new__(cls, unitary_matrix, *, fidelity=(1.0 - 1.0e-9)): """Perform the Weyl chamber decomposition, and optionally choose a specialized subclass. The flip into the Weyl Chamber is described in B. Kraus and J. I. Cirac, Phys. Rev. A 63, 062309 (2001). FIXME: There's a cleaner-seeming method based on choosing branch cuts carefully, in Andrew M. Childs, Henry L. Haselgrove, and Michael A. Nielsen, Phys. Rev. A 68, 052311, but I wasn't able to get that to work. The overall decomposition scheme is taken from Drury and Love, arXiv:0806.4015 [quant-ph]. """ pi = np.pi pi2 = np.pi / 2 pi4 = np.pi / 4 # Make U be in SU(4) U = np.array(unitary_matrix, dtype=complex, copy=True) detU = la.det(U) U *= detU ** (-0.25) global_phase = cmath.phase(detU) / 4 Up = _Bd.dot(U).dot(_B) M2 = Up.T.dot(Up) # M2 is a symmetric complex matrix. We need to decompose it as M2 = P D P^T where # P ∈ SO(4), D is diagonal with unit-magnitude elements. # D, P = la.eig(M2) # this can fail for certain kinds of degeneracy state = np.random.default_rng(2020) for _ in range(100): # FIXME: this randomized algorithm is horrendous M2real = state.normal() * M2.real + state.normal() * M2.imag _, P = np.linalg.eigh(M2real) D = P.T.dot(M2).dot(P).diagonal() if np.allclose(P.dot(np.diag(D)).dot(P.T), M2, rtol=0, atol=1.0e-13): break else: raise QiskitError("TwoQubitWeylDecomposition: failed to diagonalize M2") d = -np.angle(D) / 2 d[3] = -d[0] - d[1] - d[2] cs = np.mod((d[:3] + d[3]) / 2, 2 * np.pi) # Reorder the eigenvalues to get in the Weyl chamber cstemp = np.mod(cs, pi2) np.minimum(cstemp, pi2 - cstemp, cstemp) order = np.argsort(cstemp)[[1, 2, 0]] cs = cs[order] d[:3] = d[order] P[:, :3] = P[:, order] # Fix the sign of P to be in SO(4) if np.real(la.det(P)) < 0: P[:, -1] = -P[:, -1] # Find K1, K2 so that U = K1.A.K2, with K being product of single-qubit unitaries K1 = _B.dot(Up).dot(P).dot(np.diag(np.exp(1j * d))).dot(_Bd) K2 = _B.dot(P.T).dot(_Bd) K1l, K1r, phase_l = decompose_two_qubit_product_gate(K1) K2l, K2r, phase_r = decompose_two_qubit_product_gate(K2) global_phase += phase_l + phase_r K1l = K1l.copy() # Flip into Weyl chamber if cs[0] > pi2: cs[0] -= 3 * pi2 K1l = K1l.dot(_ipy) K1r = K1r.dot(_ipy) global_phase += pi2 if cs[1] > pi2: cs[1] -= 3 * pi2 K1l = K1l.dot(_ipx) K1r = K1r.dot(_ipx) global_phase += pi2 conjs = 0 if cs[0] > pi4: cs[0] = pi2 - cs[0] K1l = K1l.dot(_ipy) K2r = _ipy.dot(K2r) conjs += 1 global_phase -= pi2 if cs[1] > pi4: cs[1] = pi2 - cs[1] K1l = K1l.dot(_ipx) K2r = _ipx.dot(K2r) conjs += 1 global_phase += pi2 if conjs == 1: global_phase -= pi if cs[2] > pi2: cs[2] -= 3 * pi2 K1l = K1l.dot(_ipz) K1r = K1r.dot(_ipz) global_phase += pi2 if conjs == 1: global_phase -= pi if conjs == 1: cs[2] = pi2 - cs[2] K1l = K1l.dot(_ipz) K2r = _ipz.dot(K2r) global_phase += pi2 if cs[2] > pi4: cs[2] -= pi2 K1l = K1l.dot(_ipz) K1r = K1r.dot(_ipz) global_phase -= pi2 a, b, c = cs[1], cs[0], cs[2] # Save the non-specialized decomposition for later comparison od = super().__new__(TwoQubitWeylDecomposition) od.a = a od.b = b od.c = c od.K1l = K1l od.K1r = K1r od.K2l = K2l od.K2r = K2r od.global_phase = global_phase od.requested_fidelity = fidelity od.calculated_fidelity = 1.0 od.unitary_matrix = np.array(unitary_matrix, dtype=complex, copy=True) od.unitary_matrix.setflags(write=False) od._original_decomposition = None od._is_flipped_from_original = False def is_close(ap, bp, cp): da, db, dc = a - ap, b - bp, c - cp tr = 4 * complex( math.cos(da) * math.cos(db) * math.cos(dc), math.sin(da) * math.sin(db) * math.sin(dc), ) fid = trace_to_fid(tr) return fid >= fidelity if fidelity is None: # Don't specialize if None instance = super().__new__( TwoQubitWeylGeneral if cls is TwoQubitWeylDecomposition else cls ) elif is_close(0, 0, 0): instance = super().__new__(TwoQubitWeylIdEquiv) elif is_close(pi4, pi4, pi4) or is_close(pi4, pi4, -pi4): instance = super().__new__(TwoQubitWeylSWAPEquiv) elif (lambda x: is_close(x, x, x))(_closest_partial_swap(a, b, c)): instance = super().__new__(TwoQubitWeylPartialSWAPEquiv) elif (lambda x: is_close(x, x, -x))(_closest_partial_swap(a, b, -c)): instance = super().__new__(TwoQubitWeylPartialSWAPFlipEquiv) elif is_close(a, 0, 0): instance = super().__new__(TwoQubitWeylControlledEquiv) elif is_close(pi4, pi4, c): instance = super().__new__(TwoQubitWeylMirrorControlledEquiv) elif is_close((a + b) / 2, (a + b) / 2, c): instance = super().__new__(TwoQubitWeylfSimaabEquiv) elif is_close(a, (b + c) / 2, (b + c) / 2): instance = super().__new__(TwoQubitWeylfSimabbEquiv) elif is_close(a, (b - c) / 2, (c - b) / 2): instance = super().__new__(TwoQubitWeylfSimabmbEquiv) else: instance = super().__new__(TwoQubitWeylGeneral) instance._original_decomposition = od return instance
) ### conjugate transpose assert array_equal( sp.array([[1j, 2j]]).conjugate().T, sp.array([[-1j], [-2j]]), ) ### identity assert sp.array_equal(sp.eye(2), sp.array([[1., 0.], [0., 1.]])) ### determinant assert array_equal(la.det(sp.array([[1, 2], [3, 4]])), -2) ### inverse # **DO NOT USE THIS TO SOLVE LINEAR SYSTEMS** # use <# solve> instead, or an explicit LU decomposition. # (solve likely uses LU it under the hood) # This will be faster and more stable. # Learn what LU decomposition is now if you don't know so. A = sp.array([[1, 2], [3, 4]]) assert array_equal(la.inv(A).dot(A), sp.eye(2))
''' Created on 2018年7月1日 @author: Administrator ''' import matplotlib.pyplot as plt import numpy as np import tensorflow as tf from scipy import fftpack as fft from scipy import io as spio from scipy import linalg from scipy import optimize def f(x): return x**2 + 10 * np.sin(x) if __name__ == '__main__': a = np.ones([3, 3]) spio.savemat('file.mat', {'a': a}) data = spio.loadmat("file.mat", struct_as_record=True) print(data['a']) arr = np.array([[1, 2, 3], [3, 4, 6], [5, 7, 8]]) print('arr:', linalg.det(arr)) x = np.arange(-10, 10, 0.1) print("fmin:", optimize.fmin(f, -5)) plt.plot(x, f(x)) plt.show() pass
def test_simple_complex(self): a = [[1, 2], [3, 4j]] a_det = det(a) assert_almost_equal(a_det, -6 + 4j)
# creating a numpy 32x32 array A with normally distributed random numbers g_(i,j)~N(0,1) as it's elements # this means a normal distribution with mu = 0 and standard deviation of 1.0 # if you want values only between 0 and 1 then use np.random.random((size, size)) A = np.random.normal(0, 1, (32, 32)) print(A) # calculating the inverse B= A^(-1) B = lalg.inv(A) print(B) # transpose matrix C = A.T #print(C) # find the determinant determinant_A = lalg.det(A) #print(determinant_A) # The product of AB using the matrices A and B D = np.multiply(A, B) print(D) # The Dot product (dot and vector) E = np.dot(A, B) #print(E) F = np.vdot(A, B) #print(F) # calculating eigenvalues and eigenvectors using scipy module .eig eigenvalues, eigenvectors = lalg.eig(A)
xmax, ymax, zmax = 1., 1., 1. # Physical domain that density estimation is performed on. xdim, ydim, zdim = 65, 65, 65 # Grid resolution of the physical domain. H = np.zeros((3, 3)) # bandwidth matrix H[0, 0], H[0, 1], H[0, 2] = .0025, 0., 0. H[1, 0], H[1, 1], H[1, 2] = 0., .0025, 0. H[2, 0], H[2, 1], H[2, 2] = 0., 0., .0025 # ------------------------------------------------------------------------------ # SDE computation -------------------------------------------------------------- a, b, c = verts[0], verts[1], verts[2] # three vertices of the triangle area = TriangleArea(a, b, c) # area of the triangle Hi = linalg.inv(H) # inverse of the bandwidth matrix Hi_sqrt = linalg.sqrtm(Hi) # square root of Hi (i.e., Hi_sqrt x Hi_sqrt = Hi) Hi_sqrt_det = float(linalg.det(Hi_sqrt)) # determinant of Hi_sqrt Hi_sqrt = Hi_sqrt.flatten().tolist() # Create a numpy array to store SDE. sde = np.zeros([zdim, ydim, xdim]) # Compute SDE for each grid point. for i in tqdm(range(xdim * ydim * zdim)): # physical position of the grid point gk = math.floor(i / (xdim * ydim)) gj = math.floor((i - gk * xdim * ydim) / xdim) gi = i % xdim x = [ gi * (xmax - xmin) / (xdim - 1.) + xmin, gj * (ymax - ymin) / (ydim - 1.) + ymin,
def var_bound(data, modelState, queryState): ''' Determines the variational bounds. Values are mutated in place, but are reset afterwards to their initial values. So it's safe to call in a serial manner. ''' # Unpack the the structs, for ease of access and efficiency W = data.words D,_ = W.shape means, expMeans, varcs, docLens = queryState.means, queryState.expMeans, queryState.varcs, queryState.docLens K, topicMean, sigT, vocab, vocabPrior, A = modelState.K, modelState.topicMean, modelState.sigT, modelState.vocab, modelState.vocabPrior, modelState.A # Calculate some implicit variables isigT = la.inv(sigT) bound = 0 if USE_NIW_PRIOR: pseudoObsMeans = K + NIW_PSEUDO_OBS_MEAN pseudoObsVar = K + NIW_PSEUDO_OBS_VAR # distribution over topic covariance bound -= 0.5 * K * pseudoObsVar * log(NIW_PSI) bound -= 0.5 * K * pseudoObsVar * log(2) bound -= fns.multigammaln(pseudoObsVar / 2., K) bound -= 0.5 * (pseudoObsVar + K - 1) * safe_log_det(sigT) bound += 0.5 * NIW_PSI * np.trace(isigT) # and its entropy # is a constant which we skip # distribution over means bound -= 0.5 * K * log(1./pseudoObsMeans) * safe_log_det(sigT) bound -= 0.5 / pseudoObsMeans * (topicMean).T.dot(isigT).dot(topicMean) # and its entropy bound += 0.5 * safe_log_det(sigT) # + a constant # Distribution over document topics bound -= (D*K)/2. * LN_OF_2_PI bound -= D/2. * la.det(sigT) diff = means - topicMean[np.newaxis,:] bound -= 0.5 * np.sum (diff.dot(isigT) * diff) bound -= 0.5 * np.sum(varcs * np.diag(isigT)[np.newaxis,:]) # = -0.5 * sum_d tr(V_d \Sigma^{-1}) when V_d is diagonal only. # And its entropy # bound += 0.5 * D * K * LN_OF_2_PI_E + 0.5 * np.sum(np.log(varcs)) # Distribution over word-topic assignments and words and the formers # entropy. This is somewhat jumbled to avoid repeatedly taking the # exp and log of the means expMeans = np.exp(means - means.max(axis=1)[:,np.newaxis], out=expMeans) R = sparseScalarQuotientOfDot(W, expMeans, vocab) # D x V [W / TB] is the quotient of the original over the reconstructed doc-term matrix V = expMeans * (R.dot(vocab.T)) # D x K bound += np.sum(docLens * np.log(np.sum(expMeans, axis=1))) bound += np.sum(sparseScalarProductOfSafeLnDot(W, expMeans, vocab).data) bound += np.sum(means * V) bound += np.sum(2 * ssp.diags(docLens,0) * means.dot(A) * means) bound -= 2. * scaledSelfSoftDot(means, docLens) bound -= 0.5 * np.sum(docLens[:,np.newaxis] * V * (np.diag(A))[np.newaxis,:]) bound -= np.sum(means * V) return bound
# -*- coding: utf-8 -*- from numpy import * from scipy import linalg as LA from matplotlib.pyplot import * import matplotlib.cm as cm # 多変量分布の図示 rho = 0.5 mu = array([0, 0]) # 平均 S = array([[1, rho], [rho, 1]]) # 分散 Sinv = LA.inv(S) detS = LA.det(S) def f(x): return exp(-(x - mu).T.dot(Sinv).dot(x - mu) / 2) / (2 * pi * sqrt(detS)) X, Y = meshgrid(linspace(-3, 3, 100), linspace(-3, 3, 100)) Z = vectorize(lambda x, y: f([x, y]))(X, Y) xlim(-3, 3) ylim(-3, 3) pcolor(X, Y, Z, alpha=0.3) show() # Gibbs sampling def next(x): new_x = random.normal(rho * x[1], 1 - rho**2) new_y = random.normal(rho * new_x, 1 - rho**2)
cursor.execute("SELECT VERSION()") data = cursor.fetchone() print(data) db.close() import numpy as np from scipy import linalg A = np.array([[1,2],[3,4]]) print(A) print(linalg.inv(A)) b=np.array([[5],[6]]) print(b.T) print(A*b) print(np.linalg.solve(A,b)) print(linalg.det(A)) import numpy as np from scipy import linalg import matplotlib.pyplot as plt c1, c2 = 5.0, 2.0 i = np.r_[1:11] xi = 0.1*i yi = c1*np.exp(-xi) + c2*xi zi = yi + 0.05 * np.max(yi) * np.random.randn(len(yi)) A = np.c_[np.exp(-xi)[:, np.newaxis], xi[:, np.newaxis]] print(linalg.lstsq(A, zi)) import numpy as np from scipy import linalg
def time_det(self, size, contig, module): if module == 'numpy': nl.det(self.a) else: sl.det(self.a)
print(np.matmul(A,resMat)) print("Least squares solution") print(np.matmul(A,resMatLstSq)) #f) Solve the eigenvalue problem for A eigenvals, eigenvecs = la.eig(A) print("Eigenvalues: ", eigenvals) print("Eigenvectors: ", eigenvecs) #print(np.matmul(A,eigenvecs[:,1])) #print(np.dot(eigenvals[1],eigenvecs[:,1])) print("Difference between A*eigvec and eigval*eigvec: ", la.norm(np.matmul(A,eigenvecs[:,1])-np.dot(eigenvals[1],eigenvecs[:,1]))) #g) Calculate the inverse, determinant of A invA = la.inv(A) print("Inverse of A: ", invA) detA = la.det(A) print("Determinant of A: ", detA) #Calculate norm of A with different orders norm2A = la.norm(A, ord=2) print("Matrix 2-norm of A: ", norm2A) normMaxRowsA = la.norm(A, ord=1) print("Max of sum over rows of A: ", normMaxRowsA) normMaxColsA = la.norm(A, ord=np.inf) print("Max of sum over cols of A: ", normMaxColsA)