glint_parity_eval: arch-aware loader (Qwen3 cfg from ckpt) - fix 64M maintainer load

glint_parity_eval.py

@@ -180,12 +180,14 @@ def evaluate_arc_easy(logits_fn, tokenizer, device):
 # WIRING NASZEGO MODELU (Monter: wypelnij) -- to jedyna czesc nie-Glint.
 # ---------------------------------------------------------------------------
 def load_our_model(ckpt_path, tokenizer_path, device):
-    """Zwroc (logits_fn, tokenizer). cfg-aware: ckpt["config"] (Qwen3-arch: rope/swiglu/
-    qk_norm/value_residual) -> GPT(...,cfg); legacy nanoGPT (bez config) -> stary 5-arg.
-    Fix Hart 2026-09-24: 64M-flagship = Qwen3, GPT() wymaga cfg + brak pos.weight (rope)."""
+    """Zwroc (logits_fn, tokenizer). logits_fn(ids[B,T]) -> logits[B,T,REAL_VOCAB].
+    TODO Monter: zaimportuj nasza GPT-klase (z train-kodu gollem), zaladuj ckpt,
+    ustaw eval()+to(device). Nasz block=1024 > 256 chunki Glinta wiec forward OK.
+    Wazne: przytnij logits do realnego vocab (bez padded-vocab) jesli mamy padding.
+    Ponizej szkielet - dopasuj do naszej sygnatury forward()."""
     import importlib.util, os
-    from types import SimpleNamespace
-    tokenizer = HFTokenizer.from_file(tokenizer_path)
+    tokenizer = HFTokenizer.from_file(tokenizer_path)  # BPE-12k tokenizer.json
+    # import naszej klasy GPT z train_gpt_ref.py (typowe lokalizacje: pod / lokalnie)
     gpt_src = None
     for cand in ("/workspace/gollem/corpus/scripts/train_gpt_ref.py",
                  os.path.join(os.path.dirname(os.path.abspath(__file__)), "train_gpt_ref.py"),
@@ -199,23 +201,29 @@ def load_our_model(ckpt_path, tokenizer_path, device):
     GPT = tgr.GPT
     ck = torch.load(ckpt_path, map_location="cpu", weights_only=False)
     sd = ck["model"] if isinstance(ck, dict) and "model" in ck else ck
-    sd = {k.replace("_orig_mod.", ""): v for k, v in sd.items()}
-    cfg_d = ck.get("config") if isinstance(ck, dict) else None
-    if cfg_d is not None:
-        cfg = SimpleNamespace(**cfg_d)
-        model = GPT(int(cfg_d["vocab"]), int(cfg_d["n_layer"]), int(cfg_d["n_embd"]),
-                    int(cfg_d["n_head"]), int(cfg_d["block"]), cfg)
-        h = cfg_d["n_head"]
-    else:
-        vocab, n_embd = sd["tok.weight"].shape
+    sd = {k.replace("_orig_mod.", ""): v for k, v in sd.items()}  # strip torch.compile
+    vocab, n_embd = sd["tok.weight"].shape
+    n_layer = 1 + max(int(k.split(".")[1]) for k in sd if k.startswith("blocks."))
+    import types
+    cfgd = ck.get("config") if isinstance(ck, dict) else None
+    if cfgd:  # RB2 arch-aware ckpt: odtworz arch z zapisanego configu
+        cfg = types.SimpleNamespace(
+            norm=cfgd.get("norm", "layernorm"), norm_eps=cfgd.get("norm_eps", 1e-6),
+            pos=cfgd.get("pos", "learned"), rope_theta=cfgd.get("rope_theta", 10000.0),
+            ffn=cfgd.get("ffn", "gelu"), ffn_mult=cfgd.get("ffn_mult", 2.667),
+            value_residual=cfgd.get("value_residual", False), qk_norm=cfgd.get("qk_norm", False))
+        n_head = int(cfgd.get("n_head") or os.environ.get("N_HEAD", "6"))
+        block = int(cfgd.get("block") or (sd["pos.weight"].shape[0] if "pos.weight" in sd else 1024))
+    else:  # legacy pre-RB2 ckpt: LayerNorm / learned-pos / GELU
+        cfg = types.SimpleNamespace(norm="layernorm", norm_eps=1e-6, pos="learned", rope_theta=10000.0,
+                                    ffn="gelu", ffn_mult=2.667, value_residual=False, qk_norm=False)
+        n_head = int(os.environ.get("N_HEAD", "6"))
         block = sd["pos.weight"].shape[0]
-        n_layer = 1 + max(int(k.split(".")[1]) for k in sd if k.startswith("blocks."))
-        h = int(os.environ.get("N_HEAD", "6"))
-        model = GPT(int(vocab), int(n_layer), int(n_embd), int(h), int(block))
-    miss, unexp = model.load_state_dict(sd, strict=False)
-    assert not unexp and miss in ([], ["head.weight"]), (miss, unexp)
+    model = GPT(int(vocab), int(n_layer), int(n_embd), int(n_head), int(block), cfg)
+    model.load_state_dict(sd, strict=True)
     model.eval().to(device)
-    print(f"[load_our_model] cfg={cfg_d is not None} h={h} dev={device} loaded-ok", flush=True)
+    print(f"[load_our_model] vocab={vocab} L={n_layer} d={n_embd} h={n_head} block={block} "
+          f"norm={cfg.norm} pos={cfg.pos} ffn={cfg.ffn} vr={cfg.value_residual} dev={device}", flush=True)
     def logits_fn(ids):
         out = model(ids)
         logits = out[0] if isinstance(out, (tuple, list)) else out