File size: 4,365 Bytes
cbf7f76 56f230a cbf7f76 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 | #!/usr/bin/env python3
"""Validate checksums and tensor invariants for this artifact bundle."""
from __future__ import annotations
import hashlib
import json
import math
from pathlib import Path
ROOT = Path(__file__).resolve().parent
def sha256(path: Path) -> str:
digest = hashlib.sha256()
with path.open("rb") as handle:
for chunk in iter(lambda: handle.read(1024 * 1024), b""):
digest.update(chunk)
return digest.hexdigest()
def verify_manifest() -> None:
manifest = json.loads((ROOT / "manifest.json").read_text())
for relative, expected in manifest["files"].items():
path = ROOT / relative
if not path.is_file():
raise AssertionError(f"missing file: {relative}")
if path.stat().st_size != expected["bytes"]:
raise AssertionError(f"size mismatch: {relative}")
actual = sha256(path)
if actual != expected["sha256"]:
raise AssertionError(f"checksum mismatch: {relative}")
print(f"Checksums OK: {len(manifest['files'])} files")
def load_tensor(path, torch):
try:
return torch.load(path, map_location="cpu", weights_only=True)
except TypeError:
return torch.load(path, map_location="cpu")
def verify_layer_bundle(path: Path, layers: list[int], hidden_size: int, torch) -> None:
bundle = load_tensor(path, torch)
if set(bundle) != {"raw", "unit", "norm"}:
raise AssertionError(f"unexpected keys in {path}")
for family in ("raw", "unit", "norm"):
if set(bundle[family]) != set(layers):
raise AssertionError(f"layer mismatch in {path}:{family}")
for layer in layers:
raw = bundle["raw"][layer].float()
unit = bundle["unit"][layer].float()
stored_norm = float(bundle["norm"][layer])
if tuple(raw.shape) != (hidden_size,) or tuple(unit.shape) != (hidden_size,):
raise AssertionError(f"shape mismatch in {path}, layer {layer}")
actual_norm = float(raw.norm())
if not math.isclose(actual_norm, stored_norm, rel_tol=1e-5, abs_tol=1e-5):
raise AssertionError(f"raw norm mismatch in {path}, layer {layer}")
if not math.isclose(float(unit.norm()), 1.0, rel_tol=1e-5, abs_tol=1e-5):
raise AssertionError(f"unit norm mismatch in {path}, layer {layer}")
if not torch.allclose(unit, raw / raw.norm(), rtol=1e-5, atol=1e-6):
raise AssertionError(f"unit vector mismatch in {path}, layer {layer}")
def verify_tensors() -> None:
try:
import torch
except ImportError:
print("PyTorch not installed; skipped tensor-content validation")
return
for metadata_path in sorted(ROOT.glob("*/caa/metadata.json")):
metadata = json.loads(metadata_path.read_text())
verify_layer_bundle(
metadata_path.parent / "caa.pt",
metadata["vector"]["layers"],
metadata["model"]["hidden_size"],
torch,
)
# lat-pca, cs-grad and cs-lora all use the caa layer-bundle schema and name the file in
# metadata, so one loop covers every arm that ships a per-layer bundle.
for arm in ("lat-pca", "cs-grad", "cs-lora"):
for metadata_path in sorted(ROOT.glob(f"*/{arm}/metadata.json")):
metadata = json.loads(metadata_path.read_text())
verify_layer_bundle(
metadata_path.parent / metadata["vector"]["file"],
metadata["vector"]["layers"],
metadata["model"]["hidden_size"],
torch,
)
for metadata_path in sorted(ROOT.glob("*/direction-ablation/metadata.json")):
metadata = json.loads(metadata_path.read_text())
direction = load_tensor(metadata_path.parent / "direction.pt", torch).float()
expected_shape = (metadata["model"]["hidden_size"],)
if tuple(direction.shape) != expected_shape:
raise AssertionError(f"shape mismatch in {metadata_path.parent / 'direction.pt'}")
expected_norm = metadata["selection"]["direction_norm"]
if not math.isclose(float(direction.norm()), expected_norm, rel_tol=1e-5, abs_tol=1e-5):
raise AssertionError(f"norm mismatch in {metadata_path.parent / 'direction.pt'}")
print("Tensor contents OK")
if __name__ == "__main__":
verify_manifest()
verify_tensors()
|