Multiclassprecisionrecallcurve

---
name: multiclassprecisionrecallcurve
description: Compute the MulticlassPrecisionRecallCurve metric — provided by torchmetrics. Use when the user has predictions and ground-truth and needs to compute MulticlassPrecisionRecallCurve, or asks how to score with MulticlassPrecisionRecallCurve.
metadata:
  skill_kind: metric
  source_lib: torchmetrics
  import_path: torchmetrics.classification.MulticlassPrecisionRecallCurve
  source: library_introspection
---

# multiclassprecisionrecallcurve

> Metric `MulticlassPrecisionRecallCurve` from `torchmetrics` (torchmetrics.classification.MulticlassPrecisionRecallCurve)

## When to invoke this skill

The user has predictions + ground truth and asks to evaluate with MulticlassPrecisionRecallCurve, or
mentions `torchmetrics.classification.MulticlassPrecisionRecallCurve` directly, or wants the standard torchmetrics implementation.

## Reference signature

```python
from torchmetrics.classification import MulticlassPrecisionRecallCurve

# MulticlassPrecisionRecallCurve(num_classes: int, thresholds: Union[int, list[float], torch.Tensor, NoneType] = None, average: Optional[Literal['micro', 'macro']] = None, ignore_index: Optional[int] = None, validate_args: bool = True, **kwargs: Any) -> None
```

## Library docstring

```
Compute the precision-recall curve for multiclass tasks.

The curve consist of multiple pairs of precision and recall values evaluated at different thresholds, such that the
tradeoff between the two values can been seen.

For multiclass the metric is calculated by iteratively treating each class as the positive class and all other
classes as the negative, which is referred to as the one-vs-rest approach. One-vs-one is currently not supported by
this metric.

As input to ``forward`` and ``update`` the metric accepts the following input:

- ``preds`` (:class:`~torch.Tensor`): A float tensor of shape ``(N, C, ...)``. Preds should be a tensor containing
  probabilities or logits for each observation. If preds has values outside [0,1] range we consider the input to
  be logits and will auto apply softmax per sample.
- ``target`` (:class:`~torch.Tensor`): An int tensor of shape ``(N, ...)``. Target should be a tensor containing
  ground truth labels, and therefore only contain values in the [0, n_classes-1] range (except if `ignore_index`
  is specified).

.. tip::
   Additional dimension ``...`` will be flattened into the batch dimension.

As output to ``forward`` and ``compute`` the metric returns the following output:

- ``precision`` (:class:`~torch.Tensor`): A 1d tensor of size ``(n_thresholds+1, )`` with precision values
- ``recall`` (:class:`~torch.Tensor`): A 1d tensor of size ``(n_thresholds+1, )`` with recall values
- ``thresholds`` (:class:`~torch.Tensor`): A 1d tensor of size ``(n_thresholds, )`` with increasing threshold values

.. note::
   The implementation both supports calculating the metric in a non-binned but accurate version and a binned version
   that is less accurate but more memory efficient. Setting the `thresholds` argument to `None` will activate the
   non-binned  version that uses memory of size :math:`\mathcal{O}(n_{samples})` whereas setting the `thresholds`
   argument to either an integer, list or a 1d tensor will use a binned version that uses memory of
   size :math:`\mathcal{O}(n_{thresholds} \times n_{classes})` (constant memory).

Args:
    num_classes: Integer specifying the number of classes
    thresholds:
        Can be one o
```

## Quick recipe

```python
import torchmetrics.classification as _m
score = _m.MulticlassPrecisionRecallCurve(y_true, y_pred)
```

## Don'ts

- Don't reimplement when the library version handles edge cases (NaN, ties, empty inputs) better than a hand-rolled formula.
- Always check the library version's argument order — sklearn is `(y_true, y_pred)` while torchmetrics is `(preds, target)`.