def _init_svd_solver(nsv=6, SVDType='cross', tol=None, maxiter=None, ncv=None, comm=None): SLEPc, comm = get_slepc(comm=comm) svd_solver = SLEPc.SVD().create(comm=comm) svd_solver.setType(SVDType) svd_solver.setTolerances(tol=tol, max_it=maxiter) svd_solver.setDimensions(nsv=nsv, ncv=ncv) svd_solver.setFromOptions() return svd_solver
def calculate_condition_number(A, num_of_factors, backend: str = "scipy", use_sparse: bool = False, zero_tol: float = 1e-5): backend = backend.lower() if backend == "scipy": size = A.getSize() Mnp = csr_matrix(A.getValuesCSR()[::-1], shape=size) Mnp.eliminate_zeros() if use_sparse: singular_values = svds(A=Mnp, k=num_of_factors, which="LM", maxiter=5000, return_singular_vectors=False, solver="lobpcg") else: M = Mnp.toarray() singular_values = svd(M, compute_uv=False, check_finite=False) singular_values = singular_values[singular_values > zero_tol] condition_number = singular_values.max() / singular_values.min() elif backend == "slepc": S = SLEPc.SVD() S.create() S.setOperator(A) S.setType(SLEPc.SVD.Type.LAPACK) S.setDimensions(nsv=num_of_factors) S.setTolerances(max_it=5000) S.setWhichSingularTriplets(SLEPc.SVD.Which.LARGEST) S.solve() num_converged_values = S.getConverged() singular_values_list = list() if num_converged_values > 0: for i in range(num_converged_values): singular_value = S.getValue(i) singular_values_list.append(singular_value) else: raise RuntimeError("SLEPc SVD has not converged.") singular_values = np.array(singular_values_list) singular_values = singular_values[singular_values > zero_tol] condition_number = singular_values.max() / singular_values.min() else: raise NotImplementedError( "The required method for condition number estimation is currently unavailable." ) return condition_number
def svd_slepc(A, k, tol, max_iter): ### Setup matrix operator n = A.shape[0] mat = MatrixOperator(A, allow_tranpose_mult=True) A_operator = PETSc.Mat().createPython([n, n], mat) A_operator.setUp() ### Solve eigenproblem S = SLEPc.SVD() S.create() S.setOperator(A_operator) S.setDimensions(k) S.setTolerances(tol, max_iter) S.solve() print("Number of calls to Ax: %d" % mat.n_calls) ### Collect results print("") its = S.getIterationNumber() print("Number of iterations of the method: %i" % its) sol_type = S.getType() print("Solution method: %s" % sol_type) nev, ncv, mpd = S.getDimensions() print("NEV %d NCV %d MPD %d" % (nev, ncv, mpd)) tol, maxit = S.getTolerances() print("Stopping condition: tol=%.4g, maxit=%d" % (tol, maxit)) nconv = S.getConverged() print("Number of converged eigenpairs: %d" % nconv) nconv = min(nconv, k) if nconv < k: raise ZeroDivisionError("Failed to converge for requested number of k with maxiter=%d" % max_iter) vecs = np.zeros([n, nconv]) vecs2 = np.zeros([n, nconv]) vals = np.zeros(nconv) v, u = A_operator.getVecs() if nconv > 0: for i in range(nconv): sigma = S.getSingularTriplet(i, v, u) vals[i] = sigma vecs[:, i] = v vecs2[:, i] = u return vals, vecs, vecs2
def svd(X, method='lanczos'): r""" Compute SVD using SLEPc. Parameters ---------- X : (n, m) ndarray input matrix method : str, optional, default='lanczos' SVD solver to use, can be one of `'lanczos'`, `'cyclic'`, `'lapack'`, `'trlanczos'`, `'cross'`. Returns ------- u, s, vh """ _handle_import_error() assert method in svd._mapping.keys( ), f'Illegal method, must be one of {list(svd._mapping.keys())}.' mat = _to_petsc_matrix(X) S = SLEPc.SVD() S.create() S.setOperator(mat) S.setFromOptions() S.setType(svd._mapping[method]) S.setDimensions(nsv=min(X.shape)) S.solve() nconv = S.getConverged() s = np.empty((nconv, ), dtype=PETSc.ScalarType) U = np.empty((nconv, X.shape[0]), dtype=PETSc.ScalarType) Vh = np.empty((nconv, X.shape[1]), dtype=PETSc.ScalarType) if nconv > 0: for i in range(nconv): U_ = PETSc.Vec().createWithArray(U[i]) V_ = PETSc.Vec().createWithArray(Vh[i]) s[i] = S.getValue(i) S.getVectors(i, U_, V_) return U, s, Vh
else: Print("n-periodic case") iR, B = load_gep_n(folder + '/A1.dat', folder + '/A2.dat', folder + '/A3.dat', folder + '/B1.dat', folder + '/B2.dat', folder + '/B3.dat', j, n) iR.axpy(-np.exp(1j * omega * dt), B) iR.scale(-1) if np.abs(omega * dt) >= 1e-4: iR.scale((np.exp(1j * omega * dt) - 1) / (1j * omega * dt)) else: iR.scale(1 + 0.5 * (1j * omega * dt)) ctx = ResolventOperator(iR, I, Mh12, Mh12 / Rh12) S = SLEPc.SVD() S.create() MhRsize = (I.getSize()[0], I.getSize()[0]) MhR = PETSc.Mat().createPython((MhRsize, MhRsize), ctx) MhR.setUp() S.setOperator(MhR) S.setFromOptions() S.solve() Print = PETSc.Sys.Print Print("******************************") Print("*** SLEPc Solution Results ***")
def condition_number(A, method='simplified'): """ Estimate the condition number of the matrix A """ if method == 'simplified': # Calculate max(abs(A))/min(abs(A)) amin, amax = 1e10, -1e10 for irow in range(A.size(0)): _indices, values = A.getrow(irow) aa = abs(values) amax = max(amax, aa.max()) aa[aa == 0] = amax amin = min(amin, aa.min()) amin = dolfin.MPI.min(dolfin.MPI.comm_world, float(amin)) amax = dolfin.MPI.max(dolfin.MPI.comm_world, float(amax)) return amax / amin elif method == 'numpy': from numpy.linalg import cond A = mat_to_scipy_csr(A).todense() return cond(A) elif method == 'SLEPc': from petsc4py import PETSc from slepc4py import SLEPc # Get the petc4py matrix PA = dolfin.as_backend_type(A).mat() # Calculate the largest and smallest singular value opts = { 'svd_type': 'cross', 'svd_eps_type': 'gd', # 'help': 'svd_type' } with petsc_options(opts): S = SLEPc.SVD() S.create() S.setOperator(PA) S.setFromOptions() S.setDimensions(1, PETSc.DEFAULT, PETSc.DEFAULT) S.setWhichSingularTriplets(SLEPc.SVD.Which.LARGEST) S.solve() if S.getConverged() == 1: sigma_1 = S.getSingularTriplet(0) else: raise ValueError( 'Could not find the highest singular value (%d)' % S.getConvergedReason()) print('Highest singular value:', sigma_1) S.setWhichSingularTriplets(SLEPc.SVD.Which.SMALLEST) S.solve() if S.getConverged() == 1: sigma_n = S.getSingularTriplet(0) else: raise ValueError( 'Could not find the lowest singular value (%d)' % S.getConvergedReason()) print('Lowest singular value:', sigma_n) print(PETSc.Options().getAll()) print(PETSc.Options().getAll()) return sigma_1 / sigma_n
def help(args=None): import sys # program name try: prog = sys.argv[0] except Exception: prog = getattr(sys, 'executable', 'python') # arguments if args is None: args = sys.argv[1:] elif isinstance(args, str): args = args.split() else: args = [str(a) for a in args] # initialization import slepc4py slepc4py.init([prog, '-help'] + args) from slepc4py import SLEPc # and finally ... COMM = SLEPc.COMM_SELF if 'eps' in args: eps = SLEPc.EPS().create(comm=COMM) eps.setFromOptions() eps.destroy() del eps if 'svd' in args: svd = SLEPc.SVD().create(comm=COMM) svd.setFromOptions() svd.destroy() del svd if 'pep' in args: pep = SLEPc.PEP().create(comm=COMM) pep.setFromOptions() pep.destroy() del pep if 'nep' in args: nep = SLEPc.NEP().create(comm=COMM) nep.setFromOptions() nep.destroy() del nep if 'mfn' in args: mfn = SLEPc.MFN().create(comm=COMM) mfn.setFromOptions() mfn.destroy() del mfn if 'st' in args: st = SLEPc.ST().create(comm=COMM) st.setFromOptions() st.destroy() del st if 'bv' in args: bv = SLEPc.BV().create(comm=COMM) bv.setFromOptions() bv.destroy() del bv if 'rg' in args: rg = SLEPc.RG().create(comm=COMM) rg.setFromOptions() rg.destroy() del rg if 'fn' in args: fn = SLEPc.FN().create(comm=COMM) fn.setFromOptions() fn.destroy() del fn if 'ds' in args: ds = SLEPc.DS().create(comm=COMM) ds.setFromOptions() ds.destroy() del ds
for row in df.itertuples(): _, i, j, wcCount = row wCount = counts[i] cCount = counts[j] ppmi = PPMI(wcCount, total, wCount, cCount, alpha=alpha) data.append(ppmi) rowIndex.append(i) columnIndex.append(j) csr = csr_matrix((data, (rowIndex, columnIndex)), shape=(n, n)) print("Doing SVD") print("PPMI[99,2]=", csr[99, 2]) A = PETSc.Mat().createAIJ(size=(n, n), csr=(csr.indptr, csr.indices, csr.data)) A.assemble() svd = SLEPc.SVD() svd.create() svd.setOperator(A) svd.setType(svd.Type.TRLANCZOS) svd.setDimensions(nsv=50, ncv=100) svd.setFromOptions() svd.solve() iterations = svd.getIterationNumber() nsv, ncv, mpd = svd.getDimensions() nconv = svd.getConverged() v, u = A.createVecs() U = [] V = []