scripts/check_checkpoints.py

"""Inventory and integrity-check the Orbax checkpoints written by a pi0.5 training run.

    python3 scripts/check_checkpoints.py /data/checkpoints/pi05_g1_pickplace/pickplace_full_v1

Pure stdlib, no GPU, no JAX -- safe to run while training still holds the A100. It answers the
questions you cannot answer from `ls` alone:

  * which steps exist, and which are resumable (train_state present) vs params-only (pruned)
  * whether any save is INCOMPLETE -- an aborted or in-flight write leaves a
    `.orbax-checkpoint-tmp-*` directory, or a step dir with no commit marker
  * whether `assets/norm_stats.json` is present, because a checkpoint without it serves
    garbage actions while looking perfectly healthy
  * zero-byte files, which is what a checkpoint written into a full disk looks like

Exit code is 0 only if every complete checkpoint passes. `--json` emits machine-readable output.
"""
import argparse
import json
import pathlib
import sys

# Orbax drops one of these in a step directory once the write has been committed. Which one
# depends on the version, so presence of ANY is treated as "committed".
COMMIT_MARKERS = ("commit_success.txt", "_CHECKPOINT_METADATA", "_METADATA")
GIB = 1024**3


def human(n: int) -> str:
    """Adaptive units -- a 12.5 GiB params dir and a 4 KiB assets dir both need to read."""
    for unit, div in (("T", 1024**4), ("G", GIB), ("M", 1024**2), ("K", 1024)):
        if n >= div:
            return f"{n / div:.1f}{unit}"
    return f"{n}B"


def dir_stats(path: pathlib.Path) -> tuple[int, int, int]:
    """(total bytes, file count, zero-byte file count) over a directory tree."""
    total = files = empty = 0
    for f in path.rglob("*"):
        if not f.is_file():
            continue
        try:
            size = f.stat().st_size
        except OSError:
            continue
        total += size
        files += 1
        empty += size == 0
    return total, files, empty


def inspect(step_dir: pathlib.Path) -> dict:
    r: dict = {"step": int(step_dir.name), "path": str(step_dir), "problems": []}

    r["committed"] = any((step_dir / m).exists() for m in COMMIT_MARKERS) or any(
        (step_dir / sub / m).exists() for sub in ("params",) for m in COMMIT_MARKERS
    )

    for sub in ("params", "train_state", "assets"):
        d = step_dir / sub
        if d.is_dir():
            size, files, empty = dir_stats(d)
            r[sub] = {"bytes": size, "files": files, "empty_files": empty}
            if empty:
                r["problems"].append(f"{sub}/ has {empty} zero-byte file(s) -- disk full?")
            if files == 0:
                r["problems"].append(f"{sub}/ exists but is empty")
        else:
            r[sub] = None

    if r["params"] is None:
        r["problems"].append("no params/ -- nothing deployable here")

    # assets/ carries norm_stats.json. Without it the policy denormalises with the wrong
    # statistics and the robot does nothing while every log looks fine.
    hits = list((step_dir / "assets").rglob("norm_stats.json")) if (step_dir / "assets").is_dir() else []
    r["norm_stats"] = str(hits[0].relative_to(step_dir)) if hits else None
    if not hits:
        r["problems"].append("no assets/**/norm_stats.json -- served policy would emit garbage")

    r["resumable"] = r["train_state"] is not None
    return r


def main() -> int:
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("root", type=pathlib.Path, help="the exp directory, e.g. .../pickplace_full_v1")
    ap.add_argument("--frames", type=int, default=161_440, help="dataset frames, for the epoch column")
    ap.add_argument("--batch-size", type=int, default=32)
    ap.add_argument("--json", action="store_true")
    a = ap.parse_args()

    if not a.root.is_dir():
        print(f"FAIL: {a.root} is not a directory", file=sys.stderr)
        return 2

    partial = sorted({p.name for p in a.root.glob("*orbax-checkpoint-tmp-*")})
    steps = sorted((p for p in a.root.iterdir() if p.is_dir() and p.name.isdigit()),
                   key=lambda p: int(p.name))

    if not steps and not partial:
        print(f"No checkpoints in {a.root} yet.")
        return 0

    rows = [inspect(s) for s in steps]
    spe = a.frames / a.batch_size  # steps per epoch

    if a.json:
        print(json.dumps({"root": str(a.root), "in_flight": partial, "checkpoints": rows}, indent=2))
    else:
        print(f"{a.root}\n")
        hdr = f"{'step':>7}  {'epoch':>5}  {'params':>8}  {'tstate':>8}  {'norm_stats':>10}  state"
        print(hdr)
        print("-" * len(hdr))
        for r in rows:
            p = human(r["params"]["bytes"]) if r["params"] else "--"
            t = human(r["train_state"]["bytes"]) if r["train_state"] else "--"
            n = "yes" if r["norm_stats"] else "NO"
            state = "resumable" if r["resumable"] else "params only"
            if r["problems"]:
                state = "PROBLEM"
            print(f"{r['step']:>7}  {r['step']/spe:>5.2f}  {p:>8}  {t:>8}  {n:>10}  {state}")

        total = sum((r["params"]["bytes"] if r["params"] else 0)
                    + (r["train_state"]["bytes"] if r["train_state"] else 0) for r in rows)
        print(f"\n{len(rows)} checkpoint(s), {human(total)} total")
        if partial:
            print(f"\n{len(partial)} save(s) IN FLIGHT or aborted (Orbax temp dirs):")
            for p in partial:
                print(f"  {p}")
            print("  A save in progress is normal. One that persists after training exits is not --")
            print("  delete it, that step never committed.")

        uncommitted = [r["step"] for r in rows if not r["committed"]]
        if uncommitted:
            print(f"\nNOTE: no commit marker found for step(s) {uncommitted}. Orbax layout varies by")
            print("version, so this is weak evidence on its own -- trust the load test instead.")

        bad = [r for r in rows if r["problems"]]
        if bad:
            print("\nPROBLEMS")
            for r in bad:
                for p in r["problems"]:
                    print(f"  step {r['step']}: {p}")
        else:
            print("\nAll checkpoints structurally OK. Structure is not the same as loadable --")
            print("run the load test in the runbook (Step 11.1) on at least one of them.")

    return 1 if any(r["problems"] for r in rows) else 0


if __name__ == "__main__":
    sys.exit(main())