Upload alea/ngram.py with huggingface_hub

alea/ngram.py

@@ -77,8 +77,65 @@ class NGramEncoder(nn.Module):
         return self.proj(torch.cat(feats, dim=-1))
 
 
+class NGramEncoderMH(nn.Module):
+    """Multi-hash compositional n-gram encoder.
+
+    Improvements over NGramEncoder at fixed param budget:
+    - K=2 independent tables per order; a collision must hit BOTH tables
+      to fully collide (effective capacity >> single table of same size).
+    - Thin rows (d_ng=64) buy 2x table coverage vs d_ng=128.
+    - Bucket budgets skewed toward higher orders (heavier tails).
+
+    Table pair per order uses a quotient-remainder split of one rolling
+    hash: h mod B1 selects row in table1, h // B1 selects row in table2
+    (valid since h < B1*B2 and B1*B2*P < 2^63 for B<=2M).
+    """
+
+    def __init__(self, d_model, orders=(3, 4, 5, 6), b1=262144, b2=262144,
+                 d_ng=64):
+        super().__init__()
+        self.orders = tuple(orders)
+        self.b1, self.b2 = b1, b2
+        self.mod = b1 * b2
+        self.embs1 = nn.ModuleList(
+            [nn.Embedding(b1, d_ng) for _ in self.orders])
+        self.embs2 = nn.ModuleList(
+            [nn.Embedding(b2, d_ng) for _ in self.orders])
+        for e in list(self.embs1) + list(self.embs2):
+            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):
+        """Rolling hash mod (b1*b2) -> (idx1, idx2), each [B,L]."""
+        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.mod
+        return h % self.b1, h // self.b1
+
+    def forward(self, input_ids):
+        feats = []
+        for e1, e2, n in zip(self.embs1, self.embs2, self.orders):
+            i1, i2 = self._hash(input_ids, n)
+            feats.append(e1(i1) + e2(i2))
+        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
+
+
+def ngram_mh_param_count(d_model, orders=(3, 4, 5, 6), b1=262144,
+                         b2=262144, d_ng=64):
+    return len(orders) * ((b1 + b2) * d_ng + d_ng * d_model)