gmnet/code/journal_exp/scripts/audit_e4_alignment_smoke.py

#!/usr/bin/env python3
"""Audit the exact-code, eight-GPU strict-resume smoke for E4 launches."""

from __future__ import annotations

import argparse
import hashlib
import json
import math
import os
import re
import sys
from datetime import UTC, datetime
from pathlib import Path
from typing import Any

import torch
import yaml

SCRIPT_PATH = Path(__file__).resolve()
JOURNAL_ROOT = SCRIPT_PATH.parents[1]
DEFAULT_ROOT = Path("/tmp/gmnet_runs/e4_alignment_smoke")
DEFAULT_OUTPUT = Path(
    "/nfs/ywang29/GmNet/depoly/e4_alignment_20260716/smoke_evidence.json"
)
DEFAULT_MANIFEST = JOURNAL_ROOT / "configs/code_manifests/e4_alignment_20260716.json"
PROTOCOL_ID = "imagenet-e4-alignment-single-seed-20260716"
INTERVENTION_SEED = 41_041
BLOCK_SEED_STRIDE = 10_007
WORLD_SIZE = 8
SHA256_PATTERN = re.compile(r"[0-9a-f]{64}")
TASKS = {
    "e4a_s3_stop_gradient_seed0": {
        "mode": "stop_gradient",
        "directory": "stop_gradient",
        "config_path": "configs/smoke/imagenet5_gmnet_s1_e4_stop_gradient.yaml",
    },
    "e4a_s3_channel_derangement_seed0": {
        "mode": "channel_derangement",
        "directory": "channel_derangement",
        "config_path": ("configs/smoke/imagenet5_gmnet_s1_e4_channel_derangement.yaml"),
    },
}
REQUIRED_RUN_FILES = (
    "checkpoint_epoch0.pt",
    "checkpoint_last.pt",
    "config_source.yaml",
    "config_resolved.yaml",
    "data_manifest.json",
    "metrics.jsonl",
)


def file_sha256(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as handle:
        for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""):
            digest.update(chunk)
    return digest.hexdigest()


def stable_sha256(value: Any) -> str:
    payload = json.dumps(
        value, sort_keys=True, separators=(",", ":"), ensure_ascii=True
    ).encode("utf-8")
    return hashlib.sha256(payload).hexdigest()


def load_json(path: Path) -> dict[str, Any]:
    loaded = json.loads(path.read_text(encoding="utf-8"))
    if not isinstance(loaded, dict):
        raise ValueError(f"expected JSON object: {path}")
    return loaded


def load_yaml(path: Path) -> dict[str, Any]:
    loaded = yaml.safe_load(path.read_text(encoding="utf-8"))
    if not isinstance(loaded, dict):
        raise ValueError(f"expected YAML mapping: {path}")
    return loaded


def require_sha256(value: Any, location: str) -> str:
    if not isinstance(value, str) or SHA256_PATTERN.fullmatch(value) is None:
        raise ValueError(f"invalid SHA-256 at {location}: {value!r}")
    return value


def assert_finite(value: Any, location: str) -> None:
    if isinstance(value, float) and not math.isfinite(value):
        raise ValueError(f"non-finite value at {location}")
    if isinstance(value, dict):
        for key, child in value.items():
            assert_finite(child, f"{location}.{key}")
    elif isinstance(value, list):
        for index, child in enumerate(value):
            assert_finite(child, f"{location}[{index}]")


def resolve_manifest(path: Path) -> Path:
    return path if path.is_absolute() else JOURNAL_ROOT / path


def verify_code_manifest(path: Path) -> tuple[dict[str, Any], str]:
    resolved = resolve_manifest(path).resolve()
    manifest = load_json(resolved)
    if str(JOURNAL_ROOT) not in sys.path:
        sys.path.insert(0, str(JOURNAL_ROOT))
    from scripts.code_fingerprint import build_manifest

    actual = build_manifest(JOURNAL_ROOT)
    if manifest != actual:
        raise ValueError(
            "E4 code manifest does not match current source: "
            f"expected={manifest.get('code_sha256')} "
            f"actual={actual.get('code_sha256')}"
        )
    require_sha256(manifest.get("code_sha256"), "manifest.code_sha256")
    return manifest, file_sha256(resolved)


def load_checkpoint(path: Path) -> dict[str, Any]:
    checkpoint = torch.load(path, map_location="cpu", weights_only=False)
    if not isinstance(checkpoint, dict):
        raise ValueError(f"checkpoint is not a mapping: {path}")
    return checkpoint


def check_progress(
    checkpoint: dict[str, Any],
    *,
    epoch: int,
    global_step: int,
    training_complete: bool,
    location: str,
) -> None:
    expected = {
        "epoch": epoch,
        "global_step": global_step,
        "epoch_complete": True,
        "steps_in_epoch": 1,
        "expected_steps_per_epoch": 1,
        "training_complete": training_complete,
        "seed": 0,
        "world_size": WORLD_SIZE,
    }
    for key, value in expected.items():
        if checkpoint.get(key) != value:
            raise ValueError(
                f"{location}.{key}={checkpoint.get(key)!r}, expected {value!r}"
            )
    states = checkpoint.get("rng_state_by_rank")
    if not isinstance(states, list) or len(states) != WORLD_SIZE:
        raise ValueError(f"{location} lacks {WORLD_SIZE} per-rank RNG states")


def checkpoint_config(
    checkpoint: dict[str, Any], *, mode: str, code_sha256: str, location: str
) -> dict[str, Any]:
    config = checkpoint.get("config")
    if not isinstance(config, dict):
        raise ValueError(f"{location}.config is missing")
    model = config.get("model")
    train = config.get("train")
    data = config.get("data")
    protocol = config.get("protocol")
    if not all(isinstance(item, dict) for item in (model, train, data, protocol)):
        raise ValueError(f"{location} has incomplete config sections")
    expected = {
        "model.variant": model.get("variant"),
        "model.num_classes": model.get("num_classes"),
        "model.gate_type": model.get("gate_type"),
        "model.gate_intervention": model.get("gate_intervention"),
        "model.gate_intervention_seed": model.get("gate_intervention_seed"),
        "data.batch_size": data.get("batch_size"),
        "train.epochs": train.get("epochs"),
        "train.strict_resume": train.get("strict_resume"),
        "train.fail_on_nonfinite": train.get("fail_on_nonfinite"),
        "protocol.code_sha256": protocol.get("code_sha256"),
    }
    required = {
        "model.variant": "s1",
        "model.num_classes": 5,
        "model.gate_type": "relu6_self",
        "model.gate_intervention": mode,
        "model.gate_intervention_seed": INTERVENTION_SEED,
        "data.batch_size": 1,
        "train.epochs": 2,
        "train.strict_resume": True,
        "train.fail_on_nonfinite": True,
        "protocol.code_sha256": code_sha256,
    }
    for key, value in required.items():
        if expected[key] != value:
            raise ValueError(f"{location}.{key}={expected[key]!r}, expected {value!r}")
    return config


def model_identity(
    checkpoint: dict[str, Any], *, mode: str, location: str
) -> dict[str, Any]:
    if str(JOURNAL_ROOT) not in sys.path:
        sys.path.insert(0, str(JOURNAL_ROOT))
    from gmnet.engine import state_dict_schema_sha256
    from gmnet.models import create_gmnet

    state = checkpoint.get("model")
    config = checkpoint["config"]
    if not isinstance(state, dict):
        raise ValueError(f"{location}.model is missing")
    model_config = dict(config["model"])
    variant = str(model_config.pop("variant"))
    num_classes = int(model_config.pop("num_classes"))
    model = create_gmnet(variant, num_classes=num_classes, **model_config)
    model.load_state_dict(state, strict=True)
    parameter_count = sum(parameter.numel() for parameter in model.parameters())
    schema_sha256 = state_dict_schema_sha256(model.state_dict())
    if checkpoint.get("parameter_count") != parameter_count:
        raise ValueError(f"{location} parameter_count is inconsistent")
    if checkpoint.get("model_state_schema_sha256") != schema_sha256:
        raise ValueError(f"{location} state schema is inconsistent")

    rows = model.gate_intervention_metadata()
    if len(rows) != 16:
        raise ValueError(f"{location} expected 16 S1 blocks, got {len(rows)}")
    for index, row in enumerate(rows):
        expected_seed = INTERVENTION_SEED + index * BLOCK_SEED_STRIDE
        if (
            row.get("global_block_index") != index
            or row.get("mode") != mode
            or row.get("seed") != expected_seed
        ):
            raise ValueError(
                f"{location} intervention metadata drifted at block {index}"
            )
        if mode == "channel_derangement":
            require_sha256(
                row.get("permutation_sha256"),
                f"{location}.block[{index}].permutation_sha256",
            )
            if (
                row.get("permutation_hash_encoding") != "little_endian_int64_c_order"
                or row.get("is_bijection") is not True
                or row.get("fixed_points") != 0
            ):
                raise ValueError(
                    f"{location} invalid channel derangement at block {index}"
                )
        elif any(
            row.get(key) is not None
            for key in (
                "permutation_sha256",
                "permutation_hash_encoding",
                "is_bijection",
                "fixed_points",
            )
        ):
            raise ValueError(f"{location} unexpectedly has a permutation")
    return {
        "parameter_count": parameter_count,
        "state_tensor_count": len(model.state_dict()),
        "model_state_schema_sha256": schema_sha256,
        "block_count": len(rows),
        "block_seed_stride": BLOCK_SEED_STRIDE,
        "intervention_manifest_sha256": stable_sha256(rows),
        "blocks": rows,
    }


def parse_metrics(path: Path) -> list[dict[str, Any]]:
    records: list[dict[str, Any]] = []
    for line_number, line in enumerate(
        path.read_text(encoding="utf-8").splitlines(), 1
    ):
        if not line.strip():
            continue
        record = json.loads(line)
        if not isinstance(record, dict):
            raise ValueError(f"metrics line {line_number} is not an object: {path}")
        assert_finite(record, f"{path}[{line_number}]")
        records.append(record)
    epochs = [record for record in records if record.get("kind") == "epoch"]
    expected = ((0, 1, False), (1, 2, True))
    if len(epochs) != len(expected):
        raise ValueError(f"{path} must contain exactly two epoch records")
    for record, (epoch, step, complete) in zip(epochs, expected, strict=True):
        required = {
            "epoch": epoch,
            "global_step": step,
            "epoch_complete": True,
            "steps_in_epoch": 1,
            "expected_steps_per_epoch": 1,
            "training_complete": complete,
        }
        for key, value in required.items():
            if record.get(key) != value:
                raise ValueError(f"{path} epoch {epoch} field {key} drifted")
    return records


def audit_task(
    task_id: str,
    specification: dict[str, str],
    *,
    root: Path,
    code_sha256: str,
) -> tuple[dict[str, Any], dict[str, Any]]:
    mode = specification["mode"]
    run_dir = (root / specification["directory"]).resolve()
    for name in REQUIRED_RUN_FILES:
        if not (run_dir / name).is_file():
            raise FileNotFoundError(f"missing E4 smoke artifact: {run_dir / name}")
    first_path = run_dir / "checkpoint_epoch0.pt"
    final_path = run_dir / "checkpoint_last.pt"
    first = load_checkpoint(first_path)
    final = load_checkpoint(final_path)
    check_progress(
        first,
        epoch=0,
        global_step=1,
        training_complete=False,
        location=f"{task_id}.epoch0",
    )
    check_progress(
        final,
        epoch=1,
        global_step=2,
        training_complete=True,
        location=f"{task_id}.final",
    )
    first_config = checkpoint_config(
        first, mode=mode, code_sha256=code_sha256, location=f"{task_id}.epoch0"
    )
    final_config = checkpoint_config(
        final, mode=mode, code_sha256=code_sha256, location=f"{task_id}.final"
    )
    identity_fields = ("config_fingerprint", "run_name", "seed", "world_size")
    for field in identity_fields:
        if first.get(field) != final.get(field):
            raise ValueError(f"{task_id} strict-resume identity drifted: {field}")
    if first_config != final_config:
        raise ValueError(f"{task_id} checkpoint config changed across resume")
    if first.get("data_manifest") != final.get("data_manifest"):
        raise ValueError(f"{task_id} data manifest changed across resume")
    if first.get("global_step", 0) >= final.get("global_step", 0):
        raise ValueError(f"{task_id} did not advance after resume")

    resolved = load_yaml(run_dir / "config_resolved.yaml")
    runtime = resolved.get("runtime", {})
    if not isinstance(runtime, dict):
        raise ValueError(f"{task_id} resolved runtime is missing")
    runtime_expected = {
        "run_name": final["run_name"],
        "seed": 0,
        "world_size": WORLD_SIZE,
        "config_fingerprint": final["config_fingerprint"],
        "data_manifest_sha256": final["data_manifest"]["manifest_sha256"],
    }
    for key, value in runtime_expected.items():
        if runtime.get(key) != value:
            raise ValueError(f"{task_id} resolved runtime drifted: {key}")
    disk_manifest = load_json(run_dir / "data_manifest.json")
    if disk_manifest != final["data_manifest"]:
        raise ValueError(f"{task_id} disk/checkpoint data manifests differ")

    records = parse_metrics(run_dir / "metrics.jsonl")
    first_model = model_identity(first, mode=mode, location=f"{task_id}.epoch0")
    final_model = model_identity(final, mode=mode, location=f"{task_id}.final")
    if first_model != final_model:
        raise ValueError(f"{task_id} model intervention identity changed across resume")
    artifact_hashes = {name: file_sha256(run_dir / name) for name in REQUIRED_RUN_FILES}
    first_sha = artifact_hashes["checkpoint_epoch0.pt"]
    final_sha = artifact_hashes["checkpoint_last.pt"]
    if first_sha == final_sha:
        raise ValueError(f"{task_id} final checkpoint did not change")
    return (
        {
            "gate_intervention": mode,
            "gate_intervention_seed": INTERVENTION_SEED,
            "smoke_config_path": specification["config_path"],
            "smoke_run_dir": str(run_dir),
            "run_name": final["run_name"],
            "checkpoint_epoch0_sha256": first_sha,
            "checkpoint_last_sha256": final_sha,
            "resume_verified": True,
            "training_complete": True,
            "epoch0": {"epoch": 0, "global_step": 1, "training_complete": False},
            "final": {"epoch": 1, "global_step": 2, "training_complete": True},
            "config_fingerprint": final["config_fingerprint"],
            "data_manifest_sha256": final["data_manifest"]["manifest_sha256"],
            "metric_record_count": len(records),
            "model_identity": final_model,
            "artifacts_sha256": artifact_hashes,
        },
        final_model,
    )


