docs: def residuals_plot(model,
                     X,
                     y,
                     ax=None,
                     hist=True,
                     test_size=0.25,
                     train_color='b',
                     test_color='g',
                     line_color=LINE_COLOR,
                     random_state=None,
                     train_alpha=0.75,
                     test_alpha=0.75,
                     **kwargs):
      """Quick method:
  
      Divides the dataset X, y into a train and test split (the size of the
      splits determined by test_size) then plots the training and test residuals
      agains the predicted value for the given model.
  
      This helper function is a quick wrapper to utilize the ResidualsPlot
      ScoreVisualizer for one-off analysis.
  
      Parameters
      ----------
      model : a Scikit-Learn regressor
          Should be an instance of a regressor, otherwise will raise a
          YellowbrickTypeError exception on instantiation.
  
      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 axes to plot the figure on. If None is passed in the current axes
          will be used (or generated if required).
  
      hist : {True, False, None, 'density', 'frequency'}, default: True
          Draw a histogram showing the distribution of the residuals on the
          right side of the figure. Requires Matplotlib >= 2.0.2.
          If set to 'density', the probability density function will be plotted.
          If set to True or 'frequency' then the frequency will be plotted.
  
      test_size : float, int default: 0.25
          If float, should be between 0.0 and 1.0 and represent the proportion
          of the dataset to include in the test split. If int, represents the
          absolute number of test samples.
  
      train_color : color, default: 'b'
          Residuals for training data are ploted with this color but also
          given an opacity of 0.5 to ensure that the test data residuals
          are more visible. Can be any matplotlib color.
  
      test_color : color, default: 'g'
          Residuals for test data are plotted with this color. In order to
          create generalizable models, reserved test data residuals are of
          the most analytical interest, so these points are highlighted by
          having full opacity. Can be any matplotlib color.
  
      line_color : color, default: dark grey
          Defines the color of the zero error line, can be any matplotlib color.
  
      random_state : int, RandomState instance or None, optional
          Passed to the train_test_split function.
  
      train_alpha : float, default: 0.75
          Specify a transparency for traininig data, where 1 is completely opaque 
          and 0 is completely transparent. This property makes densely clustered 
          points more visible.
      
      test_alpha : float, default: 0.75
          Specify a transparency for test data, where 1 is completely opaque and 
          0 is completely transparent. This property makes densely clustered 
          points more visible.
  
      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 residuals plot was drawn on.
      """
      # Instantiate the visualizer
      
      visualizer = ResidualsPlot(
          model=model, ax=ax, hist=hist, train_color=train_color,
          test_color=test_color, line_color=line_color, 
          train_alpha=train_alpha,test_alpha=test_alpha,
          **kwargs
      )
  
      # Create the train and test splits
      X_train, X_test, y_train, y_test = train_test_split(
          X, y, test_size=test_size, random_state=random_state
      )
  
      # 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