class_docstr: Precision-Recall curves are a metric used to evaluate a classifier's quality,
  particularly when classes are very imbalanced. The precision-recall curve
  shows the tradeoff between precision, a measure of result relevancy, and
  recall, a measure of completeness. For each class, precision is defined as
  the ratio of true positives to the sum of true and false positives, and
  recall is the ratio of true positives to the sum of true positives and false
  negatives.
  
  A large area under the curve represents both high recall and precision, the
  best case scenario for a classifier, showing a model that returns accurate
  results for the majority of classes it selects.
  
  Parameters
  ----------
  estimator : estimator
      A scikit-learn estimator that should be a classifier. If the model is
      not a classifier, an exception is raised. If the internal model is not
      fitted, it is fit when the visualizer is fitted, unless otherwise specified
      by ``is_fitted``.
  
  ax : matplotlib Axes, default: None
      The axes to plot the figure on. If not specified the current axes will be
      used (or generated if required).
  
  classes : list of str, default: None
      The class labels to use for the legend ordered by the index of the sorted
      classes discovered in the ``fit()`` method. Specifying classes in this
      manner is used to change the class names to a more specific format or
      to label encoded integer classes. Some visualizers may also use this
      field to filter the visualization for specific classes. For more advanced
      usage specify an encoder rather than class labels.
  
  colors : list of strings,  default: None
      An optional list or tuple of colors to colorize the curves when
      ``per_class=True``. If ``per_class=False``, this parameter will
      be ignored. If both ``colors`` and ``cmap`` are provided,
      ``cmap`` will be ignored.
  
  cmap : string or Matplotlib colormap, default: None
      An optional string or Matplotlib colormap to colorize the curves
      when ``per_class=True``. If ``per_class=False``, this parameter
      will be ignored. If both ``colors`` and ``cmap`` are provided,
      ``cmap`` will be ignored.
  
  encoder : dict or LabelEncoder, default: None
      A mapping of classes to human readable labels. Often there is a mismatch
      between desired class labels and those contained in the target variable
      passed to ``fit()`` or ``score()``. The encoder disambiguates this mismatch
      ensuring that classes are labeled correctly in the visualization.
  
  fill_area : bool, default: True
      Fill the area under the curve (or curves) with the curve color.
  
  ap_score : bool, default: True
      Annotate the graph with the average precision score, a summary of the
      plot that is computed as the weighted mean of precisions at each
      threshold, with the increase in recall from the previous threshold used
      as the weight.
  
  micro : bool, default: True
      If multi-class classification, draw the precision-recall curve for the
      micro-average of all classes. In the multi-class case, either micro or
      per-class must be set to True. Ignored in the binary case.
  
  iso_f1_curves : bool, default: False
      Draw ISO F1-Curves on the plot to show how close the precision-recall
      curves are to different F1 scores.
  
  iso_f1_values : tuple , default: (0.2, 0.4, 0.6, 0.8)
      Values of f1 score for which to draw ISO F1-Curves
  
  per_class : bool, default: False
      If multi-class classification, draw the precision-recall curve for
      each class using a OneVsRestClassifier to compute the recall on a
      per-class basis. In the multi-class case, either micro or per-class
      must be set to True. Ignored in the binary case.
  
  fill_opacity : float, default: 0.2
      Specify the alpha or opacity of the fill area (0 being transparent,
      and 1.0 being completly opaque).
  
  line_opacity : float, default: 0.8
      Specify the alpha or opacity of the lines (0 being transparent, and
      1.0 being completly opaque).
  
  is_fitted : bool or str, default="auto"
      Specify if the wrapped estimator is already fitted. If False, the estimator
      will be fit when the visualizer is fit, otherwise, the estimator will not be
      modified. If "auto" (default), a helper method will check if the estimator
      is fitted before fitting it again.
  
  force_model : bool, default: False
      Do not check to ensure that the underlying estimator is a classifier. This
      will prevent an exception when the visualizer is initialized but may result
      in unexpected or unintended behavior.
  
  kwargs : dict
      Keyword arguments passed to the visualizer base classes.
  
  Attributes
  ----------
  target_type_ : str
      Either ``"binary"`` or ``"multiclass"`` depending on the type of target
      fit to the visualizer. If ``"multiclass"`` then the estimator is
      wrapped in a OneVsRestClassifier classification strategy.
  
  score_ : float or dict of floats
      Average precision, a summary of the plot as a weighted mean of
      precision at each threshold, weighted by the increase in recall from
      the previous threshold. In the multiclass case, a mapping of class/metric
      to the average precision score.
  
  precision_ : array or dict of array with shape=[n_thresholds + 1]
      Precision values such that element i is the precision of predictions
      with score >= thresholds[i] and the last element is 1. In the multiclass
      case, a mapping of class/metric to precision array.
  
  recall_ : array or dict of array with shape=[n_thresholds + 1]
      Decreasing recall values such that element i is the recall of
      predictions with score >= thresholds[i] and the last element is 0.
      In the multiclass case, a mapping of class/metric to recall array.
  
  classes_ : ndarray of shape (n_classes,)
      The class labels observed while fitting.
  
  class_count_ : ndarray of shape (n_classes,)
      Number of samples encountered for each class during fitting.
  
  
  Examples
  --------
  
  >>> from yellowbrick.classifier import PrecisionRecallCurve
  >>> from sklearn.model_selection import train_test_split
  >>> from sklearn.svm import LinearSVC
  >>> X_train, X_test, y_train, y_test = train_test_split(X, y)
  >>> viz = PrecisionRecallCurve(LinearSVC())
  >>> viz.fit(X_train, y_train)
  >>> viz.score(X_test, y_test)
  >>> viz.show()
  
  Notes
  -----
  To support multi-label classification, the estimator is wrapped in a
  ``OneVsRestClassifier`` to produce binary comparisons for each class
  (e.g. the positive case is the class and the negative case is any other
  class). The precision-recall curve can then be computed as the micro-average
  of the precision and recall for all classes (by setting micro=True), or individual
  curves can be plotted for each class (by setting per_class=True).
  
  Note also that some parameters of this visualizer are learned on the ``score``
  method, not only on ``fit``.
  
  .. seealso:: https://bit.ly/2kOIeCC
