class_docstr: FastICA: a fast algorithm for Independent Component Analysis.
  
  The implementation is based on [1]_.
  
  Read more in the :ref:`User Guide <ICA>`.
  
  Parameters
  ----------
  n_components : int, default=None
      Number of components to use. If None is passed, all are used.
  
  algorithm : {'parallel', 'deflation'}, default='parallel'
      Specify which algorithm to use for FastICA.
  
  whiten : str or bool, default='unit-variance'
      Specify the whitening strategy to use.
  
      - If 'arbitrary-variance', a whitening with variance
        arbitrary is used.
      - If 'unit-variance', the whitening matrix is rescaled to ensure that
        each recovered source has unit variance.
      - If False, the data is already considered to be whitened, and no
        whitening is performed.
  
      .. versionchanged:: 1.3
          The default value of `whiten` changed to 'unit-variance' in 1.3.
  
  fun : {'logcosh', 'exp', 'cube'} or callable, default='logcosh'
      The functional form of the G function used in the
      approximation to neg-entropy. Could be either 'logcosh', 'exp',
      or 'cube'.
      You can also provide your own function. It should return a tuple
      containing the value of the function, and of its derivative, in the
      point. The derivative should be averaged along its last dimension.
      Example::
  
          def my_g(x):
              return x ** 3, (3 * x ** 2).mean(axis=-1)
  
  fun_args : dict, default=None
      Arguments to send to the functional form.
      If empty or None and if fun='logcosh', fun_args will take value
      {'alpha' : 1.0}.
  
  max_iter : int, default=200
      Maximum number of iterations during fit.
  
  tol : float, default=1e-4
      A positive scalar giving the tolerance at which the
      un-mixing matrix is considered to have converged.
  
  w_init : array-like of shape (n_components, n_components), default=None
      Initial un-mixing array. If `w_init=None`, then an array of values
      drawn from a normal distribution is used.
  
  whiten_solver : {"eigh", "svd"}, default="svd"
      The solver to use for whitening.
  
      - "svd" is more stable numerically if the problem is degenerate, and
        often faster when `n_samples <= n_features`.
  
      - "eigh" is generally more memory efficient when
        `n_samples >= n_features`, and can be faster when
        `n_samples >= 50 * n_features`.
  
      .. versionadded:: 1.2
  
  random_state : int, RandomState instance or None, default=None
      Used to initialize ``w_init`` when not specified, with a
      normal distribution. Pass an int, for reproducible results
      across multiple function calls.
      See :term:`Glossary <random_state>`.
  
  Attributes
  ----------
  components_ : ndarray of shape (n_components, n_features)
      The linear operator to apply to the data to get the independent
      sources. This is equal to the unmixing matrix when ``whiten`` is
      False, and equal to ``np.dot(unmixing_matrix, self.whitening_)`` when
      ``whiten`` is True.
  
  mixing_ : ndarray of shape (n_features, n_components)
      The pseudo-inverse of ``components_``. It is the linear operator
      that maps independent sources to the data.
  
  mean_ : ndarray of shape(n_features,)
      The mean over features. Only set if `self.whiten` is True.
  
  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
      If the algorithm is "deflation", n_iter is the
      maximum number of iterations run across all components. Else
      they are just the number of iterations taken to converge.
  
  whitening_ : ndarray of shape (n_components, n_features)
      Only set if whiten is 'True'. This is the pre-whitening matrix
      that projects data onto the first `n_components` principal components.
  
  See Also
  --------
  PCA : Principal component analysis (PCA).
  IncrementalPCA : Incremental principal components analysis (IPCA).
  KernelPCA : Kernel Principal component analysis (KPCA).
  MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis.
  SparsePCA : Sparse Principal Components Analysis (SparsePCA).
  
  References
  ----------
  .. [1] A. Hyvarinen and E. Oja, Independent Component Analysis:
         Algorithms and Applications, Neural Networks, 13(4-5), 2000,
         pp. 411-430.
  
  Examples
  --------
  >>> from sklearn.datasets import load_digits
  >>> from sklearn.decomposition import FastICA
  >>> X, _ = load_digits(return_X_y=True)
  >>> transformer = FastICA(n_components=7,
  ...         random_state=0,
  ...         whiten='unit-variance')
  >>> X_transformed = transformer.fit_transform(X)
  >>> X_transformed.shape
  (1797, 7)
docstr: Fit the model and recover the sources from X.
  
  Parameters
  ----------
  X : array-like of shape (n_samples, n_features)
      Training data, where `n_samples` is the number of samples
      and `n_features` is the number of features.
  
  y : Ignored
      Not used, present for API consistency by convention.
  
  Returns
  -------
  X_new : ndarray of shape (n_samples, n_components)
      Estimated sources obtained by transforming the data with the
      estimated unmixing matrix.
docstr_tok: ["Fit","the","model","and","recover","the","sources","from","X.","Parameters","--","--","--","--","--","X",":","array-like","of","shape","(","n_samples",",","n_features",")","Training","data",",","where","`","n_samples","`","is","the","number","of","samples","and","`","n_features","`","is","the","number","of","features",".","y",":","Ignored","Not","used",",","present","for","API","consistency","by","convention",".","Returns","--","--","--","-","X_new",":","ndarray","of","shape","(","n_samples",",","n_components",")","Estimated","sources","obtained","by","transforming","the","data","with","the","estimated","unmixing","matrix","."]
code: def fit_transform(self, X, y=None):
      """Fit the model and recover the sources from X.
  
      Parameters
      ----------
      X : array-like of shape (n_samples, n_features)
          Training data, where `n_samples` is the number of samples
          and `n_features` is the number of features.
  
      y : Ignored
          Not used, present for API consistency by convention.
  
      Returns
      -------
      X_new : ndarray of shape (n_samples, n_components)
          Estimated sources obtained by transforming the data with the
          estimated unmixing matrix.
      """
      return self._fit_transform(X, compute_sources=True)
  
imports: import warnings
  from numbers import Integral, Real
  import numpy
  from scipy import linalg
  from ..base import BaseEstimator, ClassNamePrefixFeaturesOutMixin, TransformerMixin, _fit_context
  from ..exceptions import ConvergenceWarning
  from ..utils import as_float_array, check_array, check_random_state
  from ..utils._param_validation import Interval, Options, StrOptions, validate_params
  from ..utils.validation import check_is_fitted
label_desc: Use image node_id 3 for calling the FastICA obj's underlying member method code with example usage: obj.fit_transform(X, y) and returns: self