class_docstr: Dictionary learning.
  
  Finds a dictionary (a set of atoms) that performs well at sparsely
  encoding the fitted data.
  
  Solves the optimization problem::
  
      (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
  
  ||.||_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 :ref:`User Guide <DictionaryLearning>`.
  
  Parameters
  ----------
  n_components : int, default=None
      Number of dictionary elements to extract. If None, then ``n_components``
      is set to ``n_features``.
  
  alpha : float, default=1.0
      Sparsity controlling parameter.
  
  max_iter : int, default=1000
      Maximum number of iterations to perform.
  
  tol : float, default=1e-8
      Tolerance for numerical error.
  
  fit_algorithm : {'lars', 'cd'}, default='lars'
      * `'lars'`: uses the least angle regression method to solve the lasso
        problem (:func:`~sklearn.linear_model.lars_path`);
      * `'cd'`: uses the coordinate descent method to compute the
        Lasso solution (:class:`~sklearn.linear_model.Lasso`). Lars will be
        faster if the estimated components are sparse.
  
      .. versionadded:: 0.17
         *cd* coordinate descent method to improve speed.
  
  transform_algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp',             'threshold'}, default='omp'
      Algorithm used to transform the data:
  
      - `'lars'`: uses the least angle regression method
        (:func:`~sklearn.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 (:class:`~sklearn.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'``.
  
      .. versionadded:: 0.17
         *lasso_cd* coordinate descent method to improve speed.
  
  transform_n_nonzero_coefs : int, default=None
      Number of nonzero coefficients to target in each column of the
      solution. This is only used by `algorithm='lars'` and
      `algorithm='omp'`. If `None`, then
      `transform_n_nonzero_coefs=int(n_features / 10)`.
  
  transform_alpha : float, default=None
      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 `None`, defaults to `alpha`.
  
      .. versionchanged:: 1.2
          When None, default value changed from 1.0 to `alpha`.
  
  n_jobs : int or None, default=None
      Number of parallel jobs to run.
      ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
      ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
      for more details.
  
  code_init : ndarray of shape (n_samples, n_components), default=None
      Initial value for the code, for warm restart. Only used if `code_init`
      and `dict_init` are not None.
  
  dict_init : ndarray of shape (n_components, n_features), default=None
      Initial values for the dictionary, for warm restart. Only used if
      `code_init` and `dict_init` are not None.
  
  callback : callable, default=None
      Callable that gets invoked every five iterations.
  
      .. versionadded:: 1.3
  
  verbose : bool, default=False
      To control the verbosity of the procedure.
  
  split_sign : bool, default=False
      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.
  
  random_state : int, RandomState instance or None, default=None
      Used for initializing the dictionary when ``dict_init`` is not
      specified, randomly shuffling the data when ``shuffle`` is set to
      ``True``, and updating the dictionary. Pass an int for reproducible
      results across multiple function calls.
      See :term:`Glossary <random_state>`.
  
  positive_code : bool, default=False
      Whether to enforce positivity when finding the code.
  
      .. versionadded:: 0.20
  
  positive_dict : bool, default=False
      Whether to enforce positivity when finding the dictionary.
  
      .. versionadded:: 0.20
  
  transform_max_iter : int, default=1000
      Maximum number of iterations to perform if `algorithm='lasso_cd'` or
      `'lasso_lars'`.
  
      .. versionadded:: 0.22
  
  Attributes
  ----------
  components_ : ndarray of shape (n_components, n_features)
      dictionary atoms extracted from the data
  
  error_ : array
      vector of errors at each iteration
  
  n_features_in_ : int
      Number of features seen during :term:`fit`.
  
      .. versionadded:: 0.24
  
  feature_names_in_ : ndarray of shape (`n_features_in_`,)
      Names of features seen during :term:`fit`. Defined only when `X`
      has feature names that are all strings.
  
      .. versionadded:: 1.0
  
  n_iter_ : int
      Number of iterations run.
  
  See Also
  --------
  MiniBatchDictionaryLearning: A faster, less accurate, version of the
      dictionary learning algorithm.
  MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis.
  SparseCoder : Find a sparse representation of data from a fixed,
      precomputed dictionary.
  SparsePCA : Sparse Principal Components Analysis.
  
  References
  ----------
  
  J. Mairal, F. Bach, J. Ponce, G. Sapiro, 2009: Online dictionary learning
  for sparse coding (https://www.di.ens.fr/sierra/pdfs/icml09.pdf)
  
  Examples
  --------
  >>> import numpy as np
  >>> from sklearn.datasets import make_sparse_coded_signal
  >>> from sklearn.decomposition import DictionaryLearning
  >>> X, dictionary, code = make_sparse_coded_signal(
  ...     n_samples=30, n_components=15, n_features=20, n_nonzero_coefs=10,
  ...     random_state=42,
  ... )
  >>> dict_learner = DictionaryLearning(
  ...     n_components=15, transform_algorithm='lasso_lars', transform_alpha=0.1,
  ...     random_state=42,
  ... )
  >>> X_transformed = dict_learner.fit(X).transform(X)
  
  We can check the level of sparsity of `X_transformed`:
  
  >>> np.mean(X_transformed == 0)
  0.52...
  
  We can compare the average squared euclidean norm of the reconstruction
  error of the sparse coded signal relative to the squared euclidean norm of
  the original signal:
  
  >>> X_hat = X_transformed @ dict_learner.components_
  >>> np.mean(np.sum((X_hat - X) ** 2, axis=1) / np.sum(X ** 2, axis=1))
  0.05...
docstr: Number of transformed output features.
docstr_tok: ["Number","of","transformed","output","features","."]
code: def _n_features_out(self):
      """Number of transformed output features."""
      return self.components_.shape[0]
  
imports: import itertools
  import sys
  import time
  from numbers import Integral, Real
  from warnings import warn
  import numpy
  from joblib import effective_n_jobs
  from scipy import linalg
  from ..base import BaseEstimator, ClassNamePrefixFeaturesOutMixin, TransformerMixin, _fit_context
  from ..linear_model import Lars, Lasso, LassoLars, orthogonal_mp_gram
  from ..utils import check_array, check_random_state, gen_batches, gen_even_slices
  from ..utils._param_validation import Hidden, Interval, StrOptions, validate_params
  from ..utils.extmath import randomized_svd, row_norms, svd_flip
  from ..utils.parallel import Parallel, delayed
  from ..utils.validation import check_is_fitted
label_desc: Use image node_id 4 for calling the DictionaryLearning obj's underlying member method code with example usage: obj._n_features_out() and returns: self