def _solve(self, b, tol): import numpy as np from scipy.linalg.blas import dasum, daxpy, ddot A = self._A M = self._M tol *= dasum(b) # Initialize. x = np.zeros(b.shape) r = b.copy() z = M(r) rz = ddot(r, z) p = z.copy() # Iterate. while True: Ap = A(p) alpha = rz / ddot(p, Ap) x = daxpy(p, x, a=alpha) r = daxpy(Ap, r, a=-alpha) if dasum(r) < tol: return x z = M(r) beta = ddot(r, z) beta, rz = beta / rz, beta p = daxpy(p, z, a=beta)
def fit(self, X, Y): """ Train a linear classifier using the perceptron learning algorithm. Note that this will only work if X is a sparse matrix, such as the output of a scikit-learn vectorizer. """ self.find_classes(Y) # First determine which output class will be associated with positive # and negative scores, respectively. Ye = self.encode_outputs(Y) # Initialize the weight vector to all zeros. self.w = np.zeros(X.shape[1]) X = X.toarray() # Iteration through sparse matrices can be a bit slow, so we first # prepare this list to speed up iteration. XY = list(zip(X, Ye)) lam = 1 / len(Y) for i in range(1, self.n_iter): x, y = random.choice(XY) n = 1 / (lam * i) score = blas.ddot(x, self.w) self.w = (1 - n * lam) * self.w if score * y < 1: a = n * y blas.daxpy(x, self.w, a=a)
def solve(self): x = self.rho/(self.rho+2)* self.K + 2/(self.rho+2) * self.D cost = ddot(self.D+x,self.D+x) #LA.norm(self.D+x)^2 return (x,cost)
def P(x): x -= asarray(x * X * X.T)[0, :] if not normalized: x -= x.sum() / n else: x = daxpy(e, x, a=-ddot(x, e)) return x
def solve(self): x = self.rho/(self.rho-2)* self.K - 2/(self.rho-2) * self.D cost = ddot(self.D-x,self.D-x) #LA.norm(self.D-x)^2 return (x,cost)
def solveX(self): x, c = self.optimizeX() c=self.gamma*self.delta*self.alpha*ddot(x, x) #self.problem.value #self.x.value = xRslt #self.xk = xRslt return (x, c)
def solveX(self): xRslt, costRslt = self.optimizeX() costRslt=self.gamma*self.alpha*ddot(xRslt, xRslt) #self.x.value = xRslt #self.xk = xRslt return (xRslt, costRslt)
def solveX(self): x = self.rho/(self.rho+2)* self.K + 2/(self.rho+2) * self.D cost = ddot(self.D+x,self.D+x) #LA.norm(self.D+x)^2 self.x = x self.xk = x return (x,cost)
def g09_calculate_coupling(homo_monomer_a, lumo_monomer_a, homo_monomer_b, lumo_monomer_b, nbf_monomer_a, f_d, s_d, cfrag): """ :param homo_monomer_a: :param lumo_monomer_a: :param homo_monomer_b: :param lumo_monomer_b: :param nbf_monomer_a: :param f_d: :param s_d: :param cfrag: :return: "MO 1", "MO 2", "e 1, eV", "e 2, eV", "J_12, eV", "S_12", "e^eff_1, eV", "e^eff_2, eV", "J^eff_12, eV", "dE_12, eV" """ irange = tuple(range(homo_monomer_a - 1, lumo_monomer_a)) jrange = tuple( range(homo_monomer_b - 1 + nbf_monomer_a, lumo_monomer_b + nbf_monomer_a)) out = [] for i in irange: for j in jrange: ctmp = cfrag[i, :] * f_d e1 = blas.ddot(cfrag[i, :], ctmp) * 27.2116 ctmp = cfrag[j, :] * f_d e2 = blas.ddot(cfrag[j, :], ctmp) * 27.2116 ctmp = cfrag[j, :] * f_d j12 = blas.ddot(cfrag[i, :], ctmp) * 27.2116 ctmp = cfrag[j, :] * s_d s12 = blas.ddot(cfrag[i, :], ctmp) ee1 = 0.5 * ( (e1 + e2) - 2.0 * j12 * s12 + (e1 - e2) * np.sqrt(1.0 - s12 * s12)) / (1.0 - s12 * s12) ee2 = 0.5 * ( (e1 + e2) - 2.0 * j12 * s12 - (e1 - e2) * np.sqrt(1.0 - s12 * s12)) / (1.0 - s12 * s12) je12 = (j12 - 0.5 * (e1 + e2) * s12) / (1.0 - s12 * s12) de = np.sqrt((ee1 - ee2)**2 + (2 * je12)**2) out.append((i + 1, j + 1 - nbf_monomer_a, e1, e2, j12, s12, ee1, ee2, je12, de)) return out
def _solve(self, b, tol): A = self._A M = self._M tol *= dasum(b) # Initialize. x = zeros(b.shape) r = b.copy() z = M(r) rz = ddot(r, z) p = z.copy() # Iterate. while True: Ap = A(p) alpha = rz / ddot(p, Ap) x = daxpy(p, x, a=alpha) r = daxpy(Ap, r, a=-alpha) if dasum(r) < tol: return x z = M(r) beta = ddot(r, z) beta, rz = beta / rz, beta p = daxpy(p, z, a=beta)
def solveX(self): if(self.rho.value == 2): self.rho.value += 1e-9 x = (self.rho/(self.rho-2)* self.K - 2/(self.rho-2) * self.D).value self.x.value = x self.xk = x cost = ddot(self.D-x,self.D-x) #LA.norm(self.D-x)^2 return (x,cost)
def effectiveSampleSize(samples, monotSensitivity=0.01): length = float(len(samples)) mean = sum(samples) / length shiftedSamples = np.array([x - mean for x in samples], float, order="F") gamma = [(blas.ddot(shiftedSamples, shiftedSamples, offx=i) / length) for i in range(len(samples))] monot = next(i for i, g in enumerate(gamma) if g < monotSensitivity * gamma[0]) gammaSum = sum(gamma[1:monot]) v = (gamma[0] + 2 * gammaSum) / length ess = gamma[0] / float(v) return ess
xsum += x[i] # the mean of all agents profiles (EVs + aggregator) x_mean = xsum / N for i in xrange(N): # ADMM iteration step (simplified for optimal exchage) zi_old = np.copy(z[i]) z[i] = x[i] - x_mean u[i] = u[i] + x_mean # used for calculating convergence nxstack += ddot(x[i], x[i])# x[i]^2 nystack += ddot(u[i], u[i]) nzstack += ddot(z[i], z[i]) zdiff = z[i] - zi_old nzdiffstack += ddot(zdiff, zdiff) # Temporary results for the convergence test nxstack = np.sqrt(nxstack) # sqrt(sum ||x_i||_2^2) nystack = rho * np.sqrt(nystack) # sqrt(sum ||y_i||_2^2); rescaling y := rho * u nzstack = np.sqrt(nzstack) # dnrm2(-1 * zi) nzdiffstack = np.sqrt(nzdiffstack) # To calculate the real cost of EVs we need only the EVs profiles sum (=> - aggregator) x_sum = xsum - xAggr cost = costEVs + costAggr
# generate random vector x_vec = np.random.normal(0, 1, N) x_et = Vector('x', x_vec) y_vec = np.random.normal(0, 1, N) y_et = Vector('y', y_vec) # run dgemm in ET start = time.time() s = et.ddot(x_et, y_et) end = time.time() native_times.append(end - start) # run dgemv in scipy start = time.time() s = blas.ddot(x_vec, y_vec) end = time.time() scipy_times.append(end - start) dims.append(N) N += 100 # plot the results fig, axs = plt.subplots() axs.plot(dims, native_times, color='k', linestyle='--', label="ET") axs.plot(dims, scipy_times, color='r', linestyle='--', label="Scipy") axs.set_xlabel(r"dimension ($n$)") axs.set_ylabel("log time (log(sec))") axs.set_yscale("log") plt.legend() plt.title(r"DDOT: log time (log(sec)) vs. dimension ($n$)")
# uk+1 = uk + Axk+1 + Bzk+1 − c u[i] = problem.solveU(x[i], z[i], u[i]) # Axi + Bzi - c ri = problem.getPrimalResidual(x[i], z[i]) # rho * A.T * B * (zi-zi_old) si = problem.getDualResidual(z[i], z_old[i]) # (Axi, Bzi, c) eps_pri = problem.getPrimalFeasability() # A.T * ui eps_dual = problem.getDualFeasability() # used for calculating convergence r_norm += ddot(ri, ri) # (ri)^2 s_norm += ddot(si, si) # (si)^2 # used for calculating convergence nxstack += ddot(eps_pri[0], eps_pri[0]) # (Axi)^2 nzstack += ddot(eps_pri[1], eps_pri[1]) # (Bzi)^2 ncstack += ddot(eps_pri[2], eps_pri[2]) # c^2 nystack += ddot(eps_dual, eps_dual) # (A.T * ui)^2 #### ## ## ADMM convergence criteria ## ## x ∈ Rn and z ∈ Rm, where A ∈ Rp×n, B ∈ Rp×m, and c ∈ Rp ##
def solve(self): xRslt = self.optimize() costRslt=self.gamma*self.alpha*ddot(xRslt, xRslt) return (xRslt, costRslt)
def solve(self): xRslt = self.optimize() costRslt=self.gamma*self.delta*self.alpha*ddot(xRslt, xRslt) #self.problem.value return (xRslt, costRslt)
for i in xrange(cs): # uk+1 = uk + Axk+1 + Bzk+1 − c ui[i] = problem.solveU(xi[i], zi[i], ui[i]) # Axi + Bzi - c ri = problem.getPrimalResidual(xi[i],zi[i]) # rho * A.T * B * (zi-zi_old) si = problem.getDualResidual(zi[i], zi_old[i]) # (Axi, Bzi, c) eps_pri = problem.getPrimalFeasability() # A.T * ui eps_dual = problem.getDualFeasability() # used for calculating convergence send[0] += ddot(ri, ri)# (ri)^2 send[1] += ddot(si, si)# (si)^2 # used for calculating convergence send[2] += ddot(eps_pri[0], eps_pri[0])# (Axi)^2 send[3] += ddot(eps_pri[1], eps_pri[1])# (Bzi)^2 send[4] += ddot(eps_pri[2], eps_pri[2])# c^2 send[5] += ddot(eps_dual, eps_dual)# (A.T * ui)^2 if(i == 0 and RESOURCE_LIB): send[7] = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss #memory usage # Reduces values on all processes to a single value onto all processes: # Here the operation computes the global sum over all processors of the contents of the vector # "send", and stores the result on every processor in "recv".
def lsqr(A, b, niter = 0, x = None, damp = 0, condlim = 0, atol = 0, btol = 0, Kr = None, Kl = None, debug = 0): """ x, rho, eta, (info, i, msg, anorm, arnorm, acond) = lsqr(A, b, niter = 0, x = None, damp = 0, condlim = 0, atol = 0, btol = 0, K = None, debug = 0) compute the regularized iterative solution of Ax = b rho and eta contain the norms of the solution and residual Kr (Kl) can be a right (left) pre-conditioner K which has to implement the call K.precon(x, y) for y = Kx Reference: C. C. Paige & M. A. Saunders, "LSQR: an algorithm for sparse linear equations and sparse least squares", ACM Trans. Math. Software 8 (1982), 43-71. see also the Matlab implementation at: http://www.stanford.edu/group/SOL/software/lsqr/matlab/lsqr.m """ Ax = A.matvec Atx = A.matvec_transp m, n = A.shape if niter <= 0: niter = min(m, n) info = 0 msg = [ 'The iteration limit has been reached', 'Ax - b is small enough, given atol, btol', 'The least-squares solution is good enough, given atol', 'The estimate of cond(Abar) has exceeded condlim', 'Ax - b is small enough for this machine', 'The least-squares solution is good enough for this machine', 'Cond(Abar) seems to be too large for this machine', ] # Prepare for LSQR iteration if nxTypecode(b) != nxFloat or len(b) != m: raise TypeError("Vector b has wrong type or length") bnorm = norm2(b) if bnorm == 0: raise ValueError("Vector b must be nonzero") # solution vector if x is None: x = N.zeros(n, nxFloat) else: if nxTypecode(x) != nxFloat or len(x) != n: raise TypeError("Vector x has wrong type or length") x[:] = 0 # auxiliary vectors p = N.zeros(m, nxFloat) r = N.zeros(n, nxFloat) # the Preconditioner needs one extra storage vector if Kr is not None: rv = N.zeros(x.shape, nxTypecode(x)) if Kl is not None: lv = N.zeros(b.shape, nxTypecode(b)) # Initialize the bi-diagonalization if Kl is not None: # use the left pre-conditioner u = N.zeros(b.shape, nxTypecode(b)) Kl.precon(b, u) bnorm = norm2(u) u /= bnorm else: u = b/bnorm beta = bnorm Atx(u, r) if Kr is not None: # use the right pre-conditioner Kr.precon(r, rv) tmpv = r r = rv rv = tmpv alpha = norm2(r) v = r/alpha w = copy.copy(v) rho_bar = alpha phi_bar = beta # initialize variables for the computation of norms eta = [] rho = [] res2 = 0 c2 = -1 s2 = 0 z = 0 xnorm = 0 bbnorm = 0 ddnorm = 0 xxnorm = 0 rnorm = beta arnorm = alpha*beta dampsq = damp*damp ctol = 0 if condlim > 0: ctol = 1/condlim if debug: s = "%3s%10s%10s%10s%10s%10s%10s%10s\n" % ('nit', 'alpha', 'beta', 'rrho', 'phi', 'theta', 'rho_bar', 'phi_bar') s += '-' * (len(s)-1) print s i = 1 while i < niter and info == 0: i += 1 alpha_old = alpha beta_old = beta # Continue the bi-diagonalization if Kr is not None: # use the right pre-conditioner Kr.precon(v, rv) tmpv = v v = rv rv = tmpv Ax(v, p) u *= alpha p -= u # p = A v - alpha u beta = norm2(p) u = N.divide(p, beta, u) if Kl is not None: # use the left pre-conditioner Kl.precon(u, lv) tmpv = u u = lv lv = tmpv Atx(u, r) v *= beta r -= v # r = A^T u - beta v alpha = norm2(r) v = N.divide(r, alpha, v) # Use a plane rotation to eliminate the damping parameter. # This alters the diagonal (rho_bar) of the lower-bidiagonal matrix. rho_bar1 = pythag(rho_bar, damp) c1 = rho_bar / rho_bar1 s1 = damp / rho_bar1 psi = s1 * phi_bar phi_bar = c1 * phi_bar # Use a plane rotation to eliminate the subdiagonal element (beta) # of the lower-bidiagonal matrix, giving an upper-bidiagonal matrix. rrho = pythag(rho_bar1, beta) c1 = rho_bar1 / rrho s1 = beta / rrho theta = s1 * alpha rho_bar = -c1 * alpha phi = c1 * phi_bar phi_bar = s1 * phi_bar if debug: print "%3d%10.4f%10.4f%10.4f%10.4f%10.4f%10.4f%10.4f" % \ (i, alpha, beta, rrho, phi, theta, rho_bar, phi_bar) # Update x and w w /= rrho r = N.multiply(w, phi, r) x += r # x = x + (phi/rrho) * w ddnorm += ddot(w, w) w *= -theta w += v # w = v - (theta/rrho) * w # Use a plane rotation on the right to eliminate the # super-diagonal element (theta) of the upper-bidiagonal matrix. # Then use the result to estimate norm(x). delta = s2*rrho gamma_bar = -c2*rrho rhs = phi - delta*z z_bar = rhs/gamma_bar xnorm = N.sqrt(xxnorm + z_bar*z_bar) gamma = pythag(gamma_bar, theta) c2 = gamma_bar/gamma s2 = theta/gamma z = rhs/gamma xxnorm += z*z eta.append(xnorm) # Compute norms for convergence criteria (see TOMS 583) bbnorm += alpha_old*alpha_old + beta*beta anorm = N.sqrt(bbnorm) acond = anorm * N.sqrt(ddnorm) arnorm = alpha * abs(s1*phi) res1 = phi_bar * phi_bar res2 += psi * psi rnorm = N.sqrt(res1 + res2) rho.append(rnorm) # Distinguish between # r1norm = ||b - Ax|| and # r2norm = rnorm in current code # = sqrt(r1norm^2 + damp^2*||x||^2). # Estimate r1norm from # r1norm = sqrt(r2norm^2 - damp^2*||x||^2). # Although there is cancellation, it might be accurate enough. r1sq = rnorm*rnorm - dampsq*xxnorm r1norm = N.sqrt(abs(r1sq)) if r1sq < 0: r1norm = -r1norm r2norm = rnorm # Now use these norms to estimate certain other quantities, # some of which will be small near a solution. test1 = rnorm/bnorm test2 = arnorm/(anorm*rnorm) test3 = 1/acond t1 = test1/(1 + anorm*xnorm/bnorm) rtol = btol + atol*anorm*xnorm/bnorm # The following tests guard against extremely small values of # atol, btol or ctol. (The user may have set any or all of # the parameters atol, btol, conlim to 0.) # The effect is equivalent to the normal tests using # atol = eps, btol = eps, condlim = 1/eps. if 1 + test3 <= 1: info = 6 if 1 + test2 <= 1: info = 5 if 1 + t1 <= 1: info = 4 # Allow for tolerances set by the user. if test3 <= ctol: info = 3 if test2 <= atol: info = 2 if test1 <= rtol: info = 1 if Kr is not None: Kr.precon(x, rv) x[:] = rv return x, rho, eta, (info, i, msg[info], anorm, arnorm, acond)
# To calculate the real cost of EVs we need only the EVs profiles sum (=> - aggregator) x_sum = x_mean - xAggr # now, it is really the mean x_mean /= N for i in xrange(n): # ADMM iteration step (simplified for optimal exchage) zi_old = np.copy(zi[i]) zi[i] = xi[i] - x_mean ui[i] = ui[i] + x_mean # used for calculating convergence send[0] += ddot(xi[i], xi[i])# xi[i]^2 send[1] += ddot(ui[i], ui[i]) send[2] += ddot(zi[i], zi[i]) zdiff = zi[i] - zi_old send[3] += ddot(zdiff, zdiff) if(RESOURCE_LIB and i == 0): send[5] = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss #memory usage # similarly, sums all local "send" into "recv" comm.Allreduce(send, recv, op=MPI.SUM) # Temporary results for the convergence test nxstack = np.sqrt(recv[0]) # sqrt(sum ||x_i||_2^2) nystack = rho * np.sqrt(recv[1]) # sqrt(sum ||y_i||_2^2) ; rescaling y := rho * u
xsum += x[i] # the mean of all agents profiles (EVs + aggregator) x_mean = xsum / N for i in xrange(N): # ADMM iteration step (simplified for optimal exchage) zi_old = np.copy(z[i]) z[i] = x[i] - x_mean u[i] = u[i] + x_mean # used for calculating convergence nxstack += ddot(x[i], x[i])# x[i]^2 nystack += ddot(u[i], u[i]) nzstack += ddot(z[i], z[i]) zdiff = z[i] - zi_old nzdiffstack += ddot(zdiff, zdiff) # Temporary results for the convergence test nxstack = np.sqrt(nxstack) # sqrt(sum ||x_i||_2^2) nystack = rho * np.sqrt(nystack) # sqrt(sum ||y_i||_2^2); rescaling y := rho * u nzstack = np.sqrt(nzstack) # dnrm2(-1 * zi) nzdiffstack = np.sqrt(nzdiffstack) # To calculate the real cost of EVs we need only the EVs profiles sum (=> - aggregator) x_sum = xsum - xAggr
def L2_inner_ddot(f,g,dx): return blas.ddot(f,g)*dx/np.pi
send[4] += ci #costEVs # sum all profiles xsum += xi[i] # Reduces values on all processes to a single value onto all processes. # Here the operation computes the global sum over all processors of the contents of # the vector "xsum", and stores the result on every processor in "x_mean". comm.Allreduce(xsum, x_mean, op=MPI.SUM) # at this point x_mean represents the sum of all agents profiles (EVs + aggregator) if rank == 0: # To calculate the real cost of EVs we need only the EVs profiles sum (=> - aggregator) x_sum = x_mean - xAggr cost = ddot(D + x_sum, D + x_sum) #+ delta*costEVs; real cost of the EVs # now, it is really the mean x_mean /= N for i in xrange(n): # ADMM iteration step (simplified for optimal exchage) zi_old = np.copy(zi[i]) zi[i] = xi[i] - x_mean ui[i] = ui[i] + x_mean # used for calculating convergence send[0] += ddot(xi[i], xi[i])# xi[i]^2 send[1] += ddot(ui[i], ui[i])
def cgls(A, b, niter = 0, x = None, condlim = 0, atol = 0, btol = 0, Kl = None, Ki = None, Kr = None, debug = 0): """ preconditioners: Kl ... left preconditioner: Kl At (A x - b) = 0 Kr ... right preconditioner: At (A Kr x - b) = 0 Kl & Kr ... split preconditioner: Kl At (A Kr x - b) = 0 Ki ... inner preconditioner: At Ki (A x - b) = 0 """ swap = lambda x,y: (y,x) Ax = A.matvec Atx = A.matvec_transp m, n = A.shape if niter <= 0: niter = min(m, n) info = 0 if debug: fmt = "%4d " + "%16.6e" * 4 # Prepare for CGLS iteration if nxTypecode(b) != nxFloat or len(b) != m: raise TypeError("Vector b has wrong type or length") bnorm = norm2(b) if bnorm == 0: raise ValueError("Vector b must be nonzero") # solution vector, we use x0 = 0 if x is None: x = N.zeros(n, nxFloat) else: if nxTypecode(x) != nxFloat or len(x) != n: raise TypeError("Vector x has wrong type or length") x[:] = 0 # auxiliary vectors s = N.zeros(n, nxFloat) q = N.zeros(m, nxFloat) # the Preconditioners need one extra storage vector if Kl is not None or Kr is not None: vn = N.zeros(x.shape, nxTypecode(x)) if Ki is not None: vm = N.zeros(b.shape, nxTypecode(b)) # initialize CG iteration if Ki is not None: r = N.zeros(b.shape, nxFloat) Ki.precon(b, r) else: r = copy.copy(b) # since: x0 = 0 and thus also: Kr x0 = 0 bnorm = norm2(r) Atx(r, s) if Kl is not None: p = N.zeros(s.shape, nxFloat) Kl.precon(s, p) else: p = copy.copy(s) gamma = ddot(s, p) # continue CG iteration i = 1 while i < niter and info == 0: i += 1 if Kr is not None: Kr.precon(p, vn) p, vn = swap(p, vn) Ax(p, q) if Ki is not None: Ki.precon(q, vm) q, vm = swap(q, vm) alpha = gamma/ddot(q, vm) else: alpha = gamma/ddot(q, q) x += N.multiply(p, alpha, s) # temporary use of s r -= N.multiply(q, alpha, q) Atx(r, s) if Kl is not None: Kl.precon(s, vn) s, vn = swap(s, vn) gamma_new = ddot(s, vn) else: gamma_new = ddot(s, s) beta = gamma_new/gamma if debug: print fmt % (i, alpha, beta, gamma, gamma_new) gamma = gamma_new p *= beta p += s if norm2(r)/bnorm < 1e-8: info = 1 if gamma < 1e-8: info = 3 return x, r, (info, i)