---
title: Precision At Fixed Recall
description: >-
  Compute the highest possible recall value given the minimum precision
  thresholds provided.
canonical: >-
  https://lightning.ai/docs/torchmetrics/stable/classification/precision_at_fixed_recall
---
# Precision At Fixed Recall {#precision-at-fixed-recall}

## Module Interface {#module-interface}

### `class torchmetrics.PrecisionAtFixedRecall(**kwargs)` {#torchmetrics.PrecisionAtFixedRecall}

[\[source\]](https://github.com/Lightning-AI/torchmetrics/blob/v1.9.0/src/torchmetrics/classification/precision_fixed_recall.py#L473-L515)

Compute the highest possible recall value given the minimum precision thresholds provided.

This is done by first calculating the precision-recall curve for different thresholds and the find the recall for a given precision level.

This function is a simple wrapper to get the task specific versions of this metric, which is done by setting the `task` argument to either `'binary'`, `'multiclass'` or `'multilabel'`. See the documentation of [`BinaryPrecisionAtFixedRecall`](#torchmetrics.classification.BinaryPrecisionAtFixedRecall "torchmetrics.classification.BinaryPrecisionAtFixedRecall"), [`MulticlassPrecisionAtFixedRecall`](#torchmetrics.classification.MulticlassPrecisionAtFixedRecall "torchmetrics.classification.MulticlassPrecisionAtFixedRecall") and [`MultilabelPrecisionAtFixedRecall`](#torchmetrics.classification.MultilabelPrecisionAtFixedRecall "torchmetrics.classification.MultilabelPrecisionAtFixedRecall") for the specific details of each argument influence and examples.

#### `static __new__(cls, task, min_recall, thresholds=None, num_classes=None, num_labels=None, ignore_index=None, validate_args=True, **kwargs)` {#torchmetrics.PrecisionAtFixedRecall.__new__}

[\[source\]](https://github.com/Lightning-AI/torchmetrics/blob/v1.9.0/src/torchmetrics/classification/precision_fixed_recall.py#L488-L515)

Initialize task metric.

Return type:

[`Metric`](/docs/torchmetrics/1.9.0/api-reference/metric.md#torchmetrics.Metric "torchmetrics.metric.Metric")

### BinaryPrecisionAtFixedRecall {#binaryprecisionatfixedrecall}

### `class torchmetrics.classification.BinaryPrecisionAtFixedRecall(min_recall, thresholds=None, ignore_index=None, validate_args=True, **kwargs)` {#torchmetrics.classification.BinaryPrecisionAtFixedRecall}

[\[source\]](https://github.com/Lightning-AI/torchmetrics/blob/v1.9.0/src/torchmetrics/classification/precision_fixed_recall.py#L49-L179)

Compute the highest possible precision value given the minimum recall thresholds provided.

This is done by first calculating the precision-recall curve for different thresholds and the find the precision for a given recall level.

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

*   `preds` ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")): A float tensor of shape `(N, ...)`. 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 sigmoid per element.
    
*   `target` ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")): An int tensor of shape `(N, ...)`. Target should be a tensor containing ground truth labels, and therefore only contain {0,1} values (except if ignore\_index is specified). The value 1 always encodes the positive class.
    

Tip

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

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

*   `precision` ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")): A scalar tensor with the maximum precision for the given recall level
    
*   `threshold` ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")): A scalar tensor with the corresponding threshold level
    

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 $`\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 $`\mathcal{O}(n_{thresholds})`$ (constant memory).

Parameters:

*   **min\_recall** ([`float`](https://docs.python.org/3/library/functions.html#float "(in Python v3.14)")) – float value specifying minimum recall threshold.
    
*   **thresholds** (`Union`\[[`int`](https://docs.python.org/3/library/functions.html#int "(in Python v3.14)"), [`list`](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.14)")\[[`float`](https://docs.python.org/3/library/functions.html#float "(in Python v3.14)")\], [`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)"), [`None`](https://docs.python.org/3/library/constants.html#None "(in Python v3.14)")\]) –
    
    Can be one of:
    
    *   If set to `None`, will use a non-binned approach where thresholds are dynamically calculated from all the data. Most accurate but also most memory consuming approach.
        
    *   If set to an `int` (larger than 1), will use that number of thresholds linearly spaced from 0 to 1 as bins for the calculation.
        
    *   If set to an `list` of floats, will use the indicated thresholds in the list as bins for the calculation
        
    *   If set to an 1d [`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)") of floats, will use the indicated thresholds in the tensor as bins for the calculation.
        
    
*   **validate\_args** ([`bool`](https://docs.python.org/3/library/functions.html#bool "(in Python v3.14)")) – bool indicating if input arguments and tensors should be validated for correctness. Set to `False` for faster computations.
    
*   **kwargs** ([`Any`](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.14)")) – Additional keyword arguments, see [Advanced metric settings](/docs/torchmetrics/1.9.0/user-guide/overview.md#metric-kwargs) for more info.
    

Example

```python
>>> from torch import tensor
>>> from torchmetrics.classification import BinaryPrecisionAtFixedRecall
>>> preds = tensor([0, 0.5, 0.7, 0.8])
>>> target = tensor([0, 1, 1, 0])
>>> metric = BinaryPrecisionAtFixedRecall(min_recall=0.5, thresholds=None)
>>> metric(preds, target)
(tensor(0.6667), tensor(0.5000))
>>> metric = BinaryPrecisionAtFixedRecall(min_recall=0.5, thresholds=5)
>>> metric(preds, target)
(tensor(0.6667), tensor(0.5000))
```

#### `plot(val=None, ax=None)` {#torchmetrics.classification.BinaryPrecisionAtFixedRecall.plot}

[\[source\]](https://github.com/Lightning-AI/torchmetrics/blob/v1.9.0/src/torchmetrics/classification/precision_fixed_recall.py#L137-L179)

Plot a single or multiple values from the metric.

Parameters:

*   **val** (`Union`\[[`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)"), [`Sequence`](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(in Python v3.14)")\[[`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")\], [`None`](https://docs.python.org/3/library/constants.html#None "(in Python v3.14)")\]) – Either a single result from calling metric.forward or metric.compute or a list of these results. If no value is provided, will automatically call metric.compute and plot that result.
    
*   **ax** ([`Optional`](https://docs.python.org/3/library/typing.html#typing.Optional "(in Python v3.14)")\[[`Axes`](https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.html#matplotlib.axes.Axes "(in Matplotlib v3.11.1)")\]) – An matplotlib axis object. If provided will add plot to that axis
    

Return type:

[`tuple`](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.14)")\[[`Figure`](https://matplotlib.org/stable/api/_as_gen/matplotlib.figure.Figure.html#matplotlib.figure.Figure "(in Matplotlib v3.11.1)"), `Union`\[[`Axes`](https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.html#matplotlib.axes.Axes "(in Matplotlib v3.11.1)"), [`ndarray`](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(in NumPy v2.5)")\]\]

Returns:

Figure object and Axes object

Raises:

[**ModuleNotFoundError**](https://docs.python.org/3/library/exceptions.html#ModuleNotFoundError "(in Python v3.14)") – If matplotlib is not installed

```python
>>> from torch import rand, randint
>>> # Example plotting a single value
>>> from torchmetrics.classification import BinaryPrecisionAtFixedRecall
>>> metric = BinaryPrecisionAtFixedRecall(min_recall=0.5)
>>> metric.update(rand(10), randint(2,(10,)))
>>> fig_, ax_ = metric.plot()  # the returned plot only shows the maximum recall value by default
```

[![../../\_images/precision\_at\_fixed\_recall-1.png](/docs/torchmetrics/1.9.0/static/_images/precision_at_fixed_recall-1.png)](/docs/torchmetrics/1.9.0/static/_images/precision_at_fixed_recall-1.png)

```python
>>> from torch import rand, randint
>>> # Example plotting multiple values
>>> from torchmetrics.classification import BinaryPrecisionAtFixedRecall
>>> metric = BinaryPrecisionAtFixedRecall(min_recall=0.5)
>>> values = [ ]
>>> for _ in range(10):
...     # we index by 0 such that only the maximum recall value is plotted
...     values.append(metric(rand(10), randint(2,(10,)))[0])
>>> fig_, ax_ = metric.plot(values)
```

[![../../\_images/precision\_at\_fixed\_recall-2.png](/docs/torchmetrics/1.9.0/static/_images/precision_at_fixed_recall-2.png)](/docs/torchmetrics/1.9.0/static/_images/precision_at_fixed_recall-2.png)

### MulticlassPrecisionAtFixedRecall {#multiclassprecisionatfixedrecall}

### `class torchmetrics.classification.MulticlassPrecisionAtFixedRecall(num_classes, min_recall, thresholds=None, ignore_index=None, validate_args=True, **kwargs)` {#torchmetrics.classification.MulticlassPrecisionAtFixedRecall}

[\[source\]](https://github.com/Lightning-AI/torchmetrics/blob/v1.9.0/src/torchmetrics/classification/precision_fixed_recall.py#L182-L324)

Compute the highest possible precision value given the minimum recall thresholds provided.

This is done by first calculating the precision-recall curve for different thresholds and the find the precision for a given recall level.

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

*   `preds` ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")): 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` ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")): 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 a tuple of either 2 tensors or 2 lists containing:

*   `precision` ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")): A 1d tensor of size `(n_classes, )` with the maximum precision for the given recall level per class
    
*   `threshold` ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")): A 1d tensor of size `(n_classes, )` with the corresponding threshold level per class
    

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 $`\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 $`\mathcal{O}(n_{thresholds} \times n_{classes})`$ (constant memory).

Parameters:

*   **num\_classes** ([`int`](https://docs.python.org/3/library/functions.html#int "(in Python v3.14)")) – Integer specifying the number of classes
    
*   **min\_recall** ([`float`](https://docs.python.org/3/library/functions.html#float "(in Python v3.14)")) – float value specifying minimum recall threshold.
    
*   **thresholds** (`Union`\[[`int`](https://docs.python.org/3/library/functions.html#int "(in Python v3.14)"), [`list`](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.14)")\[[`float`](https://docs.python.org/3/library/functions.html#float "(in Python v3.14)")\], [`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)"), [`None`](https://docs.python.org/3/library/constants.html#None "(in Python v3.14)")\]) –
    
    Can be one of:
    
    *   If set to `None`, will use a non-binned approach where thresholds are dynamically calculated from all the data. Most accurate but also most memory consuming approach.
        
    *   If set to an `int` (larger than 1), will use that number of thresholds linearly spaced from 0 to 1 as bins for the calculation.
        
    *   If set to an `list` of floats, will use the indicated thresholds in the list as bins for the calculation
        
    *   If set to an 1d [`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)") of floats, will use the indicated thresholds in the tensor as bins for the calculation.
        
    
*   **validate\_args** ([`bool`](https://docs.python.org/3/library/functions.html#bool "(in Python v3.14)")) – bool indicating if input arguments and tensors should be validated for correctness. Set to `False` for faster computations.
    
*   **kwargs** ([`Any`](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.14)")) – Additional keyword arguments, see [Advanced metric settings](/docs/torchmetrics/1.9.0/user-guide/overview.md#metric-kwargs) for more info.
    

Example

```python
>>> from torch import tensor
>>> from torchmetrics.classification import MulticlassPrecisionAtFixedRecall
>>> preds = tensor([[0.75, 0.05, 0.05, 0.05, 0.05],
...                 [0.05, 0.75, 0.05, 0.05, 0.05],
...                 [0.05, 0.05, 0.75, 0.05, 0.05],
...                 [0.05, 0.05, 0.05, 0.75, 0.05]])
>>> target = tensor([0, 1, 3, 2])
>>> metric = MulticlassPrecisionAtFixedRecall(num_classes=5, min_recall=0.5, thresholds=None)
>>> metric(preds, target)  
(tensor([1.0000, 1.0000, 0.2500, 0.2500, 0.0000]),
 tensor([0.7500, 0.7500, 0.0500, 0.0500, nan]))
>>> mcrafp = MulticlassPrecisionAtFixedRecall(num_classes=5, min_recall=0.5, thresholds=5)
>>> mcrafp(preds, target)  
(tensor([1.0000, 1.0000, 0.2500, 0.2500, 0.0000]),
 tensor([0.7500, 0.7500, 0.0000, 0.0000, nan]))
```

#### `plot(val=None, ax=None)` {#torchmetrics.classification.MulticlassPrecisionAtFixedRecall.plot}

[\[source\]](https://github.com/Lightning-AI/torchmetrics/blob/v1.9.0/src/torchmetrics/classification/precision_fixed_recall.py#L282-L324)

Plot a single or multiple values from the metric.

Parameters:

*   **val** (`Union`\[[`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)"), [`Sequence`](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(in Python v3.14)")\[[`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")\], [`None`](https://docs.python.org/3/library/constants.html#None "(in Python v3.14)")\]) – Either a single result from calling metric.forward or metric.compute or a list of these results. If no value is provided, will automatically call metric.compute and plot that result.
    
*   **ax** ([`Optional`](https://docs.python.org/3/library/typing.html#typing.Optional "(in Python v3.14)")\[[`Axes`](https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.html#matplotlib.axes.Axes "(in Matplotlib v3.11.1)")\]) – An matplotlib axis object. If provided will add plot to that axis
    

Return type:

[`tuple`](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.14)")\[[`Figure`](https://matplotlib.org/stable/api/_as_gen/matplotlib.figure.Figure.html#matplotlib.figure.Figure "(in Matplotlib v3.11.1)"), `Union`\[[`Axes`](https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.html#matplotlib.axes.Axes "(in Matplotlib v3.11.1)"), [`ndarray`](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(in NumPy v2.5)")\]\]

Returns:

Figure object and Axes object

Raises:

[**ModuleNotFoundError**](https://docs.python.org/3/library/exceptions.html#ModuleNotFoundError "(in Python v3.14)") – If matplotlib is not installed

```python
>>> from torch import rand, randint
>>> # Example plotting a single value per class
>>> from torchmetrics.classification import MulticlassPrecisionAtFixedRecall
>>> metric = MulticlassPrecisionAtFixedRecall(num_classes=3, min_recall=0.5)
>>> metric.update(rand(20, 3).softmax(dim=-1), randint(3, (20,)))
>>> fig_, ax_ = metric.plot()  # the returned plot only shows the maximum recall value by default
```

[![../../\_images/precision\_at\_fixed\_recall-3.png](/docs/torchmetrics/1.9.0/static/_images/precision_at_fixed_recall-3.png)](/docs/torchmetrics/1.9.0/static/_images/precision_at_fixed_recall-3.png)

```python
>>> from torch import rand, randint
>>> # Example plotting a multiple values per class
>>> from torchmetrics.classification import MulticlassPrecisionAtFixedRecall
>>> metric = MulticlassPrecisionAtFixedRecall(num_classes=3, min_recall=0.5)
>>> values = []
>>> for _ in range(20):
...     # we index by 0 such that only the maximum recall value is plotted
...     values.append(metric(rand(20, 3).softmax(dim=-1), randint(3, (20,)))[0])
>>> fig_, ax_ = metric.plot(values)
```

[![../../\_images/precision\_at\_fixed\_recall-4.png](/docs/torchmetrics/1.9.0/static/_images/precision_at_fixed_recall-4.png)](/docs/torchmetrics/1.9.0/static/_images/precision_at_fixed_recall-4.png)

### MultilabelPrecisionAtFixedRecall {#multilabelprecisionatfixedrecall}

### `class torchmetrics.classification.MultilabelPrecisionAtFixedRecall(num_labels, min_recall, thresholds=None, ignore_index=None, validate_args=True, **kwargs)` {#torchmetrics.classification.MultilabelPrecisionAtFixedRecall}

[\[source\]](https://github.com/Lightning-AI/torchmetrics/blob/v1.9.0/src/torchmetrics/classification/precision_fixed_recall.py#L327-L470)

Compute the highest possible precision value given the minimum recall thresholds provided.

This is done by first calculating the precision-recall curve for different thresholds and the find the precision for a given recall level.

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

*   `preds` ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")): 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 sigmoid per element.
    
*   `target` ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")): An int tensor of shape `(N, ...)`. Target should be a tensor containing ground truth labels, and therefore only contain {0,1} values (except if ignore\_index is specified). The value 1 always encodes the positive class.
    

Tip

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

As output to `forward` and `compute` the metric returns a tuple of either 2 tensors or 2 lists containing:

*   `precision` ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")): A 1d tensor of size `(n_classes, )` with the maximum precision for the given recall level per class
    
*   `threshold` ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")): A 1d tensor of size `(n_classes, )` with the corresponding threshold level per class
    

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 $`\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 $`\mathcal{O}(n_{thresholds} \times n_{labels})`$ (constant memory).

Parameters:

*   **num\_labels** ([`int`](https://docs.python.org/3/library/functions.html#int "(in Python v3.14)")) – Integer specifying the number of labels
    
*   **min\_recall** ([`float`](https://docs.python.org/3/library/functions.html#float "(in Python v3.14)")) – float value specifying minimum recall threshold.
    
*   **thresholds** (`Union`\[[`int`](https://docs.python.org/3/library/functions.html#int "(in Python v3.14)"), [`list`](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.14)")\[[`float`](https://docs.python.org/3/library/functions.html#float "(in Python v3.14)")\], [`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)"), [`None`](https://docs.python.org/3/library/constants.html#None "(in Python v3.14)")\]) –
    
    Can be one of:
    
    *   If set to `None`, will use a non-binned approach where thresholds are dynamically calculated from all the data. Most accurate but also most memory consuming approach.
        
    *   If set to an `int` (larger than 1), will use that number of thresholds linearly spaced from 0 to 1 as bins for the calculation.
        
    *   If set to an `list` of floats, will use the indicated thresholds in the list as bins for the calculation
        
    *   If set to an 1d [`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)") of floats, will use the indicated thresholds in the tensor as bins for the calculation.
        
    
*   **validate\_args** ([`bool`](https://docs.python.org/3/library/functions.html#bool "(in Python v3.14)")) – bool indicating if input arguments and tensors should be validated for correctness. Set to `False` for faster computations.
    
*   **kwargs** ([`Any`](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.14)")) – Additional keyword arguments, see [Advanced metric settings](/docs/torchmetrics/1.9.0/user-guide/overview.md#metric-kwargs) for more info.
    

Example

```python
>>> from torch import tensor
>>> from torchmetrics.classification import MultilabelPrecisionAtFixedRecall
>>> preds = tensor([[0.75, 0.05, 0.35],
...                 [0.45, 0.75, 0.05],
...                 [0.05, 0.55, 0.75],
...                 [0.05, 0.65, 0.05]])
>>> target = tensor([[1, 0, 1],
...                  [0, 0, 0],
...                  [0, 1, 1],
...                  [1, 1, 1]])
>>> metric = MultilabelPrecisionAtFixedRecall(num_labels=3, min_recall=0.5, thresholds=None)
>>> metric(preds, target)
(tensor([1.0000, 0.6667, 1.0000]), tensor([0.7500, 0.5500, 0.3500]))
>>> mlrafp = MultilabelPrecisionAtFixedRecall(num_labels=3, min_recall=0.5, thresholds=5)
>>> mlrafp(preds, target)
(tensor([1.0000, 0.6667, 1.0000]), tensor([0.7500, 0.5000, 0.2500]))
```

#### `plot(val=None, ax=None)` {#torchmetrics.classification.MultilabelPrecisionAtFixedRecall.plot}

[\[source\]](https://github.com/Lightning-AI/torchmetrics/blob/v1.9.0/src/torchmetrics/classification/precision_fixed_recall.py#L428-L470)

Plot a single or multiple values from the metric.

Parameters:

*   **val** (`Union`\[[`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)"), [`Sequence`](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(in Python v3.14)")\[[`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")\], [`None`](https://docs.python.org/3/library/constants.html#None "(in Python v3.14)")\]) – Either a single result from calling metric.forward or metric.compute or a list of these results. If no value is provided, will automatically call metric.compute and plot that result.
    
*   **ax** ([`Optional`](https://docs.python.org/3/library/typing.html#typing.Optional "(in Python v3.14)")\[[`Axes`](https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.html#matplotlib.axes.Axes "(in Matplotlib v3.11.1)")\]) – An matplotlib axis object. If provided will add plot to that axis
    

Return type:

[`tuple`](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.14)")\[[`Figure`](https://matplotlib.org/stable/api/_as_gen/matplotlib.figure.Figure.html#matplotlib.figure.Figure "(in Matplotlib v3.11.1)"), `Union`\[[`Axes`](https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.html#matplotlib.axes.Axes "(in Matplotlib v3.11.1)"), [`ndarray`](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(in NumPy v2.5)")\]\]

Returns:

Figure object and Axes object

Raises:

[**ModuleNotFoundError**](https://docs.python.org/3/library/exceptions.html#ModuleNotFoundError "(in Python v3.14)") – If matplotlib is not installed

```python
>>> from torch import rand, randint
>>> # Example plotting a single value
>>> from torchmetrics.classification import MultilabelPrecisionAtFixedRecall
>>> metric = MultilabelPrecisionAtFixedRecall(num_labels=3, min_recall=0.5)
>>> metric.update(rand(20, 3), randint(2, (20, 3)))
>>> fig_, ax_ = metric.plot()  # the returned plot only shows the maximum recall value by default
```

[![../../\_images/precision\_at\_fixed\_recall-5.png](/docs/torchmetrics/1.9.0/static/_images/precision_at_fixed_recall-5.png)](/docs/torchmetrics/1.9.0/static/_images/precision_at_fixed_recall-5.png)

```python
>>> from torch import rand, randint
>>> # Example plotting multiple values
>>> from torchmetrics.classification import MultilabelPrecisionAtFixedRecall
>>> metric = MultilabelPrecisionAtFixedRecall(num_labels=3, min_recall=0.5)
>>> values = [ ]
>>> for _ in range(10):
...     # we index by 0 such that only the maximum recall value is plotted
...     values.append(metric(rand(20, 3), randint(2, (20, 3)))[0])
>>> fig_, ax_ = metric.plot(values)
```

[![../../\_images/precision\_at\_fixed\_recall-6.png](/docs/torchmetrics/1.9.0/static/_images/precision_at_fixed_recall-6.png)](/docs/torchmetrics/1.9.0/static/_images/precision_at_fixed_recall-6.png)

## Functional Interface {#functional-interface}

### binary_precision_at_fixed_recall {#binary-precision-at-fixed-recall}

### `torchmetrics.functional.classification.binary_precision_at_fixed_recall(preds, target, min_recall, thresholds=None, ignore_index=None, validate_args=True)` {#torchmetrics.functional.classification.binary_precision_at_fixed_recall}

[\[source\]](https://github.com/Lightning-AI/torchmetrics/blob/v1.9.0/src/torchmetrics/functional/classification/precision_fixed_recall.py#L63-L135)

Compute the highest possible precision value given the minimum recall thresholds provided for binary tasks.

This is done by first calculating the precision-recall curve for different thresholds and the find the precision for a given recall level.

Accepts the following input tensors:

*   `preds` (float tensor): `(N, ...)`. 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 sigmoid per element.
    
*   `target` (int tensor): `(N, ...)`. Target should be a tensor containing ground truth labels, and therefore only contain {0,1} values (except if ignore\_index is specified). The value 1 always encodes the positive class.
    

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

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 $`\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 $`\mathcal{O}(n_{thresholds})`$ (constant memory).

Parameters:

*   **preds** ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")) – Tensor with predictions
    
*   **target** ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")) – Tensor with true labels
    
*   **min\_recall** ([`float`](https://docs.python.org/3/library/functions.html#float "(in Python v3.14)")) – float value specifying minimum recall threshold.
    
*   **thresholds** (`Union`\[[`int`](https://docs.python.org/3/library/functions.html#int "(in Python v3.14)"), [`list`](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.14)")\[[`float`](https://docs.python.org/3/library/functions.html#float "(in Python v3.14)")\], [`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)"), [`None`](https://docs.python.org/3/library/constants.html#None "(in Python v3.14)")\]) –
    
    Can be one of:
    
    *   If set to `None`, will use a non-binned approach where thresholds are dynamically calculated from all the data. Most accurate but also most memory consuming approach.
        
    *   If set to an `int` (larger than 1), will use that number of thresholds linearly spaced from 0 to 1 as bins for the calculation.
        
    *   If set to an `list` of floats, will use the indicated thresholds in the list as bins for the calculation
        
    *   If set to an 1d [`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)") of floats, will use the indicated thresholds in the tensor as bins for the calculation.
        
    
*   **ignore\_index** ([`Optional`](https://docs.python.org/3/library/typing.html#typing.Optional "(in Python v3.14)")\[[`int`](https://docs.python.org/3/library/functions.html#int "(in Python v3.14)")\]) – Specifies a target value that is ignored and does not contribute to the metric calculation
    
*   **validate\_args** ([`bool`](https://docs.python.org/3/library/functions.html#bool "(in Python v3.14)")) – bool indicating if input arguments and tensors should be validated for correctness. Set to `False` for faster computations.
    

Returns:

a tuple of 2 tensors containing:

*   precision: an scalar tensor with the maximum precision for the given precision level
    
*   threshold: an scalar tensor with the corresponding threshold level
    

Return type:

([tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.14)"))

Example

```python
>>> from torchmetrics.functional.classification import binary_precision_at_fixed_recall
>>> preds = torch.tensor([0, 0.5, 0.7, 0.8])
>>> target = torch.tensor([0, 1, 1, 0])
>>> binary_precision_at_fixed_recall(preds, target, min_recall=0.5, thresholds=None)
(tensor(0.6667), tensor(0.5000))
>>> binary_precision_at_fixed_recall(preds, target, min_recall=0.5, thresholds=5)
(tensor(0.6667), tensor(0.5000))
```

### multiclass_precision_at_fixed_recall {#multiclass-precision-at-fixed-recall}

### `torchmetrics.functional.classification.multiclass_precision_at_fixed_recall(preds, target, num_classes, min_recall, thresholds=None, ignore_index=None, validate_args=True)` {#torchmetrics.functional.classification.multiclass_precision_at_fixed_recall}

[\[source\]](https://github.com/Lightning-AI/torchmetrics/blob/v1.9.0/src/torchmetrics/functional/classification/precision_fixed_recall.py#L138-L221)

Compute the highest possible precision value given the minimum recall thresholds provided for multiclass tasks.

This is done by first calculating the precision-recall curve for different thresholds and the find the precision for a given recall level.

Accepts the following input tensors:

*   `preds` (float tensor): `(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` (int tensor): `(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).
    

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

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 $`\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 $`\mathcal{O}(n_{thresholds} \times n_{classes})`$ (constant memory).

Parameters:

*   **preds** ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")) – Tensor with predictions
    
*   **target** ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")) – Tensor with true labels
    
*   **num\_classes** ([`int`](https://docs.python.org/3/library/functions.html#int "(in Python v3.14)")) – Integer specifying the number of classes
    
*   **min\_recall** ([`float`](https://docs.python.org/3/library/functions.html#float "(in Python v3.14)")) – float value specifying minimum recall threshold.
    
*   **thresholds** (`Union`\[[`int`](https://docs.python.org/3/library/functions.html#int "(in Python v3.14)"), [`list`](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.14)")\[[`float`](https://docs.python.org/3/library/functions.html#float "(in Python v3.14)")\], [`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)"), [`None`](https://docs.python.org/3/library/constants.html#None "(in Python v3.14)")\]) –
    
    Can be one of:
    
    *   If set to `None`, will use a non-binned approach where thresholds are dynamically calculated from all the data. Most accurate but also most memory consuming approach.
        
    *   If set to an `int` (larger than 1), will use that number of thresholds linearly spaced from 0 to 1 as bins for the calculation.
        
    *   If set to an `list` of floats, will use the indicated thresholds in the list as bins for the calculation
        
    *   If set to an 1d [`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)") of floats, will use the indicated thresholds in the tensor as bins for the calculation.
        
    
*   **ignore\_index** ([`Optional`](https://docs.python.org/3/library/typing.html#typing.Optional "(in Python v3.14)")\[[`int`](https://docs.python.org/3/library/functions.html#int "(in Python v3.14)")\]) – Specifies a target value that is ignored and does not contribute to the metric calculation
    
*   **validate\_args** ([`bool`](https://docs.python.org/3/library/functions.html#bool "(in Python v3.14)")) – bool indicating if input arguments and tensors should be validated for correctness. Set to `False` for faster computations.
    

Returns:

a tuple of either 2 tensors or 2 lists containing

*   precision: an 1d tensor of size (n\_classes, ) with the maximum precision for the given recall level per class
    
*   thresholds: an 1d tensor of size (n\_classes, ) with the corresponding threshold level per class
    

Return type:

([tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.14)"))

Example

```python
>>> from torchmetrics.functional.classification import multiclass_precision_at_fixed_recall
>>> preds = torch.tensor([[0.75, 0.05, 0.05, 0.05, 0.05],
...                       [0.05, 0.75, 0.05, 0.05, 0.05],
...                       [0.05, 0.05, 0.75, 0.05, 0.05],
...                       [0.05, 0.05, 0.05, 0.75, 0.05]])
>>> target = torch.tensor([0, 1, 3, 2])
>>> multiclass_precision_at_fixed_recall(  
...     preds, target, num_classes=5, min_recall=0.5, thresholds=None)
(tensor([1.0000, 1.0000, 0.2500, 0.2500, 0.0000]),
 tensor([0.7500, 0.7500, 0.0500, 0.0500, nan]))
>>> multiclass_precision_at_fixed_recall(  
...     preds, target, num_classes=5, min_recall=0.5, thresholds=5)
(tensor([1.0000, 1.0000, 0.2500, 0.2500, 0.0000]),
 tensor([0.7500, 0.7500, 0.0000, 0.0000, nan]))
```

### multilabel_precision_at_fixed_recall {#multilabel-precision-at-fixed-recall}

### `torchmetrics.functional.classification.multilabel_precision_at_fixed_recall(preds, target, num_labels, min_recall, thresholds=None, ignore_index=None, validate_args=True)` {#torchmetrics.functional.classification.multilabel_precision_at_fixed_recall}

[\[source\]](https://github.com/Lightning-AI/torchmetrics/blob/v1.9.0/src/torchmetrics/functional/classification/precision_fixed_recall.py#L224-L306)

Compute the highest possible precision value given the minimum recall thresholds provided for multilabel tasks.

This is done by first calculating the precision-recall curve for different thresholds and the find the precision for a given recall level.

Accepts the following input tensors:

*   `preds` (float tensor): `(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 sigmoid per element.
    
*   `target` (int tensor): `(N, C, ...)`. Target should be a tensor containing ground truth labels, and therefore only contain {0,1} values (except if ignore\_index is specified).
    

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

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 $`\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 $`\mathcal{O}(n_{thresholds} \times n_{labels})`$ (constant memory).

Parameters:

*   **preds** ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")) – Tensor with predictions
    
*   **target** ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)")) – Tensor with true labels
    
*   **num\_labels** ([`int`](https://docs.python.org/3/library/functions.html#int "(in Python v3.14)")) – Integer specifying the number of labels
    
*   **min\_recall** ([`float`](https://docs.python.org/3/library/functions.html#float "(in Python v3.14)")) – float value specifying minimum recall threshold.
    
*   **thresholds** (`Union`\[[`int`](https://docs.python.org/3/library/functions.html#int "(in Python v3.14)"), [`list`](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.14)")\[[`float`](https://docs.python.org/3/library/functions.html#float "(in Python v3.14)")\], [`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)"), [`None`](https://docs.python.org/3/library/constants.html#None "(in Python v3.14)")\]) –
    
    Can be one of:
    
    *   If set to `None`, will use a non-binned approach where thresholds are dynamically calculated from all the data. Most accurate but also most memory consuming approach.
        
    *   If set to an `int` (larger than 1), will use that number of thresholds linearly spaced from 0 to 1 as bins for the calculation.
        
    *   If set to an `list` of floats, will use the indicated thresholds in the list as bins for the calculation
        
    *   If set to an 1d [`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.13)") of floats, will use the indicated thresholds in the tensor as bins for the calculation.
        
    
*   **ignore\_index** ([`Optional`](https://docs.python.org/3/library/typing.html#typing.Optional "(in Python v3.14)")\[[`int`](https://docs.python.org/3/library/functions.html#int "(in Python v3.14)")\]) – Specifies a target value that is ignored and does not contribute to the metric calculation
    
*   **validate\_args** ([`bool`](https://docs.python.org/3/library/functions.html#bool "(in Python v3.14)")) – bool indicating if input arguments and tensors should be validated for correctness. Set to `False` for faster computations.
    

Returns:

a tuple of either 2 tensors or 2 lists containing

*   precision: an 1d tensor of size (n\_classes, ) with the maximum precision for the given recall level per class
    
*   thresholds: an 1d tensor of size (n\_classes, ) with the corresponding threshold level per class
    

Return type:

([tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.14)"))

Example

```python
>>> from torchmetrics.functional.classification import multilabel_precision_at_fixed_recall
>>> preds = torch.tensor([[0.75, 0.05, 0.35],
...                       [0.45, 0.75, 0.05],
...                       [0.05, 0.55, 0.75],
...                       [0.05, 0.65, 0.05]])
>>> target = torch.tensor([[1, 0, 1],
...                        [0, 0, 0],
...                        [0, 1, 1],
...                        [1, 1, 1]])
>>> multilabel_precision_at_fixed_recall(preds, target, num_labels=3, min_recall=0.5, thresholds=None)
(tensor([1.0000, 0.6667, 1.0000]), tensor([0.7500, 0.5500, 0.3500]))
>>> multilabel_precision_at_fixed_recall(preds, target, num_labels=3, min_recall=0.5, thresholds=5)
(tensor([1.0000, 0.6667, 1.0000]), tensor([0.7500, 0.5000, 0.2500]))
```

---

**Navigation**

- Parent: [Classification](/docs/torchmetrics/1.9.0/classification.md)