code: def __init__(
      self,
      estimator,
      ax=None,
      classes=None,
      colors=None,
      cmap=None,
      encoder=None,
      fill_area=True,
      ap_score=True,
      micro=True,
      iso_f1_curves=False,
      iso_f1_values=DEFAULT_ISO_F1_VALUES,
      per_class=False,
      fill_opacity=0.2,
      line_opacity=0.8,
      is_fitted="auto",
      force_model=False,
      **kwargs,
  ):
      super(PrecisionRecallCurve, self).__init__(
          estimator,
          ax=ax,
          classes=classes,
          encoder=encoder,
          is_fitted=is_fitted,
          force_model=force_model,
          **kwargs,
      )
  
      # Set visual params
      self.fill_area = fill_area
      self.ap_score = ap_score
      self.colors = colors
      self.cmap = cmap
      self.micro = micro
      self.iso_f1_curves = iso_f1_curves
      self.iso_f1_values = set(iso_f1_values)
      self.per_class = per_class
      self.fill_opacity = fill_opacity
      self.line_opacity = line_opacity
  
      if self.micro and self.per_class:
          warnings.warn(
              "micro=True is ignored;"
              "specify per_class=False to draw a PR curve after micro-averaging",
              YellowbrickWarning,
          )
  
imports: import warnings
  import numpy
  from sklearn.preprocessing import label_binarize
  from sklearn.multiclass import OneVsRestClassifier
  from sklearn.utils.multiclass import type_of_target
  from sklearn.metrics import average_precision_score
  from sklearn.metrics import precision_recall_curve
  from yellowbrick.style.colors import resolve_colors
  from yellowbrick.exceptions import YellowbrickWarning
  from yellowbrick.exceptions import ModelError, NotFitted
  from yellowbrick.exceptions import YellowbrickValueError
  from yellowbrick.classifier.base import ClassificationScoreVisualizer
label_desc: Use image node_id 1 to create a new PrecisionRecallCurve object from inherited base classes: ClassificationScoreVisualizer with example: obj = PrecisionRecallCurve(estimator, ax, classes, colors, cmap, encoder, fill_area, ap_score, micro, iso_f1_curves, iso_f1_values, per_class, fill_opacity, line_opacity, is_fitted, force_model)