code: def manifold_embedding(
      X,
      y=None,
      ax=None,
      manifold="mds",
      n_neighbors=None,
      features=None,
      classes=None,
      colors=None,
      colormap=None,
      target_type="auto",
      projection=2,
      alpha=0.75,
      random_state=None,
      colorbar=True,
      show=True,
      **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 axis to plot the figure on. If None is passed in 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 above, or an actual scikit-learn
          transformer. The constructed manifold is accessible with the manifold
          property, so as to modify hyperparameters before fit.
  
      n_neighbors : int, default: None
          Many manifold algorithms are nearest neighbors based, for those that
          are, this parameter specfies the number of neighbors to use in the
          embedding. If n_neighbors is not specified for those embeddings, it is
          set to 5 and a warning is issued. If the manifold algorithm doesn't use
          nearest neighbors, then this parameter is ignored.
  
      features : list, default: None
          The names of the features specified by the columns of the input dataset.
          This length of this list must match the number of columns in X, otherwise
          an exception will be raised on ``fit()``.
  
      classes : list, default: None
          The class labels for each class in y, ordered by sorted class index. These
          names act as a label encoder for the legend, identifying integer classes
          or renaming string labels. If omitted, the class labels will be taken from
          the unique values in y.
  
          Note that the length of this list must match the number of unique values in
          y, otherwise an exception is raised. This parameter is only used in the
          discrete target type case and is ignored otherwise.
  
      colors : list or tuple, default: None
          A single color to plot all instances as or a list of colors to color each
          instance according to its class in the discrete case or as an ordered
          colormap in the sequential case. If not enough colors per class are
          specified then the colors are treated as a cycle.
  
      colormap : string or cmap, default: None
          The colormap used to create the individual colors. In the discrete case
          it is used to compute the number of colors needed for each class and
          in the continuous case it is used to create a sequential color map based
          on the range of the target.
  
      target_type : str, default: "auto"
          Specify the type of target as either "discrete" (classes) or "continuous"
          (real numbers, usually for regression). If "auto", then it will
          attempt to determine the type by counting the number of unique values.
  
          If the target is discrete, the colors are returned as a dict with classes
          being the keys. If continuous the colors will be list having value of
          color for each point. In either case, if no target is specified, then
          color will be specified as the first color in the color cycle.
  
      projection : int or string, default: 2
          The number of axes to project into, either 2d or 3d. To plot 3d plots
          with matplotlib, please ensure a 3d axes is passed to the visualizer,
          otherwise one will be created using the current figure.
  
      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 or RandomState, default: None
          Fixes the random state for stochastic manifold algorithms.
  
      colorbar : bool, default: True
          If the target_type is "continous" draw a colorbar to the right of the
          scatter plot. The colobar axes is accessible using the cax property.
  
      show: bool, default: True
          If True, calls ``show()``, which in turn calls ``plt.show()`` however you cannot
          call ``plt.savefig`` from this signature, nor ``clear_figure``. If False, simply
          calls ``finalize()``
  
      kwargs : dict
          Keyword arguments passed to the base class and may influence the
          feature visualization properties.
  
      Returns
      -------
      viz : Manifold
          Returns the fitted, finalized visualizer
      """
      # Instantiate the visualizer
      viz = Manifold(
          ax=ax,
          manifold=manifold,
          n_neighbors=n_neighbors,
          features=features,
          classes=classes,
          colors=colors,
          colormap=colormap,
          target_type=target_type,
          projection=projection,
          alpha=alpha,
          random_state=random_state,
          colorbar=colorbar,
          **kwargs,
      )
  
      # Fit and transform the visualizer (calls draw)
      viz.fit_transform(X, y)
  
      if show:
          viz.show()
      else:
          viz.finalize()
  
      # Return the visualizer object
      return viz
  
imports: import warnings
  from yellowbrick.utils.timer import Timer
  from yellowbrick.utils.types import is_estimator
  from yellowbrick.exceptions import ModelError, NotFitted
  from yellowbrick.features.projection import ProjectionVisualizer
  from yellowbrick.exceptions import YellowbrickValueError, YellowbrickWarning
  from sklearn.base import clone
  from sklearn.exceptions import NotFittedError
  from sklearn.manifold import LocallyLinearEmbedding
  from sklearn.manifold import Isomap, MDS, TSNE, SpectralEmbedding
label_desc: Use image node_id 1 for calling a global function with example usage: manifold_embedding(X, y, ax, manifold, n_neighbors, features, classes, colors, colormap, target_type, projection, alpha, random_state, colorbar, show) and returns: viz