def ormp(X, D, n_nonzero_coefs=None, tol=None, n_jobs=1): # Order Recursive Matching Pursuit implementation of SPAMS package as introduced in # "Forward Sequential Algorithms for Best Basis Selection" import spams if n_nonzero_coefs is not None: Z = spams.omp(np.asfortranarray(X), np.asfortranarray(D), L=n_nonzero_coefs, return_reg_path=False, numThreads=n_jobs) elif tol is not None: Z = spams.omp(np.asfortranarray(X), np.asfortranarray(D), eps=tol, return_reg_path=False, numThreads=n_jobs) return np.array(Z.todense())
def getAlpha(Img, D, eps): PATCh_SIZE = 16 X = im2col(Img, (PATCh_SIZE, PATCh_SIZE)) X = np.asfortranarray(X) numThreads = -1 alpha = spams.omp(X, D, eps=eps, return_reg_path=False, numThreads=numThreads) return alpha
def imgOMP(img, D, L, patchsize, step, randomStep=False, coords=None, gpu=True): patches, coords = MakePatch2D(img, patchsize, step, coords, randomStep) x = np.reshape(patches, [patches.shape[0] * patches.shape[1], -1]) mx = np.tile(np.mean(x, -1)[..., np.newaxis], (1, x.shape[-1])) x -= mx if gpu: # gpu routine x = np.copy(x, 'C') D = np.copy(D, 'C') x, _ = cOMP(x, D, L) else: # spams routine x = np.asfortranarray(x.T, np.float32) D = np.asfortranarray(D.T, np.float32) coefs = spams.omp(x, D, L) x = (D @ coefs).T x = np.reshape(x + mx, patches.shape) d1 = MakePatch2DTranspose(x, coords, img.shape) d2 = MakePatch2DTranspose(np.ones_like(x), coords, img.shape) return d1 / d2
def _compute_codes(X, D, sc_mode, W, lambda1, lambda2, n_jobs, pos_coef, **args): """ Deprecated for very-large datasets! Use sparse_decode instead. """ X = np.asfortranarray(X) D = np.asfortranarray(D) gram = None cov = None if W is None: gram = np.dot(D.T, D) gram = np.asfortranarray(gram) cov = np.dot(D.T, X) cov = np.asfortranarray(cov) if sc_mode in [0, 1, 2]: if W is None: A = spams.lasso(X , D, gram, cov, lambda1=lambda1, lambda2=lambda2, numThreads=n_jobs, mode=sc_mode, pos=pos_coef) else: A = spams.lassoWeighted(X , D, W, lambda1=lambda1,mode=sc_mode, pos=pos_coef, numThreads=n_jobs) else: L = lambda1 if sc_mode == 3 else None eps = lambda1 if sc_mode == 4 else None lambda_1 = lambda1 if sc_mode == 5 else None A = spams.omp(X, D, L, eps, lambda_1, numThreads=n_jobs) return A.toarray()
def ksvd(X, lambda1=None, model=None, return_model=False, n_atoms=100, n_iter=1000, n_jobs=8): if (model is None): D = np.random.randn(X.shape[1], n_atoms) D = spams.normalize(np.asfortranarray(D, dtype=D.dtype)) A = np.random.randn(n_atoms, X.shape[0]) else: D = model[0].T A = model[1].T E = np.zeros(n_iter) for i in range(n_iter): print i # Update code A = spams.omp(X.T, D, L=lambda1, numThreads=n_jobs) # Update Dico --- should be parallelized for k in np.arange(n_atoms): print k, A.shape, D.shape, np.dot(D, A).shape, X.T.shape res = ksvd_optim_dk(X.T, D, A, k) if res is not None: D[:, k] = res[0] A[k, res[2]] = res[1] E[i] = ((X.T - np.dot(D, A))**2).sum() print 'ksvd iter', i, ' --> ', E[i] if return_model: return D.T, [A.T, D.T] return D.T, None
def encode(X, dictionary, alpha): """ Sparse coding """ X1 = np.asfortranarray(X.T) result = spams.omp(X1, dictionary, lambda1=alpha) return result.T.toarray()
def cod2sparseOMP(D, X, L=20, numThreads=-1): #D = np.asfortranarray(D / np.tile(np.sqrt((D*D).sum(axis=0)),(D.shape[0],1))) X_ = np.asfortranarray(X) D_ = np.asfortranarray(D) print "Using Orthogonal Matching Pursuit for sparse codification. Please wait..." init_time = time.time() alpha = spams.omp(X_, D_, L=L, return_reg_path=False, numThreads=numThreads) end_time = time.time() t = end_time - init_time print "%f signals processed per second\n" % (float(alpha.shape[1]) / t) print "Total time: ", t, "seconds" A = alpha.todense() #print A[0] return A
def recover_same_kron(p, kronprod): y = p.T print(y.shape, y.dtype) phikron = kronprod.T print(phikron.shape) sx = spams.omp(np.asfortranarray(y), np.asfortranarray(phikron), eps=0.001, L=6) # sx = orthogonal_mp(phikron, y, tol=0.01) # spams.ssp.save_npz('image.npz', (sx).astype(np.float16)) arr = sx.toarray() ids = np.argwhere(arr) id0 = ids[:,0].astype(np.uint8) id1 = ids[:,1].astype(np.uint16) vs = arr[arr != 0.0] # vs2 = np.log2(vs - vs.min() + 1)1616 # print(vs3.max(), vs3.min(), vs3.mean() # print(vs2[np.abs(vs2) < 0.1].shape) srtd = np.argsort(vs)[::-1] vs4 = vs[srtd] idd0 = id0[srtd] idd1 = id1[srtd] # vs3 = dct(vs4, norm='ortho') # plt.plot(np.log1p(np.abs(vs4))) # print(np.argmin(np.abs(vs4))) # plt.plot(np.abs(vs4)) # plt.show() # np.savez_compressed('img.npz', i0=id0, i1=id1, vs=vs3, mptp=[minval, ptp, (mxinit / mxend)], sh=sx.shape) print(sx.count_nonzero() / y.ravel().shape[0]) return sx
def sparse_decode(Y, D, k, worstFit=1., mink=4): while k > mink: W = spams.omp(np.asfortranarray(Y), np.asfortranarray(D), L=k, numThreads=THREADS) W = np.asarray(W.todense()) fit = 1 - np.linalg.norm(Y - D.dot(W)) ** 2 / np.linalg.norm(Y) ** 2 if fit < worstFit: break else: k -= 1 return W
def ORMP_cholesky_real(DM, N0, J, dataset): ''' Same as ORMP_cholesky but in the real setting. It copies the function of Mairal et al. (2009) for the SPAMS toolbox, as a comparison. ''' sqrtPsi = scipy.linalg.sqrtm(Psi).real import spams K = len(dataset) dataset_r = multi_complex2real(dataset) DR = np.asfortranarray(sqrtPsi @ multi_complex2real(DM.T).T) X = np.asfortranarray(sqrtPsi @ dataset_r.T) AM = spams.omp(X, D=DR, L=N0) AM = np.array(AM.todense()).reshape(J, K) return AM
def recover_same_kron(p, kronprod, L): y = p.T # print(y.shape, y.dtype) phikron = kronprod.T print(phikron.shape, y.shape) sx = spams.omp(np.asfortranarray(y, dtype=np.float32), np.asfortranarray(phikron, dtype=np.float32), eps=0.001, L=L, numThreads=-1) # print(sx.count_nonzero() / y.ravel().shape[0]) # sx = orthogonal_mp_gram(kronprod.dot(kronprod.T), kronprod.dot(y), L) return sx
def alignfirst_dico(dataset, N0, J, init=None, save=False, directory=None, verbose=False): '''Performs (real) dictionary learning on the dataset, after it is optimally rotated along its mean. Relies on the SPAMS toolbox of Mairal et al. ''' K1 = len(dataset) dataset = align_rot(dataset) dataset_r = multi_complex2real(dataset) X = sqrtPsi @ dataset_r.T X = np.asfortranarray(X) # necessary for using spams toolbox D = spams.trainDL(X, K=J, D=init, mode=3, modeD=0, lambda1=N0, verbose=verbose) A = spams.omp(X, D=D, L=N0) Ad = np.array(A.todense()).reshape(J, K) D_c = multi_real2complex((sqrtPsi_inv @ D).T).T drawMany(D_c.T, show=False) plt.title('Align-first dictionary N0 = {} J = {}'.format(N0, J)) if save: plt.savefig(directory + '/dico_alignfirst.png', dpi=200) plt.show() if verbose: DA = D_c @ A for k in test_k_set: display_res(dataset, DA, k, save=save, directory=directory) diffs = dataset.T - D_c @ Ad if K1 < 10000: E = np.diag(diffs.T.conj() @ Phi @ diffs).sum().real else: E = 0 for k in range(K): E += (diffs[:, k].conj() @ Phi @ diffs[:, k]).real print('final loss : ', E) print('RMSE :', np.sqrt(E / K)) if save: text_file = open(directory + '/readme_alignfirst.txt', 'a') text_file.write('Final loss: {}\n'.format(E)) text_file.write('Final RMSE: {}\n'.format(np.sqrt(E / K))) text_file.close() return D_c, Ad, E
def sparse_decode(analysis_coefficients, analysis_operator, lasso_scaling_factor=0.1, ridge_sparsity=None, minimum_loss=1., minimum_ridge_sparsity=0, method='omp'): """ """ print(analysis_coefficients.shape) print(analysis_operator.shape) analysis_coefficients_fortran = np.asfortranarray(analysis_coefficients) analysis_operator_fortran = np.asfortranarray(analysis_operator) coefficient_norm = np.linalg.norm(analysis_coefficients) num_bases, dimensionality = analysis_coefficients.shape _, latent_dimensionality = analysis_operator.shape if method == 'omp': if not ridge_sparsity: ridge_sparsity = min(num_bases, latent_dimensionality) while ridge_sparsity < minimum_ridge_sparsity: sparse_synthesis_coefficients = spams.omp( analysis_coefficients_fortran, analysis_operator_fortran, L=ridge_sparsity, numThreads=4) synthesis_coefficients = np.asarray( sparse_synthesis_coefficients.todense()) loss = 1 - np.linalg.norm(analysis_coefficients - analysis_operator .dot(W))**2 / coefficient_norm**2 if loss < minimium_loss: break k -= 1 elif method == 'lasso': print("Using lasso") lasso_penalty = lasso_scaling_factor * coefficient_norm**2 / dimensionality print("Lasso penalty is ", lasso_penalty) # TODO: set numThreads to some reasonable amount based on mp.cpu_count() and parallelization level sparse_synthesis_coefficients = spams.lasso( analysis_coefficients_fortran, analysis_operator_fortran, lambda1=lasso_penalty, mode=1, numThreads=4, pos=False) synthesis_coefficients = np.asarray( sparse_synthesis_coefficients.todense()) print(synthesis_coefficients.sum()) return synthesis_coefficients
def test_omp(): np.random.seed(0) print('test omp') X = np.asfortranarray(np.random.normal(size=(64,100000)),dtype= myfloat) D = np.asfortranarray(np.random.normal(size=(64,200))) D = np.asfortranarray(D / np.tile(np.sqrt((D*D).sum(axis=0)),(D.shape[0],1)),dtype= myfloat) L = 10 eps = 1.0 numThreads = -1 tic = time.time() alpha = spams.omp(X,D,L=L,eps= eps,return_reg_path = False,numThreads = numThreads) tac = time.time() t = tac - tic print("%f signals processed per second\n" %(float(X.shape[1]) / t)) ######################################## # Regularization path of a single signal ######################################## X = np.asfortranarray(np.random.normal(size=(64,1)),dtype= myfloat) D = np.asfortranarray(np.random.normal(size=(64,10))) D = np.asfortranarray(D / np.tile(np.sqrt((D*D).sum(axis=0)),(D.shape[0],1)),dtype= myfloat) L = 5 (alpha,path) = spams.omp(X,D,L=L,eps= eps,return_reg_path = True,numThreads = numThreads) return None
def test_omp(): np.random.seed(0) print('test omp') X = np.asfortranarray(np.random.normal(size=(64, 100000)), dtype=myfloat) D = np.asfortranarray(np.random.normal(size=(64, 200))) D = np.asfortranarray(D / np.tile(np.sqrt((D * D).sum(axis=0)), (D.shape[0], 1)), dtype=myfloat) L = 10 eps = 1.0 numThreads = -1 tic = time.time() alpha = spams.omp(X, D, L=L, eps=eps, return_reg_path=False, numThreads=numThreads) tac = time.time() t = tac - tic print("%f signals processed per second\n" % (float(X.shape[1]) / t)) ######################################## # Regularization path of a single signal ######################################## X = np.asfortranarray(np.random.normal(size=(64, 1)), dtype=myfloat) D = np.asfortranarray(np.random.normal(size=(64, 10))) D = np.asfortranarray(D / np.tile(np.sqrt((D * D).sum(axis=0)), (D.shape[0], 1)), dtype=myfloat) L = 5 (alpha, path) = spams.omp(X, D, L=L, eps=eps, return_reg_path=True, numThreads=numThreads) return None
def sparse_coding_omp(self, i, vectors): A = np.zeros((self.K, self.K)) B = np.zeros((self.n, self.K)) inds = np.arange(i, i + self.chunk_size) v = vectors[:, inds] a = spams.omp(v, D=self.D, eps=self.omp_eps, return_reg_path=False, numThreads=self.cpu).toarray() #a = spams.omp(v, D = self.D, L = 3, return_reg_path = False).toarray() for k in np.arange(len(inds)): A += np.outer(a[:, k], a[:, k]) B += np.outer(v[:, k], a[:, k]) return A, B
def classification(self, D, W): """ Performs the classification Args: D (np.ndarray): learned dictionary W (np.ndarray): learned classifier parameters Returns: prediction (np.ndarray): predicted labels for testing features accuracy (float): classification accuracy err (np.ndarray): misclassfication information [errid, featureid, groundtruth-label, predicted-label] """ assert isinstance(D, np.ndarray) assert isinstance(W, np.ndarray) assert isinstance(self.test_feats, np.ndarray) assert isinstance(self.test_labels, np.ndarray) assert isinstance(settings.SPARSITYTHRES, int) # sparse coding # http://spams-devel.gforge.inria.fr/doc-python/html/doc_spams005.html#sec12 Gamma = omp( self.test_feats if np.isfortran(self.test_feats) else np.asfortranarray(self.test_feats), D if np.isfortran(D) else np.asfortranarray(D), settings.SPARSITYTHRES ) # classify process errnum = 0 err = np.empty((0, 4)) prediction = np.empty((1, 0), dtype=np.int) for featureid in range(self.test_feats.shape[1]): spcode = Gamma[:, featureid] score_est = W @ spcode score_gt = self.test_labels[:, featureid] maxind_est = score_est.argmax() # classifying maxind_gt = score_gt.argmax() prediction = np.c_[prediction, maxind_est] if maxind_est != maxind_gt: errnum += 1 err = np.r_[err, [[errnum, featureid, maxind_gt, maxind_est]]] accuracy = (self.test_feats.shape[1] - errnum)/self.test_feats.shape[1] return prediction, accuracy, err
def extract(self, impath): """ Extract a ScSPM descriptor for an image. This method will return an ScSPM descriptor for an image. learn_dictionary() needs to be run (once) before this method can be used. Arguments: impath: str, the path to an image Returns: a ScSPM descriptor (array) for the image. This array either has self.dsize*sum(self.levels**2) elements, or self.compress_dim if not None. """ if self.dic is None: raise ValueError('No dictionary has been learned!') # Get and resize image img = pch.imread_resize(impath, self.maxdim) # Extract SIFT patches patches, cx, cy = sw.DSIFT_patches(img, self.psize, self.pstride) # Get OMP codes scpatch = np.transpose( omp(np.asfortranarray(patches.T, np.float64), self.dic, self.active, eps=np.spacing(1), numThreads=1).todense()) # Pyramid pooling and normalisation fea = pch.pyramid_pooling(scpatch, cx, cy, img.shape, self.levels) fea = fea / math.sqrt((fea**2).sum() + 1e-10) if self.compress_dim is not None: return np.dot(fea, self.rmat) else: return fea
def ompSQS(img, D, L, patchsize, step, randomStep=False, coords=None, gpu=True, batchSize=-1): patches, coords = MakePatch2D(img, patchsize, step, coords, randomStep) x = np.copy(np.reshape(patches, [patches.shape[0] * patches.shape[1], -1])) # mx = np.tile(np.mean(x, -1)[..., np.newaxis], (1, x.shape[-1])) # x -= mx if gpu: # gpu routine if batchSize < 0: x = np.copy(x, 'C') D = np.copy(D, 'C') x, _ = cOMP(x, D, L) else: D = np.copy(D, 'C') for i in range(0, x.shape[0], batchSize): y = np.copy(x[i:i + batchSize, :], 'C') y, _ = cOMP(y, D, L) x[i:i + batchSize, :] = y else: # spams routine x = np.asfortranarray(x.T, np.float32) D = np.asfortranarray(D.T, np.float32) coefs = spams.omp(x, D, L) x = (D @ coefs).T # x = np.reshape(x + mx, patches.shape) x = np.reshape(x, patches.shape) d1 = MakePatch2DTranspose(patches - x, coords, img.shape) d2 = MakePatch2DTranspose(np.ones_like(patches), coords, img.shape) return d1, d2, np.sqrt(np.sum((patches - x)**2))
def _transform_omp(self, X, mask): """ Performs the OMP transformation. :param X: Input data. See `.fit` for more information. :param mask: Mask on input data. See `.fit` for more information. :return: Reconstruction parameters """ if mask is None: return spams.omp(**self.omp_params(X)).T return spams.ompMask( X=np.asfortranarray(X.T), D=np.asfortranarray(self.dictionary), B=np.asfortranarray(mask.T), L=self.l0_max, lambda1=self.l1_reconstruct, numThreads=2, ).T
def extract (self, impath): """ Extract a ScSPM descriptor for an image. This method will return an ScSPM descriptor for an image. learn_dictionary() needs to be run (once) before this method can be used. Arguments: impath: str, the path to an image Returns: a ScSPM descriptor (array) for the image. This array either has self.dsize*sum(self.levels**2) elements, or self.compress_dim if not None. """ if self.dic is None: raise ValueError('No dictionary has been learned!') # Get and resize image img = pch.imread_resize(impath, self.maxdim) # Extract SIFT patches patches, cx, cy = sw.DSIFT_patches(img, self.psize, self.pstride) # Get OMP codes scpatch = np.transpose(omp(np.asfortranarray(patches.T, np.float64), self.dic, self.active, eps=np.spacing(1), numThreads=1).todense()) # Pyramid pooling and normalisation fea = pch.pyramid_pooling(scpatch, cx, cy, img.shape, self.levels) fea = fea / math.sqrt((fea**2).sum() + 1e-10) if self.compress_dim is not None: return np.dot(fea, self.rmat) else: return fea
def imgOMP3D(img, D, L, patchsize, step, randomStep=False, coords=None, gpu=False, batchSize=100000, verbose=0): patches, coords = MakePatch3D(img, patchsize, step, coords, randomStep) x = np.reshape(patches, [patches.shape[0] * patches.shape[1], -1]) mx = np.tile(np.mean(x, -1)[..., np.newaxis], (1, x.shape[-1])) x -= mx if gpu: # gpu routine D = np.copy(D, 'C') for i in range(0, x.shape[0], batchSize): if verbose: print('%d of %d' % (i, x.shape[0]), flush=True) y = np.copy(x[i:i + batchSize, :], 'C') y, _ = cOMP(y, D, L) x[i:i + batchSize, :] = y else: # spams routine x = np.asfortranarray(x.T, np.float32) D = np.asfortranarray(D.T, np.float32) coefs = spams.omp(x, D, L) x = (D @ coefs).T x = np.reshape(x + mx, patches.shape) d1 = MakePatch3DTranspose(x, coords, img.shape) d2 = MakePatch3DTranspose(np.ones_like(x), coords, img.shape) return d1 / d2
def sparse_decode(Y, D, k, worstFit=1., mink=0, method='omp', nonneg=False): if method == 'omp': while k > mink: W = spams.omp(np.asfortranarray(Y), np.asfortranarray(D), L=k, numThreads=THREADS) W = np.asarray(W.todense()) fit = 1 - np.linalg.norm(Y - D.dot(W))**2 / np.linalg.norm(Y)**2 if fit < worstFit: break else: k -= 1 elif method == 'lasso': Ynorm = np.linalg.norm(Y)**2 / Y.shape[1] W = spams.lasso(np.asfortranarray(Y), np.asfortranarray(D), lambda1=k * Ynorm, mode=1, numThreads=THREADS, pos=nonneg) W = np.asarray(W.todense()) return W
def ompSQS3D(img, D, L, patchsize, step, randomStep=False, coords=None, gpu=False, batchSize=100000, verbose=0): patches, coords = MakePatch3D(img, patchsize, step, coords, randomStep) x = np.copy(np.reshape(patches, [patches.shape[0] * patches.shape[1], -1])) if gpu: # gpu routine D = np.copy(D, 'C') for i in range(0, x.shape[0], batchSize): if verbose: print(i, x.shape[0], flush=True) y = np.copy(x[i:i + batchSize, :], 'C') y, _ = cOMP(y, D, L) x[i:i + batchSize, :] = y else: # spams routine x = np.asfortranarray(x.T, np.float32) D = np.asfortranarray(D.T, np.float32) coefs = spams.omp(x, D, L) x = (D @ coefs).T x = np.reshape(x, patches.shape) d1 = MakePatch3DTranspose(patches - x, coords, img.shape) d2 = MakePatch3DTranspose(np.ones_like(patches), coords, img.shape) return d1, d2, np.sqrt(np.sum((patches - x)**2))
def _encode(self, X, A): # Solve min_{alpha} ||x-Dalpha||_2^2 s.t. ||alpha||_0 <= L S=omp(X, A, L=self.nnz, return_reg_path = False, numThreads=-1).todense() #print "OMP nnz: %d" % count_nonzero(S) return S
def coeffs(self): """ The sparse code factor in the matrix factorization """ self.code = spams.omp(self.X1, self.d, lambda1=self.lambda1) return self.code.todense(out=np.ndarray)
import numpy as np import time np.random.seed(0) print 'test omp' X = np.asfortranarray(np.random.normal(size=(64, 100000)), dtype=float) D1 = np.asfortranarray(np.random.normal(size=(64, 200))) D1 = np.asfortranarray(D1 / np.tile(np.sqrt((D1 * D1).sum(axis=0)), (D1.shape[0], 1)), dtype=float) L = 10 eps = 1.0 numThreads = -1 tic = time.time() alpha = spams.omp(X, D1, L=L, eps=eps, return_reg_path=False, numThreads=numThreads) print alpha tac = time.time() t = tac - tic print "%f signals processed per second\n" % (float(X.shape[1]) / t) ######################################### ## Regularization path of a single signal ######################################### #X = np.asfortranarray(np.random.normal(size=(64,1)),dtype= float) #D1 = np.asfortranarray(np.random.normal(size=(64,10))) #D1 = np.asfortranarray(D1 / np.tile(np.sqrt((D1*D1).sum(axis=0)),(D1.shape[0],1)),dtype= float) #L = 5 #(alpha,path) = spams.omp(X,D1,L=L,eps= eps,return_reg_path = True,numThreads = numThreads)
def ksvd(vectors, D): chunk_size = 2**18 iter_nb = int(matrix_size / chunk_size) + 1 K = 200 D = np.zeros((n, K), dtype=np.float32) for i in range(K): ind = np.random.randint(matrix_size) D[:, i] = vectors[:, ind] for i in range(2): D_ = D.copy() print("start " + str(i)) K = 200 E_s = np.zeros((n, K)) nz_inds = np.zeros((K, matrix_size), dtype=np.bool) param = { 'lambda1': 0.1, 'lambda2': 0.1, 'numThreads': 4, 'pos': False, 'mode': 0 } #a = spams.lasso(np.asfortranarray(vectors), D = np.asfortranarray(D),**param) a = spams.omp(np.asfortranarray(vectors), D=np.asfortranarray(D), eps=0.0001, return_reg_path=False, numThreads=cpu) #nz_inds = a > 0 Ds = csc_matrix(D) R = Ds.dot(a) indices = a.indices indptr = a.indptr data = a.data print(indptr) for c in np.arange(matrix_size - 1): nz_inds[indices[indptr[c]:indptr[c + 1]], c] = True for i in range(K): print(i) inds = nz_inds[i, :] if np.sum(inds) > 0: #E_i = vectors[:, inds] E_i = R[:, inds] + np.outer(D[:, i], a.getrow(i).toarray()[:, inds]) print("compute SVD") U, s, Vh = np.linalg.svd(E_i, full_matrices=False) print(Vh[0, :]) D[:, i] = np.array(U)[:, 0] R[:, inds] = R[:, inds] + s[0] * np.outer(D[:, i], Vh[0, :]) print(D) np.save(args.output + "/D" + name2, D) D = np.load(args.output + "/D" + name2 + ".npy") D = np.asfortranarray(D) print("write vectors") vectors = np.memmap(args.input + "/abundance_el1_27_cwn", dtype='float32', mode='r', shape=(n, 2**hash_size), order='F') nz = np.array(non_zeros) nzi = np.sum(nz) vectors = np.array(vectors[:, nz]) chunk_size = 2**18 iter_nb = int(np.sum(nz) / chunk_size) + 1 di = np.arange(2**hash_size, dtype=np.int32)[nz] for k in range(iter_nb): #for k in range(3): print(k) sup = min(nzi, (k + 1) * chunk_size) inds = np.arange(k * chunk_size, sup) v = vectors[:, k * chunk_size:sup] #a = lasso(v, D) a = spams.omp(np.asfortranarray(v), D=np.asfortranarray(D), eps=0.0001, return_reg_path=False, numThreads=cpu).toarray() clusters = np.argsort(a, axis=0)[-clusters_nb:][::-1] mask = a[clusters, np.arange(len(inds))] mask = mask > 0 clusters[~mask] = -1 clusters_mm[:clusters_nb, di[inds]] = clusters + 1 clusters_mm.flush() return clusters, vectors
''' ''' Created on 2014/3/12 @author: bhchen ''' import spams import numpy as np import time np.random.seed(0) print 'test omp' X = np.asfortranarray(np.random.normal(size=(64,100000)),dtype= float) D1 = np.asfortranarray(np.random.normal(size=(64,200))) D1 = np.asfortranarray(D1 / np.tile(np.sqrt((D1*D1).sum(axis=0)),(D1.shape[0],1)),dtype= float) L = 10 eps = 1.0 numThreads = -1 tic = time.time() alpha = spams.omp(X,D1,L=L,eps= eps,return_reg_path = False,numThreads = numThreads) print alpha tac = time.time() t = tac - tic print "%f signals processed per second\n" %(float(X.shape[1]) / t) ######################################### ## Regularization path of a single signal ######################################### #X = np.asfortranarray(np.random.normal(size=(64,1)),dtype= float) #D1 = np.asfortranarray(np.random.normal(size=(64,10))) #D1 = np.asfortranarray(D1 / np.tile(np.sqrt((D1*D1).sum(axis=0)),(D1.shape[0],1)),dtype= float) #L = 5 #(alpha,path) = spams.omp(X,D1,L=L,eps= eps,return_reg_path = True,numThreads = numThreads)