def update(self, preds: torch.Tensor, target: torch.Tensor):
"""
Update state with predictions and targets.
Args:
preds: Predictions from model (probabilities or labels)
target: Ground truth values
"""
tp, fp, tn, fn = _stat_scores_update(
preds,
target,
reduce=self.reduce,
mdmc_reduce=self.mdmc_reduce,
threshold=self.threshold,
num_classes=self.num_classes,
top_k=self.top_k,
is_multiclass=self.is_multiclass,
ignore_index=self.ignore_index,
)
# Update states
if self.reduce != "samples" and self.mdmc_reduce != "samplewise":
self.tp += tp
self.fp += fp
self.tn += tn
self.fn += fn
else:
self.tp.append(tp)
self.fp.append(fp)
self.tn.append(tn)
self.fn.append(fn)
def precision(
preds: torch.Tensor,
target: torch.Tensor,
average: str = "micro",
mdmc_average: Optional[str] = None,
ignore_index: Optional[int] = None,
num_classes: Optional[int] = None,
threshold: float = 0.5,
top_k: Optional[int] = None,
is_multiclass: Optional[bool] = None,
class_reduction: Optional[str] = None,
) -> torch.Tensor:
r"""
Computes `Precision <https://en.wikipedia.org/wiki/Precision_and_recall>`_:
.. math:: \text{Precision} = \frac{\text{TP}}{\text{TP} + \text{FP}}
Where :math:`\text{TP}` and :math:`\text{FP}` represent the number of true positives and
false positives respecitively. With the use of ``top_k`` parameter, this metric can
generalize to Precision@K.
The reduction method (how the precision scores are aggregated) is controlled by the
``average`` parameter, and additionally by the ``mdmc_average`` parameter in the
multi-dimensional multi-class case.
Args:
preds: Predictions from model (probabilities or labels)
target: Ground truth values
average:
Defines the reduction that is applied. Should be one of the following:
- ``'micro'`` [default]: Calculate the metric globally, accross all samples and classes.
- ``'macro'``: Calculate the metric for each class separately, and average the
metrics accross classes (with equal weights for each class).
- ``'weighted'``: Calculate the metric for each class separately, and average the
metrics accross classes, weighting each class by its support (``tp + fn``).
- ``'none'`` or ``None``: Calculate the metric for each class separately, and return
the metric for every class.
- ``'samples'``: Calculate the metric for each sample, and average the metrics
across samples (with equal weights for each sample).
Note that what is considered a sample in the multi-dimensional multi-class case
depends on the value of ``mdmc_average``.
mdmc_average:
Defines how averaging is done for multi-dimensional multi-class inputs (on top of the
``average`` parameter). Should be one of the following:
- ``None`` [default]: Should be left unchanged if your data is not multi-dimensional
multi-class.
- ``'samplewise'``: In this case, the statistics are computed separately for each
sample on the ``N`` axis, and then averaged over samples.
The computation for each sample is done by treating the flattened extra axes ``...``
as the ``N`` dimension within the sample, and computing the metric for the sample based on that.
- ``'global'``: In this case the ``N`` and ``...`` dimensions of the inputs
are flattened into a new ``N_X`` sample axis, i.e. the inputs are treated as if they
were ``(N_X, C)``. From here on the ``average`` parameter applies as usual.
ignore_index:
Integer specifying a target class to ignore. If given, this class index does not contribute
to the returned score, regardless of reduction method. If an index is ignored, and ``average=None``
or ``'none'``, the score for the ignored class will be returned as ``nan``.
num_classes:
Number of classes. Necessary for ``'macro'``, ``'weighted'`` and ``None`` average methods.
threshold:
Threshold probability value for transforming probability predictions to binary
(0,1) predictions, in the case of binary or multi-label inputs.
top_k:
Number of highest probability entries for each sample to convert to 1s - relevant
only for inputs with probability predictions. If this parameter is set for multi-label
inputs, it will take precedence over ``threshold``. For (multi-dim) multi-class inputs,
this parameter defaults to 1.
Should be left unset (``None``) for inputs with label predictions.
is_multiclass:
Used only in certain special cases, where you want to treat inputs as a different type
than what they appear to be.
class_reduction:
.. warning :: This parameter is deprecated, use ``average``. Will be removed in v1.4.0.
Return:
The shape of the returned tensor depends on the ``average`` parameter
- If ``average in ['micro', 'macro', 'weighted', 'samples']``, a one-element tensor will be returned
- If ``average in ['none', None]``, the shape will be ``(C,)``, where ``C`` stands for the number
of classes
Raises:
ValueError:
If ``average`` is not one of ``"micro"``, ``"macro"``, ``"weighted"``,
``"samples"``, ``"none"`` or ``None``.
ValueError:
If ``mdmc_average`` is not one of ``None``, ``"samplewise"``, ``"global"``.
ValueError:
If ``average`` is set but ``num_classes`` is not provided.
ValueError:
If ``num_classes`` is set
and ``ignore_index`` is not in the range ``[0, num_classes)``.
Example:
>>> from pytorch_lightning.metrics.functional import precision
>>> preds = torch.tensor([2, 0, 2, 1])
>>> target = torch.tensor([1, 1, 2, 0])
>>> precision(preds, target, average='macro', num_classes=3)
tensor(0.1667)
>>> precision(preds, target, average='micro')
tensor(0.2500)
"""
if class_reduction:
rank_zero_warn(
"This `class_reduction` parameter was deprecated in v1.2.0 in favor of"
" `reduce`. It will be removed in v1.4.0",
DeprecationWarning,
)
average = class_reduction
allowed_average = ["micro", "macro", "weighted", "samples", "none", None]
if average not in allowed_average:
raise ValueError(
f"The `average` has to be one of {allowed_average}, got {average}."
)
allowed_mdmc_average = [None, "samplewise", "global"]
if mdmc_average not in allowed_mdmc_average:
raise ValueError(
f"The `mdmc_average` has to be one of {allowed_mdmc_average}, got {mdmc_average}."
)
if average in ["macro", "weighted", "none", None] and (not num_classes
or num_classes < 1):
raise ValueError(
f"When you set `average` as {average}, you have to provide the number of classes."
)
if num_classes and ignore_index is not None and (
not 0 <= ignore_index < num_classes or num_classes == 1):
raise ValueError(
f"The `ignore_index` {ignore_index} is not valid for inputs with {num_classes} classes"
)
reduce = "macro" if average in ["weighted", "none", None] else average
tp, fp, tn, fn = _stat_scores_update(
preds,
target,
reduce=reduce,
mdmc_reduce=mdmc_average,
threshold=threshold,
num_classes=num_classes,
top_k=top_k,
is_multiclass=is_multiclass,
ignore_index=ignore_index,
)
return _precision_compute(tp, fp, tn, fn, average, mdmc_average)
