lamba_cpu: kalibre bayraklari (ANG_SIGN/ANG_DT/ROPE_INTER) grid-search icin

code/kod/lamba_cpu.py

@@ -33,6 +33,11 @@ def rms_norm(x, w, eps=1e-5):
 
 # ───────────── Mamba-3 mixer (saf-PyTorch, fork matematiği) ─────────────
 class Mamba3CPU(nn.Module):
+    # KALİBRE bayrakları (Colab grid-search ile fork'a karşı belirlenir)
+    ANG_SIGN = 1.0       # angle birikim işareti (+1 / -1)
+    ANG_DT = True        # increment DT ile ölçekli mi (DT·ang vs ang)
+    ROPE_INTER = False   # RoPE: interleaved (True) vs pairwise j↔j+n (False)
+
     def __init__(self, cfg):
         super().__init__()
         d = cfg["d_model"]
@@ -58,15 +63,20 @@ class Mamba3CPU(nn.Module):
         self.B_norm = nn.Parameter(torch.ones(bc))
         self.C_norm = nn.Parameter(torch.ones(bc))
 
-    def _rope_pairwise(self, t, cos, sin):
-        """rope_fraction=0.5 pairwise: ilk `rot` boyutta j ↔ j+rot/2 çiftleri döner; gerisi sabit.
-        t: (..., d_state)  cos/sin: (..., n_ang)"""
+    def _rope(self, t, cos, sin):
+        """Partial RoPE (ilk `rot`=d_state/2 boyut döner; gerisi sabit).
+        pairwise: j ↔ j+n çiftleri | interleaved: (2j, 2j+1) çiftleri."""
         rot, n = self.rot, self.n_ang
-        a = t[..., :n]            # ilk yarı (döner çift sol)
-        b = t[..., n:rot]         # ikinci yarı (döner çift sağ)
-        ra = a * cos - b * sin
-        rb = a * sin + b * cos
-        return torch.cat([ra, rb, t[..., rot:]], dim=-1)
+        rest = t[..., rot:]
+        if Mamba3CPU.ROPE_INTER:
+            head = t[..., :rot]
+            x1, x2 = head[..., 0::2], head[..., 1::2]
+            ra, rb = x1 * cos - x2 * sin, x1 * sin + x2 * cos
+            out = torch.stack([ra, rb], dim=-1).flatten(-2)
+            return torch.cat([out, rest], dim=-1)
+        a, b = t[..., :n], t[..., n:rot]
+        ra, rb = a * cos - b * sin, a * sin + b * cos
+        return torch.cat([ra, rb, rest], dim=-1)
 
     def forward(self, u):
         """u: (B, L, d_model) → (B, L, d_model). Token-token recurrence."""
@@ -96,10 +106,13 @@ class Mamba3CPU(nn.Module):
         cum = torch.zeros(B, H, self.n_ang)
         ys = []
         for t in range(L):
-            cum = cum - DT[:, t].unsqueeze(-1) * ang[:, t].float().unsqueeze(1)   # (B,H,n_ang)  # KALİBRE: negatif birikim (minimal gibi)
+            inc = ang[:, t].float().unsqueeze(1)                         # (B,1,n_ang)→broadcast head
+            if Mamba3CPU.ANG_DT:
+                inc = inc * DT[:, t].unsqueeze(-1)                       # DT ölçeği
+            cum = cum + Mamba3CPU.ANG_SIGN * inc                         # (B,H,n_ang)
             cos, sin = torch.cos(cum), torch.sin(cum)
-            Bk = self._rope_pairwise(Bm[:, t], cos, sin)                # (B,H,S)
-            Cq = self._rope_pairwise(Cm[:, t], cos, sin)
+            Bk = self._rope(Bm[:, t], cos, sin)                         # (B,H,S)
+            Cq = self._rope(Cm[:, t], cos, sin)
             xt = x[:, t]                                                # (B,H,P)
             a = alpha[:, t].view(B, H, 1, 1)
             diff = (beta[:, t].view(B, H, 1, 1) * x_prev.unsqueeze(-1) * Bk_prev.unsqueeze(-2)