Upload 2 files

v5/eval_inverter_v5_generate.py

@@ -0,0 +1,596 @@
+#!/usr/bin/env python3
+"""
+Eval V5 inverter on GPT-OSS-20B generated text (sliding windows, overlapping).
+
+Fixes / robustness:
+- GPT-OSS does NOT support SDPA in HF currently -> map sdpa -> eager.
+- If flash_attention_2 requested but flash_attn missing -> fallback to eager.
+- IMPORTANT: Do NOT enable output_router_logits during .generate() (it triggers
+  MoE aux-loss path that can crash). We only request router logits in the
+  separate router-collection pass.
+- Auto-enable layer_gating if checkpoint contains encoder_in.layer_gate.
+- By default, override inverter hyperparams from checkpoint config (prevents
+  state_dict shape mismatches).
+"""
+
+import argparse
+import json
+import os
+import random
+import sys
+from dataclasses import dataclass
+from typing import Iterable, List, Tuple
+
+import numpy as np
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from train_inverter_v5 import EncoderOnlyModel
+
+
+# ----------------- misc -----------------
+
+def _set_seed(seed: int) -> None:
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+
+def _default_device() -> str:
+    return "cuda" if torch.cuda.is_available() else "cpu"
+
+
+# ----------------- ckpt helpers -----------------
+
+def _load_ckpt(path: str) -> dict:
+    return torch.load(path, map_location="cpu")
+
+
+def _load_state_dict(path: str) -> dict:
+    ckpt = _load_ckpt(path)
+    state = ckpt.get("model", ckpt)
+    if any(k.startswith("_orig_mod.") for k in state.keys()):
+        state = {k.replace("_orig_mod.", ""): v for k, v in state.items()}
+    return state
+
+
+def _load_ckpt_config(path: str) -> dict:
+    ckpt = _load_ckpt(path)
+    cfg = ckpt.get("config", None)
+    return cfg if isinstance(cfg, dict) else {}
+
+
+# ----------------- router logits reshape -----------------
+
+def _reshape_router_logits(
+    layer_logits: torch.Tensor,
+    batch_size: int,
+    seq_len: int,
+    layer_idx: int,
+) -> torch.Tensor:
+    """Normalize per-layer router logits into [B, S, E]."""
+    if layer_logits.ndim == 3:
+        if layer_logits.shape[0] == batch_size:
+            return layer_logits
+        if layer_logits.shape[1] == batch_size:
+            return layer_logits.permute(1, 0, 2)
+        raise RuntimeError(
+            f"Unexpected 3D router logits shape for layer {layer_idx}: "
+            f"{tuple(layer_logits.shape)} (batch={batch_size}, seq={seq_len})"
+        )
+
+    if layer_logits.ndim == 2:
+        if layer_logits.shape[0] == batch_size * seq_len:
+            return layer_logits.view(batch_size, seq_len, -1)
+        if layer_logits.shape[0] == seq_len and batch_size == 1:
+            return layer_logits.unsqueeze(0)
+        raise RuntimeError(
+            f"Unexpected 2D router logits shape for layer {layer_idx}: "
+            f"{tuple(layer_logits.shape)} (batch={batch_size}, seq={seq_len})"
+        )
+
+    raise RuntimeError(
+        f"Unexpected router logits rank for layer {layer_idx}: {tuple(layer_logits.shape)}"
+    )
+
+
+# ----------------- LLM loading with attention fallback -----------------
+
+def _load_llm_with_fallback(
+    model_name: str,
+    revision: str | None,
+    device: str,
+    attn_impl: str | None,
+):
+    """
+    GPT-OSS in HF:
+      - supports eager
+      - supports flash_attention_2 if flash_attn installed
+      - does NOT support sdpa (errors)
+    """
+    dtype = torch.bfloat16 if device != "cpu" else torch.float32
+
+    def _try(attn: str | None):
+        kwargs = {"revision": revision}
+        if attn is not None:
+            kwargs["attn_implementation"] = attn
+        # Prefer `dtype` (newer stacks), fall back to torch_dtype if needed.
+        try:
+            m = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                dtype=dtype,
+                device_map={"": device} if device != "cpu" else "auto",
+                **kwargs,
+            )
+        except TypeError:
+            m = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                torch_dtype=dtype,
+                device_map={"": device} if device != "cpu" else "auto",
+                **kwargs,
+            )
+        return m
+
+    # Normalize request
+    if attn_impl == "sdpa":
+        print("Note: GPT-OSS does not support SDPA; using eager instead.", file=sys.stderr)
+        attn_impl = "eager"
+
+    tried = []
+    llm = None
+
+    if attn_impl is not None:
+        try:
+            tried.append(attn_impl)
+            llm = _try(attn_impl)
+        except (ImportError, ValueError) as exc:
+            print(f"Warning: attn_implementation={attn_impl} failed: {exc}", file=sys.stderr)
+            llm = None
+
+    if llm is None:
+        if "eager" not in tried:
+            tried.append("eager")
+        llm = _try("eager")
+
+    llm.eval()
+    for p in llm.parameters():
+        p.requires_grad_(False)
+
+    # IMPORTANT: do NOT set llm.config.output_router_logits = True globally.
+    # We only request router logits in the router-collection forward pass.
+
+    # Also try to disable any aux-loss coefficients (harmless for inference).
+    for attr in ("router_aux_loss_coef", "aux_loss_coef", "moe_aux_loss_coef"):
+        if hasattr(llm.config, attr):
+            try:
+                setattr(llm.config, attr, 0.0)
+            except Exception:
+                pass
+
+    return llm, dtype
+
+
+# ----------------- generation -----------------
+
+@torch.inference_mode()
+def generate_tokens(
+    llm,
+    tokenizer,
+    prompt: str,
+    max_new_tokens: int,
+    temperature: float,
+    top_p: float,
+    device: str,
+) -> Tuple[List[int], int]:
+    enc = tokenizer(prompt, return_tensors="pt", add_special_tokens=False)
+    input_ids = enc["input_ids"].to(device)
+    prompt_len = int(input_ids.shape[1])
+
+    # Ensure we do NOT accidentally enable router logits during generation.
+    # Some configs might have it set; force-off temporarily.
+    had_cfg = hasattr(llm, "config")
+    old_output_router = getattr(llm.config, "output_router_logits", None) if had_cfg else None
+    if had_cfg and old_output_router is not None:
+        llm.config.output_router_logits = False
+
+    do_sample = temperature is not None and temperature > 0.0
+    try:
+        gen = llm.generate(
+            input_ids=input_ids,
+            max_new_tokens=max_new_tokens,
+            do_sample=do_sample,
+            temperature=temperature if do_sample else None,
+            top_p=top_p if do_sample else None,
+            use_cache=True,
+            pad_token_id=tokenizer.pad_token_id,
+            eos_token_id=tokenizer.eos_token_id,
+        )
+    finally:
+        if had_cfg and old_output_router is not None:
+            llm.config.output_router_logits = old_output_router
+
+    return gen[0].tolist(), prompt_len
+
+
+# ----------------- router topk collection (chunked KV cache) -----------------
+
+@torch.inference_mode()
+def collect_router_topk_indices_chunked(
+    llm,
+    input_ids_cpu: torch.LongTensor,  # [1, N] on CPU
+    topk: int,
+    chunk_size: int,
+    min_chunk_size: int,
+    save_dtype: torch.dtype = torch.int32,
+) -> torch.Tensor:
+    """
+    Returns:
+      topk_idx_cpu: [N, L, topk] on CPU
+    """
+    if input_ids_cpu.ndim != 2 or input_ids_cpu.shape[0] != 1:
+        raise ValueError("input_ids_cpu must have shape [1, N]")
+
+    device = next(llm.parameters()).device
+    n_tokens = int(input_ids_cpu.shape[1])
+    num_layers = int(llm.config.num_hidden_layers)
+    num_experts = int(llm.config.num_local_experts)
+    if topk > num_experts:
+        raise ValueError(f"router topk={topk} exceeds num_experts={num_experts}")
+
+    topk_idx_cpu = torch.empty((n_tokens, num_layers, topk), dtype=save_dtype, device="cpu")
+
+    past = None
+    pos = 0
+    batch_size = 1
+    chunk_size = max(1, min(int(chunk_size), n_tokens))
+    min_chunk_size = max(1, int(min_chunk_size))
+
+    while pos < n_tokens:
+        current_chunk = min(chunk_size, n_tokens - pos)
+        while True:
+            try:
+                chunk = input_ids_cpu[:, pos : pos + current_chunk].to(device, non_blocking=True)
+                chunk_len = int(chunk.shape[1])
+
+                outputs = llm(
+                    input_ids=chunk,
+                    use_cache=True,
+                    past_key_values=past,
+                    output_router_logits=True,   # ONLY HERE
+                    return_dict=True,
+                )
+                break
+            except torch.cuda.OutOfMemoryError:
+                if device.type != "cuda":
+                    raise
+                torch.cuda.empty_cache()
+                if current_chunk <= min_chunk_size:
+                    raise
+                current_chunk = max(min_chunk_size, current_chunk // 2)
+                chunk_size = min(chunk_size, current_chunk)
+
+        past = outputs.past_key_values
+        router_logits_layers = outputs.router_logits
+        if router_logits_layers is None:
+            raise RuntimeError("outputs.router_logits is None (model may not support router logits)")
+
+        per_layer = []
+        for i, layer_logits in enumerate(router_logits_layers):
+            reshaped = _reshape_router_logits(layer_logits, batch_size, chunk_len, i)  # [1,S,E]
+            per_layer.append(reshaped[0])  # [S,E]
+
+        router_chunk = torch.stack(per_layer, dim=1)  # [S, L, E]
+        idx = torch.topk(router_chunk, k=topk, dim=-1).indices  # [S,L,topk]
+        topk_idx_cpu[pos : pos + chunk_len].copy_(idx.to("cpu", dtype=save_dtype))
+
+        pos += chunk_len
+
+    if device.type == "cuda":
+        torch.cuda.synchronize()
+
+    return topk_idx_cpu
+
+
+# ----------------- sliding windows -----------------
+
+def sliding_windows(
+    token_ids: List[int],
+    expert_topk_idx: torch.Tensor,  # [N, L, K] on CPU
+    seq_len: int,
+    stride: int,
+    pad_id: int,
+) -> Iterable[Tuple[List[int], torch.Tensor, List[bool], List[bool]]]:
+    """
+    Counts each token exactly once:
+      - first window counts all real positions
+      - subsequent windows count only the NEW region (last `stride` positions)
+    """
+    n = len(token_ids)
+    if n == 0:
+        return
+
+    seq_len = int(seq_len)
+    stride = max(1, int(stride))
+    overlap_skip = max(0, seq_len - stride)
+
+    start = 0
+    first = True
+    while start < n:
+        end = min(start + seq_len, n)
+        win_len = end - start
+
+        win_tokens = token_ids[start:end]
+        win_experts = expert_topk_idx[start:end]  # [win_len, L, K]
+
+        if win_len < seq_len:
+            win_tokens = win_tokens + [pad_id] * (seq_len - win_len)
+            if win_len > 0:
+                pad_row = win_experts[-1].unsqueeze(0)  # [1,L,K]
+            else:
+                pad_row = torch.zeros_like(expert_topk_idx[:1])
+            pad_block = pad_row.expand(seq_len - win_len, -1, -1)
+            win_experts = torch.cat([win_experts, pad_block], dim=0)
+
+        attention_mask = [True] * win_len + [False] * (seq_len - win_len)
+
+        if first:
+            eval_mask = [True] * seq_len
+            first = False
+        else:
+            eval_mask = [False] * overlap_skip + [True] * (seq_len - overlap_skip)
+
+        yield win_tokens, win_experts, attention_mask, eval_mask
+        start += stride
+
+
+# ----------------- main -----------------
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Eval V5 inverter on GPT-OSS-20B generated text (sliding windows)."
+    )
+    parser.add_argument("--checkpoint", required=True)
+
+    # LLM
+    parser.add_argument("--model", default="openai/gpt-oss-20b")
+    parser.add_argument("--model-revision", default=None)
+    parser.add_argument(
+        "--attn-impl",
+        choices=["auto", "flash_attention_2", "sdpa", "eager"],
+        default="auto",
+        help="GPT-OSS: flash_attention_2 (needs flash_attn) or eager. sdpa maps to eager.",
+    )
+
+    # Generation
+    parser.add_argument("--prompt", action="append", default=None)
+    parser.add_argument("--gen-tokens", type=int, default=2048)
+    parser.add_argument("--temperature", type=float, default=1.0)
+    parser.add_argument("--top-p", type=float, default=0.95)
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument("--segments", type=int, default=1)
+    parser.add_argument("--include-prompt", action="store_true")
+
+    # Router collection
+    parser.add_argument("--router-topk", type=int, default=4)
+    parser.add_argument("--router-chunk-size", type=int, default=1024)
+    parser.add_argument("--router-min-chunk-size", type=int, default=128)
+
+    # Sliding window eval
+    parser.add_argument("--seq-len", type=int, default=32)
+    parser.add_argument("--stride", type=int, default=8)
+    parser.add_argument("--batch-size", type=int, default=8)
+    parser.add_argument("--eval-topk", default="1,5,10")
+
+    # Inverter arch (overridden from ckpt config by default)
+    parser.add_argument("--use-ckpt-config", action="store_true", default=True)
+    parser.add_argument("--no-use-ckpt-config", action="store_false", dest="use_ckpt_config")
+    parser.add_argument("--layers", type=int, default=24)
+    parser.add_argument("--d-model", type=int, default=768)
+    parser.add_argument("--n-head", type=int, default=12)
+    parser.add_argument("--d-ff", type=int, default=2048)
+    parser.add_argument("--n-layer", type=int, default=6)
+    parser.add_argument("--layer-hidden", type=int, default=64)
+    parser.add_argument("--layer-proj", type=int, default=64)
+    parser.add_argument("--dropout", type=float, default=0.1)
+    parser.add_argument("--logit-softcap", type=float, default=0.0)
+    parser.add_argument("--layer-gating", action="store_true", default=False)
+
+    parser.add_argument("--hard-exit", action="store_true")
+    parser.add_argument("--debug", action="store_true")
+    args = parser.parse_args()
+
+    device = _default_device()
+    if device == "cuda":
+        torch.backends.cuda.matmul.allow_tf32 = True
+        torch.backends.cudnn.allow_tf32 = True
+        torch.set_float32_matmul_precision("high")
+
+    _set_seed(args.seed)
+
+    # Load ckpt config/state early
+    ckpt_cfg = _load_ckpt_config(args.checkpoint)
+    state_dict = _load_state_dict(args.checkpoint)
+
+    # Auto-enable gating if checkpoint has it
+    ckpt_has_gate = bool(ckpt_cfg.get("layer_gating", False)) or ("encoder_in.layer_gate" in state_dict)
+    if ckpt_has_gate and not args.layer_gating:
+        print("Note: checkpoint contains encoder_in.layer_gate; enabling layer_gating for eval.", file=sys.stderr)
+        args.layer_gating = True
+
+    # Override arch from checkpoint config to avoid mismatches
+    if args.use_ckpt_config and ckpt_cfg:
+        mapping = {
+            "seq_len": "seq_len",
+            "layers": "layers",
+            "d_model": "d_model",
+            "n_head": "n_head",
+            "d_ff": "d_ff",
+            "n_layer": "n_layer",
+            "layer_hidden": "layer_hidden",
+            "layer_proj": "layer_proj",
+            "dropout": "dropout",
+            "logit_softcap": "logit_softcap",
+        }
+        for ck, ak in mapping.items():
+            if ck in ckpt_cfg:
+                setattr(args, ak, ckpt_cfg[ck])
+
+    # Tokenizer + LLM
+    tokenizer = AutoTokenizer.from_pretrained(args.model, revision=args.model_revision)
+    if tokenizer.pad_token_id is None:
+        tokenizer.pad_token_id = tokenizer.eos_token_id
+
+    attn_impl = args.attn_impl
+    if attn_impl == "auto":
+        attn_impl = "flash_attention_2" if device != "cpu" else "eager"
+
+    llm, _llm_dtype = _load_llm_with_fallback(args.model, args.model_revision, device, attn_impl)
+
+    # Build inverter
+    inv = EncoderOnlyModel(
+        vocab_size=len(tokenizer),
+        num_experts=32,
+        num_layers=int(args.layers),
+        topk=int(args.router_topk),
+        d_model=int(args.d_model),
+        n_head=int(args.n_head),
+        d_ff=int(args.d_ff),
+        n_layer=int(args.n_layer),
+        dropout=float(args.dropout),
+        max_len=int(args.seq_len),
+        layer_gating=bool(args.layer_gating),
+        logit_softcap=float(args.logit_softcap),
+        layer_hidden=int(args.layer_hidden),
+        layer_proj=int(args.layer_proj),
+    ).to(device)
+
+    inv.load_state_dict(state_dict, strict=True)
+    inv.eval()
+
+    eval_topk = sorted({int(x) for x in args.eval_topk.split(",") if x.strip() and int(x) > 0})
+    correct = {k: 0 for k in eval_topk}
+    total = 0
+
+    prompts = args.prompt or [
+        "Write a concise overview of black holes, including formation, event horizon, and Hawking radiation.\n\n",
+        "Explain transformers and attention in simple terms.\n\n",
+        "A dialogue between a detective and a chef.\n\n",
+        "Summarize the pros and cons of open-source AI models.\n\n",
+    ]
+
+    def run_window_batch(batch_tokens, batch_experts, batch_attn, batch_evalmask):
+        nonlocal total
+        input_ids = torch.tensor(batch_tokens, dtype=torch.long, device=device)
+        expert_idx = torch.stack(batch_experts, dim=0).to(device=device, dtype=torch.long)  # [B,S,L,K]
+        attention_mask = torch.tensor(batch_attn, dtype=torch.bool, device=device)
+        eval_mask = torch.tensor(batch_evalmask, dtype=torch.bool, device=device)
+        count_mask = attention_mask & eval_mask
+
+        with torch.autocast(device_type=device, dtype=torch.bfloat16, enabled=(device == "cuda")):
+            logits = inv(expert_idx, attention_mask)
+
+        for k in eval_topk:
+            topk_pred = torch.topk(logits, k=k, dim=-1).indices
+            match = (topk_pred == input_ids.unsqueeze(-1)).any(dim=-1)
+            match = match & count_mask
+            correct[k] += int(match.sum().item())
+
+        total += int(count_mask.sum().item())
+
+    # segments
+    for seg in range(int(args.segments)):
+        prompt = prompts[seg % len(prompts)]
+
+        full_ids, prompt_len = generate_tokens(
+            llm=llm,
+            tokenizer=tokenizer,
+            prompt=prompt,
+            max_new_tokens=max(1, int(args.gen_tokens)),
+            temperature=float(args.temperature),
+            top_p=float(args.top_p),
+            device=device,
+        )
+
+        # Collect router indices on full sequence
+        input_ids_cpu = torch.tensor([full_ids], dtype=torch.long, device="cpu")
+        topk_idx_cpu = collect_router_topk_indices_chunked(
+            llm=llm,
+            input_ids_cpu=input_ids_cpu,
+            topk=int(args.router_topk),
+            chunk_size=max(1, int(args.router_chunk_size)),
+            min_chunk_size=max(1, int(args.router_min_chunk_size)),
+            save_dtype=torch.int32,
+        )  # [N, L, K] CPU
+
+        if (not args.include_prompt) and prompt_len > 0:
+            token_ids = full_ids[prompt_len:]
+            topk_idx_cpu = topk_idx_cpu[prompt_len:]
+        else:
+            token_ids = full_ids
+
+        if len(token_ids) == 0:
+            continue
+
+        # truncate router layers
+        L = int(args.layers)
+        topk_idx_cpu = topk_idx_cpu[:, :L, :]
+
+        # sliding eval
+        batch_tokens = []
+        batch_experts = []
+        batch_attn = []
+        batch_evalmask = []
+
+        for win_tokens, win_experts, attn_mask, eval_mask in sliding_windows(
+            token_ids=token_ids,
+            expert_topk_idx=topk_idx_cpu,
+            seq_len=int(args.seq_len),
+            stride=int(args.stride),
+            pad_id=int(tokenizer.pad_token_id),
+        ):
+            batch_tokens.append(win_tokens)
+            batch_experts.append(win_experts)
+            batch_attn.append(attn_mask)
+            batch_evalmask.append(eval_mask)
+
+            if len(batch_tokens) >= int(args.batch_size):
+                run_window_batch(batch_tokens, batch_experts, batch_attn, batch_evalmask)
+                batch_tokens, batch_experts, batch_attn, batch_evalmask = [], [], [], []
+
+        if batch_tokens:
+            run_window_batch(batch_tokens, batch_experts, batch_attn, batch_evalmask)
+
+    acc = {str(k): (correct[k] / total if total > 0 else 0.0) for k in eval_topk}
+
+    if args.debug:
+        vals = [acc[str(k)] for k in eval_topk]
+        if any(vals[i] > vals[i + 1] + 1e-9 for i in range(len(vals) - 1)):
+            print("WARNING: accuracy is not monotonic with k; check eval.", file=sys.stderr)
+
+    result = {
+        "tokens": int(total),
+        "accuracy": acc,
+        "config": {
+            "llm": args.model,
+            "checkpoint": args.checkpoint,
+            "seq_len": int(args.seq_len),
+            "stride": int(args.stride),
+            "layers": int(args.layers),
+            "router_topk": int(args.router_topk),
+            "segments": int(args.segments),
+            "gen_tokens_per_segment": int(args.gen_tokens),
+            "include_prompt": bool(args.include_prompt),
+            "attn_impl_requested": args.attn_impl,
+            "layer_gating": bool(args.layer_gating),
+            "use_ckpt_config": bool(args.use_ckpt_config),
+        },
+    }
+    print(json.dumps(result, indent=2))
+
+    if args.hard_exit:
+        os._exit(0)
+
+
+if __name__ == "__main__":
+    main()

