docs: def learning_curve(model, X, y, ax=None, groups=None,
                 train_sizes=DEFAULT_TRAIN_SIZES, cv=None, scoring=None,
                 exploit_incremental_learning=False, n_jobs=1,
                 pre_dispatch="all", shuffle=False, random_state=None,
                 **kwargs):
      """
      Displays a learning curve based on number of samples vs training and
      cross validation scores. The learning curve aims to show how a model
      learns and improves with experience.
  
      This helper function is a quick wrapper to utilize the LearningCurve
      for one-off analysis.
  
      Parameters
      ----------
      model : a scikit-learn estimator
          An object that implements ``fit`` and ``predict``, can be a
          classifier, regressor, or clusterer so long as there is also a valid
          associated scoring metric.
  
          Note that the object is cloned for each validation.
  
      X : array-like, shape (n_samples, n_features)
          Training vector, where n_samples is the number of samples and
          n_features is the number of features.
  
      y : array-like, shape (n_samples) or (n_samples, n_features), optional
          Target relative to X for classification or regression;
          None for unsupervised learning.
  
      ax : matplotlib.Axes object, optional
          The axes object to plot the figure on.
  
      groups : array-like, with shape (n_samples,)
          Optional group labels for the samples used while splitting the dataset
          into train/test sets.
  
      train_sizes : array-like, shape (n_ticks,)
          default: ``np.linspace(0.1,1.0,5)``
  
          Relative or absolute numbers of training examples that will be used to
          generate the learning curve. If the dtype is float, it is regarded as
          a fraction of the maximum size of the training set, otherwise it is
          interpreted as absolute sizes of the training sets.
  
      cv : int, cross-validation generator or an iterable, optional
          Determines the cross-validation splitting strategy.
          Possible inputs for cv are:
  
            - None, to use the default 3-fold cross-validation,
            - integer, to specify the number of folds.
            - An object to be used as a cross-validation generator.
            - An iterable yielding train/test splits.
  
          see the scikit-learn
          `cross-validation guide <http://scikit-learn.org/stable/modules/cross_validation.html>`_
          for more information on the possible strategies that can be used here.
  
      scoring : string, callable or None, optional, default: None
          A string or scorer callable object / function with signature
          ``scorer(estimator, X, y)``. See scikit-learn model evaluation
          documentation for names of possible metrics.
  
      exploit_incremental_learning : boolean, default: False
          If the estimator supports incremental learning, this will be used to
          speed up fitting for different training set sizes.
  
      n_jobs : integer, optional
          Number of jobs to run in parallel (default 1).
  
      pre_dispatch : integer or string, optional
          Number of predispatched jobs for parallel execution (default is
          all). The option can reduce the allocated memory. The string can
          be an expression like '2*n_jobs'.
  
      shuffle : boolean, optional
          Whether to shuffle training data before taking prefixes of it
          based on``train_sizes``.
  
      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`. Used when ``shuffle`` is True.
  
      kwargs : dict
          Keyword arguments that are passed to the base class and may influence
          the visualization as defined in other Visualizers. These arguments are
          also passed to the `poof()` method, e.g. can pass a path to save the
          figure to.
  
      Returns
      -------
      ax : matplotlib axes
          Returns the axes that the learning curve were drawn on.
      """
      # Initialize the visualizer
      oz = LearningCurve(
          model, ax=ax, groups=groups, train_sizes=train_sizes, cv=cv,
          scoring=scoring, n_jobs=n_jobs, pre_dispatch=pre_dispatch,
          shuffle=shuffle, random_state=random_state,
          exploit_incremental_learning=exploit_incremental_learning,
      )
  
      # Fit and poof the visualizer
      oz.fit(X, y)
      oz.poof(**kwargs)
      return oz.ax