Functional

danling.metrics.functional

binary_accuracy

Bases: _BinaryConfmatMetric

Metric function version of binary accuracy.

Relies on a confusion matrix if available, otherwise falls back to torchmetrics’ functional binary accuracy implementation.

Source code in danling/metrics/functional/binary.py

class binary_accuracy(_BinaryConfmatMetric):
    """
    Metric function version of binary accuracy.

    Relies on a confusion matrix if available, otherwise falls back to
    torchmetrics' functional binary accuracy implementation.
    """

    def __init__(self, threshold: float = 0.5, ignore_index: int | None = -100, *, name: Optional[str] = "acc") -> None:
        super().__init__(threshold=threshold, ignore_index=ignore_index, name=name)

    def __call__(self, state: MetricState) -> Tensor | float:
        confmat = state.confmat
        if confmat is None:
            return self._fallback(state, tm_binary_accuracy)

        correct = torch.diag(confmat).sum()
        total = confmat.sum()
        return correct / total if total > 0 else torch.tensor(float("nan"), device=confmat.device)

binary_auprc

Bases: _BinaryMetricBase

Metric function version of binary AUPRC.

Source code in danling/metrics/functional/binary.py

class binary_auprc(_BinaryMetricBase):
    """
    Metric function version of binary AUPRC.
    """

    def __init__(self, ignore_index: int | None = -100, *, name: Optional[str] = "auprc") -> None:
        super().__init__(name=name, preds_targets=True, ignore_index=ignore_index)

    def __call__(self, state: MetricState) -> Tensor | float:
        if self._is_empty(state):
            return self._nan()
        return tm_binary_auprc(state.preds, state.targets, ignore_index=self.ignore_index)

binary_auroc

Bases: _BinaryMetricBase

Metric function version of binary AUROC.

Requires raw predictions and targets; does not use confusion matrix.

Source code in danling/metrics/functional/binary.py

class binary_auroc(_BinaryMetricBase):
    """
    Metric function version of binary AUROC.

    Requires raw predictions and targets; does not use confusion matrix.
    """

    def __init__(self, ignore_index: int | None = -100, *, name: Optional[str] = "auroc") -> None:
        super().__init__(name=name, preds_targets=True, ignore_index=ignore_index)

    def __call__(self, state: MetricState) -> Tensor | float:
        if self._is_empty(state):
            return self._nan()
        return tm_binary_auroc(state.preds, state.targets, ignore_index=self.ignore_index)

binary_balanced_accuracy

Bases: _BinaryConfmatMetric

Metric function version of binary balanced accuracy.

Source code in danling/metrics/functional/binary.py

class binary_balanced_accuracy(_BinaryConfmatMetric):
    """
    Metric function version of binary balanced accuracy.
    """

    def __init__(
        self, threshold: float = 0.5, ignore_index: int | None = -100, *, name: Optional[str] = "balanced_accuracy"
    ) -> None:
        super().__init__(threshold=threshold, ignore_index=ignore_index, name=name)

    def __call__(self, state: MetricState) -> Tensor | float:
        confmat = state.confmat
        if confmat is None:
            recall = self._fallback(state, tm_binary_recall)
            specificity = self._fallback(state, tm_binary_specificity)
            return 0.5 * (recall + specificity)

        tp = confmat[1, 1]
        fn = confmat[1, 0]
        tn = confmat[0, 0]
        fp = confmat[0, 1]
        tpr = tp / (tp + fn).clamp(min=1)
        tnr = tn / (tn + fp).clamp(min=1)
        return 0.5 * (tpr + tnr)

binary_f1

Bases: binary_fbeta

Metric function version of binary F1 score.

Source code in danling/metrics/functional/binary.py

class binary_f1(binary_fbeta):
    """
    Metric function version of binary F1 score.
    """

    def __init__(self, threshold: float = 0.5, ignore_index: int | None = -100, *, name: Optional[str] = "f1") -> None:
        super().__init__(beta=1.0, threshold=threshold, ignore_index=ignore_index, name=name)

binary_fbeta

Bases: _BinaryConfmatMetric

Metric function version of binary F-beta score.

Source code in danling/metrics/functional/binary.py

