def show_solution(A, b, bp, ls): # "real" solution x = solve(A, b) for l in ls: bc = l * bp # current b matrix db = abs(bc - b) print "With %f: " % l print "\t║𝚫b║₂ = %f" % frobenius(db) # solve it xc = solve(A, l*bp) dx = abs(xc - x) # Calcualte the errors Ainv = inv(A) cond = frobenius(A) * frobenius(Ainv) abserr = frobenius(Ainv) * frobenius(db) relerr = cond * (frobenius(db) / frobenius(b)) print "\t Expected max error %f" % abserr print "\t║𝚫x║₂ = %f" % frobenius(dx) print "\t Expected rel error %f" % relerr print "\t║𝚫x║₂/║x║₂ = %f" % (frobenius(dx) / frobenius(x)) print ""
def rols(self, keep=True): """Return: array(T-ncoefs by ncoefs) Compute "recursive OLS" parameter estimates. :todo: add standard errors """ if self._rols_coefs is not None: return self._rols_coefs from numpy.linalg import solve Y, X = np.asmatrix(self.Y), np.asmatrix(self.X) nobs, ncoefs = X.shape X0 = X[:ncoefs] #square matrix Y0 = Y[:ncoefs] #square matrix #create array to hold parameter estimates coef_array = np.empty( (nobs-ncoefs+1, ncoefs) ) coef_array[0] = solve(X0,Y0).A1 xTx = X0.T * X0 xTy = X0.T * Y0 #get initial parameter estimate (shortest possible data sample) #iteratively update parameter estimates for i in range(ncoefs,nobs): xTx += X[i].T * X[i] xTy += X[i].T * Y[i] coef_array[i-ncoefs+1] = solve(xTx,xTy).A1 if keep: self._rols_coefs = coef_array return coef_array
def ridge_regression(X, Y, c1=0.0, c2=0.0, offset=None): """ Also known as Tikhonov regularization. This solves the minimization problem: min_{beta} ||(beta X - Y)||^2 + c1||beta||^2 + c2||beta - offset||^2 One can find more information here: http://en.wikipedia.org/wiki/Tikhonov_regularization Parameters: X: a (n,d) numpy array Y: a (n,) numpy array c1: a scalar c2: a scalar offset: a (d,) numpy array. Returns: beta_hat: the solution to the minimization problem. V = (X*X^T + (c1+c2)I)^{-1} X^T """ n, d = X.shape X = X.astype(float) penalizer_matrix = (c1 + c2) * np.eye(d) if offset is None: offset = np.zeros((d,)) A = (np.dot(X.T, X) + penalizer_matrix) b = (np.dot(X.T, Y) + c2 * offset) # rather than explicitly computing the inverse, just solve the system of equations return (solve(A, b), solve(A, X.T))
def als_step(self, latent_vectors, fixed_vecs, ratings, _lambda, type='user'): """ One of the two ALS steps. Solve for the latent vectors specified by type. """ if type == 'user': # Precompute YTY = fixed_vecs.T.dot(fixed_vecs) lambdaI = np.eye(YTY.shape[0]) * _lambda for u in xrange(latent_vectors.shape[0]): latent_vectors[u, :] = solve((YTY + lambdaI), ratings[u, :].dot(fixed_vecs)) elif type == 'item': # Precompute XTX = fixed_vecs.T.dot(fixed_vecs) lambdaI = np.eye(XTX.shape[0]) * _lambda for i in xrange(latent_vectors.shape[0]): latent_vectors[i, :] = solve((XTX + lambdaI), ratings[:, i].T.dot(fixed_vecs)) return latent_vectors
def qzswitch(i, A2, B2, Q, Z): #print i, A2, B2, Q, Z Aout = A2.copy(); Bout = B2.copy(); Qout = Q.copy(); Zout = Z.copy() ix = i-1 # from 1-based to 0-based indexing... # use all 1x1-matrices for convenient conjugate-transpose even if real: a = mat(A2[ix, ix]); d = mat(B2[ix, ix]); b = mat(A2[ix, ix+1]); e = mat(B2[ix, ix+1]); c = mat(A2[ix+1, ix+1]); f = mat(B2[ix+1, ix+1]) wz = c_[c*e - f*b, (c*d - f*a).H] xy = c_[(b*d - e*a).H, (c*d - f*a).H] n = sqrt(wz*wz.H) m = sqrt(xy*xy.H) if n[0,0] == 0: return (Aout, Bout, Qout, Zout) wz = solve(n, wz) xy = solve(m, xy) wz = r_[ wz, \ c_[-wz[:,1].H, wz[:,0].H]] xy = r_[ xy, \ c_[-xy[:,1].H, xy[:,0].H]] Aout[ix:ix+2, :] = xy * Aout[ix:ix+2, :] Bout[ix:ix+2, :] = xy * Bout[ix:ix+2, :] Aout[:, ix:ix+2] = Aout[:, ix:ix+2] * wz Bout[:, ix:ix+2] = Bout[:, ix:ix+2] * wz Zout[:, ix:ix+2] = Zout[:, ix:ix+2] * wz Qout[ix:ix+2, :] = xy * Qout[ix:ix+2, :] return (Aout, Bout, Qout, Zout)
def row_3_step(f, Jf, yi, h): r"""Rosenbrock-Wanner Methode der Ordnung 3 Input: f: Die rhs Funktion f(x): R^(nx1) -> R^(nx1) Jf: Jacobi Matrix J(x) der Funktion: R^(nx1) -> R^(nxn) yi: Aktueller Wert y_i zur Zeit ti h: Schrittweite Output: yip1: Zeitpropagierter Wert y(t+h): R^(nx1) """ yi = atleast_2d(yi) n = yi.shape[0] yip1 = zeros_like(yi) #################################################### # # # TODO: Implementieren Sie die ROW-3 Methode hier. # # # #################################################### a = 1/(2+sqrt(2)) d31 = -(4+sqrt(2))/(2+sqrt(2)) d32 = (6+sqrt(2))/(2+sqrt(2)) J = Jf(yi) I = identity(n) k1 = solve((I - a*h*J), f(yi)) k2 = solve((I - a*h*J), f(yi+h*0.5*k1) - a*h*J.dot(k1)) k3 = solve((I - a*h*J), f(yi+h*k2) - d31*h*J.dot(k1) - d32*h*J.dot(k2)) yip1 = yi + h/6*(k1+4*k2+k3) return yip1
def setCoefs(self): self.aquiferParent = self.modelParent.aq.findAquiferData(self.xw,self.yw) self.rwsq = self.rw**2; self.pylayers = self.layers-1; self.NscreenedLayers = len(self.layers) if self.NscreenedLayers == 1: # Screened in only one layer, no unknown parameters self.parameters = array([[self.discharge]]) else: self.parameters = zeros((self.NscreenedLayers,1),'d') self.coef = ones((self.NscreenedLayers,self.aquiferParent.Naquifers),'d') if self.aquiferParent.Naquifers > 1: # Multiple aquifers, must compute coefficients if self.aquiferParent.type == self.aquiferParent.conf: for i in range(self.NscreenedLayers): pylayer = self.pylayers[i] ramat = self.aquiferParent.eigvec[:,1:] # All eigenvectors, but not first normalized transmissivity ramat = vstack(( ramat[0:pylayer,:], ramat[pylayer+1:,:] )) # Remove row pylayer rb = self.aquiferParent.eigvec[:,0] / (2.0*pi) # Store Tn vector in rb rb = hstack(( rb[0:pylayer], rb[pylayer+1:] )) # solve takes rowvector self.coef[i,1:self.aquiferParent.Naquifers] = linalg.solve(ramat,rb) elif self.aquiferParent.type == self.aquiferParent.semi: for i in range(self.NscreenedLayers): pylayer = self.pylayers[i] ramat = self.aquiferParent.eigvec rb = zeros(self.aquiferParent.Naquifers,'d') rb[pylayer] = - 1.0 / (2.0 * pi) self.coef[i,:] = linalg.solve(ramat,rb) if self.aquiferParent.Naquifers == 1 and self.aquiferParent.type == self.aquiferParent.semi: self.coef[0,0] = -1.0 / (2.0 * pi) self.paramxcoef = sum( self.parameters * self.coef, 0 ) # Parameters times coefficients
def fJr(pars, x, y = 0, calcJ = True): """ calculate f and J for reduced system (only nonlinear parameters) """ F, Fd = rF(pars, x) #calculate linear Parameters FtF = inner(F, F) Fty = inner(F, y) c = solve(FtF, Fty) #calculate residuum r = dot(c, F) - y if not calcJ: return r, c, F ##calculate complete Jacobian cd = numpy.empty(shape = (len(pars),) + c.shape) Jr = numpy.empty(shape = (len(pars),) + x.shape) for j in range(len(pars)): cd[j] = solve(FtF, inner(Fd[j], r) - inner(F, dot(c, Fd[j]))) Jr[j] = dot(c, Fd[j]) + dot(cd[j], F) return r, Jr
def resolveSistema(chuteInicial,dimensao): erro = 0.00001 matrizJacobiana = matrix(calculaMatrizJacobiana(dimensao,chuteInicial)) matrizTermoFonte = matrix(calculaTermoFonte(dimensao,chuteInicial)) try: matrizSolucao = linalg.solve(matrizJacobiana,matrizTermoFonte) #resolver sistema linear except LinAlgError: #return [0,0] return 'ERRO' deltas = [] for linha in range(dimensao): deltas.append(matrizSolucao[linha,0]) for linha in range(dimensao): chuteInicial[linha] = chuteInicial[linha] + deltas[linha] while (criterioParada(matrizTermoFonte,erro,dimensao) == 0): matrizJacobiana = matrix(calculaMatrizJacobiana(dimensao,chuteInicial)) matrizTermoFonte = matrix(calculaTermoFonte(dimensao,chuteInicial)) try: matrizSolucao = linalg.solve(matrizJacobiana,matrizTermoFonte) except LinAlgError: #return [0,0] return 'ERRO' for linha in range(dimensao): deltas[linha] = matrizSolucao[linha,0] for linha in range(dimensao): chuteInicial[linha] = chuteInicial[linha] + deltas[linha] return chuteInicial
def observables2parameters(self,features_covariance=None): """ Computes the conversion matrix M that allows to match a feature vector V to its best fit parameters P, in the sense P = P[fiducial] + MV :param features_covariance: covariance matrix of the simulated features, must be provided! :type features_covariance: 2 dimensional array (or 1 dimensional if diagonal) :returns: the (p,N) conversion matrix :rtype: array """ #Safety checks assert features_covariance is not None,"No science without the covariance matrix, you must provide one!" assert features_covariance.shape in [self.training_set.shape[-1:],self.training_set.shape[-1:]*2] #Check if derivatives are already computed if not hasattr(self,"derivatives"): self.compute_derivatives() #Linear algebra manipulations (parameters = M x features) if features_covariance.shape == self.training_set.shape[1:] * 2: Y = solve(features_covariance,self.derivatives.transpose()) else: Y = (1/features_covariance[:,np.newaxis]) * self.derivatives.transpose() XY = np.dot(self.derivatives,Y) return solve(XY,Y.transpose())
def transform(data, canvas, replace=False): x = solve(data.A, data.b) x2 = solve(data.A2, data.b2) a1 = data.A[:, 0] * x[0] b1 = data.A[:, 1] * x[1] c1 = data.A[:, 2] * x[2] a2 = data.A2[:, 0] * x2[0] b2 = data.A2[:, 1] * x2[1] c2 = data.A2[:, 2] * x2[2] L1 = inv(np.array([a1, b1, c1]).transpose()) L2 = np.array([a2, b2, c2]).transpose() L = np.dot(L2, L1) result = np.dot(L, data.chosen_point) result = result / result[2] if not replace: data.transformed_point = canvas.create_oval(result[0] + Const.RADIUS, result[1] + Const.RADIUS, result[0] - Const.RADIUS, result[1] - Const.RADIUS, fill="red") else: canvas.coords(data.transformed_point, result[0] + Const.RADIUS, result[1] + Const.RADIUS, result[0] - Const.RADIUS, result[1] - Const.RADIUS)
def marginalLikelihood(kernel, X, Y, nhyper, computeGradient=True, useCholesky=True, noise=1e-3): """ get the negative log marginal likelihood and its partial derivatives wrt each hyperparameter """ NX = len(X) assert NX == len(Y) # compute covariance matrix K = kernel.covMatrix(X) + eye(NX)*noise if useCholesky: # avoid inversion by using Cholesky decomp. try: L = cholesky(K) alpha = solve(L.T, solve(L, Y)) except LinAlgError, e: print '\n ================ error in matrix' print '\thyper =', kernel.hyperparams print '====================================' logBadParams(kernel) pdb.set_trace() nlml = 0.5 * dot(Y, alpha) + sum(log(diag(L))) + 0.5 * NX * log(2.0*pi) if computeGradient: W = solve(L.T, solve(L, eye(NX))) - outer(alpha, alpha) dnlml = array([sum(W*kernel.derivative(X, i)) / 2.0 for i in xrange(nhyper)]) # print ' loglik =', nlml, ' d loglik =', dnlml return nlml, dnlml else: return nlml
def ROBO_output(self): if len(self.d) == 1: return fits = len(self.d) ctrls = fits + 2 knots = ctrls + 4 self.xfit = concatenate((self.xfit, zeros((2)))) # pad with 2 endpoint constraints self.yfit = concatenate((self.yfit, zeros((2)))) # pad with 2 endpoint constraints self.d = concatenate((self.d, zeros((6)))) # pad with 3 duplicates at each end self.d[fits+2] = self.d[fits+1] = self.d[fits] = self.d[fits-1] solmatrix = zeros((ctrls,ctrls), dtype=float) for i in range(fits): solmatrix[i,i] = get_matrix(self.d, i, i) solmatrix[i,i+1] = get_matrix(self.d, i, i+1) solmatrix[i,i+2] = get_matrix(self.d, i, i+2) solmatrix[fits, 0] = self.d[2]/self.d[fits-1] # curvature at start = 0 solmatrix[fits, 1] = -(self.d[1] + self.d[2])/self.d[fits-1] solmatrix[fits, 2] = self.d[1]/self.d[fits-1] solmatrix[fits+1, fits-1] = (self.d[fits-1] - self.d[fits-2])/self.d[fits-1] # curvature at end = 0 solmatrix[fits+1, fits] = (self.d[fits-3] + self.d[fits-2] - 2*self.d[fits-1])/self.d[fits-1] solmatrix[fits+1, fits+1] = (self.d[fits-1] - self.d[fits-3])/self.d[fits-1] xctrl = solve(solmatrix, self.xfit) yctrl = solve(solmatrix, self.yfit) self.handle += 1 self.dxf_add(" 0\nSPLINE\n 5\n%x\n100\nAcDbEntity\n 8\n%s\n 62\n%d\n100\nAcDbSpline\n" % (self.handle, self.layer_ROBO, self.color_ROBO)) self.dxf_add(" 70\n0\n 71\n3\n 72\n%d\n 73\n%d\n 74\n%d\n" % (knots, ctrls, fits)) for i in range(knots): self.dxf_add(" 40\n%f\n" % self.d[i-3]) for i in range(ctrls): self.dxf_add(" 10\n%f\n 20\n%f\n 30\n0.0\n" % (xctrl[i],yctrl[i])) for i in range(fits): self.dxf_add(" 11\n%f\n 21\n%f\n 31\n0.0\n" % (self.xfit[i],self.yfit[i]))
def test_0_size(self): class ArraySubclass(np.ndarray): pass # Test system of 0x0 matrices a = np.arange(8).reshape(2, 2, 2) b = np.arange(6).reshape(1, 2, 3).view(ArraySubclass) expected = linalg.solve(a, b)[:, 0:0,:] result = linalg.solve(a[:, 0:0, 0:0], b[:, 0:0,:]) assert_array_equal(result, expected) assert_(isinstance(result, ArraySubclass)) # Test errors for non-square and only b's dimension being 0 assert_raises(linalg.LinAlgError, linalg.solve, a[:, 0:0, 0:1], b) assert_raises(ValueError, linalg.solve, a, b[:, 0:0,:]) # Test broadcasting error b = np.arange(6).reshape(1, 3, 2) # broadcasting error assert_raises(ValueError, linalg.solve, a, b) assert_raises(ValueError, linalg.solve, a[0:0], b[0:0]) # Test zero "single equations" with 0x0 matrices. b = np.arange(2).reshape(1, 2).view(ArraySubclass) expected = linalg.solve(a, b)[:, 0:0] result = linalg.solve(a[:, 0:0, 0:0], b[:, 0:0]) assert_array_equal(result, expected) assert_(isinstance(result, ArraySubclass)) b = np.arange(3).reshape(1, 3) assert_raises(ValueError, linalg.solve, a, b) assert_raises(ValueError, linalg.solve, a[0:0], b[0:0]) assert_raises(ValueError, linalg.solve, a[:, 0:0, 0:0], b)
def _update(self): """ Calculate those terms for prediction that do not depend on predictive inputs. """ from numpy.linalg import cholesky, solve, LinAlgError from numpy import transpose, eye, matrix import types self._K = self.calc_covariance(self.X) if not self._K.shape[0]: # we didn't have any data self._L = matrix(zeros((0, 0), numpy.float64)) self._alpha = matrix(zeros((0, 1), numpy.float64)) self.LL = 0. else: try: self._L = matrix(cholesky(self._K)) except LinAlgError as detail: raise RuntimeError("""Cholesky decomposition of covariance """ """matrix failed. Your kernel may not be positive """ """definite. Scipy complained: %s""" % detail) self._alpha = solve(self._L.T, solve(self._L, self.y)) self.LL = ( - self.n * math.log(2.0 * math.pi) - (self.y.T * self._alpha)[0, 0] ) / 2.0 # print self.LL # import IPython; IPython.Debugger.Pdb().set_trace() self.LL -= log(diagonal(self._L)).sum()
def cal_varcov(self, θ2_vec): """calculate variance covariance matrix""" θ2, ix_θ2_T, Z, LinvW, X1 = self.θ2, self.ix_θ2_T, self.Z, self.LinvW, self.X1 θ2.T[ix_θ2_T] = θ2_vec # update δ δ = self.cal_δ(θ2) jacob = self.cal_jacobian(θ2, δ) θ1, ξ = self.cal_θ1_and_ξ(δ) Zres = Z * ξ.reshape(-1, 1) Ω = Zres.T @ Zres # covariance of the momconds G = (np.c_[X1, jacob].T @ Z).T # gradient of the momconds WG = cho_solve(LinvW, G) WΩ = cho_solve(LinvW, Ω) tmp = solve(G.T @ WG, G.T @ WΩ @ WG).T # G'WΩWG(G'WG)^(-1) part varcov = solve((G.T @ WG), tmp) return varcov
def serial_solve(M,Y, debug=False): ''' :param M: a pxpxN array :param Y: a pxN array :return X: a pxN array X such that M(:,:,i)*X(:,i) = Y(:,:,i) ''' ## surprisingly it is slower than inverting M and doing a serial multiplication ! import numpy from numpy.linalg import solve p = M.shape[0] assert(M.shape[1] == p) N = M.shape[2] assert(Y.shape == (p,N) ) X = numpy.zeros((p,N)) if not debug: for i in range(N): X[:,i] = solve(M[:,:,i],Y[:,i]) else: for i in range(N): try: X[:,i] = solve(M[:,:,i],Y[:,i]) except Exception as e: print('Derivative {}'.format(i)) print(M[:,:,i]) raise Exception('Error while solving point {}'.format(i)) return X
def unteraufgabe_c(): f = lambda x: np.sin(10*x*np.cos(x)) [A10,A20] = unteraufgabe_b() b10 = np.zeros_like(x10) b20 = np.zeros_like(x20) alpha10 = np.zeros_like(x10) alpha20 = np.zeros_like(x20) b10 = f(x10) b20 = f(x20) alpha10 = solve(A10,b10) alpha20 = solve(A20,b20) x = np.linspace(0.0, 1.0, 100) pi10 = np.zeros_like(x) pi20 = np.zeros_like(x) pi10 = np.polyval(alpha10,x) pi20 = np.polyval(alpha20,x) plt.figure() plt.plot(x,f(x),"-b",label=r"$f(x)$") plt.plot(x,pi10 ,"-g",label=r"$p_{10}(x)$") plt.plot(x10,b10,"dg") plt.plot(x,pi20 ,"-r",label=r"$p_{20}(x)$") plt.plot(x20,b20,"or") plt.grid(True) plt.xlabel(r"$x$") plt.ylabel(r"$y$") plt.legend() plt.savefig("interpolation.eps")
def get_sdrgain_upd(amat, wnrm='fro', maxeps=None, baseA=None, baseZ=None, baseGain=None, maxfac=None): deltaA = amat - baseA # nda = npla.norm(deltaA, ord=wnrm) # nz = npla.norm(baseZ, ord=wnrm) # na = npla.norm(baseA, ord=wnrm) # import ipdb; ipdb.set_trace() epsP = spla.solve_sylvester(amat, -baseZ, -deltaA) # print('debugging!!!') # epsP = 0*amat eps = npla.norm(epsP, ord=wnrm) print('|amat - baseA|: {0} -- |E|: {1}'. format(npla.norm(deltaA, ord=wnrm), eps)) if maxeps is not None: if eps < maxeps: updGaint = npla.solve(epsP+np.eye(epsP.shape[0]), baseGain.T) return updGaint.T, True elif maxfac is not None: if (1+eps)/(1-eps) < maxfac and eps < 1: updGaint = npla.solve(epsP+np.eye(epsP.shape[0]), baseGain.T) return updGaint.T, True return None, False
def nf2(l): # Find x(l) xl = solve((LV + (l + sigma * delta) * identity(D)),dot(-UV.T,g)) # Calculate |xl|-delta (for newton stopping rule) xlmd = norm(xl) - delta # Calculate f(l) for p=-1 fl = 1 / norm(xl) - 1 / delta # Find x'(l) xlp = solve((LV + (l + sigma * delta) * identity(D)),(-xl)) # Calculate f'(l) for p=-1 flp = -dot(xl,xlp) * (dot(xl,xl) ** (-1.5)) # Calculate increment dl = fl / flp # Set Delta Delta = delta return xlmd, dl, Delta
def normal_eq_comb(AtA, AtB, PassSet = None): num_cholesky = 0 num_eq = 0 if AtB.size == 0: Z = np.zeros([]) elif (PassSet is None) or np.all(PassSet): Z = nla.solve(AtA, AtB) num_cholesky = 1 num_eq = AtB.shape[1] else: Z = np.zeros(AtB.shape) #(n, k) if PassSet.shape[1] == 1: if np.any(PassSet): cols = np.nonzero(PassSet)[0] Z[cols] = nla.solve(AtA[np.ix_(cols, cols)], AtB[cols]) num_cholesky = 1 num_eq = 1 else: groups = column_group(PassSet) for g in groups: cols = np.nonzero(PassSet[:, g[0]])[0] if cols.size > 0: ix1 = np.ix_(cols, g) ix2 = np.ix_(cols, cols) Z[ix1] = nla.solve(AtA[ix2], AtB[ix1]) num_cholesky += 1 num_eq += len(g) num_eq += len(g) return Z, num_cholesky, num_eq
def lu_inv(L): from numpy.linalg import solve from numpy import eye n = L.shape[0] K_inv = solve(L.T, solve(L, eye(n))) return K_inv
def rand(self): m, n = self.__m, self.__n s = linalg.cholesky(self.__prod).transpose() w = self.__weight # Compute the parameters of the posterior distribution. mu = linalg.solve(s[:m, :m], s[:m, m:]) omega = np.dot(s[:m, :m].transpose(), s[:m, :m]) sigma = np.dot(s[m:, m:].transpose(), s[m:, m:]) / w eta = w # Simulate the marginal Wishart distribution. f = linalg.solve(np.diag(np.sqrt(2.0*random.gamma( (eta - np.arange(n))/2.0))) + np.tril(random.randn(n, n), -1), np.sqrt(eta)*linalg.cholesky(sigma).transpose()) b = np.dot(f.transpose(), f) # Simulate the conditional Gauss distribution. a = mu + linalg.solve(linalg.cholesky(omega).transpose(), np.dot(random.randn(m, n), linalg.cholesky(b).transpose())) return a, b
def GMRES(A, b, krylovSize=10, useQR = True): def MultiplyMatrix(x): return dot(A, x) arnoldi = ArnoldiIterations(A, MultiplyMatrix, krylovSize) arnoldi.Setup(startVector = b) arnoldi.ArnoldiIterations() #converged = False #while not converged: #arnoldi step #check residual #Solve least square problem x = None bdStep = arnoldi.BreakdownStep if useQR: Q,R = linalg.qr(arnoldi.Hessenberg[:bdStep+1,:bdStep]) Qb = dot(transpose(arnoldi.ArnoldiVectors[:,:bdStep+1]), b) Qbb = dot(transpose(Q), Qb) y = linalg.solve(R[:bdStep+1,:bdStep], Qbb) x = dot(arnoldi.ArnoldiVectors[:,:bdStep], y) else: HH = dot(transpose(arnoldi.Hessenberg), arnoldi.Hessenberg) bb = dot(transpose(arnoldi.Hessenberg), dot(transpose(arnoldi.ArnoldiVectors), b)) y = linalg.solve(HH, bb) x = dot(arnoldi.ArnoldiVectors[:,:-1], y) return x
def rbf_int(tocke, rbf, z): """ Funkcija rbf_int resi interpolacijski problem F(tocke[i]) = z[i] z radialnimi baznimi funkcijami oblike rbf(norm(x-tocke[i])) Vhodni podatki: tocke ... nxk tabela n-tock v R^k rbf ... funkcija, ki doloca obliko z ... predpisane vrednosti v tockah Rezultat: alpha ... koeficienti v razvoju po RBF """ # zgradimo matriko sistema n,k = tocke.shape A = zeros((n,n)) for i in range(n): for j in range(n): A[i,j] = rbf(norm(tocke[i,:]-tocke[j,:])**2) # razcep choleskega try: R = cholesky(A) U = R.T # obratno vstavljanje R*y = z y = solve(R,z) # direktno vstavljanje R^T*alpha = y alpha = solve(R.T,y) except: #matrika ni pozitivno definitna alpha = solve(A,z) alpha = solve(A,z) return alpha
def MdcNE(A, b): """ Résolution du problème des moindres carrés linéaire : Min_{alpha} || b - A*alpha ||^2 par factorisation de Cholesky du système des équations normales. Parameters ---------- A : np.array ou np.matrix b : np.array ou np.matrix Returns ------- alpha : np.array (dans tous les cas) solution du problème des moindres carrés linéaire """ S = np.matrix(A).T * np.matrix(A) # Vérification au préalable du conditionnement du système et de la stabilité # numérique de la résolution qui va suivre c = la.cond(S) if c > 1e16: print('Attention : le conditionnement de la matrice des équations') print(' normales est très grand ---> %0.5g' % c) # Factorisation suivi de la résolution L = la.cholesky(S) # matrice triangulaire inférieure m = b.size bvect = np.matrix( b.reshape(m,1) ) y = A.T * bvect z = la.solve(L, y) alpha = np.array( la.solve(L.T, z) ) return alpha
def inverse_chol(self, K=None, Chl=None): """ One can use this function for calculating the inverse of K through cholesky decomposition Parameters ---------- K: ndarray covariance K Chl: ndarray cholesky decomposition of K Returns ------- ndarray the inverse of K """ if Chl is not None: chol = Chl else: chol = self.calc_chol(K) if chol is None: return None inve = 0 error_k = 1e-25 while(True): try: choly = chol + error_k * np.eye(chol.shape[0]) inve = solve(choly.T, solve(choly, np.eye(choly.shape[0]))) break except np.linalg.LinAlgError: error_k *= 10 return inve
def bfgs_cholesky_backtracking(fn, x0, max_iter=500, vtr=1e-6, verbose=False): # Wrap cost function fn so that it takes a row vector and return # value plus column vector. n = len(x0) x = asarray(x0)[:,None] def cost_func(x): cost_func.calls += 1 f,g = fn(x[:,0]) return f,asarray(g)[:,None] cost_func.calls = 0 # ----- Initial step ----- # initial Hessian matrix H is the Identity matrix f, g = cost_func(x) # function value and gradient scale = max(f, 1) # scale diagonals of init Hessian H = scale * eye(n) # initial Hessian #x_star = Inf fv = array(zeros((max_iter, 1))) for k in range(1, max_iter+1): if verbose: print k, x[:,0] # Newton step L, H = mh.modelhess(n, H, 1, eps) y = linalg.solve(L, -g) p = linalg.solve(L.T, y) Sx = ones((n,1)) maxstep = 10 steptol = 1e-6 x_new, f_new, retcode = ls.linesearch(cost_func, n, x, f, g, p, Sx, maxstep, steptol) f_new,g_new = cost_func(x_new) # Gradient difference vector y = g_new - g # Hessian estimate TODO : if dot(y.T,p) > sqrt(eps) * linalg.norm(y) * linalg.norm(p): # ISMET : I added this if statement based on cond in Algorithm A941 p_rot = dot(H,p) H = H + outer(y, y) / dot(y.T, p) - outer(p_rot, p_rot) / dot(p.T, p_rot) # Update parameters g = g_new x = x_new f = f_new # currently not used fv[k-1] = f # Check for convergence if linalg.norm(g) < vtr: print 'Convergence is achieved after', k, 'iterations', cost_func.calls,'calls' #x_star = x_new return x[:,0], fv else: print 'Failed to converge after',k,'iterations',cost_func.calls,'calls' return None,None
def corrector(self, dt): r = zeros(8) self._lambda[0:8] = 0.0 for i_iter in range(self._n_newton_iter): # calculate residual cos_arms = 0.5 * self._length * cos(self._a_pos) sin_arms = 0.5 * self._length * sin(self._a_pos) r[0] = self._x_pos[0] - self._x_pos[1] - sin_arms[0] - sin_arms[1] r[1] = self._y_pos[0] - self._y_pos[1] - cos_arms[0] - cos_arms[1] r[2] = self._x_pos[1] - self._x_pos[2] - sin_arms[1] - sin_arms[2] r[3] = self._y_pos[1] - self._y_pos[2] - cos_arms[1] - cos_arms[2] r[4] = self._a_vel[0] - self._a_vel[1] - self._control[0] r[5] = self._a_vel[1] - self._a_vel[2] - self._control[1] r[0:4] /= 0.5 * dt**2 r[4:6] /= dt self.calc_C_matrix(dt) J = asmatrix(self._C[0:6,:]) * asmatrix(self._M_inv) * \ asmatrix(self._F[:,0:6]) self._lambda[0:6] -= solve(J, r[0:6]) _logger.debug('Air Newton iter %d norm = %f' % (i_iter, norm(r[0:6]))) self._V[0:9] = self._V0 + dt * dot(self._M_inv, self._G + \ dot(self._F[:,0:6], self._lambda[0:6])) self._X[0:9] = self._X0 + dt * (self._V0 + self._V) / 2.0 # determine if foot is in air or on ground if self._y_pos[2] - cos_arms[2] < 0: # calculate foot x position x1, y1 = self._x_pos[2] - sin_arms[2], self._y_pos[2] - cos_arms[2] x0 = self._X0[6] - 0.5 * self._length[2] * sin(self._X0[8]) y0 = self._X0[7] - 0.5 * self._length[2] * cos(self._X0[8]) if y1 - y0 != 0: foot_pos = x0 - (x1 - x0) / (y1 - y0) * y0 else: foot_pos = x0 for i_iter in range(self._n_newton_iter): cos_arms = 0.5 * self._length * cos(self._a_pos) sin_arms = 0.5 * self._length * sin(self._a_pos) r[0] = self._x_pos[0] - self._x_pos[1] - sin_arms[0] - sin_arms[1] r[1] = self._y_pos[0] - self._y_pos[1] - cos_arms[0] - cos_arms[1] r[2] = self._x_pos[1] - self._x_pos[2] - sin_arms[1] - sin_arms[2] r[3] = self._y_pos[1] - self._y_pos[2] - cos_arms[1] - cos_arms[2] r[4] = self._a_vel[0] - self._a_vel[1] - self._control[0] r[5] = self._a_vel[1] - self._a_vel[2] - self._control[1] r[6] = self._x_vel[2] - cos_arms[2] * self._a_vel[2] r[7] = self._y_vel[2] + sin_arms[2] * self._a_vel[2] r[0:4] /= 0.5 * dt**2 r[4:8] /= dt _logger.debug('Land Newton iter %d norm = %f' % \ (i_iter, norm(r[0:8]))) self.calc_C_matrix(dt) J = asmatrix(self._C) * asmatrix(self._M_inv) * asmatrix(self._F) self._lambda -= solve(J, r[0:8]) self._V[0:9] = self._V0 + dt * dot(self._M_inv, self._G + \ dot(self._F, self._lambda)) self._X[0:9] = self._X0 + dt * (self._V0 + self._V) / 2.0 # put it on the ground cos_arms = 0.5 * self._length * cos(self._a_pos) sin_arms = 0.5 * self._length * sin(self._a_pos) self._x_pos[0:3] += foot_pos - self._x_pos[2] + sin_arms[2] self._y_pos[0:3] -= self._y_pos[2] - cos_arms[2]
def dare(A, B, R, Q, tolerance=1e-10, max_iter=150): """ Solves the discrete-time algebraic Riccati equation X = A'XA - A'XB(B'XB + R)^{-1}B'XA + Q via the doubling algorithm. An explanation of the algorithm can be found in "Optimal Filtering" by B.D.O. Anderson and J.B. Moore (Dover Publications, 2005, p. 159). Parameters ============ All arguments should be NumPy ndarrays. * A is k x k * B is k x n * Q is k x k, symmetric and nonnegative definite * R is n x n, symmetric and positive definite Returns ======== X : a k x k numpy.ndarray representing the approximate solution """ # == Set up == # error = tolerance + 1 fail_msg = "Convergence failed after {} iterations." # == Make sure that all arrays are two-dimensional == # A, B, Q, R = map(np.atleast_2d, (A, B, Q, R)) k = Q.shape[0] I = np.identity(k) # == Initial conditions == # a0 = A b0 = dot(B, solve(R, B.T)) g0 = Q i = 1 # == Main loop == # while error > tolerance: if i > max_iter: raise ValueError(fail_msg.format(i)) else: a1 = dot(a0, solve(I + dot(b0, g0), a0)) b1 = b0 + dot(a0, solve(I + dot(b0, g0), dot(b0, a0.T))) g1 = g0 + dot(dot(a0.T, g0), solve(I + dot(b0, g0), a0)) error = np.max(np.abs(g1 - g0)) a0 = a1 b0 = b1 g0 = g1 i += 1 return g1 # Return X
def mlrsl(train_data, params, m=0, max_iter=100, tol=1e-4): Xtrain = train_data['Xtrain'] Ytrain = train_data['Ytrain'] Ls = train_data['Ls'] R0 = train_data['R0'] mu = params['mu'] lam = params['lam'] beta = params['beta'] alpha = params['alpha'] gam = params['gam'] if m == 0: m = len(Xtrain) n, l = Ytrain.shape d = [Xtrain[i].shape[1] for i in range(m)] G = [zeros((d[i], l)) for i in range(m)] R = np.random.uniform(size=(l, l)) theta = ones(m) / m t1 = 1 t2 = 1 check_step = 1 total_loss_old = 1 for ii in range(0, max_iter): Gold = [G[i].copy() for i in range(m)] Q = Ytrain L = zeros((n, n)) for i in range(m): Q = Q + mu * Xtrain[i] @ G[i] L = L + theta[i]**gam * Ls[i] P = (1 + m * mu) * eye(n) + L F = solve(P, Q) Rn = 0 Rd = 0 for i in range(m): GG = G[i].T @ G[i] GG_pos = (abs(GG) + GG) / 2 GG_neg = (abs(GG) - GG) / 2 Rn += GG_pos GG_diag = diag(diag(GG)) Rd += GG_neg + GG_diag @ ones((l, l)) + ones( (l, l)) @ GG_diag - GG_diag Rn = lam / 2 * Rn + 2 * alpha * R0 Rd = lam / 2 * Rd + 2 * alpha * R R[Rd != 0] = R[Rd != 0] * sqrt(Rn[Rd != 0] / Rd[Rd != 0]) LR = diag(R.sum(1)) - R for i in range(m): Gpk = G[i] + (t1 - 1) / t2 * (G[i] - Gold[i]) A = mu * Xtrain[i].T @ Xtrain[i] - mu**2 * Xtrain[i].T @ solve( P.T, Xtrain[i]) dfGpk = A @ Gpk - mu * Xtrain[i].T @ solve(P, Ytrain) + lam * Gpk @ LR for j in range(m): if i == j: continue else: dfGpk = dfGpk - mu**2 * Xtrain[i].T @ solve( P.T, Xtrain[j]) @ Gold[j] Lf = sqrt(2 * norm(A, 2)**2 + 2 * norm(lam * LR, 2)**2) Zk = Gpk - 1 / Lf * dfGpk G[i] = soft_threshold(Zk, beta / Lf) t1, t2 = t2, (1 + sqrt(4 * t1**2 + 1)) / 2 for i in range(m): theta[i] = (1 / trace(F.T @ Ls[i] @ F))**(1 / (gam - 1)) theta = theta / theta.sum() for i in range(m): L = L + theta[i]**gam * Ls[i] predict_loss = 1 / 2 * norm(F - Ytrain, 'fro')**2 + alpha * norm( R - R0, 'fro')**2 correlation = 1 / 2 * trace(F.T @ L @ F) sparse = 0 for i in range(m): predict_loss += mu / 2 * norm(Xtrain[i] @ G[i] - F, 'fro')**2 correlation += lam / 2 * trace(LR @ G[i].T @ G[i]) sparse += beta * sum(sum(abs(G[i]))) total_loss = predict_loss + correlation + sparse loss_perc = abs((total_loss_old - total_loss) / total_loss_old) if ii % check_step == 0: print("ii = %i, loss = %.4f, loss perc = %.4f" % (ii, total_loss, loss_perc)) if loss_perc < tol: break else: total_loss_old = total_loss return G, F, theta, ii
def find_theta(sg, f_on_grid): """ Given a SmolyakGrid object and the value of the function on the points of the grid, this function will return the coefficients theta """ return la.solve(sg.B_U, la.solve(sg.B_L, f_on_grid))
def propagate_wfs(self, sourceC_nM, targetC_nM, S_MM, H_MM, dt): self.timer.start('Linear solve') if self.blacs: # XXX, Preallocate target_blockC_nm = self.Cnm_block_descriptor.empty(dtype=complex) temp_blockC_nm = self.Cnm_block_descriptor.empty(dtype=complex) temp_block_mm = self.mm_block_descriptor.empty(dtype=complex) if self.density.gd.comm.rank != 0: # XXX Fake blacks nbands, nao, nbands, nao grid because some # weird asserts # (these are 0,x or x,0 arrays) sourceC_nM = self.CnM_unique_descriptor.zeros(dtype=complex) # 1. target = (S+0.5j*H*dt) * source # Wave functions to target self.CnM2nm.redistribute(sourceC_nM, temp_blockC_nm) # XXX It can't be this f'n hard to symmetrize a matrix (tri2full) # Remove upper diagonal scalapack_zero(self.mm_block_descriptor, H_MM, 'U') # Lower diagonal matrix: temp_block_mm[:] = S_MM - (0.5j * dt) * H_MM scalapack_set(self.mm_block_descriptor, temp_block_mm, 0, 0, 'U') # Note it's strictly lower diagonal matrix # Add transpose of H pblas_tran(-0.5j * dt, H_MM, 1.0, temp_block_mm, self.mm_block_descriptor, self.mm_block_descriptor) # Add transpose of S pblas_tran(1.0, S_MM, 1.0, temp_block_mm, self.mm_block_descriptor, self.mm_block_descriptor) pblas_simple_gemm(self.Cnm_block_descriptor, self.mm_block_descriptor, self.Cnm_block_descriptor, temp_blockC_nm, temp_block_mm, target_blockC_nm) # 2. target = (S-0.5j*H*dt)^-1 * target # temp_block_mm[:] = S_MM + (0.5j*dt) * H_MM # XXX It can't be this f'n hard to symmetrize a matrix (tri2full) # Lower diagonal matrix: temp_block_mm[:] = S_MM + (0.5j * dt) * H_MM # Not it's stricly lower diagonal matrix: scalapack_set(self.mm_block_descriptor, temp_block_mm, 0, 0, 'U') # Add transpose of H: pblas_tran(+0.5j * dt, H_MM, 1.0, temp_block_mm, self.mm_block_descriptor, self.mm_block_descriptor) # Add transpose of S pblas_tran(1.0, S_MM, 1.0, temp_block_mm, self.mm_block_descriptor, self.mm_block_descriptor) scalapack_solve(self.mm_block_descriptor, self.Cnm_block_descriptor, temp_block_mm, target_blockC_nm) if self.density.gd.comm.rank != 0: # XXX is this correct? # XXX Fake blacks nbands, nao, nbands, nao grid because some # weird asserts # (these are 0,x or x,0 arrays) target = self.CnM_unique_descriptor.zeros(dtype=complex) else: target = targetC_nM self.Cnm2nM.redistribute(target_blockC_nm, target) self.density.gd.comm.broadcast(targetC_nM, 0) # Is this required? else: # Note: The full equation is conjugated (therefore -+, not +-) targetC_nM[:] = \ solve(S_MM - 0.5j * H_MM * dt, np.dot(S_MM + 0.5j * H_MM * dt, sourceC_nM.T.conjugate())).T.conjugate() self.timer.stop('Linear solve')
p.append(True) if False in p: positiva = False m += 1 print m return A, b def grad_conj(A, b, tol): n = A.shape[0] xk = np.squeeze(np.asarray(np.zeros((1, n), dtype=float))) rk = np.squeeze(np.asarray(-b)) betak = 0 pk = np.squeeze(np.asarray(b)) b = np.squeeze(np.asarray(b)) while la.norm(rk, 2) > tol or la.norm(rk, 2) == tol: Apk = np.dot(A, pk) tauk = -(np.inner(pk, rk) / (np.inner(pk, Apk))) xk = xk + tauk * pk rk = np.squeeze(np.asarray(np.dot(A, xk))) - b betak = np.inner(rk, Apk) / np.inner(pk, Apk) pk = -rk - betak * pk return xk A, b = matrizes() print A print b print grad_conj(A, b, 1.e-5) print "exata:" + str(la.solve(A, b))
def ctrl_traj(x, y, th, ctrl_prev, x_d, y_d, xd_d, yd_d, xdd_d, ydd_d, x_g, y_g, th_g): ''' This function computes the closed-loop control law. Inputs: (x,y,th): current state ctrl_prev: previous control input (V,om) (x_d, y_d): desired position (xd_d, yd_d): desired velocity (xdd_d, ydd_d): desired acceleration (x_g,y_g,th_g): desired final state Outputs: (V, om): a numpy array np.array([V, om]) containing the desired control inputs ''' # Timestep dt = 0.005 ########## Code starts here ########## kpx = 1 kpy = 1 kdx = 2 kdy = 2 dist_from_goal = np.sqrt((x_g - x)**2 + (y_g - y)**2) if (dist_from_goal < 0.5): # switch control laws because we're close to the goal [V, om] = ctrl_pose(x, y, th, x_g, y_g, th_g) else: # Set up and solve for a, w V_prev = ctrl_prev[0] w_prev = ctrl_prev[1] xdot = V_prev * np.cos(th) ydot = V_prev * np.sin(th) u1 = xdd_d + kpx * (x_d - x) + kdx * (xd_d - xdot) u2 = ydd_d + kpy * (y_d - y) + kdy * (yd_d - ydot) J = np.array([[np.cos(th), -V_prev * np.sin(th)], [np.sin(th), V_prev * np.cos(th)]]) u = np.array([u1, u2]) aw = linalg.solve(J, u) a = aw[0] om = aw[1] # Integrate to obtain V V = V_prev + a * dt #reset V if it becomes 0 to avoid singularity if (abs(V) < 0.01): V = np.sqrt((xd_d - xdot)**2 + (yd_d - xdot)**2) #Apply saturation limits V = np.sign(V) * min(0.5, abs(V)) om = np.sin(om) * min(1.0, abs(om)) ########## Code ends here ########## return np.array([V, om])
def Jf(xvec): x, y = xvec return np.array([[1, 2], [2 * x, 8 * y]]) # Pick an initial guess. # In[5]: x = np.array([1, 2]) # Now implement Newton's method. # In[6]: x = x - la.solve(Jf(x), f(x)) print(x) # Check if that's really a solution: # In[7]: f(x) # * What's the cost of one iteration? # * Is there still something like quadratic convergence? # -------------------- # Let's keep an error history and check. # In[8]:
data = np.loadtxt(open("YearPredictionMSD.txt", "rb"), delimiter=",") labels = np.mat(data[:, 0]).T values = np.mat(data[:, 1:]) training_labels = labels[:TRAINING_SIZE] training_values = values[:TRAINING_SIZE] test_labels = labels[TRAINING_SIZE:] test_values = values[TRAINING_SIZE:] # Train beta # X.T * X * beta = X.T Y X = training_values.T * training_values Y = training_values.T * training_labels beta = linalg.solve(X, Y) # Test calc_labels = test_values * beta RES = calc_labels - test_labels # Matrix only has one value RSS = np.asarray(0.5 * (RES.T * RES))[0][0] print "RSS:" + str(RSS) print "Max:" + str(max(calc_labels)) print "Min:" + str(min(calc_labels)) #pdb.set_trace() #plt.stem(np.asarray(beta).T[0]) #plt.show()
def ncpsolve(f, a, b, x, tol=None, infos=False, verbose=False, serial=False): ''' don't ask what ncpsolve can do for you... :param f: :param a: :param b: :param x: :param tol: :param serial: :return: ''' maxit = 100 if tol is None: tol = sqrt(finfo(float64).eps) maxsteps = 10 showiters = True it = 0 if verbose: headline = '|{0:^5} | {1:^12} | {2:^12} |'.format( 'k', ' backsteps', '||f(x)||') stars = '-' * len(headline) print(stars) print(headline) print(stars) while it < maxit: it += 1 [fval, fjac] = f(x) [ftmp, fjac] = smooth(x, a, b, fval, fjac, serial=serial) fnorm = norm(ftmp, ord=inf) if fnorm < tol: if verbose: print(stars) if infos: return [x, it] else: return x if serial: from dolo.numeric.serial_operations import serial_solve dx = -serial_solve(fjac, ftmp) else: dx = -solve(fjac, ftmp) fnormold = inf for backsteps in range(maxsteps): xnew = x + dx fnew = f(xnew)[0] # TODO: don't ask for derivatives fnew = smooth(xnew, a, b, fnew, serial=serial) fnormnew = norm(fnew, ord=inf) if fnormnew < fnorm: break if fnormold < fnormnew: dx = 2 * dx break fnormold = fnormnew dx = dx / 2 x = x + dx if verbose: print('|{0:5} | {2:12.3e} | {2:12.3e} |'.format( it, backsteps, fnormnew)) if verbose: print(stars) warnings.Warning('Failure to converge in ncpsolve') fval = f(x) return [x, fval]
def do(self, a, b): x = linalg.solve(a, b) assert_almost_equal(b, dot_generalized(a, x)) assert_(imply(isinstance(b, matrix), isinstance(x, matrix)))
def check(dtype): x = np.array([[1, 0.5], [0.5, 1]], dtype=dtype) assert_equal(linalg.solve(x, x).dtype, dtype)
# 組み合わせ計算 def COM(n, r): fac = [1, 1] finv = [1, 1] inv = [0, 1] for i in range(2, MAX): fac.append(fac[i - 1] * i % MOD) inv.append(-inv[MOD % i] * (MOD // i)) finv.append(finv[i - 1] * inv[i] % MOD) if n < r: return 0 if n < 0 or r < 0: return 0 return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD x, y = map(int, input().split()) if (x + y) % 3 != 0: print(0) exit() l = solve([[2, 1], [1, 2]], [x, y]) if l[0] < 0 or l[1] < 0: #n,m <0の時0 print(0) exit() # n+m回のうち,どのn回で移動するか n+mCOMnを計算 print(COM(int(l[0] + l[1]), int(l[0])))
def uLSIF(x, y, sigma_range, lambda_range, kernel_num=100, verbose=True): """Estimate Density Ratio p(x)/q(y) by uLSIF (unconstrained Least-Square Importance Fitting) Args: x (numpy.matrix): sample from p(x). y (numpy.matrix): sample from p(x). sigma_range (list<float>): search range of Gaussian kernel bandwidth. lambda_range (list<float>): search range of regularization parameter. Kwargs: kernel_num (int): number of kernels. (default 100) verbose (bool): indicator to print messages (deafult True) Returns: densratio.DensityRatio object which has `compute_density_ratio()`. """ nx = x.shape[0] ny = y.shape[0] kernel_num = min(kernel_num, nx) centers = x[randint(nx, size=kernel_num)] if verbose: print("################## Start uLSIF ##################") if sigma_range.size == 1 and lambda_range.size == 1: sigma = sigma_range[0] lambda_ = lambda_range[0] else: if verbose: print("Searching optimal sigma and lambda...") opt_params = search_sigma_and_lambda(x, y, centers, sigma_range, lambda_range, verbose) sigma = opt_params["sigma"] lambda_ = opt_params["lambda"] if verbose: print("Found optimal sigma = %.3f, lambda = %.3f." % (sigma, lambda_)) if verbose: print("Optimizing alpha...") phi_x = compute_kernel_Gaussian(x, centers, sigma) phi_y = compute_kernel_Gaussian(y, centers, sigma) H = phi_y.T.dot(phi_y) / ny h = phi_x.mean(axis=0).T alpha = solve(H + diag(array(lambda_).repeat(kernel_num)), h).A1 alpha[alpha < 0] = 0 if verbose: print("End.") kernel_info = KernelInfo(kernel_type="Gaussian RBF", kernel_num=kernel_num, sigma=sigma, centers=centers) def compute_density_ratio(x): x = to_numpy_matrix(x) phi_x = compute_kernel_Gaussian(x, centers, sigma) density_ratio = phi_x.dot(matrix(alpha).T).A1 return density_ratio result = DensityRatio(method="uLSIF", alpha=alpha, lambda_=lambda_, kernel_info=kernel_info, compute_density_ratio=compute_density_ratio) if verbose: print("################## Finished uLSIF ###############") return result
# image file: # ### Newton # In[5]: # Initialize the method iterates = [np.array([2, 2. / 5])] # In[6]: # Evaluate this cell many times in-place x = iterates[-1] s = la.solve(ddf(x), -df(x)) next_iterate = x + s print f(next_iterate) iterates.append(next_iterate) # plot function and iterates pt.axis("equal") pt.contour(xmesh, ymesh, fmesh, 50) it_array = np.array(iterates) pt.plot(it_array.T[0], it_array.T[1], "x-") # Out[6]: # 0.0 #
def _rss_generate(states, inputs, outputs, type): """Generate a random state space. This does the actual random state space generation expected from rss and drss. type is 'c' for continuous systems and 'd' for discrete systems. """ # Probability of repeating a previous root. pRepeat = 0.05 # Probability of choosing a real root. Note that when choosing a complex # root, the conjugate gets chosen as well. So the expected proportion of # real roots is pReal / (pReal + 2 * (1 - pReal)). pReal = 0.6 # Probability that an element in B or C will not be masked out. pBCmask = 0.8 # Probability that an element in D will not be masked out. pDmask = 0.3 # Probability that D = 0. pDzero = 0.5 # Check for valid input arguments. if states < 1 or states % 1: raise ValueError("states must be a positive integer. states = %g." % states) if inputs < 1 or inputs % 1: raise ValueError("inputs must be a positive integer. inputs = %g." % inputs) if outputs < 1 or outputs % 1: raise ValueError("outputs must be a positive integer. outputs = %g." % outputs) # Make some poles for A. Preallocate a complex array. poles = zeros(states) + zeros(states) * 0.j i = 0 while i < states: if rand() < pRepeat and i != 0 and i != states - 1: # Small chance of copying poles, if we're not at the first or last # element. if poles[i - 1].imag == 0: # Copy previous real pole. poles[i] = poles[i - 1] i += 1 else: # Copy previous complex conjugate pair of poles. poles[i:i + 2] = poles[i - 2:i] i += 2 elif rand() < pReal or i == states - 1: # No-oscillation pole. if type == 'c': poles[i] = -exp(randn()) + 0.j elif type == 'd': poles[i] = 2. * rand() - 1. i += 1 else: # Complex conjugate pair of oscillating poles. if type == 'c': poles[i] = complex(-exp(randn()), 3. * exp(randn())) elif type == 'd': mag = rand() phase = 2. * math.pi * rand() poles[i] = complex(mag * cos(phase), mag * sin(phase)) poles[i + 1] = complex(poles[i].real, -poles[i].imag) i += 2 # Now put the poles in A as real blocks on the diagonal. A = zeros((states, states)) i = 0 while i < states: if poles[i].imag == 0: A[i, i] = poles[i].real i += 1 else: A[i, i] = A[i + 1, i + 1] = poles[i].real A[i, i + 1] = poles[i].imag A[i + 1, i] = -poles[i].imag i += 2 # Finally, apply a transformation so that A is not block-diagonal. while True: T = randn(states, states) try: A = dot(solve(T, A), T) # A = T \ A * T break except LinAlgError: # In the unlikely event that T is rank-deficient, iterate again. pass # Make the remaining matrices. B = randn(states, inputs) C = randn(outputs, states) D = randn(outputs, inputs) # Make masks to zero out some of the elements. while True: Bmask = rand(states, inputs) < pBCmask if any(Bmask): # Retry if we get all zeros. break while True: Cmask = rand(outputs, states) < pBCmask if any(Cmask): # Retry if we get all zeros. break if rand() < pDzero: Dmask = zeros((outputs, inputs)) else: Dmask = rand(outputs, inputs) < pDmask # Apply masks. B = B * Bmask C = C * Cmask D = D * Dmask return StateSpace(A, B, C, D)
def ensure_gram_matrix(self): if self._C is not None: return self._C = self._covf.compute_gram_matrix(self._train_x) self._Cinvt = solve(self._C, self._train_t)
]] known_values = [ my, find_known(1), find_known(2), find_known(3), find_known(4), find_known(5), find_known(6), find_known(7), find_known(8), find_known(9), find_known(10) ] beta = solve(values, known_values) print("\nРівняння регресії:") print( "{:.3f} + {:.3f} * X1 + {:.3f} * X2 + {:.3f} * X3 + {:.3f} * Х1X2 + {:.3f} * Х1X3 + {:.3f} * Х2X3 + {:.3f} * Х1Х2X3 + {:.3f} * X11^2 + {:.3f} * X22^2 + {:.3f} * X33^2 = ŷ\n\nПеревірка" .format(beta[0], beta[1], beta[2], beta[3], beta[4], beta[5], beta[6], beta[7], beta[8], beta[9], beta[10])) for i in range(N): print("ŷ{} = {:.3f} ≈ {:.3f}".format((i + 1), check_result(beta, i), middle_y[i])) while not homogeneity: print( "\n" + " " * 65 + "Матриця планування" + " " * 65 + " X1 X2 X3 X1X2 X1X3 X2X3 X1X2X3 X1X1 X2X2 X3X3 Yi ..." ) for row in range(N):
#!/usr/bin/python # -*- coding:utf-8 -*- import numpy as np from numpy import linalg # (c) A = np.mat('100,100;100,100.01') b = np.mat('2;2.0001') x = linalg.solve(A, b) print(x) ''' when the b is recorrected, x turn out to be [0.01;0.01], which is the right answer. And the error in A was squared by x, then shown in b. ''' # (d) det_A = linalg.det(A) con = max(linalg.svd(A)[1]) / min(linalg.svd(A)[1]) print('Determinant={0} Condition number={1}'.format(det_A, con)) ''' explain: Since the kp(A) is so big ,so when there is error in b, the corresponding error in x is multiplied many times, and it seems quietly different. '''
F[i*band + j] += f[j] for l in range(enodes): K[i*band + j,i*band + l] += k[j,l] xi +=he # forcing Dirichlet boundaries u0 = 0 u1 = 0 K[0,:] = numpy.eye(size)[0,:] # K[:,0] = numpy.eye(size)[:,0] K[-1,:] = numpy.eye(size)[-1,:] # K[:,-1] = numpy.eye(size)[:,-1] F[0] = u0 F[-1] = u1 # solving system u = solve(K,F) # print(k,f) # print('\n',K) # print(F) # print(K.shape) # print(u) # plot solutions x = numpy.linspace(0,1,size) xv = numpy.linspace(0,1,100) xh, uh, du = plot_sol(u,x,band) # print(uh) plt.subplot(1,2,2);plt.plot(xh,du,label='approx du');plt.plot(xv,dv(xv),'m--',label='exact');plt.legend() plt.subplot(1,2,1);plt.plot(xh,uh,label='approx solution');plt.plot(xv,v(xv),'m--',label='exact');plt.legend();plt.show()
def main(): inv_dx = 20 dx = 1 / inv_dx w = 0.8 #The calculation needs only to be done to the inner points since we have #dirichlet conditions on the boundaries for the middle room. -> (2n-1)x(n-1) #For the small rooms we need to include the points with the the neumann #conditions aswell. -> (n-1)x(n-1+1) if rank == 0: #rank 0 for the middle and 3 room #bounary vectors for the middle room: left2 = np.ones(inv_dx * 2 - 1) * 15 top2 = np.ones(inv_dx - 1) * 40 bot2 = np.ones(inv_dx - 1) * 5 right2 = np.ones(inv_dx * 2 - 1) * 15 top13 = np.ones(inv_dx) * 15 bot13 = np.ones(inv_dx) * 15 right3 = np.ones(inv_dx - 1) * 40 u2L = laplaceMidMatrix((inv_dx * 2 + 1, inv_dx + 1)) / ( dx**2) #the size is + 1 for the points u3L = laplaceSideMatrix(inv_dx + 1, 3) / (dx**2) #boundary for the small rooms: if rank == 1: #rank 1 for the 1 room left1 = np.ones(inv_dx - 1) * 40 top13 = np.ones(inv_dx) * 15 bot13 = np.ones(inv_dx) * 15 u1L = laplaceSideMatrix(inv_dx + 1, 1) / (dx**2) #the laplaceMatricies for the rooms: for i in range(100): #starting with solving the right room, dirichlet beeing in the boundary vectors #initially set to 15 if rank == 0: b2 = give_b_vector(left2, top2, right2, bot2) / (dx**2) b2 = np.hstack(b2) u2new = nl.solve(u2L, -b2) if i == 0: u2 = u2new else: u2 = w * u2 + (1 - w) * u2new #the neuman conditions for the left room: tempneu1 = u2.reshape((2 * inv_dx - 1, inv_dx - 1))[-inv_dx + 1:, 0] neu1 = gradfunc(left2[-inv_dx + 1:], tempneu1, dx) comm.send(neu1, dest=1, tag=11) #neumann for right room: tempneu3 = u2.reshape((2 * inv_dx - 1, inv_dx - 1))[:inv_dx - 1, -1] neu3 = gradfunc(tempneu3, right2[:inv_dx - 1], dx) #solve right b3 = give_b_vector(-dx * neu3, top13, right3, bot13) / (dx**2) b3 = np.hstack(b3) u3new = nl.solve(u3L, -b3) if i == 0: u3 = u3new else: u3 = w * u3 + (1 - w) * u3new u1send = comm.recv(source=1, tag=12) #putting the solution from room 1 and 3 to the boundary vectors left2[-inv_dx + 1:] = u1send right2[:inv_dx - 1] = u3.reshape((inv_dx - 1, inv_dx))[:, 0] if rank == 1: #hopefully this worked #solve left neu1 = comm.recv(source=0, tag=11) b1 = give_b_vector(left1, top13, neu1 * dx, bot13) / (dx**2) b1 = np.hstack(b1) u1new = nl.solve(u1L, -b1) if i == 0: u1 = u1new else: u1 = w * u1 + (1 - w) * u1new u1send = u1.reshape((inv_dx - 1, inv_dx))[:, -1] comm.send(u1send, dest=0, tag=12) if rank == 1: u1 = u1.reshape((inv_dx - 1, inv_dx)) comm.send(u1, dest=0, tag=20) if rank == 0: u3 = u3.reshape((inv_dx - 1, inv_dx)) u2 = u2.reshape((2 * inv_dx - 1, inv_dx - 1)) u1 = comm.recv(source=1, tag=20) mid_h, mid_w = u2.shape left_h, left_w = u1.shape right_h, right_w = u3.shape plot_matrix_width = mid_w + left_w + right_w + 2 plot_matrix_height = mid_h + 2 plot_matrix = np.zeros((plot_matrix_height, plot_matrix_width)) plot_matrix[-inv_dx:-1, 1:inv_dx + 1] = u1 plot_matrix[1:-1, inv_dx + 1:2 * inv_dx] = u2 plot_matrix[1:inv_dx, 2 * inv_dx:-1] = u3 plot_matrix[-1, 1:inv_dx + 1] = np.ones(inv_dx) * 15 plot_matrix[-1, inv_dx + 1:2 * inv_dx] = np.ones(inv_dx - 1) * 5 plot_matrix[-inv_dx - 1:, 0] = np.ones(inv_dx + 1) * 40 plot_matrix[-inv_dx - 1, 1:inv_dx + 1] = np.ones(inv_dx) * 15 plot_matrix[:inv_dx, inv_dx] = np.ones(inv_dx) * 15 plot_matrix[0, inv_dx + 1:2 * inv_dx] = np.ones(mid_w) * 40 plot_matrix[:inv_dx + 1, -1] = np.ones(inv_dx + 1) * 40 plot_matrix[inv_dx + 1:, 2 * inv_dx] = np.ones(inv_dx) * 15 plot_matrix[inv_dx, 2 * inv_dx:-1] = np.ones(inv_dx) * 15 plot_matrix[0, 2 * inv_dx:-1] = np.ones(right_w) * 15 heatplot = plt.imshow(plot_matrix) heatplot.set_cmap('hot') plt.colorbar() plt.show()
def norm_cop_pdf(u, mu, sigma2): """For details, see here. Parameters ---------- u : array, shape (n_,) mu : array, shape (n_,) sigma2 : array, shape (n_, n_) Returns ------- pdf_u : scalar """ # Step 1: Compute the inverse marginal cdf's svec = np.sqrt(np.diag(sigma2)) x = stats.norm.ppf(u.flatten(), mu.flatten(), svec).reshape(-1, 1) # Step 2: Compute the joint pdf n_ = len(u) pdf_x = (2*np.pi)**(-n_ / 2)*((det(sigma2))**(-.5))*np.exp(-0.5 * (x - mu.reshape(-1, 1)).T@(solve(sigma2, x - mu.reshape(-1, 1)))) # Step 3: Compute the marginal pdf's pdf_xn = stats.norm.pdf(x.flatten(), mu.flatten(), svec) # Compute the pdf of the copula pdf_u = np.squeeze(pdf_x / np.prod(pdf_xn)) return pdf_u
def norm(self, x, u): xinvu = la.solve(x, u) return np.sqrt(self.inner(x, u, v))
#LEAST squares method begin x = np.array([random.uniform(-1, 1) for i in range(NODES)]) Q = np.full((NODES, NODES), 0, dtype=float) for i in range(0, NODES): for j in range(0, DEGREE + 1): Q[i][j] = x[i]**j H = Q.T.dot(Q) y = np.fromiter(map(func, x), float) b = Q.T.dot(y) #Dodging from singular case for i in range(0, NODES): for j in range(DEGREE + 1, NODES): H[i][j] = i solve = LA.solve(H, b) #end #Lezhandr method #Definition tbe multipliers of searchable polinom cn = np.array([ 1 / 3, (np.sin(1) - np.cos(1)) * 3, 2 / 3, (28 * np.cos(1) - 18 * np.sin(1)) / (2 / 7) ]) #endjkh #Initial data a = -1 b = 1 m = 100
def inner(self, x, u, v): return (np.tensordot(la.solve(x, u), multitransp(la.solve(x, v)), axes=x.ndim))
def ols(y, X, get_cov=True, cov_est='hc1', get_t=True, get_p=True, clustvar=None): # Inputs # y: [n,1] vector, LHS variables # X: [n,k] matrix, RHS variables # get_cov: boolean, if true, the function returns an estimate of the # variance/covariance matrix, in addition to the OLS coefficients # cov_est: string, specifies which variance/covariance matrix estimator to # use. Currently, must be either hmsd (for the homoskedastic # estimator) or hc1 (for the Eicker-Huber-White HC1 estimator) # get_t: boolean, if true, the function returns t-statistics for the simple # null of beta[i] = 0, for each element of the coefficient vector # separately # get_p: boolean, if true, calculate the p-values for a two-sided test of # beta[i] = 0, for each element of the coefficient vector separately # # Outputs: # beta_hat: [k,1] vector, coefficient estimates # V_hat: [k,k] matrix, estimate of the variance/covariance matrix # t: [k,1] vector, t-statistics # p: [k,1] vector, p-values # If p-values are necessary, then t-statistics will be needed if get_p and not get_t: get_t = True # If t-statistics are necessary, then the covariance has to be estimated if get_t and not get_cov: get_cov = True # Get number of observations n and number of coefficients k n, k = X.shape[0], X.shape[1] # Calculate OLS coefficients XXinv = solve(X.transpose() @ X, np.eye(k)) # Calculate (X'X)^(-1) beta_hat = XXinv @ (X.transpose() @ y) # Check whether covariance is needed if get_cov: # Get residuals U_hat = y - X @ beta_hat # Check which covariance estimator to use if cov_est == 'hmsd': # For the homoskedastic estimator, just calculate the standard # variance V_hat = (1 / (n - k)) * XXinv * (U_hat.transpose() @ U_hat) elif cov_est == 'hc1': # Calculate component of middle part of EHW sandwich, # S_i = X_i u_i, which makes it very easy to calculate # sum_i X_i X_i' u_i^2 = S'S) S = (U_hat @ np.ones(shape=(1, k))) * X # Calculate EHW variance/covariance matrix V_hat = (n / (n - k)) * XXinv @ (S.transpose() @ S) @ XXinv elif cov_est == 'cluster': # Calculate number of clusters J = len(np.unique(clustvar)) # Same thing as S above, but needs to be a DataFrame, because pandas # has the groupby method, which is needed in the next step S = pd.DataFrame((U_hat @ np.ones(shape=(1, k))) * X) # Sum all covariates within clusters S = S.groupby(clustvar[:, 0], axis=0).sum().values # Calculate cluster-robust variance estimator V_hat = ((n / (n - k)) * (J / (J - 1)) * XXinv @ (S.transpose() @ S) @ XXinv) else: # Print an error message print('Error in ', ols.__name__, '(): The specified covariance ' 'method could not be recognized. Please specify another ', 'method.', sep='') # Exit the program return # Replace NaNs as zeros (happen if division by zero occurs) V_hat[np.isnan(V_hat)] = 0 # Check whether to get t-statistics if get_t: # Calculate t-statistics (I like having them as a column vector, but # to get that, I have to convert the square root of the diagonal # elements of V_hat into a proper column vector first) t = beta_hat / larry(np.sqrt(np.diag(V_hat))) # Check whether to calculate p-values if get_p: # Calculate p-values p = 2 * (1 - norm.cdf(np.abs(t))) # Return coefficients, variance/covariance matrix, t-statistics, # and p-values return beta_hat, V_hat, t, p else: # Return coefficients, variance/covariance matrix, and # t-statistics return beta_hat, V_hat, t else: # Return coefficients and variance/covariance matrix return beta_hat, V_hat else: # Otherwise, just return coefficients return beta_hat
def interpolate(self, pts, interp=True, deriv=False, deriv_th=False, deriv_X=False): """ Basic Lagrange interpolation, with optional first derivatives (gradient) Parameters ---------- pts : array (float, ndim=2) A 2d array of points on which to evaluate the function. Each row is assumed to be a new d-dimensional point. Therefore, pts must have the same number of columns as ``si.SGrid.d`` interp : bool, optional(default=false) Whether or not to compute the actual interpolation values at pts deriv : bool, optional(default=false) Whether or not to compute the gradient of the function at each of the points. This will have the same dimensions as pts, where each column represents the partial derivative with respect to a new dimension. deriv_th : bool, optional(default=false) Whether or not to compute the ???? derivative with respect to the Smolyak polynomial coefficients (maybe?) deriv_X : bool, optional(default=false) Whether or not to compute the ???? derivative with respect to grid points Returns ------- rets : list (array(float)) A list of arrays containing the objects asked for. There are 4 possible objects that can be computed in this function. They will, if they are called for, always be in the following order: 1. Interpolation values at pts 2. Gradient at pts 3. ???? at pts 4. ???? at pts If the user only asks for one of these objects, it is returned directly as an array and not in a list. Notes ----- This is a stripped down port of ``dolo.SmolyakBasic.interpolate`` TODO: There may be a better way to do this TODO: finish the docstring for the 2nd and 3rd type of derivatives """ d = pts.shape[1] sg = self.sg theta = self.theta trans_points = sg.dom2cube(pts) # Move points to correct domain rets = [] if deriv: new_B, der_B = build_B(d, sg.mu, trans_points, sg.pinds, True) vals = new_B.dot(theta) d_vals = np.tensordot(theta, der_B, (0, 0)).T if interp: rets.append(vals) rets.append(sg.dom2cube(d_vals)) elif not deriv and interp: # No derivs in build_B. Just do vals new_B = build_B(d, sg.mu, trans_points, sg.pinds) vals = new_B.dot(theta) rets.append(vals) if deriv_th: # The derivative wrt the coeffs is just new_B if not interp and not deriv: # we haven't found this yet new_B = build_B(d, sg.mu, trans_points, sg.pinds) rets.append(new_B) if deriv_X: if not interp and not deriv and not deriv_th: new_B = build_B(d, sg.mu, trans_points, sg.pinds) d_X = la.solve(sg.B_U, la.solve(sg.B_L, new_B.T)) rets.append(d_X) if len(rets) == 1: rets = rets[0] return rets
def main(n): # варіант 101 x1min = -40 x1max = 20 x2min = 10 x2max = 60 x3min = -20 x3max = 20 # максимальне та мінімальне значення y_max = 200 + (x1max + x2max + x3max) / 3 y_min = 200 + (x1min + x2min + x3min) / 3 # матриця ПФЕ xn = [[1, 1, 1, 1, 1, 1, 1, 1], [-1, -1, 1, 1, -1, -1, 1, 1], [-1, 1, -1, 1, -1, 1, -1, 1], [-1, 1, 1, -1, 1, -1, -1, 1]] x1x2_norm, x1x3_norm, x2x3_norm, x1x2x3_norm = [0] * 8, [0] * 8, [0] * 8, [ 0 ] * 8 for i in range(n): x1x2_norm[i] = xn[1][i] * xn[2][i] x1x3_norm[i] = xn[1][i] * xn[3][i] x2x3_norm[i] = xn[2][i] * xn[3][i] x1x2x3_norm[i] = xn[1][i] * xn[2][i] * xn[3][i] # заповнення у(генерація) y1 = [random.randint(int(y_min), int(y_max)) for i in range(8)] y2 = [random.randint(int(y_min), int(y_max)) for i in range(8)] y3 = [random.randint(int(y_min), int(y_max)) for i in range(8)] # матриця планування y_matrix = [[y1[0], y2[0], y3[0]], [y1[1], y2[1], y3[1]], [y1[2], y2[2], y3[2]], [y1[3], y2[3], y3[3]], [y1[4], y2[4], y3[4]], [y1[5], y2[5], y3[5]], [y1[6], y2[6], y3[6]], [y1[7], y2[7], y3[7]]] # вивід данних за допомогою цикла print("Матриця планування y : \n") for i in range(n): print(y_matrix[i]) x0 = [1, 1, 1, 1, 1, 1, 1, 1] # заміна -1 на х1_мін, 1 на х1_макс x1 = [10, 10, 50, 50, 10, 10, 50, 50] # заміна -1 на х2_мін, 1 на х2_макс x2 = [20, 60, 20, 60, 20, 60, 20, 60] # заміна -1 на х3_мін, 1 на х3_макс x3 = [20, 25, 25, 20, 25, 20, 20, 25] # заповнення нулями х1х2, х1х3, х1х2х3 x1x2, x1x3, x2x3, x1x2x3 = [0] * 8, [0] * 8, [0] * 8, [0] * 8 # заповнення х1х2, х1х3, х1х2х3 добутками for i in range(n): x1x2[i] = x1[i] * x2[i] x1x3[i] = x1[i] * x3[i] x2x3[i] = x2[i] * x3[i] x1x2x3[i] = x1[i] * x2[i] * x3[i] # середні у Y_average = [] for i in range(len(y_matrix)): Y_average.append(np.mean(y_matrix[i], axis=0)) # формуємо списки b i a list_for_b = [ xn[0], xn[1], xn[2], xn[3], x1x2_norm, x1x3_norm, x2x3_norm, x1x2x3_norm ] list_for_a = list(zip(x0, x1, x2, x3, x1x2, x1x3, x2x3, x1x2x3)) # вивід матриці планування Х print("Матриця планування X:") for i in range(n): print(list_for_a[i]) # нормовані фактори b_i bi = [] for k in range(n): S = 0 for i in range(n): S += (list_for_b[k][i] * Y_average[i]) / n bi.append(round(S, 3)) # розрахунок аі(система рівнянь) через функцію solve, вивід рівняння регресії ai = [round(i, 3) for i in solve(list_for_a, Y_average)] print( "Рівняння регресії: \n" "y = {} + {}*x1 + {}*x2 + {}*x3 + {}*x1x2 + {}*x1x3 + {}*x2x3 + {}*x1x2x3" .format(ai[0], ai[1], ai[2], ai[3], ai[4], ai[5], ai[6], ai[7])) # вивід даних print("Рівняння регресії для нормованих факторів: \n" "y = {} + {}*x1 + {}*x2 + {}*x3 + {}*x1x2 + {}*x1x3 +" " {}*x2x3 + {}*x1x2x3".format(bi[0], bi[1], bi[2], bi[3], bi[4], bi[5], bi[6], bi[7])) print("Перевірка за критерієм Кохрена") print("Середні значення відгуку за рядками:", "\n", +Y_average[0], Y_average[1], Y_average[2], Y_average[3], Y_average[4], Y_average[5], Y_average[6], Y_average[7]) # розрахунок дисперсій dispersions = [] for i in range(len(y_matrix)): a = 0 for k in y_matrix[i]: a += (k - np.mean(y_matrix[i], axis=0))**2 dispersions.append(a / len(y_matrix[i])) # експериментально Gp = max(dispersions) / sum(dispersions) # теоретично Gt = 0.5157 # перевірка однорідності дисперсій if Gp < Gt: print("Дисперсія однорідна") else: print( "\nДисперсія неоднорідна, потрібно розпочати експеримет з початку\n" ) main(n + 1) # критерій Стьюдента print(" Перевірка значущості коефіцієнтів за критерієм Стьюдента") sb = sum(dispersions) / len(dispersions) sbs = (sb / (8 * 3))**0.5 t_list = [abs(bi[i]) / sbs for i in range(0, 8)] d = 0 res = [0] * 8 coef_1 = [] coef_2 = [] # кількість повторень кожної комбінації m = 3 F3 = (m - 1) * n # перевірка значущості коефіцієнтів for i in range(n): if t_list[i] < t.ppf(q=0.975, df=F3): coef_2.append(bi[i]) res[i] = 0 else: coef_1.append(bi[i]) res[i] = bi[i] d += 1 # вивід print("Значущі коефіцієнти регресії:", coef_1) print("Незначущі коефіцієнти регресії:", coef_2) # значення y з коефіцієнтами регресії y_st = [] for i in range(n): y_st.append(res[0] + res[1] * xn[1][i] + res[2] * xn[2][i] + res[3] * xn[3][i] + res[4] * x1x2_norm[i] \ + res[5] * x1x3_norm[i] + res[6] * x2x3_norm[i] + res[7] * x1x2x3_norm[i]) print("Значення з отриманими коефіцієнтами:\n", y_st) # критерій Фішера print("\nПеревірка адекватності за критерієм Фішера\n") Sad = m * sum([(y_st[i] - Y_average[i])**2 for i in range(8)]) / (n - d) Fp = Sad / sb F4 = n - d if Fp < f.ppf(q=0.95, dfn=F4, dfd=F3): print("Рівняння регресії адекватне при рівні значимості 0.05") else: print("Рівняння регресії неадекватне при рівні значимості 0.05")
def inverted(self): return AffineMap(la.inv(self.matrix), -la.solve(self.matrix, self.offset))
def _solve(k, A_k, X, Y, f, lam, lam_y, mu): '''Update one single factor''' s_u, i_u = get_row(Y, k) a = np.dot(s_u * A_k[i_u], X[i_u]) B = X.T.dot(A_k[:, np.newaxis] * X) + lam * np.eye(f) return LA.solve(B, a)
def getv(n, k): a = np.mat([[1, 1], [1, -1]]) # 系数矩阵 b = np.mat([n, k]).T # 常数项列矩阵 x = solve(a, b) # 方程组的解 return x
# ### Observe Spacing # In[6]: pt.plot(nodes, 0*nodes, "o") # ## Part III: Chebyshev Interpolation # In[9]: V = np.cos(i*np.arccos(nodes.reshape(-1, 1))) data = np.random.randn(n) coeffs = la.solve(V, data) # In[10]: x = np.linspace(-1, 1, 1000) Vfull = np.cos(i*np.arccos(x.reshape(-1, 1))) pt.plot(x, np.dot(Vfull, coeffs)) pt.plot(nodes, data, "o") # ## Part IV: Conditioning # In[13]: