| |
| """Fail-closed validation for the E4 matched spectral audit inputs.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import sys |
| from pathlib import Path |
| from typing import Any |
|
|
| import numpy as np |
|
|
|
|
| EXPECTED_ARMS = {"B", "D", "S", "C", "SC"} |
| EXPECTED_PROTOCOL_ID = "gmnet-e4-imagenet-matched-spectral-v1" |
| EXPECTED_INPUT_MANIFEST_SHA256 = "8b32da7c33f6b578dd2b5359d727afe313462be0c0040212a2640755ad2fadf7" |
| EXPECTED_PROTOCOL_SHA256 = "b66f0aa2f620135584483fb0057fe6fec9a55b4b501b08fd26065034a892b4a2" |
| EXPECTED_AUDIT_RUNTIME_CODE_SHA256 = "f6bd434a2ac86c772f2e23683431f3bb7ccb06f539558682a3bea6464bacebf9" |
| EXPECTED_ALIGNMENT_TRAINING_CODE_SHA256 = "4a62bc48370247d882196cd9afc1a0f1629a5bbfd522c3f599ffaf0c1187641f" |
| EXPECTED_AUDIT_RUNTIME_MANIFEST_SHA256 = "e354339142ffc72e669234a9f297113a64e5294ce8ff37dd658e62f723f0b239" |
| EXPECTED_ALIGNMENT_TRAINING_MANIFEST_SHA256 = "fa1a6ba00c82619dbd51b9af61489a34326b635978d83ef948584e45f93cddbc" |
| EXPECTED_TORCH = "2.9.0+cu130" |
| EXPECTED_TORCHVISION = "0.24.0+cu130" |
| EXPECTED_SCHEMA = "352cb771eaf4123fb9364dfd25d0151f9c2e6fa5493b989759091819f8981c99" |
| EXPECTED_PERMUTATION = "0219d0a289ae2e3c2bde90568af4b05d23ca629522f1b19b6a1d09473d87fb8b" |
|
|
|
|
| def 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 require(condition: bool, message: str) -> None: |
| if not condition: |
| raise RuntimeError(message) |
|
|
|
|
| def read_json(path: Path) -> dict[str, Any]: |
| require(path.is_file(), f"missing JSON file: {path}") |
| value = json.loads(path.read_text(encoding="utf-8")) |
| require(isinstance(value, dict), f"expected a JSON object: {path}") |
| return value |
|
|
|
|
| def verify_artifact(path: Path, expected: str, label: str) -> str: |
| require(path.is_file(), f"missing {label}: {path}") |
| actual = sha256(path) |
| require(actual == expected, f"{label} hash mismatch: expected {expected}, got {actual}") |
| return actual |
|
|
|
|
| def verify_arm(arm: dict[str, Any]) -> dict[str, Any]: |
| name = str(arm["arm"]) |
| run_dir = Path(arm["run_dir"]) |
| require(run_dir.is_dir(), f"{name}: run directory missing: {run_dir}") |
| require((run_dir / "official_eval" / "COMPLETE").is_file(), f"{name}: official COMPLETE missing") |
|
|
| checkpoint = Path(arm["checkpoint"]) |
| checkpoint_hash = verify_artifact( |
| checkpoint, str(arm["checkpoint_sha256"]), f"{name} checkpoint" |
| ) |
| verify_artifact( |
| Path(arm["config_source"]), |
| str(arm["config_source_sha256"]), |
| f"{name} config source", |
| ) |
| results_path = Path(arm["official_results"]) |
| verify_artifact( |
| results_path, |
| str(arm["official_results_sha256"]), |
| f"{name} official results", |
| ) |
| checks_path = Path(arm["official_checks"]) |
| verify_artifact( |
| checks_path, |
| str(arm["official_checks_sha256"]), |
| f"{name} official checks", |
| ) |
| per_sample_path = Path(arm["official_per_sample"]) |
| verify_artifact( |
| per_sample_path, |
| str(arm["official_per_sample_sha256"]), |
| f"{name} official per-sample evidence", |
| ) |
|
|
| results = read_json(results_path) |
| checks = read_json(checks_path) |
| require(checks.get("status") == "passed", f"{name}: official checks did not pass") |
| require(results.get("status") == "complete", f"{name}: official result is incomplete") |
| require(results.get("partial_evaluation") is False, f"{name}: official result is partial") |
| require(results.get("checkpoint_epoch") == 299, f"{name}: checkpoint is not fixed-last epoch 299") |
| require(results.get("training_epochs") == 300, f"{name}: expected 300 training epochs") |
| require(results.get("training_completion", {}).get("training_complete") is True, f"{name}: training incomplete") |
| require(results.get("training_completion", {}).get("world_size") == 8, f"{name}: training world size is not 8") |
| require(results.get("metrics", {}).get("samples") == 50000, f"{name}: expected 50,000 official samples") |
| require(results.get("hashes", {}).get("checkpoint_sha256") == checkpoint_hash, f"{name}: certificate checkpoint hash mismatch") |
| require(results.get("topology", {}).get("model_state_schema_sha256") == EXPECTED_SCHEMA, f"{name}: model state schema mismatch") |
| require(results.get("topology", {}).get("parameter_count") == 7791544, f"{name}: parameter count mismatch") |
| require(results.get("topology", {}).get("state_tensor_count") == 365, f"{name}: state tensor count mismatch") |
| require(results.get("gate_intervention", {}).get("mode") == arm["gate_intervention"], f"{name}: intervention mismatch") |
| require( |
| abs(float(results["metrics"]["top1"]) - float(arm["official_top1"])) < 1e-12, |
| f"{name}: official Top-1 mismatch", |
| ) |
| require( |
| abs(float(results["metrics"]["top5"]) - float(arm["official_top5"])) < 1e-12, |
| f"{name}: official Top-5 mismatch", |
| ) |
| require(round(float(results["metrics"]["top1"]) * 500) == arm["official_top1_correct"], f"{name}: official Top-1 count mismatch") |
| require(round(float(results["metrics"]["top5"]) * 500) == arm["official_top5_correct"], f"{name}: official Top-5 count mismatch") |
| with np.load(per_sample_path, allow_pickle=False) as per_sample: |
| require( |
| set(per_sample.files) |
| == {"sample_index", "target", "prediction", "confidence", "correct", "top5_correct", "nll"}, |
| f"{name}: official per-sample schema mismatch", |
| ) |
| require( |
| all(per_sample[field].shape == (50000,) for field in per_sample.files), |
| f"{name}: official per-sample shapes mismatch", |
| ) |
| require( |
| np.array_equal(per_sample["sample_index"], np.arange(50000, dtype=np.int64)), |
| f"{name}: official per-sample index is not canonical", |
| ) |
| require(int(per_sample["correct"].sum()) == arm["official_top1_correct"], f"{name}: per-sample Top-1 count mismatch") |
| require(int(per_sample["top5_correct"].sum()) == arm["official_top5_correct"], f"{name}: per-sample Top-5 count mismatch") |
| permutation = results.get("gate_intervention", {}).get("permutation_manifest_sha256") |
| if name in {"C", "SC"}: |
| require(permutation == EXPECTED_PERMUTATION, f"{name}: frozen channel permutation mismatch") |
| if name == "D": |
| require( |
| results.get("gate_intervention", {}).get("batch_derangement_manifest_sha256"), |
| "D: missing official batch-derangement mapping manifest", |
| ) |
| return { |
| "arm": name, |
| "checkpoint_sha256": checkpoint_hash, |
| "official_top1": results["metrics"]["top1"], |
| "permutation_manifest_sha256": permutation, |
| "status": "passed", |
| } |
|
|
|
|
| def verify_runtime() -> dict[str, Any]: |
| import torch |
| import torchvision |
|
|
| require(torch.__version__ == EXPECTED_TORCH, f"expected torch {EXPECTED_TORCH}, got {torch.__version__}") |
| require(torchvision.__version__ == EXPECTED_TORCHVISION, f"expected torchvision {EXPECTED_TORCHVISION}, got {torchvision.__version__}") |
| require(torch.cuda.is_available(), "CUDA is unavailable") |
| require(torch.cuda.device_count() == 8, f"expected exactly 8 visible GPUs, got {torch.cuda.device_count()}") |
| return { |
| "python": sys.version.split()[0], |
| "torch": torch.__version__, |
| "torchvision": torchvision.__version__, |
| "cuda_devices": torch.cuda.device_count(), |
| } |
|
|
|
|
| def verify_equivalence(path: Path, manifest: dict[str, Any]) -> dict[str, Any]: |
| evidence = read_json(path) |
| require(evidence.get("status") == "passed", "source-equivalence audit did not pass") |
| require(evidence.get("runtime", {}).get("torch") == EXPECTED_TORCH, "source-equivalence audit did not run under torch 2.9") |
| provenance = manifest["code_provenance"] |
| require(evidence.get("old_source", {}).get("sha256") == provenance["alignment_source_gmnet_sha256"], "source-equivalence old source mismatch") |
| require(evidence.get("new_source", {}).get("sha256") == provenance["audit_runtime_gmnet_sha256"], "source-equivalence current source mismatch") |
| arms = evidence.get("arms", []) |
| require({arm.get("arm") for arm in arms} == {"B", "S", "C"}, "source-equivalence arm set mismatch") |
| for arm in arms: |
| name = arm["arm"] |
| for field in ( |
| "forward_bitwise_equal", |
| "input_gradient_bitwise_equal", |
| "parameter_gradients_bitwise_equal", |
| ): |
| require(arm.get(field) is True, f"source-equivalence {name} failed {field}") |
| require(all(float(value) == 0.0 for value in arm.get("maximum_abs", {}).values()), f"source-equivalence {name} has nonzero error") |
| require(arm.get("parameter_count") == 7791544, f"source-equivalence {name} parameter count mismatch") |
| require(arm.get("state_tensor_count") == 365, f"source-equivalence {name} state count mismatch") |
| stop = evidence.get("explicit_stop_gradient_semantics", {}) |
| require(stop.get("stop_gradient_matches_detached_formula") is True, "stop-gradient formula audit failed") |
| require(stop.get("baseline_matches_full_formula") is True, "baseline gradient formula audit failed") |
| return {"path": str(path), "sha256": sha256(path), "status": "passed"} |
|
|
|
|
| def verify_frozen_subset(manifest: dict[str, Any]) -> tuple[list[dict[str, Any]], dict[str, Any]]: |
| registration = manifest["spectral_subset"] |
| path = Path(registration["artifact_path"]) |
| digest = verify_artifact(path, registration["sha256"], "frozen spectral subset") |
| rows = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line] |
| require(len(rows) == registration["num_samples"] == 4096, "frozen spectral subset row count mismatch") |
| indices = [row.get("canonical_index") for row in rows] |
| require(len(set(indices)) == 4096, "frozen spectral subset indices are not unique") |
| counts: dict[int, int] = {} |
| for row in rows: |
| require( |
| set(row) |
| == {"canonical_index", "relative_path", "class_id", "selection_sha256", "within_class_rank", "selection_kind"}, |
| "frozen spectral subset row schema mismatch", |
| ) |
| class_id = int(row["class_id"]) |
| counts[class_id] = counts.get(class_id, 0) + 1 |
| expected_hash = hashlib.sha256( |
| b"gmnet-e4-spectral-v1\0" + row["relative_path"].encode("utf-8") |
| ).hexdigest() |
| require(row["selection_sha256"] == expected_hash, "frozen spectral subset selection hash mismatch") |
| rank = row["within_class_rank"] |
| require(rank in range(1, 6), "frozen spectral subset rank is outside 1..5") |
| require( |
| row["selection_kind"] == ("base_four" if rank <= 4 else "extra_fifth"), |
| "frozen spectral subset kind/rank mismatch", |
| ) |
| require(set(counts) == set(range(1000)), "frozen spectral subset does not cover all classes") |
| histogram = {count: list(counts.values()).count(count) for count in set(counts.values())} |
| require(histogram == {4: 904, 5: 96}, f"frozen spectral subset class balance mismatch: {histogram}") |
| return rows, {"path": str(path), "sha256": digest, "rows": len(rows), "class_histogram": histogram} |
|
|
|
|
| def verify_data_root(path: Path, manifest: dict[str, Any]) -> dict[str, Any]: |
| from gmnet.data import imagefolder_split_fingerprint |
| from torchvision import datasets |
|
|
| expected = Path(manifest["dataset"]["runtime_root"]) |
| require(path.resolve() == expected, f"data root must be {expected}, got {path.resolve()}") |
| ready_path = path / ".READY" |
| require(ready_path.is_file(), f"staged ImageNet marker missing: {ready_path}") |
| require((path / "train").is_dir(), f"ImageNet train directory missing: {path}") |
| require((path / "val").is_dir(), f"ImageNet val directory missing: {path}") |
| data = manifest["dataset"] |
| ready = read_json(ready_path) |
| require(ready.get("status") == "ready", "ImageNet .READY status is not ready") |
| require(ready.get("source") == data["source_archive_uri"], "ImageNet .READY source URI mismatch") |
| require(ready.get("archive_bytes") == data["expected_archive_bytes"], "ImageNet archive byte count mismatch") |
|
|
| val_root = path / "val" |
| imagefolder = datasets.ImageFolder(val_root) |
| require(len(imagefolder) == data["expected_val_samples"], "ImageNet validation count mismatch") |
| require(len(imagefolder.classes) == 1000, "ImageNet class count mismatch") |
| class_hash = hashlib.sha256( |
| json.dumps( |
| imagefolder.class_to_idx, |
| sort_keys=True, |
| separators=(",", ":"), |
| ensure_ascii=True, |
| ).encode("utf-8") |
| ).hexdigest() |
| require(class_hash == data["class_to_idx_sha256"], "ImageNet class mapping hash mismatch") |
| fingerprint = imagefolder_split_fingerprint(imagefolder, val_root) |
| require( |
| fingerprint["sample_index_sha256"] == data["val_sample_index_sha256"], |
| "ImageNet canonical validation order hash mismatch", |
| ) |
| require( |
| fingerprint["sampled_content_sha256"] == data["val_sampled_content_sha256"], |
| "ImageNet sampled validation content hash mismatch", |
| ) |
| require( |
| fingerprint["sampled_content_samples"] == data["val_sampled_content_samples"], |
| "ImageNet sampled validation content count mismatch", |
| ) |
| subset_rows, subset_summary = verify_frozen_subset(manifest) |
| samples = [ |
| (Path(sample_path).relative_to(val_root).as_posix(), int(class_id)) |
| for sample_path, class_id in imagefolder.samples |
| ] |
| for row in subset_rows: |
| index = int(row["canonical_index"]) |
| require(0 <= index < len(samples), "frozen subset canonical index is out of range") |
| require( |
| samples[index] == (row["relative_path"], int(row["class_id"])), |
| "frozen subset receiver identity differs from canonical ImageFolder order", |
| ) |
| return { |
| "data_root": str(path), |
| "status": "ready", |
| "class_to_idx_sha256": class_hash, |
| "frozen_subset": subset_summary, |
| **fingerprint, |
| } |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--manifest", type=Path, required=True) |
| parser.add_argument("--runner", type=Path) |
| parser.add_argument("--runner-sha256") |
| parser.add_argument("--runtime", action="store_true") |
| parser.add_argument("--data-root", type=Path) |
| parser.add_argument("--equivalence", type=Path) |
| args = parser.parse_args() |
|
|
| verify_artifact( |
| args.manifest, |
| EXPECTED_INPUT_MANIFEST_SHA256, |
| "frozen input manifest", |
| ) |
| manifest = read_json(args.manifest) |
| require(manifest.get("schema_version") == 1, "unsupported manifest schema") |
| require(manifest.get("protocol_id") == EXPECTED_PROTOCOL_ID, "protocol ID changed") |
| protocol = manifest["protocol"] |
| require( |
| protocol.get("sha256") == EXPECTED_PROTOCOL_SHA256, |
| "registered protocol SHA changed", |
| ) |
| verify_artifact(Path(protocol["path"]), protocol["sha256"], "frozen protocol") |
| provenance = manifest["code_provenance"] |
| expected_provenance = { |
| "audit_runtime_code_sha256": EXPECTED_AUDIT_RUNTIME_CODE_SHA256, |
| "alignment_training_code_sha256": EXPECTED_ALIGNMENT_TRAINING_CODE_SHA256, |
| "audit_runtime_manifest_sha256": EXPECTED_AUDIT_RUNTIME_MANIFEST_SHA256, |
| "alignment_training_manifest_sha256": EXPECTED_ALIGNMENT_TRAINING_MANIFEST_SHA256, |
| } |
| require( |
| all(provenance.get(key) == value for key, value in expected_provenance.items()), |
| "frozen training-code provenance changed", |
| ) |
| for prefix in ("audit_runtime", "alignment_training"): |
| path = Path(provenance[f"{prefix}_manifest"]) |
| verify_artifact(path, provenance[f"{prefix}_manifest_sha256"], f"{prefix} code manifest") |
| code_manifest = read_json(path) |
| require( |
| code_manifest.get("code_sha256") == provenance[f"{prefix}_code_sha256"], |
| f"{prefix} code SHA does not match its manifest", |
| ) |
| verify_artifact( |
| Path(provenance["alignment_source_snapshot_manifest"]), |
| provenance["alignment_source_snapshot_manifest_sha256"], |
| "alignment source snapshot manifest", |
| ) |
| arms = manifest.get("arms") |
| require(isinstance(arms, list) and len(arms) == 5, "manifest must contain five arms") |
| names = [str(arm.get("arm")) for arm in arms] |
| require(set(names) == EXPECTED_ARMS and len(names) == len(set(names)), f"invalid arms: {names}") |
|
|
| verified_arms = [verify_arm(arm) for arm in arms] |
| permutations = { |
| arm["permutation_manifest_sha256"] |
| for arm in verified_arms |
| if arm["arm"] in {"C", "SC"} |
| } |
| require(permutations == {EXPECTED_PERMUTATION}, "C and SC permutation manifests differ") |
| summary: dict[str, Any] = { |
| "protocol_id": manifest["protocol_id"], |
| "manifest_sha256": sha256(args.manifest), |
| "arms": verified_arms, |
| } |
| _, summary["frozen_subset"] = verify_frozen_subset(manifest) |
| if args.runner is not None: |
| require(args.runner_sha256 is not None, "--runner-sha256 is required with --runner") |
| summary["runner"] = { |
| "path": str(args.runner), |
| "sha256": verify_artifact(args.runner, args.runner_sha256, "spectral runner"), |
| } |
| if args.runtime: |
| summary["runtime"] = verify_runtime() |
| if args.data_root is not None: |
| summary["data"] = verify_data_root(args.data_root, manifest) |
| if args.equivalence is not None: |
| summary["source_equivalence"] = verify_equivalence(args.equivalence, manifest) |
| summary["status"] = "passed" |
| print(json.dumps(summary, indent=2, sort_keys=True)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
