Upload alea/losses.py with huggingface_hub

alea/losses.py

@@ -0,0 +1,64 @@
+"""Proper scoring rules for decision heads.
+
+All losses accept a target distribution q (soft, [B, K]) — for deterministic
+labels q is one-hot. Proper scoring rules are minimized at p = q either way;
+soft targets just buy lower variance.
+"""
+import torch
+import torch.nn.functional as F
+
+
+def brier_loss(logits, q, pad_mask=None):
+    """Mean over classes of (p - q)^2. logits [B,K], q [B,K], pad True=ignore."""
+    p = F.softmax(logits.float(), dim=-1)
+    loss = ((p - q.float()) ** 2).sum(-1)
+    return loss.mean()
+
+
+def ce_loss(logits, q, pad_mask=None):
+    """Cross-entropy against soft targets."""
+    logp = F.log_softmax(logits.float(), dim=-1)
+    return -(q.float() * logp).sum(-1).mean()
+
+
+def bernoulli_brier(logit, q):
+    """logit [B] for P(yes); q [B] in [0,1] target probability."""
+    p = torch.sigmoid(logit.float())
+    return ((p - q.float()) ** 2).mean()
+
+
+def crps_loss(level_logits, q, pad_mask=None):
+    """CRPS over ordered levels: sum over thresholds of (F_p - F_q)^2.
+
+    level_logits [B, L] over L ordered levels; q [B, L] target distribution
+    (one-hot for a known level). Respects ordinality — mass far from the truth
+    costs more than mass near it.
+    """
+    p = F.softmax(level_logits.float(), dim=-1)
+    Fp = p.cumsum(-1)
+    Fq = q.float().cumsum(-1)
+    return ((Fp - Fq) ** 2)[:, :-1].sum(-1).mean()  # last CDF entry is always 1
+
+
+def choice_loss(logits, q, w_brier=1.0, w_ce=0.1):
+    return w_brier * brier_loss(logits, q) + w_ce * ce_loss(logits, q)
+
+
+def _slog(x):
+    """Signed log1p: monotone, ~identity near 0, log-scale for big |x|."""
+    return torch.sign(x) * torch.log1p(x.abs())
+
+
+def pinball_loss(pred_quantiles, target_quantiles, taus):
+    """Pinball in signed-log space, normalized by mean|slog(target)|.
+
+    Quantiles commute with monotone transforms, so minimizing
+    pinball(slog(p), slog(t)) still gives p -> t in real space, but errors
+    on $1e5-scale targets get proportional gradients instead of being
+    normalized away (or dominating) the loss."""
+    t = torch.tensor(taus, device=pred_quantiles.device).float()
+    p = _slog(pred_quantiles.float())
+    y = _slog(target_quantiles.float())
+    diff = y - p
+    scale = y.abs().mean(dim=-1, keepdim=True).clamp_min(1e-3)
+    return (torch.maximum(t * diff, (t - 1) * diff) / scale).mean()