Skip to content

declearn.metrics.BinaryAccuracyPrecisionRecall

Bases: Metric[BinaryConfmat]

Binary classification accuracy, precision and recall metrics.

This metric applies to binary classifier, and computes the (opt. weighted) amount of true positives (TP), true negatives (TN), false positives (FP) and false negatives (FN) predictions over time, from which basic evaluation metrics may be derived.

Computed metrics are the following:

  • accuracy: float Accuracy of the classifier, i.e. P(pred==true). Formula: (TP + TN) / (TP + TN + FP + FN)
  • precision: float Precision score, i.e. P(true=1|pred=1). Formula: TP / (TP + FP)
  • recall: float Recall score, i.e. P(pred=1|true=1). Formula: TP / (TP + FN)
  • f-score: float F1-score, i.e. harmonic mean of precision and recall. Formula: (2TP) / (2TP + FP + FN)
  • confusion: 2-d numpy.ndarray Confusion matrix of predictions. Values: [[TN, FP], [FN, TP]]
Source code in declearn/metrics/_classif.py 
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
class BinaryAccuracyPrecisionRecall(Metric[BinaryConfmat]):
    """Binary classification accuracy, precision and recall metrics.

    This metric applies to binary classifier, and computes the (opt.
    weighted) amount of true positives (TP), true negatives (TN),
    false positives (FP) and false negatives (FN) predictions over
    time, from which basic evaluation metrics may be derived.

    Computed metrics are the following:

    * accuracy: float
        Accuracy of the classifier, i.e. P(pred==true).
        Formula: (TP + TN) / (TP + TN + FP + FN)
    * precision: float
        Precision score, i.e. P(true=1|pred=1).
        Formula: TP / (TP + FP)
    * recall: float
        Recall score, i.e. P(pred=1|true=1).
        Formula: TP / (TP + FN)
    * f-score: float
        F1-score, i.e. harmonic mean of precision and recall.
        Formula: (2*TP) / (2*TP + FP + FN)
    * confusion: 2-d numpy.ndarray
        Confusion matrix of predictions. Values: [[TN, FP], [FN, TP]]
    """

    name = "binary-classif"
    state_cls = BinaryConfmat

    def __init__(
        self,
        thresh: float = 0.5,
        label: Union[int, str] = 1,
    ) -> None:
        """Instantiate the binary accuracy / precision / recall metrics.

        Parameters
        ----------
        thresh: float, default=.5
            Threshold value around which to binarize input predictions.
        label: int or str, default=1
            Value of the positive labels in input true-label arrays.
        """
        self.thresh = thresh
        self.label = label
        super().__init__()

    def get_config(
        self,
    ) -> Dict[str, Any]:
        return {"thresh": self.thresh, "label": self.label}

    def build_initial_states(
        self,
    ) -> BinaryConfmat:
        return BinaryConfmat()

    def get_result(
        self,
    ) -> Dict[str, Union[float, np.ndarray]]:
        # Unpack state variables for code readability.
        tpos = self._states.tpos
        tneg = self._states.tneg
        fpos = self._states.fpos
        fneg = self._states.fneg
        # Compute metrics, catching division-by-zero errors (replace with 0.0).
        scores = {
            "accuracy": safe_division(tpos + tneg, tpos + tneg + fpos + fneg),
            "precision": safe_division(tpos, tpos + fpos),
            "recall": safe_division(tpos, tpos + fneg),
            "f-score": safe_division(tpos + tpos, tpos + tpos + fpos + fneg),
        }  # type: Dict[str, Union[float, np.ndarray]]
        # Add the confusion matrix and return.
        scores["confusion"] = np.array([[tneg, fpos], [fneg, tpos]])
        return scores

    def update(
        self,
        y_true: np.ndarray,
        y_pred: np.ndarray,
        s_wght: Optional[np.ndarray] = None,
    ) -> None:
        pos = y_true.flatten() == self.label
        tru = (y_pred.flatten() >= self.thresh) == pos
        s_wght = np.ones_like(tru) if s_wght is None else s_wght.flatten()
        self._states.tpos += float(sum(s_wght * (tru & pos)))
        self._states.tneg += float(sum(s_wght * (tru & ~pos)))
        self._states.fpos += float(sum(s_wght * ~(tru | pos)))
        self._states.fneg += float(sum(s_wght * (~tru & pos)))

__init__(thresh=0.5, label=1)

Instantiate the binary accuracy / precision / recall metrics.

Parameters:

Name Type Description Default
thresh float

Threshold value around which to binarize input predictions.

 0.5
label Union[int, str]

Value of the positive labels in input true-label arrays.

 1
Source code in declearn/metrics/_classif.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
def __init__(
    self,
    thresh: float = 0.5,
    label: Union[int, str] = 1,
) -> None:
    """Instantiate the binary accuracy / precision / recall metrics.

    Parameters
    ----------
    thresh: float, default=.5
        Threshold value around which to binarize input predictions.
    label: int or str, default=1
        Value of the positive labels in input true-label arrays.
    """
    self.thresh = thresh
    self.label = label
    super().__init__()