Multilabellogauc

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

# multilabellogauc

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

## When to invoke this skill

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

## Reference signature

```python
from torchmetrics.classification import MultilabelLogAUC

# MultilabelLogAUC(num_labels: int, fpr_range: Tuple[float, float] = (0.001, 0.1), average: Optional[Literal['macro', 'none']] = None, thresholds: Union[int, List[float], torch.Tensor, NoneType] = None, ignore_index: Optional[int] = None, validate_args: bool = True, **kwargs: Any) -> None
```

## Library docstring

```
Compute the `Log AUC`_ score for multiclass classification tasks.

The score is computed by first computing the ROC curve, which then is interpolated to the specified range of false
positive rates (FPR) and then the log is taken of the FPR before the area under the curve (AUC) is computed. The
score is commonly used in applications where the positive and negative are imbalanced and a low false positive rate
is of high importance.

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

- ``preds`` (:class:`~torch.Tensor`): 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`` (:class:`~torch.Tensor`): 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:

- ``logauc`` (:class:`~torch.Tensor`): If `average=None|"none"` then a 1d tensor of shape (num_labels, ) will
  be returned with logauc score per class. If `average="macro"` then a single scalar is 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 :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_{labels})` (constant memory).

Args:
    num_labels: Integer specifying the number of labels
    fpr_range: 2-element tuple with the lower and upper bound of the false positive rate range to compute the log
        AUC score.
    average:
        Defines the reduction that is applied over labels. Should be one of the following:

        - ``"macro"``: Calculate the score for each label 
```

## Quick recipe

```python
import torchmetrics.classification as _m
score = _m.MultilabelLogAUC(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)`.