docs: def roc_auc(model, X, y=None, ax=None, **kwargs):
      """ROCAUC Quick method:
  
      Receiver Operating Characteristic (ROC) curves are a measure of a
      classifier's predictive quality that compares and visualizes the tradeoff
      between the models' sensitivity and specificity. The ROC curve displays
      the true positive rate on the Y axis and the false positive rate on the
      X axis on both a global average and per-class basis. The ideal point is
      therefore the top-left corner of the plot: false positives are zero and
      true positives are one.
  
      This leads to another metric, area under the curve  (AUC), a computation
      of the relationship between false positives and true positives. The higher
      the AUC, the better the model generally is. However, it is also important
      to inspect the "steepness" of the curve, as this describes the
      maximization of the true positive rate while minimizing the false positive
      rate. Generalizing "steepness" usually leads to discussions about
      convexity, which we do not get into here.
  
      Parameters
      ----------
      model : the Scikit-Learn estimator
          Should be an instance of a classifier, else the __init__ will
          return an error.
  
      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 : the axis to plot the figure on.
  
      classes : list
          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.
          Note that the curves must be computed based on what is in the target
          vector passed to the ``score()`` method. Class names are used for
          labeling only and must be in the correct order to prevent confusion.
  
      micro : bool, default = True
          Plot the micro-averages ROC curve, computed from the sum of all true
          positives and false positives across all classes. Micro is not defined
          for binary classification problems with estimators with only a
          decision_function method.
  
      macro : bool, default = True
          Plot the macro-averages ROC curve, which simply takes the average of
          curves across all classes. Macro is not defined for binary
          classification problems with estimators with only a decision_function
          method.
  
      per_class : bool, default = True
          Plot the ROC curves for each individual class. This should be set
          to false if only the macro or micro average curves are required. Per-
          class classification is not defined for binary classification problems
          with estimators with only a decision_function method.
  
      Notes
      -----
      ROC curves are typically used in binary classification, and in fact the
      Scikit-Learn ``roc_curve`` metric is only able to perform metrics for
      binary classifiers. As a result it is necessary to binarize the output or
      to use one-vs-rest or one-vs-all strategies of classification. The
      visualizer does its best to handle multiple situations, but exceptions can
      arise from unexpected models or outputs.
  
      Another important point is the relationship of class labels specified on
      initialization to those drawn on the curves. The classes are not used to
      constrain ordering or filter curves; the ROC computation happens on the
      unique values specified in the target vector to the ``score`` method. To
      ensure the best quality visualization, do not use a LabelEncoder for this
      and do not pass in class labels.
  
      .. seealso:: http://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html
      .. todo:: Allow the class list to filter the curves on the visualization.
  
      Examples
      --------
      >>> from yellowbrick.classifier import ROCAUC
      >>> from sklearn.linear_model import LogisticRegression
      >>> data = load_data("occupancy")
      >>> features = ["temp", "relative humidity", "light", "C02", "humidity"]
      >>> X = data[features].values
      >>> y = data.occupancy.values
      >>> roc_auc(LogisticRegression(), X, y)
  
      Returns
      -------
      ax : matplotlib axes
          Returns the axes that the roc-auc curve was drawn on.
      """
      # Instantiate the visualizer
      visualizer = ROCAUC(model, ax, **kwargs)
  
      # Create the train and test splits
      X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
  
      # Fit and transform the visualizer (calls draw)
      visualizer.fit(X_train, y_train, **kwargs)
      visualizer.score(X_test, y_test)
      visualizer.finalize()
  
      # Return the axes object on the visualizer
      return visualizer.ax