File size: 2,276 Bytes
0d48417
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
"""Masked losses for multi-output regression and distribution heads."""

from __future__ import annotations

from typing import Any, Dict

import torch
import torch.nn.functional as F


LOSS_REGISTRY = {}


def register_loss(name: str):
    def deco(fn):
        LOSS_REGISTRY[name] = fn
        return fn

    return deco


def _reduce(loss: torch.Tensor, mask: torch.Tensor) -> torch.Tensor:
    mask = mask.to(loss.dtype)
    denom = mask.sum().clamp_min(1.0)
    return (loss * mask).sum() / denom


@register_loss("masked_mae")
def masked_mae(pred, target, mask, **kwargs):
    loss = (pred - target).abs()
    return _reduce(loss, mask)


@register_loss("masked_mse")
def masked_mse(pred, target, mask, **kwargs):
    loss = (pred - target) ** 2
    return _reduce(loss, mask)


@register_loss("masked_huber")
def masked_huber(pred, target, mask, beta: float = 1.0, **kwargs):
    loss = F.smooth_l1_loss(pred, target, reduction="none", beta=beta)
    return _reduce(loss, mask)


@register_loss("masked_smape")
def masked_smape(pred, target, mask, eps: float = 1e-6, **kwargs):
    denom = (target.abs() + pred.abs()) / 2.0 + 1.0
    loss = (pred - target).abs() / denom.clamp_min(eps)
    return _reduce(loss, mask)


@register_loss("masked_cross_entropy")
def masked_cross_entropy(pred, target, mask, label_smoothing: float = 0.0, **kwargs):
    # pred: (B, T, C), target: (B, T), mask: (B, T)
    if pred.dim() != 3:
        raise ValueError(f"masked_cross_entropy expects (B,T,C), got {tuple(pred.shape)}")
    C = pred.shape[-1]
    logits = pred.reshape(-1, C)
    labels = target.reshape(-1).long().clamp(0, C - 1)
    m = mask.reshape(-1).to(logits.dtype)
    loss = F.cross_entropy(logits, labels, reduction="none", label_smoothing=label_smoothing)
    denom = m.sum().clamp_min(1.0)
    return (loss * m).sum() / denom


def build_loss(cfg: Dict[str, Any]):
    name = cfg["name"]
    if name not in LOSS_REGISTRY:
        raise KeyError(f"Unknown loss '{name}'. Available: {sorted(LOSS_REGISTRY)}")
    params = dict(cfg.get("params", {}))
    fn = LOSS_REGISTRY[name]

    def loss_fn(pred, target, mask):
        return fn(pred, target, mask, **params)

    loss_fn.loss_name = name
    return loss_fn


def list_losses():
    return sorted(LOSS_REGISTRY)