class binary_fbeta(_BinaryConfmatMetric):
    """
    Metric function version of binary F-beta score.
    """

    def __init__(
        self,
        beta: float = 1.0,
        threshold: float = 0.5,
        ignore_index: int | None = -100,
        *,
        name: Optional[str] = "fbeta",
    ) -> None:
        self.beta = beta
        super().__init__(threshold=threshold, ignore_index=ignore_index, name=name)

    def __call__(self, state: MetricState) -> Tensor | float:
        confmat = state.confmat
        if confmat is None:
            return self._fallback(state, tm_binary_fbeta, beta=self.beta)

        tp = confmat[1, 1]
        fp = confmat[0, 1]
        fn = confmat[1, 0]
        beta_square = self.beta * self.beta
        numerator = (1 + beta_square) * tp
        denominator = numerator + beta_square * fn + fp
        return numerator / denominator.clamp(min=1)

binary_hamming_loss

Bases: _BinaryConfmatMetric

Metric function version of binary hamming loss.

Source code in danling/metrics/functional/binary.py

class binary_hamming_loss(_BinaryConfmatMetric):
    """
    Metric function version of binary hamming loss.
    """

    def __init__(
        self, threshold: float = 0.5, ignore_index: int | None = -100, *, name: Optional[str] = "hamming_loss"
    ) -> None:
        super().__init__(threshold=threshold, ignore_index=ignore_index, name=name)

    def __call__(self, state: MetricState) -> Tensor | float:
        confmat = state.confmat
        if confmat is None:
            return self._fallback(state, tm_binary_hamming_loss)

        fp = confmat[0, 1]
        fn = confmat[1, 0]
        total = confmat.sum()
        return (fp + fn) / total if total > 0 else torch.tensor(float("nan"), device=confmat.device)

binary_iou

Bases: binary_jaccard_index

Alias of binary Jaccard index.

Source code in danling/metrics/functional/binary.py

class binary_iou(binary_jaccard_index):
    """
    Alias of binary Jaccard index.
    """

    def __init__(self, threshold: float = 0.5, ignore_index: int | None = -100, *, name: Optional[str] = "iou") -> None:
        super().__init__(threshold=threshold, ignore_index=ignore_index, name=name)

binary_jaccard_index

Bases: _BinaryConfmatMetric

Metric function version of binary Jaccard index (IoU).

Source code in danling/metrics/functional/binary.py

class binary_jaccard_index(_BinaryConfmatMetric):
    """
    Metric function version of binary Jaccard index (IoU).
    """

    def __init__(
        self, threshold: float = 0.5, ignore_index: int | None = -100, *, name: Optional[str] = "jaccard"
    ) -> None:
        super().__init__(threshold=threshold, ignore_index=ignore_index, name=name)

    def __call__(self, state: MetricState) -> Tensor | float:
        confmat = state.confmat
        if confmat is None:
            return self._fallback(state, tm_binary_jaccard_index)

        tp = confmat[1, 1]
        fp = confmat[0, 1]
        fn = confmat[1, 0]
        return tp / (tp + fp + fn).clamp(min=1)

binary_precision

Bases: _BinaryConfmatMetric

Metric function version of binary precision.

Source code in danling/metrics/functional/binary.py

class binary_precision(_BinaryConfmatMetric):
    """
    Metric function version of binary precision.
    """

    def __init__(
        self, threshold: float = 0.5, ignore_index: int | None = -100, *, name: Optional[str] = "precision"
    ) -> None:
        super().__init__(threshold=threshold, ignore_index=ignore_index, name=name)

    def __call__(self, state: MetricState) -> Tensor | float:
        confmat = state.confmat
        if confmat is None:
            return self._fallback(state, tm_binary_precision)

        tp = confmat[1, 1]
        fp = confmat[0, 1]
        denom = (tp + fp).clamp(min=1)
        return tp / denom

binary_recall

Bases: _BinaryConfmatMetric

Metric function version of binary recall.

Source code in danling/metrics/functional/binary.py

