Repository: DistrictDataLabs/yellowbrick

Issue:
Definition of “Precision” seems incorrect...
On this page at [ClassificationReport](https://www.scikit-yb.org/en/latest/api/classifier/classification_report.html) 

![CE6AA3AE-37ED-4CA2-8D19-6AF2395DAC79](https://user-images.githubusercontent.com/15989924/76366402-1eaf6500-62e7-11ea-9c32-1ea7c17964c3.jpeg)

For binary classifier, the part **“not to label an instance positive that is actually negative”** sounded like “to correctly classified a negative”, which is the definition of **True Negative** right? I think the first sentence should be removed to avoid confusion.


Discussion:
@Scoodood I agree that we could make it more clear; however I don't think we can necessarily simply remove the first sentence; do you have an edit to suggest? 
Hi @bbengfort, 

If we simplified the first sentence it will become
"**Precision** is the ability of a classifier to correctly label a negative instance as negative."

That definition is wrong, because it belongs to the **True Negative Rate**, not **Precision**. According to the [wikipedia](https://en.wikipedia.org/wiki/Precision_and_recall), 
Precision = TP / (TP + FP) = [Positive Predictive Value (PPV)](https://en.wikipedia.org/wiki/Positive_and_negative_predictive_values)

The denominator term TP + FP also means total predicted output. So the whole equation means **for all cases that were labeled by the classifier as positive, what percent of those were actually correct**. But your second sentence said this already.  

Besides, the formula of TPR (True Positive Rate) and PPV is very similar, and yet their interpretation is different.
TPR = The ability of classifier to recognize positive instance
PPV = The ability of classifier to give relevant positive output

So if you insist to keep the first sentence, then I would like to suggest something like this
**Precision measures the ability of a classifier to give relevant positive output.**

But I really think your second sentence is clear enough even without the first sentence.


Resolving patch:
diff --git a/yellowbrick/classifier/prcurve.py b/yellowbrick/classifier/prcurve.py
--- a/yellowbrick/classifier/prcurve.py
+++ b/yellowbrick/classifier/prcurve.py
@@ -55,12 +55,14 @@ class PrecisionRecallCurve(ClassificationScoreVisualizer):
     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 how many relevant results are returned. 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.
+    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.
 
-    .. todo:: extend docstring
+    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
     ----------
@@ -193,6 +195,15 @@ class PrecisionRecallCurve(ClassificationScoreVisualizer):
 
     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
     """
@@ -250,8 +261,8 @@ def __init__(
 
     def fit(self, X, y=None):
         """
-        Fit the classification model; if y is multi-class, then the estimator
-        is adapted with a OneVsRestClassifier strategy, otherwise the estimator
+        Fit the classification model; if ``y`` is multi-class, then the estimator
+        is adapted with a ``OneVsRestClassifier`` strategy, otherwise the estimator
         is fit directly.
         """
         # The target determines what kind of estimator is fit
@@ -288,6 +299,7 @@ def score(self, X, y):
             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.
+
         """
         # If we don't do this check, then it is possible that OneVsRestClassifier
         # has not correctly been fitted for multi-class targets.
@@ -501,10 +513,14 @@ def precision_recall_curve(
     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 how many relevant results are returned. 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.
+    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
     ----------


Test patch: