class_docstr: Approximate a kernel map using a subset of the training data.
  
  Constructs an approximate feature map for an arbitrary kernel
  using a subset of the data as basis.
  
  Read more in the :ref:`User Guide <nystroem_kernel_approx>`.
  
  Parameters
  ----------
  kernel : string or callable, default="rbf"
      Kernel map to be approximated. A callable should accept two arguments
      and the keyword arguments passed to this object as kernel_params, and
      should return a floating point number.
  
  n_components : int
      Number of features to construct.
      How many data points will be used to construct the mapping.
  
  gamma : float, default=None
      Gamma parameter for the RBF, polynomial, exponential chi2 and
      sigmoid kernels. Interpretation of the default value is left to
      the kernel; see the documentation for sklearn.metrics.pairwise.
      Ignored by other kernels.
  
  degree : float, default=3
      Degree of the polynomial kernel. Ignored by other kernels.
  
  coef0 : float, default=1
      Zero coefficient for polynomial and sigmoid kernels.
      Ignored by other kernels.
  
  kernel_params : mapping of string to any, optional
      Additional parameters (keyword arguments) for kernel function passed
      as callable object.
  
  random_state : {int, RandomState}, optional
      If int, random_state is the seed used by the random number generator;
      if RandomState instance, random_state is the random number generator.
  
  
  Attributes
  ----------
  components_ : array, shape (n_components, n_features)
      Subset of training points used to construct the feature map.
  
  component_indices_ : array, shape (n_components)
      Indices of ``components_`` in the training set.
  
  normalization_ : array, shape (n_components, n_components)
      Normalization matrix needed for embedding.
      Square root of the kernel matrix on ``components_``.
  
  
  References
  ----------
  * Williams, C.K.I. and Seeger, M.
    "Using the Nystroem method to speed up kernel machines",
    Advances in neural information processing systems 2001
  
  * T. Yang, Y. Li, M. Mahdavi, R. Jin and Z. Zhou
    "Nystroem Method vs Random Fourier Features: A Theoretical and Empirical
    Comparison",
    Advances in Neural Information Processing Systems 2012
  
  
  See also
  --------
  RBFSampler : An approximation to the RBF kernel using random Fourier
               features.
  
  sklearn.metrics.pairwise.kernel_metrics : List of built-in kernels.
docstr: Fit estimator to data.
  
  Samples a subset of training points, computes kernel
  on these and computes normalization matrix.
  
  Parameters
  ----------
  X : array-like, shape=(n_samples, n_feature)
      Training data.
docstr_tok: ["Fit","estimator","to","data",".","Samples","a","subset","of","training","points",",","computes","kernel","on","these","and","computes","normalization","matrix",".","Parameters","--","--","--","--","--","X",":","array-like",",","shape=","(","n_samples",",","n_feature",")","Training","data","."]
code: def fit(self, X, y=None):
      """Fit estimator to data.
  
      Samples a subset of training points, computes kernel
      on these and computes normalization matrix.
  
      Parameters
      ----------
      X : array-like, shape=(n_samples, n_feature)
          Training data.
      """
      X = check_array(X, accept_sparse="csr")
      rnd = check_random_state(self.random_state)
      n_samples = X.shape[0]
  
      # get basis vectors
      if self.n_components > n_samples:
          # XXX should we just bail?
          n_components = n_samples
          warnings.warn(
              "n_components > n_samples. This is not possible.\n"
              "n_components was set to n_samples, which results"
              " in inefficient evaluation of the full kernel."
          )
  
      else:
          n_components = self.n_components
      n_components = min(n_samples, n_components)
      inds = rnd.permutation(n_samples)
      basis_inds = inds[:n_components]
      basis = X[basis_inds]
  
      basis_kernel = pairwise_kernels(
          basis,
          metric=self.kernel,
          filter_params=True,
          **self._get_kernel_params(),
      )
  
      # sqrt of kernel matrix on basis vectors
      U, S, V = svd(basis_kernel)
      S = np.maximum(S, 1e-12)
      self.normalization_ = np.dot(U * 1.0 / np.sqrt(S), V)
      self.components_ = basis
      self.component_indices_ = inds
      return self
  
imports: import warnings
  import numpy
  import scipy.sparse
  from scipy.linalg import svd
  from .base import BaseEstimator
  from .base import TransformerMixin
  from .utils import check_array, check_random_state, as_float_array
  from .utils.extmath import safe_sparse_dot
  from .utils.validation import check_is_fitted
  from .metrics.pairwise import pairwise_kernels
label_desc: Use image node_id 2 for calling the Nystroem obj's underlying member method code with example usage: obj.fit(X, y) and returns: self