def audit(root: Path, manifest_path: Path) -> dict[str, Any]:
    manifest, manifest_sha256 = verify_code_manifest(manifest_path)
    task_records: dict[str, Any] = {}
    model_identities: list[dict[str, Any]] = []
    run_names: set[str] = set()
    for task_id, specification in TASKS.items():
        record, model = audit_task(
            task_id,
            specification,
            root=root,
            code_sha256=manifest["code_sha256"],
        )
        if record["run_name"] in run_names:
            raise ValueError("E4 smoke tasks reused a run name")
        run_names.add(record["run_name"])
        task_records[task_id] = record
        model_identities.append(model)

    topology = {
        key: model_identities[0][key]
        for key in (
            "parameter_count",
            "state_tensor_count",
            "model_state_schema_sha256",
            "block_count",
        )
    }
    for model in model_identities[1:]:
        for key, value in topology.items():
            if model[key] != value:
                raise ValueError(f"E4 smoke model topology differs across modes: {key}")
    manifest_resolved = resolve_manifest(manifest_path).resolve()
    return {
        "schema_version": 1,
        "protocol_id": PROTOCOL_ID,
        "status": "passed",
        "audited_at_utc": datetime.now(UTC).isoformat(),
        "code_sha256": manifest["code_sha256"],
        "code_manifest_path": manifest_resolved.relative_to(JOURNAL_ROOT).as_posix(),
        "code_manifest_sha256": manifest_sha256,
        "smoke_root": str(root.resolve()),
        "world_size": WORLD_SIZE,
        "strict_resume": True,
        "shared_topology": topology,
        "tasks": task_records,
    }


def write_atomic(path: Path, value: dict[str, Any]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    temporary = path.with_name(f".{path.name}.tmp.{os.getpid()}")
    temporary.write_text(
        json.dumps(value, indent=2, sort_keys=True) + "\n", encoding="utf-8"
    )
    temporary.replace(path)


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--root", type=Path, default=DEFAULT_ROOT)
    parser.add_argument("--output", type=Path, default=DEFAULT_OUTPUT)
    parser.add_argument("--manifest", type=Path, default=DEFAULT_MANIFEST)
    return parser.parse_args()


def main() -> int:
    args = parse_args()
    evidence = audit(args.root, args.manifest)
    write_atomic(args.output, evidence)
    print(f"E4 smoke audit passed for {len(evidence['tasks'])} tasks: {args.output}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())