docs: def manifold_embedding(
      X,
      y=None,
      ax=None,
      manifold="lle",
      n_neighbors=10,
      colors=None,
      target=AUTO,
      alpha=0.7,
      random_state=None,
      **kwargs):
      """Quick method for Manifold visualizer.
  
      The Manifold visualizer provides high dimensional visualization for feature
      analysis by embedding data into 2 dimensions using the sklearn.manifold
      package for manifold learning. In brief, manifold learning algorithms are
      unsuperivsed approaches to non-linear dimensionality reduction (unlike PCA
      or SVD) that help visualize latent structures in data.
  
      .. seealso:: See Manifold for more details.
  
      Parameters
      ----------
      X : array-like of shape (n, m)
          A matrix or data frame with n instances and m features where m > 2.
  
      y : array-like of shape (n,), optional
          A vector or series with target values for each instance in X. This
          vector is used to determine the color of the points in X.
  
      ax : matplotlib Axes, default: None
          The axes to plot the figure on. If None, the current axes will be used
          or generated if required.
  
      manifold : str or Transformer, default: "lle"
          Specify the manifold algorithm to perform the embedding. Either one of
          the strings listed in the table below, or an actual scikit-learn
          transformer. The constructed manifold is accessible with the manifold
          property, so as to modify hyperparameters before fit.
  
          ============== ==========================
          Manifold       Description
          -------------- --------------------------
          ``"lle"``      `Locally Linear Embedding <http://scikit-learn.org/stable/modules/manifold.html#locally-linear-embedding>`_
          ``"ltsa"``     `LTSA LLE <http://scikit-learn.org/stable/modules/manifold.html#local-tangent-space-alignment>`_
          ``"hessian"``  `Hessian LLE <http://scikit-learn.org/stable/modules/manifold.html#hessian-eigenmapping>`_
          ``"modified"`` `Modified LLE <http://scikit-learn.org/stable/modules/manifold.html#modified-locally-linear-embedding>`_
          ``"isomap"``   `Isomap <http://scikit-learn.org/stable/modules/manifold.html#isomap>`_
          ``"mds"``      `Multi-Dimensional Scaling <http://scikit-learn.org/stable/modules/manifold.html#multi-dimensional-scaling-mds>`_
          ``"spectral"`` `Spectral Embedding <http://scikit-learn.org/stable/modules/manifold.html#spectral-embedding>`_
          ``"tsne"``     `t-SNE <http://scikit-learn.org/stable/modules/manifold.html#t-distributed-stochastic-neighbor-embedding-t-sne>`_
          ============== ==========================
  
      n_neighbors : int, default: 10
          Many manifold algorithms are nearest neighbors based, for those that
          are, this parameter specfies the number of neighbors to use in the
          embedding. If the manifold algorithm doesn't use nearest neighbors,
          then this parameter is ignored.
  
      colors : str or list of colors, default: None
          Specify the colors used, though note that the specification depends
          very much on whether the target is continuous or discrete. If
          continuous, colors must be the name of a colormap. If discrete, then
          colors can be the name of a palette or a list of colors to use for each
          class in the target.
  
      target : str, default: "auto"
          Specify the type of target as either "discrete" (classes) or "continuous"
          (real numbers, usually for regression). If "auto", the Manifold will
          attempt to determine the type by counting the number of unique values.
  
          If the target is discrete, points will be colored by the target class
          and a legend will be displayed. If continuous, points will be displayed
          with a colormap and a color bar will be displayed. In either case, if
          no target is specified, only a single color will be drawn.
  
      alpha : float, default: 0.7
          Specify a transparency where 1 is completely opaque and 0 is completely
          transparent. This property makes densely clustered points more visible.
  
      random_state : int or RandomState, default: None
          Fixes the random state for stochastic manifold algorithms.
  
      kwargs : dict
          Keyword arguments passed to the base class and may influence the
          feature visualization properties.
  
      Returns
      -------
      ax : matplotlib axes
          Returns the axes that the embedded scatter plot was drawn on.
      """
      # Instantiate the visualizer
      viz = Manifold(
          ax=ax, manifold=manifold, n_neighbors=n_neighbors, colors=colors,
          target=target, alpha = alpha, random_state=random_state, **kwargs
      )
  
      # Fit and poof (calls draw)
      viz.fit(X, y)
      viz.poof()
  
      # Return the axes object
      return viz.ax