Ejemplo n.º 1
0
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())
Ejemplo n.º 2
0
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
Ejemplo n.º 3
0
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
Ejemplo n.º 4
0
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()
Ejemplo n.º 5
0
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
Ejemplo n.º 6
0
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
Ejemplo n.º 8
0
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
Ejemplo n.º 9
0
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())
Ejemplo n.º 10
0
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
Ejemplo n.º 11
0
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
Ejemplo n.º 12
0
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
Ejemplo n.º 13
0
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
Ejemplo n.º 14
0
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
Ejemplo n.º 15
0
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
Ejemplo n.º 16
0
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
Ejemplo n.º 18
0
    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
Ejemplo n.º 19
0
    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
Ejemplo n.º 20
0
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))
Ejemplo n.º 21
0
    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
Ejemplo n.º 22
0
    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
Ejemplo n.º 23
0
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
Ejemplo n.º 24
0
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
Ejemplo n.º 25
0
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))
Ejemplo n.º 26
0
 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
Ejemplo n.º 27
0
 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)
Ejemplo n.º 28
0
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)
Ejemplo n.º 29
0
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
Ejemplo n.º 30
0
'''
'''
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)