class_docstr: Display a projection of a vectorized corpus in two dimensions using UMAP (Uniform
  Manifold Approximation and Projection), a nonlinear dimensionality reduction method
  that is particularly well suited to embedding in two or three dimensions for
  visualization as a scatter plot. UMAP is a relatively new technique but is often
  used to visualize clusters or groups of data points and their relative proximities.
  It typically is fast, scalable, and can be applied directly to sparse matrices
  eliminating the need to run a ``TruncatedSVD`` as a pre-processing step.
  
  The current default for UMAP is Euclidean distance. Hellinger distance would be a
  more appropriate distance function to use with CountVectorize data. That will be
  released in a forthcoming version of UMAP. In the meantime cosine distance is likely
  a better text default that Euclidean and can be set using the keyword argument
  ``metric='cosine'``.
  
  For more, see https://github.com/lmcinnes/umap
  
  Parameters
  ----------
  
  ax : matplotlib axes
      The axes to plot the figure on.
  
  labels : list of strings
      The names of the classes in the target, used to create a legend.
      Labels must match names of classes in sorted order.
  
  colors : list or tuple of colors
      Specify the colors for each individual class
  
  colormap : string or matplotlib cmap
      Sequential colormap for continuous target
  
  random_state : int, RandomState instance or None, optional, default: None
      If int, random_state is the seed used by the random number generator;
      If RandomState instance, random_state is the random number generator;
      If None, the random number generator is the RandomState instance used
      by np.random. The random state is applied to the preliminary
      decomposition as well as UMAP.
  
  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.
  
  kwargs : dict
      Pass any additional keyword arguments to the UMAP transformer.
  
  Examples
  --------
  
  >>> model = MyVisualizer(metric='cosine')
  >>> model.fit(X)
  >>> model.show()
docstr: Called from the fit method, this method draws the UMAP scatter plot,
  from a set of decomposed points in 2 dimensions. This method also
  accepts a third dimension, target, which is used to specify the colors
  of each of the points. If the target is not specified, then the points
  are plotted as a single cloud to show similar documents.
docstr_tok: ["Called","from","the","fit","method",",","this","method","draws","the","UMAP","scatter","plot",",","from","a","set","of","decomposed","points","in","2","dimensions",".","This","method","also","accepts","a","third","dimension",",","target",",","which","is","used","to","specify","the","colors","of","each","of","the","points",".","If","the","target","is","not","specified",",","then","the","points","are","plotted","as","a","single","cloud","to","show","similar","documents","."]
code: def draw(self, points, target=None, **kwargs):
      """
      Called from the fit method, this method draws the UMAP scatter plot,
      from a set of decomposed points in 2 dimensions. This method also
      accepts a third dimension, target, which is used to specify the colors
      of each of the points. If the target is not specified, then the points
      are plotted as a single cloud to show similar documents.
      """
      # Resolve the labels with the classes
      labels = self.labels if self.labels is not None else self.classes_
      if len(labels) != len(self.classes_):
          raise YellowbrickValueError(
              (
                  "number of supplied labels ({}) does not "
                  "match the number of classes ({})"
              ).format(len(labels), len(self.classes_))
          )
  
      # Create the color mapping for the labels.
      self.color_values_ = resolve_colors(
          n_colors=len(labels),
          colormap=self.colormap,
          colors=self.colors,
      )
      colors = dict(zip(labels, self.color_values_))
  
      # Transform labels into a map of class to label
      labels = dict(zip(self.classes_, labels))
  
      # Expand the points into vectors of x and y for scatter plotting,
      # assigning them to their label if the label has been passed in.
      # Additionally, filter classes not specified directly by the user.
      series = defaultdict(lambda: {"x": [], "y": []})
  
      if target is not None:
          for t, point in zip(target, points):
              label = labels[t]
              series[label]["x"].append(point[0])
              series[label]["y"].append(point[1])
      else:
          label = self.classes_[0]
          for x, y in points:
              series[label]["x"].append(x)
              series[label]["y"].append(y)
  
      # Plot the points
      for label, points in series.items():
          self.ax.scatter(
              points["x"],
              points["y"],
              c=colors[label],
              alpha=self.alpha,
              label=label,
          )
  
      return self.ax
  
file_path: yellowbrick/yellowbrick/text/umap_vis.py
imports: import warnings
  import numpy
  from collections import defaultdict
  from yellowbrick.draw import manual_legend
  from yellowbrick.text.base import TextVisualizer
  from yellowbrick.style.colors import resolve_colors
  from yellowbrick.exceptions import YellowbrickValueError
  from sklearn.pipeline import Pipeline
label_desc: Use image node_id 4 for calling the UMAPVisualizer obj's underlying member method code with example usage: obj.draw(points, target) and returns: self