Upload alea/model.py with huggingface_hub

alea/model.py

@@ -0,0 +1,150 @@
+"""AleaModel: pretrained LM trunk + structured-mask packing + set readout heads.
+
+One forward pass answers all questions in a request:
+  - state encoded once (state tokens are blind to question tokens -> cacheable)
+  - question contexts and option spans are isolated branches off the state
+  - options share position_ids and never see each other -> permutation invariant
+  - ISAB set head reintroduces option interaction without order dependence
+"""
+import torch
+import torch.nn as nn
+from transformers import AutoModel
+
+from .heads import SetChoiceHead, NoulHead, RegressHead
+from .ngram import AuxEmbedding, NGramEncoder
+from .packing import build_additive_mask, SEG_OPT, SEG_ANS, SEG_QCTX, SEG_STATE
+
+
+class AleaModel(nn.Module):
+    def __init__(self, model_name="Qwen/Qwen3-0.6B", n_inducing=16,
+                 use_set_attn=True, attn_impl="eager",
+                 use_aux_embed=False, use_ngram=False,
+                 ngram_orders=(2, 3, 4), ngram_buckets=262144, d_ng=128,
+                 use_ngram2=False):
+        super().__init__()
+        self.backbone = AutoModel.from_pretrained(
+            model_name, torch_dtype=torch.bfloat16,
+            attn_implementation=attn_impl)
+        d = self.backbone.config.hidden_size
+        self.dim = d
+        self.choice_head = SetChoiceHead(d, n_inducing, use_set_attn=use_set_attn)
+        self.score_head = SetChoiceHead(d, n_inducing, use_set_attn=use_set_attn)
+        self.noul_head = NoulHead(d)
+        self.regress_head = RegressHead(d)
+        vocab = self.backbone.config.vocab_size
+        self.aux_embed = AuxEmbedding(vocab, d) if use_aux_embed else None
+        self.ngram = (NGramEncoder(d, ngram_orders, ngram_buckets, d_ng)
+                      if use_ngram else None)
+        # second bank: longer orders + bigger hash space, separate gate
+        self.ngram2 = (NGramEncoder(d, (5, 6, 7, 8), 524288, d_ng)
+                       if use_ngram2 else None)
+
+    def _input_embeds(self, input_ids):
+        emb = self.backbone.embed_tokens(input_ids)
+        add = None
+        if self.aux_embed is not None:
+            add = self.aux_embed(input_ids)
+        if self.ngram is not None:
+            ng = self.ngram(input_ids)
+            add = ng if add is None else add + ng
+        if self.ngram2 is not None:
+            ng2 = self.ngram2(input_ids)
+            add = ng2 if add is None else add + ng2
+        if add is not None:
+            emb = emb + add.to(emb.dtype)
+        return emb
+
+    def forward(self, input_ids, attention_mask, position_ids, packeds):
+        """input_ids [B,L] int, attention_mask [B,1,L,L] float additive,
+        position_ids [B,L] int, packeds: list[Packed] of len B.
+        Returns list[list[dict]] — per sequence, per question:
+          {'qtype','logits' (choice/score) or 'p_yes' (noul)}"""
+        if (self.aux_embed is not None or self.ngram is not None
+                or self.ngram2 is not None):
+            out = self.backbone(inputs_embeds=self._input_embeds(input_ids),
+                                attention_mask=attention_mask,
+                                position_ids=position_ids)
+        else:
+            out = self.backbone(input_ids=input_ids,
+                                attention_mask=attention_mask,
+                                position_ids=position_ids)
+        H = out.last_hidden_state.float()          # [B, L, d]
+
+        results = []
+        for b, pk in enumerate(packeds):
+            hs = H[b]
+            qres = []
+            for qi, q in enumerate(pk.questions):
+                if q.qtype in ("choice", "score"):
+                    embs = []
+                    for (s, e) in pk.option_spans[qi]:
+                        embs.append(hs[s:e + 1].mean(0))
+                    O = torch.stack(embs)[None]    # [1, n, d]
+                    head = self.choice_head if q.qtype == "choice" else self.score_head
+                    logits = head(O)[0]            # [n]
+                    qres.append({"qid": q.qid, "qtype": q.qtype, "logits": logits})
+                elif q.qtype == "noul":
+                    a = pk.ans_pos[qi]
+                    p = torch.sigmoid(self.noul_head(hs[a]))
+                    qres.append({"qid": q.qid, "qtype": "noul", "p_yes": p})
+                elif q.qtype == "regress":
+                    a = pk.ans_pos[qi]
+                    qu = self.regress_head(hs[a][None])[0]   # [19] taus .05-.95
+                    qres.append({"qid": q.qid, "qtype": "regress",
+                                 "quantiles": qu})
+                else:
+                    raise ValueError(q.qtype)
+            results.append(qres)
+        return results
+
+
+def collate(packeds, pad_id):
+    """Pad a list of Packed into batched tensors (ids, additive mask, pos)."""
+    ids, pos, seg, qof, oof = collate_segments(packeds, pad_id)
+    mask = mask_from_segments(seg, qof, oof)
+    return ids, mask, pos
+
+
+def collate_segments(packeds, pad_id):
+    """Pad to (ids, pos, seg, qof, oof) — mask built later (optionally on GPU)."""
+    import torch
+    B = len(packeds)
+    L = max(len(p.input_ids) for p in packeds)
+    ids = torch.full((B, L), pad_id, dtype=torch.long)
+    pos = torch.zeros(B, L, dtype=torch.long)
+    seg = torch.zeros(B, L, dtype=torch.long)
+    qof = torch.full((B, L), -1, dtype=torch.long)
+    oof = torch.full((B, L), -1, dtype=torch.long)
+    for b, pk in enumerate(packeds):
+        l = len(pk.input_ids)
+        ids[b, :l] = torch.tensor(pk.input_ids)
+        pos[b, :l] = torch.tensor(pk.position_ids)
+        seg[b, :l] = torch.tensor(pk.seg_types)
+        qof[b, :l] = torch.tensor(pk.q_of)
+        oof[b, :l] = torch.tensor(pk.opt_of)
+    return ids, pos, seg, qof, oof
+
+
+def mask_from_segments(seg, qof, oof, neg=-1e9):
+    """Vectorized additive mask [B,1,L,L] from segment/question/option ids.
+    Runs on whatever device the inputs live on."""
+    import torch
+    a = seg[:, :, None]                      # [B, L, 1] query segment
+    b = seg[:, None, :]                      # [B, 1, L] key segment
+    same_q = (qof[:, :, None] == qof[:, None, :]) & (qof[:, :, None] >= 0)
+    same_opt = same_q & (oof[:, :, None] == oof[:, None, :]) & (oof[:, :, None] >= 0)
+
+    allowed = (
+        ((a == SEG_STATE) & (b == SEG_STATE))
+        | ((a == SEG_QCTX) & ((b == SEG_STATE) | ((b == SEG_QCTX) & same_q)))
+        | ((a == SEG_OPT) & ((b == SEG_STATE) | ((b == SEG_QCTX) & same_q)
+                             | ((b == SEG_OPT) & same_opt)))
+        | ((a == SEG_ANS) & ((b == SEG_STATE)
+                             | (((b == SEG_QCTX) | (b == SEG_OPT)
+                                 | (b == SEG_ANS)) & same_q))))
+    # padded query rows (seg==0) -> all-allowed (their outputs are dead)
+    allowed = allowed | (a == 0)
+    mask = torch.full(allowed.shape, neg, dtype=torch.float32,
+                    device=allowed.device)
+    mask[allowed] = 0.0
+    return mask[:, None]