docs: def pca_decomposition(X, y=None, ax=None, features=None, scale=True,
                        proj_dim=2, proj_features=False, color=None,
                        colormap=palettes.DEFAULT_SEQUENCE, alpha=0.75,
                        random_state=None, **kwargs):
      """Produce a two or three dimensional principal component plot of the data array ``X``
      projected onto it's largest sequential principal components. It is common practice to scale the
      data array ``X`` before applying a PC decomposition. Variable scaling can be controlled using
      the ``scale`` argument.
  
      Parameters
      ----------
      X : ndarray or DataFrame of shape n x m
          A matrix of n instances with m features.
  
      y : ndarray or Series of length n
          An array or series of target or class values.
  
      ax : matplotlib Axes, default: None
          The axes to plot the figure on. If None is passed in the current axes.
          will be used (or generated if required).
  
      features: list, default: None
          a list of feature names to use
          If a DataFrame is passed to fit and features is None, feature
          names are selected as the columns of the DataFrame.
  
      scale : bool, default: True
          Boolean that indicates if user wants to scale data.
  
      proj_dim : int, default: 2
          Dimension of the PCA visualizer.
  
      proj_features : bool, default: False
          Boolean that indicates if the user wants to project the features
          in the projected space. If True the plot will be similar to a biplot.
  
      color : list or tuple of colors, default: None
          Specify the colors for each individual class.
  
      colormap : string or cmap, default: None
          Optional string or matplotlib cmap to colorize lines.
          Use either color to colorize the lines on a per class basis or
          colormap to color them on a continuous scale.
          
      alpha : float, default: 0.75
          Specify a transparency where 1 is completely opaque and 0 is completely
          transparent. This property makes densely clustered points more visible.
  
      random_state : int, RandomState instance or None, optional (default None)
          If input data is larger than 500x500 and the number of components to
          extract is lower than 80% of the smallest dimension of the data, then
          the more efficient `randomized` solver is enabled, this parameter sets
          the random state on this solver.
  
      kwargs : dict
          Keyword arguments that are passed to the base class and may influence
          the visualization as defined in other Visualizers.
  
      Examples
      --------
      >>> from sklearn import datasets
      >>> iris = datasets.load_iris()
      >>> X = iris.data
      >>> y = iris.target
      >>> pca_decomposition(X, color=y, proj_dim=3, colormap='RdBu_r')
  
      """
      # Instantiate the visualizer
      visualizer = PCADecomposition(
          ax=ax, features=features, scale=scale, proj_dim=proj_dim,
          proj_features=proj_features, color=color, colormap=colormap,
          alpha=alpha, random_state=random_state, **kwargs
      )
  
      # Fit and transform the visualizer (calls draw)
      visualizer.fit(X, y)
      visualizer.transform(X)
      visualizer.poof()
  
      # Return the axes object on the visualizer
      return visualizer.ax