Upload scripts/verify_stage4_checkpoint.py with huggingface_hub

scripts/verify_stage4_checkpoint.py

@@ -0,0 +1,161 @@
+"""Independently verify a Pear1.5 stage checkpoint and its completion receipt.
+
+Checks are purely mechanical: deterministic READY marker, manifest fields, payload
+SHA-256/size, reloaded step/token counters, data cursor, model/implementation
+identity, lineage hash and campaign arithmetic.
+
+This script does **not** run a benchmark and does **not** produce or claim an
+official Artificial Analysis score. A benchmark is a separate, explicitly labeled
+record.
+"""
+import argparse
+import hashlib
+import json
+import re
+from pathlib import Path
+
+FORMAT = "pear15.cloud_checkpoint.v1"
+DIRECTORY = re.compile(r"step_([0-9]{12})_([0-9a-f]{32})\Z")
+FIELDS = {"format", "file", "sha256", "bytes", "step", "created_ns", "id"}
+DIGEST = re.compile(r"[0-9a-f]{64}\Z")
+
+
+def sha256_file(path, chunk=1 << 20):
+    digest = hashlib.sha256()
+    with Path(path).open("rb") as stream:
+        while True:
+            block = stream.read(chunk)
+            if not block:
+                return digest.hexdigest()
+            digest.update(block)
+
+
+def canonical_hash(value):
+    return hashlib.sha256(
+        json.dumps(value, sort_keys=True, separators=(",", ":")).encode()
+    ).hexdigest()
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dir", type=Path, required=True, help="local checkpoint directory")
+    parser.add_argument("--receipt", type=Path, required=True, help="stage completion receipt")
+    parser.add_argument("--parent-sha", required=True)
+    parser.add_argument("--parent-step", type=int, required=True)
+    parser.add_argument("--parent-tokens", type=int, required=True)
+    parser.add_argument("--data-fp", required=True)
+    parser.add_argument("--runner-sha", required=True)
+    parser.add_argument("--implementation-fp", required=True)
+    parser.add_argument("--tokens-per-step", type=int, default=16384)
+    parser.add_argument("--target", type=int, default=50_000_000_000)
+    parser.add_argument("--out", type=Path)
+    args = parser.parse_args()
+
+    checks = {}
+    errors = []
+
+    def check(name, condition, detail=None):
+        ok = bool(condition)
+        checks[name] = ok if detail is None else {"ok": ok, "detail": detail}
+        if not ok:
+            errors.append(name)
+
+    directory = args.dir
+    match = DIRECTORY.fullmatch(directory.name)
+    check("directory_name", match is not None, directory.name)
+
+    manifest_raw = (directory / "manifest.json").read_bytes()
+    ready = (directory / "READY").read_bytes()
+    expected_ready = (FORMAT + "\n" + hashlib.sha256(manifest_raw).hexdigest() + "\n").encode("ascii")
+    check("ready_marker", ready == expected_ready, {"bytes": len(ready)})
+
+    manifest = json.loads(manifest_raw)
+    check("manifest_fields", isinstance(manifest, dict) and set(manifest) == FIELDS)
+    check("manifest_format", manifest.get("format") == FORMAT and manifest.get("file") == "checkpoint.pt")
+    if match:
+        check("manifest_step", manifest.get("step") == int(match.group(1)))
+        check("manifest_id", manifest.get("id") == match.group(2))
+    check("manifest_bytes", type(manifest.get("bytes")) is int and manifest["bytes"] > 0)
+    check("manifest_sha_format", isinstance(manifest.get("sha256"), str) and DIGEST.fullmatch(manifest["sha256"]) is not None)
+    check("manifest_created_ns", type(manifest.get("created_ns")) is int and manifest["created_ns"] >= 0)
+
+    payload_path = directory / "checkpoint.pt"
+    size = payload_path.stat().st_size
+    check("payload_size", size == manifest.get("bytes"), {"actual": size, "manifest": manifest.get("bytes")})
+    actual_sha = sha256_file(payload_path)
+    check("payload_sha256", actual_sha == manifest.get("sha256"), {"actual": actual_sha})
+
+    import torch
+
+    payload = torch.load(payload_path, map_location="cpu", weights_only=True)
+    check("payload_type", isinstance(payload, dict))
+    check("payload_step", payload.get("step") == manifest.get("step"), {"payload": payload.get("step")})
+    token_count = payload.get("token_count")
+    check("token_count_integer", type(token_count) is int and token_count >= 0, token_count)
+    if type(token_count) is int:
+        check("token_count_arithmetic", token_count == manifest["step"] * args.tokens_per_step,
+              {"token_count": token_count, "step": manifest["step"], "per_step": args.tokens_per_step})
+    cursor = payload.get("data_cursor") or {}
+    check("data_cursor_offset", cursor.get("offset_tokens") == token_count, cursor)
+    check("data_cursor_epoch", cursor.get("epoch") == 0, cursor)
+
+    identity = payload.get("identity") or {}
+    check("implementation_fingerprint", identity.get("implementation_fingerprint") == args.implementation_fp)
+    check("dataset_fingerprint", identity.get("dataset_fingerprint") == args.data_fp)
+    check("model_fingerprint_present", isinstance(identity.get("model_fingerprint"), str) and DIGEST.fullmatch(identity["model_fingerprint"]) is not None)
+    config = payload.get("model_config") or {}
+    check("model_config", config.get("model_type") == "llama" and config.get("vocab_size") == 49152
+          and config.get("hidden_size") == 576 and config.get("num_hidden_layers") == 30
+          and config.get("num_attention_heads") == 9 and config.get("num_key_value_heads") == 3,
+          {k: config.get(k) for k in ("model_type", "vocab_size", "hidden_size", "num_hidden_layers", "num_attention_heads", "num_key_value_heads")})
+
+    receipt = json.loads(Path(args.receipt).read_text())
+    check("receipt_format", receipt.get("format") == "pear15-stage-session-completion-v1")
+    lineage = receipt.get("lineage") or {}
+    check("receipt_lineage_hash", receipt.get("lineage_sha256") == canonical_hash(lineage))
+    check("lineage_parent_sha", lineage.get("parent_checkpoint_sha256") == args.parent_sha)
+    check("lineage_parent_step", lineage.get("parent_step") == args.parent_step)
+    check("lineage_parent_tokens", lineage.get("parent_campaign_token_count") == args.parent_tokens)
+    check("lineage_dataset", lineage.get("dataset_fingerprint") == args.data_fp)
+    check("lineage_runner", lineage.get("initializer_source_sha256") == args.runner_sha)
+    check("lineage_target", lineage.get("target_campaign_exposures") == args.target)
+
+    claimed = (receipt.get("checkpoint") or {}).get("manifest") or {}
+    check("receipt_manifest_sha", claimed.get("sha256") == manifest["sha256"])
+    check("receipt_manifest_bytes", claimed.get("bytes") == manifest["bytes"])
+    check("receipt_manifest_step", claimed.get("step") == manifest["step"])
+
+    summary = receipt.get("summary") or {}
+    check("receipt_summary_step", summary.get("step") == payload.get("step"))
+    check("receipt_summary_tokens", summary.get("token_count") == token_count)
+    check("receipt_session_completed", receipt.get("training_session_completed") is True)
+    campaign = args.parent_tokens + token_count if type(token_count) is int else None
+    check("campaign_counter", receipt.get("campaign_token_count") == campaign,
+          {"receipt": receipt.get("campaign_token_count"), "computed": campaign})
+    check("remaining_counter", receipt.get("remaining_campaign_tokens") == max(0, args.target - campaign)
+          if campaign is not None else False)
+
+    result = {
+        "format": "pear15-stage-checkpoint-verification-v1",
+        "verified": not errors,
+        "errors": errors,
+        "checkpoint_dir": str(directory),
+        "step": payload.get("step"),
+        "token_count": token_count,
+        "campaign_token_count": campaign,
+        "remaining_campaign_tokens": max(0, args.target - campaign) if campaign is not None else None,
+        "manifest_sha256": manifest.get("sha256"),
+        "payload_sha256": actual_sha,
+        "lineage_sha256": receipt.get("lineage_sha256"),
+        "checks": checks,
+        "note": "Mechanical checkpoint/lineage verification only. No benchmark and no official Artificial Analysis score is implied.",
+    }
+    text = json.dumps(result, indent=2, sort_keys=True)
+    print(text)
+    if args.out:
+        args.out.write_text(text + "\n", encoding="utf-8")
+    raise SystemExit(0 if result["verified"] else 1)
+
+
+if __name__ == "__main__":
+    main()