class_docstr: Partial Least Square SVD
  
  Simply perform a svd on the crosscovariance matrix: X'Y
  There are no iterative deflation here.
  
  Read more in the :ref:`User Guide <cross_decomposition>`.
  
  Parameters
  ----------
  n_components : int, default 2
      Number of components to keep.
  
  scale : boolean, default True
      Whether to scale X and Y.
  
  copy : boolean, default True
      Whether to copy X and Y, or perform in-place computations.
  
  Attributes
  ----------
  x_weights_ : array, [p, n_components]
      X block weights vectors.
  
  y_weights_ : array, [q, n_components]
      Y block weights vectors.
  
  x_scores_ : array, [n_samples, n_components]
      X scores.
  
  y_scores_ : array, [n_samples, n_components]
      Y scores.
  
  See also
  --------
  PLSCanonical
  CCA
code: def fit(self, X, Y):
      # copy since this will contains the centered data
      check_consistent_length(X, Y)
      X = check_array(X, dtype=np.float64, copy=self.copy)
      Y = check_array(
          Y, dtype=np.float64, copy=self.copy, ensure_2d=False
      )
      if Y.ndim == 1:
          Y = Y.reshape(-1, 1)
  
      if self.n_components > max(Y.shape[1], X.shape[1]):
          raise ValueError(
              "Invalid number of components n_components=%d"
              " with X of shape %s and Y of shape %s."
              % (self.n_components, str(X.shape), str(Y.shape))
          )
  
      # Scale (in place)
      (
          X,
          Y,
          self.x_mean_,
          self.y_mean_,
          self.x_std_,
          self.y_std_,
      ) = _center_scale_xy(X, Y, self.scale)
      # svd(X'Y)
      C = np.dot(X.T, Y)
  
      # The arpack svds solver only works if the number of extracted
      # components is smaller than rank(X) - 1. Hence, if we want to extract
      # all the components (C.shape[1]), we have to use another one. Else,
      # let's use arpacks to compute only the interesting components.
      if self.n_components >= np.min(C.shape):
          U, s, V = linalg.svd(C, full_matrices=False)
      else:
          U, s, V = arpack.svds(C, k=self.n_components)
      # Deterministic output
      U, V = svd_flip(U, V)
      V = V.T
      self.x_scores_ = np.dot(X, U)
      self.y_scores_ = np.dot(Y, V)
      self.x_weights_ = U
      self.y_weights_ = V
      return self
  
imports: from distutils.version import LooseVersion
  from sklearn.utils.extmath import svd_flip
  from ..base import BaseEstimator, RegressorMixin, TransformerMixin
  from ..utils import check_array, check_consistent_length
  from ..externals import six
  import warnings
  from abc import ABCMeta, abstractmethod
  import numpy
  from scipy import linalg
  from ..utils import arpack
  from ..utils.validation import check_is_fitted, FLOAT_DTYPES
  import scipy
label_desc: Use image node_id 2 for calling the PLSSVD obj's underlying member method code with example usage: obj.fit(X, Y) and returns: self