faz9_recur: --sweep (k zorluk taramasi, GAP-vs-k trendi = asil GO/NO-GO kaniti)

code/kod/faz9_recur.py

@@ -171,17 +171,15 @@ class FixedDepthLM(nn.Module):
         return self.lm_head(rms_norm(h, self.norm_f))
 
 
-def compare(device="cpu", n_keys=12, k=4, steps=2000, batch=64, d_model=128, lr=1e-3, fast=False):
+def _train_eval(device, n_keys, k, steps, batch, d_model, lr, fast, verbose=True):
+    """Tek k için param-eşit fixed+recurrent eğit → (fix_acc, {R:rec_acc}, n_param)."""
     P, C = 1, 1
     cfg = tiny_cfg(d_model=d_model, vocab_size=n_keys + 1)
     rec = RecurrentDepthLM(cfg, n_prelude=P, n_coda=C, core_attn=True, prenorm_core=False, block_attn=fast).to(device)
     fix = FixedDepthLM(cfg, n_layers=P + 1 + C, all_attn=fast).to(device)
-    print(f"[compare] görev: {k}-hop / {n_keys} anahtar | device={device} | steps={steps} | fast={fast}")
-    print(f"  param: recurrent {_params(rec)/1e6:.3f}M | fixed {_params(fix)/1e6:.3f}M (eşit olmalı)")
 
     def train(model, recurrent):
-        opt = torch.optim.AdamW(model.parameters(), lr=lr)
-        model.train()
+        opt = torch.optim.AdamW(model.parameters(), lr=lr); model.train()
         for s in range(steps):
             ids, tgt = gen_khop(batch, n_keys, k, device)
             R = int(torch.randint(2, 13, (1,))) if recurrent else 1
@@ -189,8 +187,8 @@ def compare(device="cpu", n_keys=12, k=4, steps=2000, batch=64, d_model=128, lr=
             loss = F.cross_entropy(last, tgt)
             opt.zero_grad(); loss.backward()
             torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0); opt.step()
