---
title: Expected Error Rate (EER)
description: Compute Equal Error Rate (EER) for multiclass classification task.
canonical: 'https://lightning.ai/docs/torchmetrics/stable/classification/eer'
---
# Expected Error Rate (EER) {#expected-error-rate-eer}

## Module Interface {#module-interface}

### `class torchmetrics.classification.EER(**kwargs)` {#torchmetrics.classification.EER}

[\[source\]](https://github.com/Lightning-AI/torchmetrics/blob/v1.9.0/src/torchmetrics/classification/eer.py#L380-L451)

Compute Equal Error Rate (EER) for multiclass classification task.

```math
\text{EER} = \frac{\text{FAR} + (1 - \text{FRR})}{2}, \text{where} \min_t abs(FAR_t-FRR_t)
```

The Equal Error Rate (EER) is the point where the False Positive Rate (FPR) and True Positive Rate (TPR) are equal, or in practise minimized. A lower EER value signifies higher system accuracy.

This module 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 [`BinaryEER`](#torchmetrics.classification.BinaryEER "torchmetrics.classification.BinaryEER"), [`MulticlassEER`](#torchmetrics.classification.MulticlassEER "torchmetrics.classification.MulticlassEER") and [`MultilabelEER`](#torchmetrics.classification.MultilabelEER "torchmetrics.classification.MultilabelEER") for the specific details of each argument influence and examples.

Legacy Example:

```python
>>> from torch import tensor
>>> preds = tensor([0.13, 0.26, 0.08, 0.19, 0.34])
>>> target = tensor([0, 0, 1, 1, 1])
>>> eer = EER(task="binary")
>>> eer(preds, target)
tensor(0.5833)
```

```python
>>> preds = tensor([[0.90, 0.05, 0.05],
...                       [0.05, 0.90, 0.05],
...                       [0.05, 0.05, 0.90],
...                       [0.85, 0.05, 0.10],
...                       [0.10, 0.10, 0.80]])
>>> target = tensor([0, 1, 1, 2, 2])
>>> eer = EER(task="multiclass", num_classes=3)
>>> eer(preds, target)
tensor([0.0000, 0.4167, 0.4167])
```

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

[\[source\]](https://github.com/Lightning-AI/torchmetrics/blob/v1.9.0/src/torchmetrics/classification/eer.py#L415-L439)

Initialize task metric.

Return type:

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

### BinaryEER {#binaryeer}

### `class torchmetrics.classification.BinaryEER(thresholds=None, ignore_index=None, validate_args=True, normalization='sigmoid', **kwargs)` {#torchmetrics.classification.BinaryEER}

[\[source\]](https://github.com/Lightning-AI/torchmetrics/blob/v1.9.0/src/torchmetrics/classification/eer.py#L36-L140)

Compute Equal Error Rate (EER) for multiclass classification task.

```math
\text{EER} = \frac{\text{FAR} + \text{FRR}}{2}, \text{where} \min_t abs(FAR_t-FRR_t)
```

The Equal Error Rate (EER) is the point where the False Positive Rate (FPR) and True Positive Rate (TPR) are equal, or in practise minimized. A lower EER value signifies higher system accuracy.

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.15)")): A float tensor of shape `(N, ...)` 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.15)")): An int tensor of shape `(N, ...)` 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.
    

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

*   `b_eer` ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)")): A single scalar with the eer score.
    

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:

*   **thresholds** (`Union`\[[`int`](https://docs.python.org/3/builtins/functions.html#int "(in Python v3.15)"), [`list`](https://docs.python.org/3/builtins/stdtypes.html#list "(in Python v3.15)")\[[`float`](https://docs.python.org/3/builtins/functions.html#float "(in Python v3.15)")\], [`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)"), [`None`](https://docs.python.org/3/builtins/constants.html#None "(in Python v3.15)")\]) –
    
    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 of floats, will use the indicated thresholds in the tensor as bins for the calculation.
        
    
*   **validate\_args** ([`bool`](https://docs.python.org/3/builtins/functions.html#bool "(in Python v3.15)")) – 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.15)")) – 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 BinaryEER
>>> preds = tensor([0, 0.5, 0.7, 0.8])
>>> target = tensor([0, 1, 1, 0])
>>> metric = BinaryEER(thresholds=None)
>>> metric(preds, target)
tensor(0.5000)
>>> b_eer = BinaryEER(thresholds=5)
>>> b_eer(preds, target)
tensor(0.7500)
```

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

[\[source\]](https://github.com/Lightning-AI/torchmetrics/blob/v1.9.0/src/torchmetrics/classification/eer.py#L100-L140)

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.15)"), [`Sequence`](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(in Python v3.15)")\[[`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)")\], [`None`](https://docs.python.org/3/builtins/constants.html#None "(in Python v3.15)")\]) – 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.15)")\[[`Axes`](https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.html#matplotlib.axes.Axes "(in Matplotlib v3.11.2)")\]) – An matplotlib axis object. If provided will add plot to that axis
    

Return type:

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

Returns:

Figure and Axes object

Raises:

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

```python
>>> # Example plotting a single
>>> import torch
>>> from torchmetrics.classification import BinaryEER
>>> metric = BinaryEER()
>>> metric.update(torch.rand(20,), torch.randint(2, (20,)))
>>> fig_, ax_ = metric.plot()
```

[![../../\_images/eer-1.png](/docs/torchmetrics/1.9.0/static/_images/eer-1.png)](/docs/torchmetrics/1.9.0/static/_images/eer-1.png)

```python
>>> # Example plotting multiple values
>>> import torch
>>> from torchmetrics.classification import BinaryEER
>>> metric = BinaryEER()
>>> values = [ ]
>>> for _ in range(10):
...     values.append(metric(torch.rand(20,), torch.randint(2, (20,))))
>>> fig_, ax_ = metric.plot(values)
```

[![../../\_images/eer-2.png](/docs/torchmetrics/1.9.0/static/_images/eer-2.png)](/docs/torchmetrics/1.9.0/static/_images/eer-2.png)

### MulticlassEER {#multiclasseer}

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

[\[source\]](https://github.com/Lightning-AI/torchmetrics/blob/v1.9.0/src/torchmetrics/classification/eer.py#L143-L260)

Compute Equal Error Rate (EER) for multiclass classification task.

```math
\text{EER} = \frac{\text{FAR} + (1 - \text{FRR})}{2}, \text{where} \min_t abs(FAR_t-FRR_t)
```

The Equal Error Rate (EER) is the point where the False Positive Rate (FPR) and True Positive Rate (TPR) are equal, or in practise minimized. A lower EER value signifies higher system accuracy.

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.15)")): A float tensor of shape `(N, C, ...)` 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.15)")): An int tensor of shape `(N, ...)` containing ground truth labels, and therefore only contain values in the \[0, n\_classes-1\] range (except if ignore\_index is specified).
    

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

*   `mc_eer` ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)")): If average=None then a 1d tensor of shape (n\_classes, ) will be returned with eer score per class. If average=”macro”|”micro” then a single scalar will be returned.
    

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:

*   **num\_classes** ([`int`](https://docs.python.org/3/builtins/functions.html#int "(in Python v3.15)")) – Integer specifying the number of classes
    
*   **thresholds** (`Union`\[[`int`](https://docs.python.org/3/builtins/functions.html#int "(in Python v3.15)"), [`list`](https://docs.python.org/3/builtins/stdtypes.html#list "(in Python v3.15)")\[[`float`](https://docs.python.org/3/builtins/functions.html#float "(in Python v3.15)")\], [`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)"), [`None`](https://docs.python.org/3/builtins/constants.html#None "(in Python v3.15)")\]) –
    
    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 of floats, will use the indicated thresholds in the tensor as bins for the calculation.
        
    
*   **average** ([`Optional`](https://docs.python.org/3/library/typing.html#typing.Optional "(in Python v3.15)")\[[`Literal`](https://docs.python.org/3/library/typing.html#typing.Literal "(in Python v3.15)")\[`'micro'`, `'macro'`\]\]) – If aggregation of curves should be applied. By default, the curves are not aggregated and a curve for each class is returned. If average is set to `"micro"`, the metric will aggregate the curves by one hot encoding the targets and flattening the predictions, considering all classes jointly as a binary problem. If average is set to `"macro"`, the metric will aggregate the curves by first interpolating the curves from each class at a combined set of thresholds and then average over the classwise interpolated curves. See [averaging curve objects](https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html) for more info on the different averaging methods.
    
*   **ignore\_index** ([`Optional`](https://docs.python.org/3/library/typing.html#typing.Optional "(in Python v3.15)")\[[`int`](https://docs.python.org/3/builtins/functions.html#int "(in Python v3.15)")\]) – Specifies a target value that is ignored and does not contribute to the metric calculation
    
*   **validate\_args** ([`bool`](https://docs.python.org/3/builtins/functions.html#bool "(in Python v3.15)")) – 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.15)")) – Additional keyword arguments, see [Advanced metric settings](/docs/torchmetrics/1.9.0/user-guide/overview.md#metric-kwargs) for more info.
    

Examples

```python
>>> from torch import tensor
>>> from torchmetrics.classification import MulticlassEER
>>> 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 = MulticlassEER(num_classes=5, average="macro", thresholds=None)
>>> metric(preds, target)
tensor(0.4667)
>>> mc_eer = MulticlassEER(num_classes=5, average=None, thresholds=None)
>>> mc_eer(preds, target)
tensor([0.0000, 0.0000, 0.6667, 0.6667, 1.0000])
```

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

[\[source\]](https://github.com/Lightning-AI/torchmetrics/blob/v1.9.0/src/torchmetrics/classification/eer.py#L220-L260)

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.15)"), [`Sequence`](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(in Python v3.15)")\[[`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)")\], [`None`](https://docs.python.org/3/builtins/constants.html#None "(in Python v3.15)")\]) – 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.15)")\[[`Axes`](https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.html#matplotlib.axes.Axes "(in Matplotlib v3.11.2)")\]) – An matplotlib axis object. If provided will add plot to that axis
    

Return type:

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

Returns:

Figure and Axes object

Raises:

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

```python
>>> # Example plotting a single
>>> import torch
>>> from torchmetrics.classification import MulticlassEER
>>> metric = MulticlassEER(num_classes=3)
>>> metric.update(torch.randn(20, 3), torch.randint(3,(20,)))
>>> fig_, ax_ = metric.plot()
```

[![../../\_images/eer-3.png](/docs/torchmetrics/1.9.0/static/_images/eer-3.png)](/docs/torchmetrics/1.9.0/static/_images/eer-3.png)

```python
>>> # Example plotting multiple values
>>> import torch
>>> from torchmetrics.classification import MulticlassEER
>>> metric = MulticlassEER(num_classes=3)
>>> values = [ ]
>>> for _ in range(10):
...     values.append(metric(torch.randn(20, 3), torch.randint(3, (20,))))
>>> fig_, ax_ = metric.plot(values)
```

[![../../\_images/eer-4.png](/docs/torchmetrics/1.9.0/static/_images/eer-4.png)](/docs/torchmetrics/1.9.0/static/_images/eer-4.png)

### MultilabelEER {#multilabeleer}

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

[\[source\]](https://github.com/Lightning-AI/torchmetrics/blob/v1.9.0/src/torchmetrics/classification/eer.py#L263-L377)

Compute Equal Error Rate (EER) for multiclass classification task.

```math
\text{EER} = \frac{\text{FAR} + (1 - \text{FRR})}{2}, \text{where} \min_t abs(FAR_t-FRR_t)
```

The Equal Error Rate (EER) is the point where the False Positive Rate (FPR) and True Positive Rate (TPR) are equal, or in practise minimized. A lower EER value signifies higher system accuracy.

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.15)")): A float tensor of shape `(N, C, ...)` 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.15)")): An int tensor of shape `(N, C, ...)` containing ground truth labels, and therefore only contain {0,1} values (except if ignore\_index is specified).
    

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

*   `ml_eer` ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)")): A 1d tensor of shape (n\_classes, ) will be returned with eer score per label.
    

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:

*   **num\_labels** ([`int`](https://docs.python.org/3/builtins/functions.html#int "(in Python v3.15)")) – Integer specifying the number of labels
    
*   **average** –
    
    Defines the reduction that is applied over labels. Should be one of the following:
    
    *   `micro`: Sum score over all labels
        
    *   `macro`: Calculate score for each label and average them
        
    *   `weighted`: calculates score for each label and computes weighted average using their support
        
    *   `"none"` or `None`: calculates score for each label and applies no reduction
        
    
*   **thresholds** (`Union`\[[`int`](https://docs.python.org/3/builtins/functions.html#int "(in Python v3.15)"), [`list`](https://docs.python.org/3/builtins/stdtypes.html#list "(in Python v3.15)")\[[`float`](https://docs.python.org/3/builtins/functions.html#float "(in Python v3.15)")\], [`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)"), [`None`](https://docs.python.org/3/builtins/constants.html#None "(in Python v3.15)")\]) –
    
    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 of floats, will use the indicated thresholds in the tensor as bins for the calculation.
        
    
*   **validate\_args** ([`bool`](https://docs.python.org/3/builtins/functions.html#bool "(in Python v3.15)")) – 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.15)")) – 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 MultilabelEER
>>> 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]])
>>> ml_eer = MultilabelEER(num_labels=3, thresholds=None)
>>> ml_eer(preds, target)
tensor([0.5000, 0.5000, 0.1667])
```

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

[\[source\]](https://github.com/Lightning-AI/torchmetrics/blob/v1.9.0/src/torchmetrics/classification/eer.py#L337-L377)

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.15)"), [`Sequence`](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(in Python v3.15)")\[[`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)")\], [`None`](https://docs.python.org/3/builtins/constants.html#None "(in Python v3.15)")\]) – 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.15)")\[[`Axes`](https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.html#matplotlib.axes.Axes "(in Matplotlib v3.11.2)")\]) – An matplotlib axis object. If provided will add plot to that axis
    

Return type:

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

Returns:

Figure and Axes object

Raises:

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

```python
>>> # Example plotting a single
>>> import torch
>>> from torchmetrics.classification import MultilabelEER
>>> metric = MultilabelEER(num_labels=3)
>>> metric.update(torch.rand(20,3), torch.randint(2, (20,3)))
>>> fig_, ax_ = metric.plot()
```

[![../../\_images/eer-5.png](/docs/torchmetrics/1.9.0/static/_images/eer-5.png)](/docs/torchmetrics/1.9.0/static/_images/eer-5.png)

```python
>>> # Example plotting multiple values
>>> import torch
>>> from torchmetrics.classification import MultilabelEER
>>> metric = MultilabelEER(num_labels=3)
>>> values = [ ]
>>> for _ in range(10):
...     values.append(metric(torch.rand(20,3), torch.randint(2, (20,3))))
>>> fig_, ax_ = metric.plot(values)
```

[![../../\_images/eer-6.png](/docs/torchmetrics/1.9.0/static/_images/eer-6.png)](/docs/torchmetrics/1.9.0/static/_images/eer-6.png)

## Functional Interface {#functional-interface}

### `torchmetrics.functional.classification.eer(preds, target, task, thresholds=None, num_classes=None, num_labels=None, average=None, ignore_index=None, validate_args=True)` {#torchmetrics.functional.classification.eer}

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

Compute Equal Error Rate (EER) metric.

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 [`binary_eer()`](#torchmetrics.functional.classification.binary_eer "torchmetrics.functional.classification.binary_eer"), [`multiclass_eer()`](#torchmetrics.functional.classification.multiclass_eer "torchmetrics.functional.classification.multiclass_eer") and [`multilabel_eer()`](#torchmetrics.functional.classification.multilabel_eer "torchmetrics.functional.classification.multilabel_eer") for the specific details of each argument influence and examples.

Parameters:

*   **preds** ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)")) – Predictions from model (logits or probabilities)
    
*   **target** ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)")) – Ground truth labels
    
*   **task** ([`Literal`](https://docs.python.org/3/library/typing.html#typing.Literal "(in Python v3.15)")\[`'binary'`, `'multiclass'`, `'multilabel'`\]) – Type of task, either ‘binary’, ‘multiclass’ or ‘multilabel’
    
*   **thresholds** (`Union`\[[`int`](https://docs.python.org/3/builtins/functions.html#int "(in Python v3.15)"), [`List`](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.15)")\[[`float`](https://docs.python.org/3/builtins/functions.html#float "(in Python v3.15)")\], [`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)"), [`None`](https://docs.python.org/3/builtins/constants.html#None "(in Python v3.15)")\]) – Thresholds used for computing the ROC curve
    
*   **num\_classes** ([`Optional`](https://docs.python.org/3/library/typing.html#typing.Optional "(in Python v3.15)")\[[`int`](https://docs.python.org/3/builtins/functions.html#int "(in Python v3.15)")\]) – Number of classes (for multiclass task)
    
*   **num\_labels** ([`Optional`](https://docs.python.org/3/library/typing.html#typing.Optional "(in Python v3.15)")\[[`int`](https://docs.python.org/3/builtins/functions.html#int "(in Python v3.15)")\]) – Number of labels (for multilabel task)
    
*   **average** ([`Optional`](https://docs.python.org/3/library/typing.html#typing.Optional "(in Python v3.15)")\[[`Literal`](https://docs.python.org/3/library/typing.html#typing.Literal "(in Python v3.15)")\[`'micro'`, `'macro'`\]\]) – Method to average EER over multiple classes/labels
    
*   **ignore\_index** ([`Optional`](https://docs.python.org/3/library/typing.html#typing.Optional "(in Python v3.15)")\[[`int`](https://docs.python.org/3/builtins/functions.html#int "(in Python v3.15)")\]) – Specify a target value that is ignored
    
*   **validate\_args** ([`bool`](https://docs.python.org/3/builtins/functions.html#bool "(in Python v3.15)")) – Bool indicating whether to validate input arguments
    

Return type:

`Union`\[[`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)"), [`List`](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.15)")\[[`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)")\]\]

Legacy Example:

```python
>>> from torchmetrics.functional.classification import eer
>>> preds = torch.tensor([0.13, 0.26, 0.08, 0.19, 0.34])
>>> target = torch.tensor([0, 0, 1, 1, 1])
>>> eer(preds, target, task='binary')
tensor(0.5833)
```

```python
>>> preds = torch.tensor([[0.90, 0.05, 0.05],
...                       [0.05, 0.90, 0.05],
...                       [0.05, 0.05, 0.90],
...                       [0.85, 0.05, 0.10],
...                       [0.10, 0.10, 0.80]])
>>> target = torch.tensor([0, 1, 1, 2, 2])
>>> eer(preds, target, task='multiclass', num_classes=3, )
tensor([0.0000, 0.4167, 0.4167])
```

### binary_eer {#binary-eer}

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

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

Compute Equal Error Rate (EER) for binary classification task.

```math
\text{EER} = \frac{\text{FAR} + \text{FRR}}{2}, \text{where} \min_t abs(FAR_t-FRR_t)
```

The Equal Error Rate (EER) is the point where the False Positive Rate (FPR) and True Positive Rate (TPR) are equal, or in practise minimized. A lower EER value signifies higher system accuracy.

Parameters:

*   **preds** ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)")) – Tensor with predictions
    
*   **target** ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)")) – Tensor with true labels
    
*   **thresholds** (`Union`\[[`int`](https://docs.python.org/3/builtins/functions.html#int "(in Python v3.15)"), [`List`](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.15)")\[[`float`](https://docs.python.org/3/builtins/functions.html#float "(in Python v3.15)")\], [`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)"), [`None`](https://docs.python.org/3/builtins/constants.html#None "(in Python v3.15)")\]) –
    
    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 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.15)")\[[`int`](https://docs.python.org/3/builtins/functions.html#int "(in Python v3.15)")\]) – Specifies a target value that is ignored and does not contribute to the metric calculation
    
*   **validate\_args** ([`bool`](https://docs.python.org/3/builtins/functions.html#bool "(in Python v3.15)")) – bool indicating if input arguments and tensors should be validated for correctness. Set to `False` for faster computations
    

Return type:

[`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)")

Returns:

A single scalar with the eer score

Example

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

### multiclass_eer {#multiclass-eer}

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

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

Compute Equal Error Rate (EER) for multiclass classification task.

```math
\text{EER} = \frac{\text{FAR} + (1 - \text{FRR})}{2}, \text{where} \min_t abs(FAR_t-FRR_t)
```

The Equal Error Rate (EER) is the point where the False Positive Rate (FPR) and True Positive Rate (TPR) are equal, or in practise minimized. A lower EER value signifies higher system accuracy.

Parameters:

*   **preds** ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)")) – Tensor with predictions
    
*   **target** ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)")) – Tensor with true labels
    
*   **num\_classes** ([`int`](https://docs.python.org/3/builtins/functions.html#int "(in Python v3.15)")) – Integer specifying the number of classes
    
*   **thresholds** (`Union`\[[`int`](https://docs.python.org/3/builtins/functions.html#int "(in Python v3.15)"), [`List`](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.15)")\[[`float`](https://docs.python.org/3/builtins/functions.html#float "(in Python v3.15)")\], [`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)"), [`None`](https://docs.python.org/3/builtins/constants.html#None "(in Python v3.15)")\]) –
    
    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 of floats, will use the indicated thresholds in the tensor as bins for the calculation.
        
    
*   **average** ([`Optional`](https://docs.python.org/3/library/typing.html#typing.Optional "(in Python v3.15)")\[[`Literal`](https://docs.python.org/3/library/typing.html#typing.Literal "(in Python v3.15)")\[`'micro'`, `'macro'`\]\]) – If aggregation of should be applied. The aggregation is applied to underlying ROC curves. By default, eer is not aggregated and a score for each class is returned. If average is set to `"micro"` , the metric will aggregate the curves by one hot encoding the targets and flattening the predictions, considering all classes jointly as a binary problem. If average is set to `"macro"`, the metric will aggregate the curves by first interpolating the curves from each class at a combined set of thresholds and then average over the classwise interpolated curves. See [averaging curve objects](https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html) for more info on the different averaging methods.
    
*   **ignore\_index** ([`Optional`](https://docs.python.org/3/library/typing.html#typing.Optional "(in Python v3.15)")\[[`int`](https://docs.python.org/3/builtins/functions.html#int "(in Python v3.15)")\]) – Specifies a target value that is ignored and does not contribute to the metric calculation
    
*   **validate\_args** ([`bool`](https://docs.python.org/3/builtins/functions.html#bool "(in Python v3.15)")) – bool indicating if input arguments and tensors should be validated for correctness. Set to `False` for faster computations.
    

Return type:

[`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)")

Returns:

If average=None|”none” then a 1d tensor of shape (n\_classes, ) will be returned with eer score per class. If average=”macro”|”micro” then a single scalar is returned.

Example

```python
>>> from torchmetrics.functional.classification import multiclass_eer
>>> 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_eer(preds, target, num_classes=5, average="macro", thresholds=None)
tensor(0.4667)
>>> multiclass_eer(preds, target, num_classes=5, average=None, thresholds=None)
tensor([0.0000, 0.0000, 0.6667, 0.6667, 1.0000])
>>> multiclass_eer(preds, target, num_classes=5, average="macro", thresholds=5)
tensor(0.4667)
>>> multiclass_eer(preds, target, num_classes=5, average=None, thresholds=5)
tensor([0.0000, 0.0000, 0.6667, 0.6667, 1.0000])
```

### multilabel_eer {#multilabel-eer}

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

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

Compute Equal Error Rate (EER) for multilabel classification task.

```math
\text{EER} = \frac{\text{FAR} + (1 - \text{FRR})}{2}, \text{where} \min_t abs(FAR_t-FRR_t)
```

The Equal Error Rate (EER) is the point where the False Positive Rate (FPR) and True Positive Rate (TPR) are equal, or in practise minimized. A lower EER value signifies higher system accuracy.

Parameters:

*   **preds** ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)")) – Tensor with predictions
    
*   **target** ([`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)")) – Tensor with true labels
    
*   **num\_labels** ([`int`](https://docs.python.org/3/builtins/functions.html#int "(in Python v3.15)")) – Integer specifying the number of labels
    
*   **thresholds** (`Union`\[[`int`](https://docs.python.org/3/builtins/functions.html#int "(in Python v3.15)"), [`List`](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.15)")\[[`float`](https://docs.python.org/3/builtins/functions.html#float "(in Python v3.15)")\], [`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)"), [`None`](https://docs.python.org/3/builtins/constants.html#None "(in Python v3.15)")\]) –
    
    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 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.15)")\[[`int`](https://docs.python.org/3/builtins/functions.html#int "(in Python v3.15)")\]) – Specifies a target value that is ignored and does not contribute to the metric calculation
    
*   **validate\_args** ([`bool`](https://docs.python.org/3/builtins/functions.html#bool "(in Python v3.15)")) – bool indicating if input arguments and tensors should be validated for correctness. Set to `False` for faster computations.
    

Return type:

[`Tensor`](https://docs.pytorch.org/docs/stable/tensors.html#torch.Tensor "(in PyTorch v2.15)")

Returns:

A 1d tensor of shape (n\_classes, ) will be returned with eer score per label.

Example

```python
>>> from torchmetrics.functional.classification import multilabel_eer
>>> 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_eer(preds, target, num_labels=3, thresholds=None)
tensor([0.5000, 0.5000, 0.1667])
>>> multilabel_eer(preds, target, num_labels=3, thresholds=5)
tensor([0.5000, 0.7500, 0.1667])
```

---

**Navigation**

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