| |
| """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, |
| ) |
|
|
| |
| |
| 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() |
|
|
