code: def plot_precision_recall(
      y_true,
      y_probas,
      title="Precision-Recall Curve",
      plot_micro=True,
      classes_to_plot=None,
      ax=None,
      figsize=None,
      cmap="nipy_spectral",
      title_fontsize="large",
      text_fontsize="medium",
  ):
      """Generates the Precision Recall Curve from labels and probabilities
  
      Args:
          y_true (array-like, shape (n_samples)):
              Ground truth (correct) target values.
  
          y_probas (array-like, shape (n_samples, n_classes)):
              Prediction probabilities for each class returned by a classifier.
  
          title (string, optional): Title of the generated plot. Defaults to
              "Precision-Recall curve".
  
          plot_micro (boolean, optional): Plot the micro average ROC curve.
              Defaults to ``True``.
  
          classes_to_plot (list-like, optional): Classes for which the precision-recall
              curve should be plotted. e.g. [0, 'cold']. If given class does not exist,
              it will be ignored. If ``None``, all classes will be plotted. Defaults to
              ``None``.
  
          ax (:class:`matplotlib.axes.Axes`, optional): The axes upon which to
              plot the curve. If None, the plot is drawn on a new set of axes.
  
          figsize (2-tuple, optional): Tuple denoting figure size of the plot
              e.g. (6, 6). Defaults to ``None``.
  
          cmap (string or :class:`matplotlib.colors.Colormap` instance, optional):
              Colormap used for plotting the projection. View Matplotlib Colormap
              documentation for available options.
              https://matplotlib.org/users/colormaps.html
  
          title_fontsize (string or int, optional): Matplotlib-style fontsizes.
              Use e.g. "small", "medium", "large" or integer-values. Defaults to
              "large".
  
          text_fontsize (string or int, optional): Matplotlib-style fontsizes.
              Use e.g. "small", "medium", "large" or integer-values. Defaults to
              "medium".
  
      Returns:
          ax (:class:`matplotlib.axes.Axes`): The axes on which the plot was
              drawn.
  
      Example:
          >>> import scikitplot as skplt
          >>> nb = GaussianNB()
          >>> nb.fit(X_train, y_train)
          >>> y_probas = nb.predict_proba(X_test)
          >>> skplt.metrics.plot_precision_recall(y_test, y_probas)
          <matplotlib.axes._subplots.AxesSubplot object at 0x7fe967d64490>
          >>> plt.show()
  
          .. image:: _static/examples/plot_precision_recall_curve.png
             :align: center
             :alt: Precision Recall Curve
      """
      y_true = np.array(y_true)
      y_probas = np.array(y_probas)
  
      classes = np.unique(y_true)
      probas = y_probas
  
      if classes_to_plot is None:
          classes_to_plot = classes
  
      binarized_y_true = label_binarize(y_true, classes=classes)
      if len(classes) == 2:
          binarized_y_true = np.hstack(
              (1 - binarized_y_true, binarized_y_true)
          )
  
      if ax is None:
          fig, ax = plt.subplots(1, 1, figsize=figsize)
  
      ax.set_title(title, fontsize=title_fontsize)
  
      indices_to_plot = np.in1d(classes, classes_to_plot)
      for i, to_plot in enumerate(indices_to_plot):
          if to_plot:
              average_precision = average_precision_score(
                  binarized_y_true[:, i], probas[:, i]
              )
              precision, recall, _ = precision_recall_curve(
                  y_true, probas[:, i], pos_label=classes[i]
              )
              color = plt.cm.get_cmap(cmap)(float(i) / len(classes))
              ax.plot(
                  recall,
                  precision,
                  lw=2,
                  label="Precision-recall curve of class {0} "
                  "(area = {1:0.3f})".format(
                      classes[i], average_precision
                  ),
                  color=color,
              )
  
      if plot_micro:
          precision, recall, _ = precision_recall_curve(
              binarized_y_true.ravel(), probas.ravel()
          )
          average_precision = average_precision_score(
              binarized_y_true, probas, average="micro"
          )
          ax.plot(
              recall,
              precision,
              label="micro-average Precision-recall curve "
              "(area = {0:0.3f})".format(average_precision),
              color="navy",
              linestyle=":",
              linewidth=4,
          )
  
      ax.set_xlim([0.0, 1.0])
      ax.set_ylim([0.0, 1.05])
      ax.set_xlabel("Recall")
      ax.set_ylabel("Precision")
      ax.tick_params(labelsize=text_fontsize)
      ax.legend(loc="best", fontsize=text_fontsize)
      return ax
  
imports: from __future__ import absolute_import, division, print_function, unicode_literals
  import itertools
  import matplotlib.pyplot
  import numpy
  from sklearn.metrics import confusion_matrix
  from sklearn.preprocessing import label_binarize
  from sklearn.preprocessing import LabelEncoder
  from sklearn.metrics import roc_curve
  from sklearn.metrics import auc
  from sklearn.metrics import precision_recall_curve
  from sklearn.metrics import average_precision_score
  from sklearn.utils.multiclass import unique_labels
  from sklearn.metrics import silhouette_score
  from sklearn.metrics import silhouette_samples
  from sklearn.calibration import calibration_curve
  from sklearn.utils import deprecated
  from scipy import interp
  from scikitplot.helpers import binary_ks_curve, validate_labels
  from scikitplot.helpers import cumulative_gain_curve
label_desc: Use image node_id 6 for calling a global function with example usage: plot_precision_recall(y_true, y_probas, title, plot_micro, classes_to_plot, ax, figsize, cmap, title_fontsize, text_fontsize) and returns: ax