Upload alea/heads.py with huggingface_hub

alea/heads.py

@@ -0,0 +1,103 @@
+"""Set readout heads: ISAB (Induced Set Attention Block) + per-option scoring.
+
+ISAB (Lee et al. 2019, Set Transformer): options interact through m learned
+inducing points instead of directly with each other — O(mn) instead of O(n^2),
+and permutation-equivariant by construction (no positional encoding on the set).
+"""
+import torch
+import torch.nn as nn
+
+
+class MAB(nn.Module):
+    """Multihead Attention Block: X -> X + MHA(LN(X), LN(Y)); X -> X + FFN(LN(X))."""
+
+    def __init__(self, dim, heads=8, ff_mult=2):
+        super().__init__()
+        self.attn = nn.MultiheadAttention(dim, heads, batch_first=True)
+        self.ln_q = nn.LayerNorm(dim)
+        self.ln_kv = nn.LayerNorm(dim)
+        self.ff = nn.Sequential(
+            nn.Linear(dim, ff_mult * dim), nn.GELU(), nn.Linear(ff_mult * dim, dim)
+        )
+        self.ln_ff = nn.LayerNorm(dim)
+
+    def forward(self, x, y, key_padding_mask=None):
+        """key_padding_mask: [B, len_y] bool, True = position to ignore."""
+        h, _ = self.attn(self.ln_q(x), self.ln_kv(y), self.ln_kv(y),
+                         key_padding_mask=key_padding_mask, need_weights=False)
+        x = x + h
+        x = x + self.ff(self.ln_ff(x))
+        return x
+
+
+class ISAB(nn.Module):
+    def __init__(self, dim, n_inducing=16, heads=8):
+        super().__init__()
+        self.inducing = nn.Parameter(torch.randn(1, n_inducing, dim) * 0.02)
+        self.mab_i = MAB(dim, heads)   # inducing points read the set
+        self.mab_o = MAB(dim, heads)   # set members read inducing points
+
+    def forward(self, x, key_padding_mask=None):
+        """x: [B, n, d] set embeddings; key_padding_mask: [B, n] True = pad."""
+        I = self.inducing.expand(x.size(0), -1, -1)
+        H = self.mab_i(I, x, key_padding_mask=key_padding_mask)
+        return self.mab_o(x, H)
+
+
+class SetChoiceHead(nn.Module):
+    """Options -> ISAB -> per-option logit -> softmax over the option set."""
+
+    def __init__(self, dim, n_inducing=16, heads=8, use_set_attn=True):
+        super().__init__()
+        self.inp = nn.Sequential(nn.LayerNorm(dim), nn.Linear(dim, dim), nn.GELU())
+        self.isab = ISAB(dim, n_inducing, heads) if use_set_attn else None
+        self.out = nn.Linear(dim, 1)
+
+    def forward(self, opt_emb, pad_mask=None):
+        """opt_emb: [B, n, d]; pad_mask: [B, n] True = padded.
+        Returns logits [B, n] with -inf on padding."""
+        x = self.inp(opt_emb)
+        if self.isab is not None:
+            x = self.isab(x, key_padding_mask=pad_mask)
+        logits = self.out(x).squeeze(-1)
+        if pad_mask is not None:
+            logits = logits.masked_fill(pad_mask, float("-inf"))
+        return logits
+
+
+class NoulHead(nn.Module):
+    """Question summary -> P(yes)."""
+
+    def __init__(self, dim):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.LayerNorm(dim), nn.Linear(dim, dim // 4), nn.GELU(),
+            nn.Linear(dim // 4, 1))
+
+    def forward(self, q_summary):
+        return self.net(q_summary).squeeze(-1)
+
+
+class RegressHead(nn.Module):
+    """Question summary -> monotone quantile vector over a bounded range.
+
+    Predicts a base level plus softplus increments, so quantiles are
+    non-decreasing by construction. N_QUANTILES evenly spaced taus.
+    """
+
+    N_TAU = 19  # taus at 0.05, 0.10, ..., 0.95
+
+    def __init__(self, dim):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.LayerNorm(dim), nn.Linear(dim, dim // 2), nn.GELU(),
+            nn.Linear(dim // 2, self.N_TAU))
+
+    def forward(self, q_summary):
+        raw = self.net(q_summary)                       # [B, 19]
+        base = raw[..., :1]
+        inc = torch.nn.functional.softplus(raw[..., 1:])
+        return torch.cat([base, base + inc.cumsum(-1)], -1)
+
+
+TAUS = [0.05 * (i + 1) for i in range(RegressHead.N_TAU)]