숫자보다 먼저 예측을 적어

def stamp(alias: str) -> dict:
    """Who, what, when: a measurement without this is a rumour."""
    info = mx.device_info()
    return {
        "alias": alias,
        "device": info.get("device_name"),
        "memory_gb": round(info.get("memory_size", 0) / 1e9, 1),
        "recommended_working_set_gb": round(info.get("max_recommended_working_set_size", 0) / 1e9, 1),
        "macos": macos_build(),
        "mlx": mx.__version__,
        "mlx_lm": mlx_lm.__version__,
        "date": datetime.now(timezone.utc).isoformat(timespec="seconds"),
    }


def weight_bytes(path: Path) -> dict:
    """Bytes a token must read during decode — from the safetensors headers, not the config.
    Not every byte on disk is read per token: a vision tower never is; the input embedding is a
    one-row lookup unless tied to the output head; a mixture reads k of E routed experts."""
    cfg = json.loads((path / "config.json").read_text())
    text_cfg = cfg.get("text_config", cfg)
    n_experts = text_cfg.get("num_experts") or text_cfg.get("num_local_experts") or 0
    k = text_cfg.get("num_experts_per_tok") or 0
    tied = bool(cfg.get("tie_word_embeddings", text_cfg.get("tie_word_embeddings", False)))
    total = vision = embed = expert = 0
    for f in sorted(path.glob("*.safetensors")):
        with f.open("rb") as fh:
            n = struct.unpack("<Q", fh.read(8))[0]
            header = json.loads(fh.read(n))
        for name, meta in header.items():
            if name == "__metadata__":
                continue
            a, b = meta["data_offsets"]
            size = b - a
            total += size
            if "vision" in name or "visual" in name:
                vision += size
            elif "embed_tokens" in name:
                embed += size
            elif "switch_mlp" in name or ".experts." in name:
                expert += size
    touched = total - vision - (0 if tied else embed)
    if n_experts:
        touched -= expert * (1 - k / n_experts)
    return {"weight_bytes_total": total, "weight_bytes_vision": vision, "weight_bytes_embed": embed,
            "weight_bytes_experts": expert, "tied_embeddings": tied, "experts": n_experts,
            "experts_per_token": k, "weight_bytes_per_token": int(touched)}


def ladder(args) -> None:
    base = stamp(args.alias)
    for repo in args.models:
        path = snapshot_dir(repo)
        wb = weight_bytes(path)
        predicted = args.spec_gbps * 1e9 / wb["weight_bytes_per_token"]          # THE PREDICTION, before load()
        print(f"prediction: {args.spec_gbps} GB/s / {wb['weight_bytes_per_token']/1e9:.2f} GB = {predicted:.1f} tok/s ceiling")
        model, tokenizer = load(str(path))
        prompt_ids = build_prompt(tokenizer, args.prompt_tokens, QUESTION)
        run_once(model, tokenizer, prompt_ids, 8)                                  # warm the kernels; discard
        rec = {**base, "experiment": "ladder", "model": repo, **wb}
        rec.update(run_once(model, tokenizer, prompt_ids, args.max_tokens))        # prefill, TTFT, decode, peak
        rec["predicted_decode_tps"] = round(predicted, 1)
        rec["effective_gbps"] = round(rec["generation_tps"] * wb["weight_bytes_per_token"] / 1e9, 1)
        with Path(args.out).open("a") as fh:
            fh.write(json.dumps(rec) + "\n")                                        # one JSON line per run; the file is the record

# office, run 1 (every byte on disk counted per token), 2026-09-15:
#   Qwen3.5-35B-A3B-4bit  20.39 GB/tok  predicted 40.2  measured 88.99  -> effective 1814.6 GB/s on an 819 GB/s bus
# corrected: 1.66 GB/tok, predicted 493.7, measured 89.1, effective 147.9 GB/s