v5/eval_inverter_v5_generate_chunks.py

@@ -0,0 +1,561 @@
+#!/usr/bin/env python3
+"""
+Eval V5 inverter on GPT-OSS-20B generated text using NON-overlapping chunks of seq_len
+(default 32). (No sliding windows.)
+
+Fixes / robustness:
+- GPT-OSS does NOT support SDPA in HF currently -> map sdpa -> eager.
+- If flash_attention_2 requested but flash_attn missing -> fallback to eager.
+- IMPORTANT: Do NOT enable output_router_logits during .generate().
+  We only request router logits in the router-collection pass.
+- Auto-enable layer_gating if checkpoint contains encoder_in.layer_gate.
+- By default, override inverter hyperparams from checkpoint config (prevents shape mismatches).
+"""
+
+import argparse
+import json
+import os
+import random
+import sys
+from typing import Iterable, List, Tuple
+
+import numpy as np
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from train_inverter_v5 import EncoderOnlyModel
+
+
+# ----------------- misc -----------------
+
+def _set_seed(seed: int) -> None:
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+
+def _default_device() -> str:
+    return "cuda" if torch.cuda.is_available() else "cpu"
+
+
+# ----------------- ckpt helpers -----------------
+
+def _load_ckpt(path: str) -> dict:
+    return torch.load(path, map_location="cpu")
+
+
+def _load_state_dict(path: str) -> dict:
+    ckpt = _load_ckpt(path)
+    state = ckpt.get("model", ckpt)
+    if any(k.startswith("_orig_mod.") for k in state.keys()):
+        state = {k.replace("_orig_mod.", ""): v for k, v in state.items()}
+    return state
+
+
+def _load_ckpt_config(path: str) -> dict:
+    ckpt = _load_ckpt(path)
+    cfg = ckpt.get("config", None)
+    return cfg if isinstance(cfg, dict) else {}
+
+
+# ----------------- router logits reshape -----------------
+
+def _reshape_router_logits(
+    layer_logits: torch.Tensor,
+    batch_size: int,
+    seq_len: int,
+    layer_idx: int,
+) -> torch.Tensor:
+    """Normalize per-layer router logits into [B, S, E]."""
+    if layer_logits.ndim == 3:
+        if layer_logits.shape[0] == batch_size:
+            return layer_logits
+        if layer_logits.shape[1] == batch_size:
+            return layer_logits.permute(1, 0, 2)
+        raise RuntimeError(
+            f"Unexpected 3D router logits shape for layer {layer_idx}: "
+            f"{tuple(layer_logits.shape)} (batch={batch_size}, seq={seq_len})"
+        )
+
+    if layer_logits.ndim == 2:
+        if layer_logits.shape[0] == batch_size * seq_len:
+            return layer_logits.view(batch_size, seq_len, -1)
+        if layer_logits.shape[0] == seq_len and batch_size == 1:
+            return layer_logits.unsqueeze(0)
+        raise RuntimeError(
+            f"Unexpected 2D router logits shape for layer {layer_idx}: "
+            f"{tuple(layer_logits.shape)} (batch={batch_size}, seq={seq_len})"
+        )
+
+    raise RuntimeError(
+        f"Unexpected router logits rank for layer {layer_idx}: {tuple(layer_logits.shape)}"
+    )
+
+
+# ----------------- LLM loading with attention fallback -----------------
+
+def _load_llm_with_fallback(
+    model_name: str,
+    revision: str | None,
+    device: str,
+    attn_impl: str | None,
+):
+    """
+    GPT-OSS in HF:
+      - supports eager
+      - supports flash_attention_2 if flash_attn installed
+      - does NOT support sdpa (errors)
+    """
+    dtype = torch.bfloat16 if device != "cpu" else torch.float32
+
+    def _try(attn: str | None):
+        kwargs = {"revision": revision}
+        if attn is not None:
+            kwargs["attn_implementation"] = attn
+        try:
+            m = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                dtype=dtype,
+                device_map={"": device} if device != "cpu" else "auto",
+                **kwargs,
+            )
+        except TypeError:
+            m = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                torch_dtype=dtype,
+                device_map={"": device} if device != "cpu" else "auto",
+                **kwargs,
+            )
+        return m
+
+    if attn_impl == "sdpa":
+        print("Note: GPT-OSS does not support SDPA; using eager instead.", file=sys.stderr)
+        attn_impl = "eager"
+
+    tried = []
+    llm = None
+
+    if attn_impl is not None:
+        try:
+            tried.append(attn_impl)
+            llm = _try(attn_impl)
+        except (ImportError, ValueError) as exc:
+            print(f"Warning: attn_implementation={attn_impl} failed: {exc}", file=sys.stderr)
+            llm = None
+
+    if llm is None:
+        if "eager" not in tried:
+            tried.append("eager")
+        llm = _try("eager")
+
+    llm.eval()
+    for p in llm.parameters():
+        p.requires_grad_(False)
+
+    # Do NOT set output_router_logits globally.
+    for attr in ("router_aux_loss_coef", "aux_loss_coef", "moe_aux_loss_coef"):
+        if hasattr(llm.config, attr):
+            try:
+                setattr(llm.config, attr, 0.0)
+            except Exception:
+                pass
+
+    return llm, dtype
+
+
+# ----------------- generation -----------------
+
+@torch.inference_mode()
+def generate_tokens(
+    llm,
+    tokenizer,
+    prompt: str,
+    max_new_tokens: int,
+    temperature: float,
+    top_p: float,
+    device: str,
+) -> Tuple[List[int], int]:
+    enc = tokenizer(prompt, return_tensors="pt", add_special_tokens=False)
+    input_ids = enc["input_ids"].to(device)
+    prompt_len = int(input_ids.shape[1])
+
+    # Force router logits OFF during generation (prevents GPT-OSS aux-loss crash).
+    old_output_router = getattr(llm.config, "output_router_logits", None)
+    if old_output_router is not None:
+        llm.config.output_router_logits = False
+
+    do_sample = temperature is not None and temperature > 0.0
+    try:
+        gen = llm.generate(
+            input_ids=input_ids,
+            max_new_tokens=max_new_tokens,
+            do_sample=do_sample,
+            temperature=temperature if do_sample else None,
+            top_p=top_p if do_sample else None,
+            use_cache=True,
+            pad_token_id=tokenizer.pad_token_id,
+            eos_token_id=tokenizer.eos_token_id,
+        )
+    finally:
+        if old_output_router is not None:
+            llm.config.output_router_logits = old_output_router
+
+    return gen[0].tolist(), prompt_len
+
+
+# ----------------- router topk collection (chunked KV cache) -----------------
+
+@torch.inference_mode()
+def collect_router_topk_indices_chunked(
+    llm,
+    input_ids_cpu: torch.LongTensor,  # [1, N] on CPU
+    topk: int,
+    chunk_size: int,
+    min_chunk_size: int,
+    save_dtype: torch.dtype = torch.int32,
+) -> torch.Tensor:
+    """
+    Returns:
+      topk_idx_cpu: [N, L, topk] on CPU
+    """
+    if input_ids_cpu.ndim != 2 or input_ids_cpu.shape[0] != 1:
+        raise ValueError("input_ids_cpu must have shape [1, N]")
+
+    device = next(llm.parameters()).device
+    n_tokens = int(input_ids_cpu.shape[1])
+    num_layers = int(llm.config.num_hidden_layers)
+    num_experts = int(llm.config.num_local_experts)
+    if topk > num_experts:
+        raise ValueError(f"router topk={topk} exceeds num_experts={num_experts}")
+
+    topk_idx_cpu = torch.empty((n_tokens, num_layers, topk), dtype=save_dtype, device="cpu")
+
+    past = None
+    pos = 0
+    batch_size = 1
+    chunk_size = max(1, min(int(chunk_size), n_tokens))
+    min_chunk_size = max(1, int(min_chunk_size))
+
+    while pos < n_tokens:
+        current_chunk = min(chunk_size, n_tokens - pos)
+        while True:
+            try:
+                chunk = input_ids_cpu[:, pos : pos + current_chunk].to(device, non_blocking=True)
+                chunk_len = int(chunk.shape[1])
+
+                outputs = llm(
+                    input_ids=chunk,
+                    use_cache=True,
+                    past_key_values=past,
+                    output_router_logits=True,
+                    return_dict=True,
+                )
+                break
+            except torch.cuda.OutOfMemoryError:
+                if device.type != "cuda":
+                    raise
+                torch.cuda.empty_cache()
+                if current_chunk <= min_chunk_size:
+                    raise
+                current_chunk = max(min_chunk_size, current_chunk // 2)
+                chunk_size = min(chunk_size, current_chunk)
+
+        past = outputs.past_key_values
+        router_logits_layers = outputs.router_logits
+        if router_logits_layers is None:
+            raise RuntimeError("outputs.router_logits is None (model may not support router logits)")
+
+        per_layer = []
+        for i, layer_logits in enumerate(router_logits_layers):
+            reshaped = _reshape_router_logits(layer_logits, batch_size, chunk_len, i)  # [1,S,E]
+            per_layer.append(reshaped[0])  # [S,E]
+
+        router_chunk = torch.stack(per_layer, dim=1)  # [S, L, E]
+        idx = torch.topk(router_chunk, k=topk, dim=-1).indices  # [S,L,topk]
+        topk_idx_cpu[pos : pos + chunk_len].copy_(idx.to("cpu", dtype=save_dtype))
+
+        pos += chunk_len
+
+    if device.type == "cuda":
+        torch.cuda.synchronize()
+
+    return topk_idx_cpu
+
+
+# ----------------- non-overlapping chunks of seq_len -----------------
+
+def non_overlapping_chunks(
+    token_ids: List[int],
+    expert_topk_idx: torch.Tensor,  # [N, L, K] on CPU
+    seq_len: int,
+    pad_id: int,
+) -> Iterable[Tuple[List[int], torch.Tensor, List[bool]]]:
+    """
+    Yield non-overlapping chunks of exactly seq_len:
+      - attention_mask marks real tokens
+      - last chunk is padded if needed (and we only count real tokens via attention_mask)
+    """
+    n = len(token_ids)
+    if n == 0:
+        return
+
+    seq_len = int(seq_len)
+    start = 0
+    while start < n:
+        end = min(start + seq_len, n)
+        clen = end - start
+
+        chunk_tokens = token_ids[start:end]
+        chunk_experts = expert_topk_idx[start:end]  # [clen, L, K]
+
+        if clen < seq_len:
+            chunk_tokens = chunk_tokens + [pad_id] * (seq_len - clen)
+            if clen > 0:
+                pad_row = chunk_experts[-1].unsqueeze(0)
+            else:
+                pad_row = torch.zeros_like(expert_topk_idx[:1])
+            pad_block = pad_row.expand(seq_len - clen, -1, -1)
+            chunk_experts = torch.cat([chunk_experts, pad_block], dim=0)
+
+        attention_mask = [True] * clen + [False] * (seq_len - clen)
+
+        yield chunk_tokens, chunk_experts, attention_mask
+        start += seq_len
+
+
+# ----------------- main -----------------
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Eval V5 inverter on GPT-OSS-20B generated text (non-overlapping 32-token chunks)."
+    )
+    parser.add_argument("--checkpoint", required=True)
+
+    # LLM
+    parser.add_argument("--model", default="openai/gpt-oss-20b")
+    parser.add_argument("--model-revision", default=None)
+    parser.add_argument(
+        "--attn-impl",
+        choices=["auto", "flash_attention_2", "sdpa", "eager"],
+        default="auto",
+        help="GPT-OSS: flash_attention_2 (needs flash_attn) or eager. sdpa maps to eager.",
+    )
+
+    # Generation
+    parser.add_argument("--prompt", action="append", default=None)
+    parser.add_argument("--gen-tokens", type=int, default=2048)
+    parser.add_argument("--temperature", type=float, default=1.0)
+    parser.add_argument("--top-p", type=float, default=0.95)
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument("--segments", type=int, default=1)
+    parser.add_argument("--include-prompt", action="store_true")
+
+    # Router collection
+    parser.add_argument("--router-topk", type=int, default=4)
+    parser.add_argument("--router-chunk-size", type=int, default=1024)
+    parser.add_argument("--router-min-chunk-size", type=int, default=128)
+
+    # Chunk eval
+    parser.add_argument("--seq-len", type=int, default=32)
+    parser.add_argument("--batch-size", type=int, default=8)
+    parser.add_argument("--eval-topk", default="1,5,10")
+
+    # Inverter arch (overridden from ckpt config by default)
+    parser.add_argument("--use-ckpt-config", action="store_true", default=True)
+    parser.add_argument("--no-use-ckpt-config", action="store_false", dest="use_ckpt_config")
+    parser.add_argument("--layers", type=int, default=24)
+    parser.add_argument("--d-model", type=int, default=768)
+    parser.add_argument("--n-head", type=int, default=12)
+    parser.add_argument("--d-ff", type=int, default=2048)
+    parser.add_argument("--n-layer", type=int, default=6)
+    parser.add_argument("--layer-hidden", type=int, default=64)
+    parser.add_argument("--layer-proj", type=int, default=64)
+    parser.add_argument("--dropout", type=float, default=0.1)
+    parser.add_argument("--logit-softcap", type=float, default=0.0)
+    parser.add_argument("--layer-gating", action="store_true", default=False)
+
+    parser.add_argument("--hard-exit", action="store_true")
+    parser.add_argument("--debug", action="store_true")
+    args = parser.parse_args()
+
+    device = _default_device()
+    if device == "cuda":
+        torch.backends.cuda.matmul.allow_tf32 = True
+        torch.backends.cudnn.allow_tf32 = True
+        torch.set_float32_matmul_precision("high")
+
+    _set_seed(args.seed)
+
+    ckpt_cfg = _load_ckpt_config(args.checkpoint)
+    state_dict = _load_state_dict(args.checkpoint)
+
+    ckpt_has_gate = bool(ckpt_cfg.get("layer_gating", False)) or ("encoder_in.layer_gate" in state_dict)
+    if ckpt_has_gate and not args.layer_gating:
+        print("Note: checkpoint contains encoder_in.layer_gate; enabling layer_gating for eval.", file=sys.stderr)
+        args.layer_gating = True
+
+    if args.use_ckpt_config and ckpt_cfg:
+        mapping = {
+            "seq_len": "seq_len",
+            "layers": "layers",
+            "d_model": "d_model",
+            "n_head": "n_head",
+            "d_ff": "d_ff",
+            "n_layer": "n_layer",
+            "layer_hidden": "layer_hidden",
+            "layer_proj": "layer_proj",
+            "dropout": "dropout",
+            "logit_softcap": "logit_softcap",
+        }
+        for ck, ak in mapping.items():
+            if ck in ckpt_cfg:
+                setattr(args, ak, ckpt_cfg[ck])
+
+    tokenizer = AutoTokenizer.from_pretrained(args.model, revision=args.model_revision)
+    if tokenizer.pad_token_id is None:
+        tokenizer.pad_token_id = tokenizer.eos_token_id
+
+    attn_impl = args.attn_impl
+    if attn_impl == "auto":
+        attn_impl = "flash_attention_2" if device != "cpu" else "eager"
+
+    llm, _llm_dtype = _load_llm_with_fallback(args.model, args.model_revision, device, attn_impl)
+
+    inv = EncoderOnlyModel(
+        vocab_size=len(tokenizer),
+        num_experts=32,
+        num_layers=int(args.layers),
+        topk=int(args.router_topk),
+        d_model=int(args.d_model),
+        n_head=int(args.n_head),
+        d_ff=int(args.d_ff),
+        n_layer=int(args.n_layer),
+        dropout=float(args.dropout),
+        max_len=int(args.seq_len),
+        layer_gating=bool(args.layer_gating),
+        logit_softcap=float(args.logit_softcap),
+        layer_hidden=int(args.layer_hidden),
+        layer_proj=int(args.layer_proj),
+    ).to(device)
+
+    inv.load_state_dict(state_dict, strict=True)
+    inv.eval()
+
+    eval_topk = sorted({int(x) for x in args.eval_topk.split(",") if x.strip() and int(x) > 0})
+    correct = {k: 0 for k in eval_topk}
+    total = 0
+
+    prompts = args.prompt or [
+        "Write a concise overview of black holes, including formation, event horizon, and Hawking radiation.\n\n",
+        "Explain transformers and attention in simple terms.\n\n",
+        "A dialogue between a detective and a chef.\n\n",
+        "Summarize the pros and cons of open-source AI models.\n\n",
+    ]
+
+    def run_chunk_batch(batch_tokens, batch_experts, batch_attn):
+        nonlocal total
+        input_ids = torch.tensor(batch_tokens, dtype=torch.long, device=device)
+        expert_idx = torch.stack(batch_experts, dim=0).to(device=device, dtype=torch.long)  # [B,S,L,K]
+        attention_mask = torch.tensor(batch_attn, dtype=torch.bool, device=device)
+        count_mask = attention_mask
+
+        with torch.autocast(device_type=device, dtype=torch.bfloat16, enabled=(device == "cuda")):
+            logits = inv(expert_idx, attention_mask)
+
+        for k in eval_topk:
+            topk_pred = torch.topk(logits, k=k, dim=-1).indices
+            match = (topk_pred == input_ids.unsqueeze(-1)).any(dim=-1)
+            match = match & count_mask
+            correct[k] += int(match.sum().item())
+
+        total += int(count_mask.sum().item())
+
+    for seg in range(int(args.segments)):
+        prompt = prompts[seg % len(prompts)]
+
+        full_ids, prompt_len = generate_tokens(
+            llm=llm,
+            tokenizer=tokenizer,
+            prompt=prompt,
+            max_new_tokens=max(1, int(args.gen_tokens)),
+            temperature=float(args.temperature),
+            top_p=float(args.top_p),
+            device=device,
+        )
+
+        input_ids_cpu = torch.tensor([full_ids], dtype=torch.long, device="cpu")
+        topk_idx_cpu = collect_router_topk_indices_chunked(
+            llm=llm,
+            input_ids_cpu=input_ids_cpu,
+            topk=int(args.router_topk),
+            chunk_size=max(1, int(args.router_chunk_size)),
+            min_chunk_size=max(1, int(args.router_min_chunk_size)),
+            save_dtype=torch.int32,
+        )  # [N, L, K]
+
+        if (not args.include_prompt) and prompt_len > 0:
+            token_ids = full_ids[prompt_len:]
+            topk_idx_cpu = topk_idx_cpu[prompt_len:]
+        else:
+            token_ids = full_ids
+
+        if len(token_ids) == 0:
+            continue
+
+        L = int(args.layers)
+        topk_idx_cpu = topk_idx_cpu[:, :L, :]
+
+        batch_tokens = []
+        batch_experts = []
+        batch_attn = []
+
+        for chunk_tokens, chunk_experts, attn_mask in non_overlapping_chunks(
+            token_ids=token_ids,
+            expert_topk_idx=topk_idx_cpu,
+            seq_len=int(args.seq_len),
+            pad_id=int(tokenizer.pad_token_id),
+        ):
+            batch_tokens.append(chunk_tokens)
+            batch_experts.append(chunk_experts)
+            batch_attn.append(attn_mask)
+
+            if len(batch_tokens) >= int(args.batch_size):
+                run_chunk_batch(batch_tokens, batch_experts, batch_attn)
+                batch_tokens, batch_experts, batch_attn = [], [], []
+
+        if batch_tokens:
+            run_chunk_batch(batch_tokens, batch_experts, batch_attn)
+
+    acc = {str(k): (correct[k] / total if total > 0 else 0.0) for k in eval_topk}
+
+    if args.debug:
+        vals = [acc[str(k)] for k in eval_topk]
+        if any(vals[i] > vals[i + 1] + 1e-9 for i in range(len(vals) - 1)):
+            print("WARNING: accuracy is not monotonic with k; check eval.", file=sys.stderr)
+
+    result = {
+        "tokens": int(total),
+        "accuracy": acc,
+        "config": {
+            "llm": args.model,
+            "checkpoint": args.checkpoint,
+            "seq_len": int(args.seq_len),
+            "layers": int(args.layers),
+            "router_topk": int(args.router_topk),
+            "segments": int(args.segments),
+            "gen_tokens_per_segment": int(args.gen_tokens),
+            "include_prompt": bool(args.include_prompt),
+            "attn_impl_requested": args.attn_impl,
+            "layer_gating": bool(args.layer_gating),
+            "use_ckpt_config": bool(args.use_ckpt_config),
+        },
+    }
+    print(json.dumps(result, indent=2))
+
+    if args.hard_exit:
+        os._exit(0)
+
+
+if __name__ == "__main__":
+    main()