Upload alea/ngram.py with huggingface_hub

alea/ngram.py

@@ -0,0 +1,84 @@
+"""Cheap capacity modules: auxiliary token embedding + hashed n-gram encoder.
+
+Both inject into the backbone's input embeddings through zero-init gates, so a
+model loaded from an existing checkpoint starts bit-identical and the new
+capacity ramps in only where it reduces loss.
+
+AuxEmbedding: a second full embedding table (~150M params on Qwen3 vocab) —
+pure per-token lexical memory, no attention cost.
+
+NGramEncoder: per-position rolling hash of the last n token ids -> embedding
+row. ~100M params across a few orders; adds local-context lexical features the
+transformer spends layers reconstructing.
+"""
+import torch
+import torch.nn as nn
+
+# multiplicative hash constants (odd, < 2^63)
+_HASH_P = 1000003
+_SENTINEL = 1 << 20  # salt added to out-of-range positions so boundary
+                     # n-grams don't collide with interior ones
+
+
+class AuxEmbedding(nn.Module):
+    """Second trainable embedding table, gated additively into input embeds.
+
+    vocab x dim matches the backbone embedding (~155M params for Qwen3-0.6B).
+    Gate starts at 0 -> zero effect at init.
+    """
+
+    def __init__(self, vocab_size, dim):
+        super().__init__()
+        self.emb = nn.Embedding(vocab_size, dim)
+        nn.init.normal_(self.emb.weight, std=0.02)
+        self.gate = nn.Parameter(torch.zeros(1))
+
+    def forward(self, input_ids):
+        return self.gate * self.emb(input_ids)
+
+
+class NGramEncoder(nn.Module):
+    """Per-position n-gram features via rolling hash into embedding buckets.
+
+    For each order n, position i's key is hash(ids[i-n+1..i]) mod buckets.
+    Orders share no parameters; outputs are concatenated and projected to
+    d_model through a zero-init linear (gate is inside the projection).
+    """
+
+    def __init__(self, d_model, orders=(2, 3, 4), buckets=262144, d_ng=128):
+        super().__init__()
+        self.orders = tuple(orders)
+        self.buckets = buckets
+        self.embs = nn.ModuleList(
+            [nn.Embedding(buckets, d_ng) for _ in self.orders])
+        for e in self.embs:
+            nn.init.normal_(e.weight, std=0.02)
+        self.proj = nn.Linear(len(self.orders) * d_ng, d_model)
+        nn.init.zeros_(self.proj.weight)
+        nn.init.zeros_(self.proj.bias)
+
+    def _hash(self, ids, n):
+        """ids [B,L] long -> bucket index [B,L] of the n-gram ending at i."""
+        B, L = ids.shape
+        dev = ids.device
+        h = torch.zeros(B, L, dtype=torch.long, device=dev)
+        for k in range(n - 1, -1, -1):
+            shifted = torch.full_like(ids, _SENTINEL)
+            if k > 0:
+                shifted[:, k:] = ids[:, :-k]
+            else:
+                shifted = ids
+            h = (h * _HASH_P + shifted) % self.buckets
+        return h
+
+    def forward(self, input_ids):
+        feats = [emb(self._hash(input_ids, n))
+                 for emb, n in zip(self.embs, self.orders)]
+        return self.proj(torch.cat(feats, dim=-1))
+
+
+def ngram_param_count(vocab_size, d_model, orders=(2, 3, 4),
+                      buckets=262144, d_ng=128):
+    ngram = len(orders) * buckets * d_ng + len(orders) * d_ng * d_model
+    aux = vocab_size * d_model + 1
+    return ngram, aux