class binary_recall(_BinaryConfmatMetric):
    """
    Metric function version of binary recall.
    """

    def __init__(
        self, threshold: float = 0.5, ignore_index: int | None = -100, *, name: Optional[str] = "recall"
    ) -> None:
        super().__init__(threshold=threshold, ignore_index=ignore_index, name=name)

    def __call__(self, state: MetricState) -> Tensor | float:
        confmat = state.confmat
        if confmat is None:
            return self._fallback(state, tm_binary_recall)

        tp = confmat[1, 1]
        fn = confmat[1, 0]
        denom = (tp + fn).clamp(min=1)
        return tp / denom

binary_specificity

Bases: _BinaryConfmatMetric

Metric function version of binary specificity.

Source code in danling/metrics/functional/binary.py

class binary_specificity(_BinaryConfmatMetric):
    """
    Metric function version of binary specificity.
    """

    def __init__(
        self, threshold: float = 0.5, ignore_index: int | None = -100, *, name: Optional[str] = "specificity"
    ) -> None:
        super().__init__(threshold=threshold, ignore_index=ignore_index, name=name)

    def __call__(self, state: MetricState) -> Tensor | float:
        confmat = state.confmat
        if confmat is None:
            return self._fallback(state, tm_binary_specificity)

        tn = confmat[0, 0]
        fp = confmat[0, 1]
        denom = (tn + fp).clamp(min=1)
        return tn / denom

multiclass_balanced_accuracy

Bases: MetricFunc

Metric function version of multiclass balanced accuracy.

For multiclass classification, balanced accuracy is the class-balanced recall. Only the standard multiclass definition is supported: average="macro" with k=1.

Source code in danling/metrics/functional/multiclass.py

class multiclass_balanced_accuracy(MetricFunc):
    """
    Metric function version of multiclass balanced accuracy.

    For multiclass classification, balanced accuracy is the class-balanced recall.
    Only the standard multiclass definition is supported: `average="macro"` with `k=1`.
    """

    def __init__(
        self,
        num_classes: int,
        average: str | None = "macro",
        k: int = 1,
        ignore_index: int | None = -100,
        *,
        name: Optional[str] = "balanced_accuracy",
    ) -> None:
        require_standard_multiclass_balanced_accuracy(average, k)
        self.num_classes = num_classes
        self.average = average
        self.k = k
        self.ignore_index = ignore_index
        super().__init__(
            name=name,
            preds_targets=False,
            confmat=True,
            task="multiclass",
            num_classes=num_classes,
            ignore_index=ignore_index,
        )

    def __call__(self, state: MetricState) -> Tensor | float:
        confmat = state.confmat
        if confmat is not None:
            tp, fp, fn, _, support, _ = state.multiclass_stats
            return reduce_ratio_metric(tp, tp + fn, self.average, support, present=_present_mask(support, fp))

        return _call_tm_multiclass(
            state,
            tmcls.multiclass_recall,
            num_classes=self.num_classes,
            ignore_index=self.ignore_index,
            average=self.average,
            top_k=self.k,
            use_average=True,
            use_top_k=True,
        )

MetricFunc

Base class for metric functions with declared state requirements.

Metric functions behave like callables via __call__ and carry metadata so that metrics containers know which shared state to maintain.

Source code in danling/metrics/functional/utils.py

class MetricFunc:
    """
    Base class for metric functions with declared state requirements.

    Metric functions behave like callables via ``__call__`` and carry metadata
    so that metrics containers know which shared state to maintain.
    """

    name: str = ""
    preds_targets: bool = False
    confmat: bool = False
    task: str | None = None
    num_classes: int | None = None
    num_labels: int | None = None
    threshold: float | None = None
    ignore_index: int | None = None

    def __init__(
        self,
        *,
        name: str | None = None,
        preds_targets: bool = False,
        confmat: bool = False,
        task: str | None = None,
        num_classes: int | None = None,
        num_labels: int | None = None,
        threshold: float | None = None,
        ignore_index: int | None = None,
    ) -> None:
        self.name = name or self.name or self.__class__.__name__
        self.preds_targets = preds_targets
        self.confmat = confmat
        self.task = task
        self.num_classes = num_classes
        self.num_labels = num_labels
        self.threshold = threshold
        self.ignore_index = ignore_index

    def __call__(self, state: MetricState) -> Tensor | float:  # pragma: no cover - interface stub
        raise NotImplementedError