Class MiniBatchDictionaryLearningScikitsLearnNode

Mini-batch dictionary learning

This node has been automatically generated by wrapping the ``sklearn.decomposition.dict_learning.MiniBatchDictionaryLearning`` class
from the ``sklearn`` library.  The wrapped instance can be accessed
through the ``scikits_alg`` attribute.

Finds a dictionary (a set of atoms) that can best be used to represent data
using a sparse code.

Solves the optimization problem::


   (U^*,V^*) = argmin 0.5 || Y - U V ||_2^2 + alpha * || U ||_1
                (U,V)
                with || V_k ||_2 = 1 for all  0 <= k < n_components

Read more in the :ref:`User Guide <DictionaryLearning>`.

**Parameters**

n_components : int,
    number of dictionary elements to extract

alpha : float,
    sparsity controlling parameter

n_iter : int,
    total number of iterations to perform

fit_algorithm : {'lars', 'cd'}
    lars: uses the least angle regression method to solve the lasso problem
    (linear_model.lars_path)
    cd: uses the coordinate descent method to compute the
    Lasso solution (linear_model.Lasso). Lars will be faster if
    the estimated components are sparse.

transform_algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp',     'threshold'}
    Algorithm used to transform the data.
    lars: uses the least angle regression method (linear_model.lars_path)
    lasso_lars: uses Lars to compute the Lasso solution
    lasso_cd: uses the coordinate descent method to compute the
    Lasso solution (linear_model.Lasso). lasso_lars will be faster if
    the estimated components are sparse.
    omp: uses orthogonal matching pursuit to estimate the sparse solution
    threshold: squashes to zero all coefficients less than alpha from
    the projection dictionary * X'

transform_n_nonzero_coefs : int, ``0.1 * n_features`` by default
    Number of nonzero coefficients to target in each column of the
    solution. This is only used by `algorithm='lars'` and `algorithm='omp'`
    and is overridden by `alpha` in the `omp` case.

transform_alpha : float, 1. by default
    If `algorithm='lasso_lars'` or `algorithm='lasso_cd'`, `alpha` is the
    penalty applied to the L1 norm.
    If `algorithm='threshold'`, `alpha` is the absolute value of the
    threshold below which coefficients will be squashed to zero.
    If `algorithm='omp'`, `alpha` is the tolerance parameter: the value of
    the reconstruction error targeted. In this case, it overrides
    `n_nonzero_coefs`.

split_sign : bool, False by default
    Whether to split the sparse feature vector into the concatenation of
    its negative part and its positive part. This can improve the
    performance of downstream classifiers.

n_jobs : int,
    number of parallel jobs to run

dict_init : array of shape (n_components, n_features),
    initial value of the dictionary for warm restart scenarios

verbose :

    - degree of verbosity of the printed output


batch_size : int,
    number of samples in each mini-batch

shuffle : bool,
    whether to shuffle the samples before forming batches

random_state : int or RandomState
    Pseudo number generator state used for random sampling.

**Attributes**

``components_`` : array, [n_components, n_features]
    components extracted from the data

``inner_stats_`` : tuple of (A, B) ndarrays
    Internal sufficient statistics that are kept by the algorithm.
    Keeping them is useful in online settings, to avoid loosing the
    history of the evolution, but they shouldn't have any use for the
    end user.
    A (n_components, n_components) is the dictionary covariance matrix.
    B (n_features, n_components) is the data approximation matrix

``n_iter_`` : int
    Number of iterations run.

**Notes**

**References:**

J. Mairal, F. Bach, J. Ponce, G. Sapiro, 2009: Online dictionary learning
for sparse coding (http://www.di.ens.fr/sierra/pdfs/icml09.pdf)

See also

SparseCoder
DictionaryLearning
SparsePCA
MiniBatchSparsePCA

Overrides: object.__init__

Encode the data as a sparse combination of the dictionary atoms.

This node has been automatically generated by wrapping the sklearn.decomposition.dict_learning.MiniBatchDictionaryLearning class from the sklearn library. The wrapped instance can be accessed through the scikits_alg attribute.

Coding method is determined by the object parameter transform_algorithm.

Parameters

X : array of shape (n_samples, n_features)

Test data to be transformed, must have the same number of features as the data used to train the model.

Returns

X_new : array, shape (n_samples, n_components)

Transformed data

Overrides: Node.execute

Overrides: Node.is_invertible

(inherited documentation)

Overrides: Node.is_trainable

Fit the model from data in X.

This node has been automatically generated by wrapping the sklearn.decomposition.dict_learning.MiniBatchDictionaryLearning class from the sklearn library. The wrapped instance can be accessed through the scikits_alg attribute.

Parameters

X: array-like, shape (n_samples, n_features)

Training vector, where n_samples in the number of samples and n_features is the number of features.

Returns

self : object

Returns the instance itself.

Overrides: Node.stop_training