docs: def parallel_coordinates(X, y, ax=None, features=None, classes=None,
                           normalize=None, sample=1.0, color=None, colormap=None,
                           alpha=None, fast=False, vlines=True, vlines_kwds=None,
                           **kwargs):
      """Displays each feature as a vertical axis and each instance as a line.
  
      This helper function is a quick wrapper to utilize the ParallelCoordinates
      Visualizer (Transformer) for one-off analysis.
  
      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 axis 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.
  
      classes : list, default: None
          a list of class names for the legend
          If classes is None and a y value is passed to fit then the classes
          are selected from the target vector.
  
      normalize : string or None, default: None
          specifies which normalization method to use, if any
          Current supported options are 'minmax', 'maxabs', 'standard', 'l1',
          and 'l2'.
  
      sample : float or int, default: 1.0
          specifies how many examples to display from the data
          If int, specifies the maximum number of samples to display.
          If float, specifies a fraction between 0 and 1 to display.
  
      color : list or tuple, default: None
          optional list or tuple of colors to colorize lines
          Use either color to colorize the lines on a per class basis or
          colormap to color them on a continuous scale.
  
      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: None
          Specify a transparency where 1 is completely opaque and 0 is completely
          transparent. This property makes densely clustered lines more visible.
          If None, the alpha is set to 0.5 in "fast" mode and 0.25 otherwise.
  
      fast : bool, default: False
          Fast mode improves the performance of the drawing time of parallel
          coordinates but produces an image that does not show the overlap of
          instances in the same class. Fast mode should be used when drawing all
          instances is too burdensome and sampling is not an option.
  
      vlines : boolean, default: True
          flag to determine vertical line display
  
      vlines_kwds : dict, default: None
          options to style or display the vertical lines, default: None
  
      kwargs : dict
          Keyword arguments that are passed to the base class and may influence
          the visualization as defined in other Visualizers.
  
      Returns
      -------
      ax : matplotlib axes
          Returns the axes that the parallel coordinates were drawn on.
      """
      # Instantiate the visualizer
      visualizer = ParallelCoordinates(
          ax, features, classes, normalize, sample, color, colormap, alpha,
          fast, vlines, vlines_kwds, **kwargs
      )
  
      # Fit and transform the visualizer (calls draw)
      visualizer.fit(X, y, **kwargs)
      visualizer.transform(X)
  
      # Return the axes object on the visualizer
      return visualizer.ax