-            if s % max(1, steps // 5) == 0:
-                print(f"    {'REC' if recurrent else 'FIX'} step {s:>4} loss {loss.item():.3f}")
+            if verbose and s % max(1, steps // 4) == 0:
+                print(f"    {'REC' if recurrent else 'FIX'} k={k} step {s:>4} loss {loss.item():.3f}")
 
     @torch.no_grad()
     def acc(model, recurrent, R=8, n=1000):
@@ -198,17 +196,44 @@ def compare(device="cpu", n_keys=12, k=4, steps=2000, batch=64, d_model=128, lr=
         last = (model(ids, R=R) if recurrent else model(ids))[:, -1]
         return (last.argmax(-1) == tgt).float().mean().item()
 
-    print("  --- FIXED eğitiliyor ---"); train(fix, False)
-    print("  --- RECURRENT eğitiliyor ---"); train(rec, True)
+    train(fix, False); train(rec, True)
+    rec_by_R = {R: acc(rec, True, R=R) for R in (1, 2, 4, 8, 16)}
+    return acc(fix, False), rec_by_R, _params(rec)
+
+
+def compare(device="cpu", n_keys=12, k=4, steps=2000, batch=64, d_model=128, lr=1e-3, fast=False):
+    print(f"[compare] görev: {k}-hop / {n_keys} anahtar | device={device} | steps={steps} | fast={fast}")
+    fa, rec, npar = _train_eval(device, n_keys, k, steps, batch, d_model, lr, fast)
     rnd = 1.0 / n_keys
-    print(f"\n[SONUÇ] (random={rnd:.3f})")
-    print(f"  FIXED (depth {P+1+C}) acc = {acc(fix, False):.3f}")
+    print(f"\n[SONUÇ] param ~{npar/1e6:.3f}M (eşit) | random={rnd:.3f}")
+    print(f"  FIXED (depth 3) acc = {fa:.3f}")
     print(f"  RECURRENT test-zamanı R ölçekleme:")
-    for R in (1, 2, 4, 8, 16):
-        print(f"    R={R:>2} → acc {acc(rec, True, R=R):.3f}")
+    for R, a in rec.items():
+        print(f"    R={R:>2} → acc {a:.3f}")
+    print(f"  GAP (rec_best − fixed) = {max(rec.values()) - fa:+.3f}")
     print("  GO sinyali: recurrent fixed'i geçer VE R↑ ile acc↑ (özellikle R≥k).")
 
 
+def sweep(device="cpu", n_keys=12, ks=(2, 4, 6), steps=2000, batch=64, d_model=128, lr=1e-3, fast=True):
+    """ZORLUK TARAMASI: GAP (rec−fixed) k ile büyüyor mu = recursion derinlikle değer kazanıyor mu."""
+    rnd = 1.0 / n_keys
+    print(f"[sweep] k={list(ks)} / {n_keys} anahtar | device={device} | steps={steps} | fast={fast} | random={rnd:.3f}\n")
+    rows = []
+    for k in ks:
+        fa, rec, npar = _train_eval(device, n_keys, k, steps, batch, d_model, lr, fast, verbose=False)
+        bR = max(rec, key=rec.get); gap = rec[bR] - fa
+        rows.append((k, fa, rec, bR, gap))
+        print(f"  k={k}: FIX {fa:.3f} | REC R1={rec[1]:.2f} R4={rec[4]:.2f} R8={rec[8]:.2f} R16={rec[16]:.2f} "
+              f"| best@R{bR}={rec[bR]:.3f} | GAP {gap:+.3f}")
+    print(f"\n[ÖZET] GAP (rec_best − fixed) — k arttıkça büyümeli (random={rnd:.3f}):")
+    for k, fa, rec, bR, gap in rows:
+        print(f"  k={k}: GAP {gap:+.3f}  {'#' * max(0, int(gap * 60))}")
+    gaps = [r[4] for r in rows]
+    grow = all(gaps[i] <= gaps[i + 1] + 1e-9 for i in range(len(gaps) - 1)) and gaps[-1] > 0.05
+    print(f"\n  → GAP k ile {'✅ ARTIYOR = GO (recursion derinlikle değer kazanıyor)' if grow else '⚠️ ARTMIYOR/karışık = zayıf sinyal'}")
+    print("  → Ayrıca zor k'da REC acc ~R≥k civarında sıçramalı (daha çok düşünme = daha çok hop).")
+
+
 def main():
     ap = argparse.ArgumentParser()
     ap.add_argument("--smoke", action="store_true", help="CPU mekanik smoke (Faz A)")
@@ -219,13 +244,18 @@ def main():
     ap.add_argument("--steps", type=int, default=2000)
     ap.add_argument("--d_model", type=int, default=128)
     ap.add_argument("--fast", action="store_true", help="tüm bloklar attention (Mamba token-loop yok → ~30× hızlı; k-hop için uygun)")
+    ap.add_argument("--sweep", action="store_true", help="Faz B zorluk taraması: k=2/4/6 GAP trendi (asıl GO/NO-GO)")
+    ap.add_argument("--ks", default="2,4,6", help="sweep k değerleri (virgülle, örn. 2,4,6)")
     args = ap.parse_args()
     if args.smoke:
         smoke()
+    elif args.sweep:
+        ks = tuple(int(x) for x in args.ks.split(","))
+        sweep(device=args.device, n_keys=args.n_keys, ks=ks, steps=args.steps, d_model=args.d_model, fast=args.fast)
     elif args.compare:
         compare(device=args.device, n_keys=args.n_keys, k=args.k, steps=args.steps, d_model=args.d_model, fast=args.fast)
     else:
-        print("kullanım: python faz9_recur.py --smoke | --compare [--device cuda --k 4 --n_keys 12 --steps 2000]")
+        print("kullanım: python faz9_recur.py --smoke | --compare | --sweep [--device cuda --n_keys 12 --steps 3000 --fast]")
 
 
 if __name__ == "__main__":