Toggle Menu
Prev Up Next

scikit-learn 1.3.2
Other versions

Please cite us if you use the software.

# `sklearn.decomposition`.dict_learning

sklearn.decomposition.dict_learning(X, n_components, *, alpha, max_iter=100, tol=1e-08, method='lars', n_jobs=None, dict_init=None, code_init=None, callback=None, verbose=False, random_state=None, return_n_iter=False, positive_dict=False, positive_code=False, method_max_iter=1000)

  Solve a dictionary learning matrix factorization problem.

  Finds the best dictionary and the corresponding sparse code for approximating the data matrix X by solving:

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

  where V is the dictionary and U is the sparse code. ||.||_Fro stands for the Frobenius norm and ||.||_1,1 stands for the entry-wise matrix norm which is the sum of the absolute values of all the entries in the matrix.

  Read more in the User Guide.

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

      Data matrix.

    n_components int

      Number of dictionary atoms to extract.

    alpha int or float

      Sparsity controlling parameter.

    max_iter int, default=100

      Maximum number of iterations to perform.

    tol float, default=1e-8

      Tolerance for the stopping condition.

    method{‘lars’, ‘cd’}, default=’lars’

      The method used:

      - `'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.

    n_jobs int, default=None

      Number of parallel jobs to run. `None` means 1 unless in a `joblib.parallel_backend` context. `-1` means using all processors. See Glossary for more details.

    dict_init ndarray of shape (n_components, n_features), default=None

      Initial value for the dictionary for warm restart scenarios. Only used if `code_init` and `dict_init` are not None.

    code_init ndarray of shape (n_samples, n_components), default=None

      Initial value for the sparse code for warm restart scenarios. Only used if `code_init` and `dict_init` are not None.

    callback callable, default=None

      Callable that gets invoked every five iterations.

    verbose bool, default=False

      To control the verbosity of the procedure.

    random_state int, RandomState instance or None, default=None

      Used for randomly initializing the dictionary. Pass an int for reproducible results across multiple function calls. See Glossary.

    return_n_iter bool, default=False

      Whether or not to return the number of iterations.

    positive_dict bool, default=False

      Whether to enforce positivity when finding the dictionary.

      New in version 0.20.

    positive_code bool, default=False

      Whether to enforce positivity when finding the code.

      New in version 0.20.

    method_max_iter int, default=1000

      Maximum number of iterations to perform.

      New in version 0.22.

  Returns:
    code ndarray of shape (n_samples, n_components)

      The sparse code factor in the matrix factorization.

    dictionary ndarray of shape (n_components, n_features),

      The dictionary factor in the matrix factorization.

    errors array

      Vector of errors at each iteration.

    n_iter int

      Number of iterations run. Returned only if `return_n_iter` is set to True.

  See also

  `dict_learning_online`

    Solve a dictionary learning matrix factorization problem online.

  `DictionaryLearning`

    Find a dictionary that sparsely encodes data.

  `MiniBatchDictionaryLearning`

    A faster, less accurate version of the dictionary learning algorithm.

  `SparsePCA`

    Sparse Principal Components Analysis.

  `MiniBatchSparsePCA`

    Mini-batch Sparse Principal Components Analysis.