File size: 8,270 Bytes
fa30c0a 68f349e fa30c0a 68f349e fa30c0a 68f349e fa30c0a 68f349e fa30c0a 68f349e fa30c0a | 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 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 | """Pure contract and provenance helpers for the Fable expert-router campaign.
This module intentionally has no Torch dependency. It is shared by local
unit tests, the Colab/Kaggle entry points, and the GPU structural smoke.
"""
from __future__ import annotations
import hashlib
import json
import struct
from dataclasses import dataclass
from pathlib import Path
from typing import Any, Iterable
EXPECTED_PROJECTIONS = {
"gate_proj.weight": (512, 2048),
"up_proj.weight": (512, 2048),
"down_proj.weight": (2048, 512),
}
DTYPE_BYTES = {"BF16": 2, "F16": 2}
def sha256(path: Path, chunk_size: int = 8 * 1024 * 1024) -> str:
digest = hashlib.sha256()
with path.open("rb") as handle:
while chunk := handle.read(chunk_size):
digest.update(chunk)
return digest.hexdigest()
def canonical_json_sha256(value: Any) -> str:
encoded = json.dumps(value, sort_keys=True, separators=(",", ":")).encode("utf-8")
return hashlib.sha256(encoded).hexdigest()
def read_json(path: Path) -> dict[str, Any]:
payload = json.loads(path.read_text(encoding="utf-8"))
if not isinstance(payload, dict):
raise ValueError(f"expected a JSON object: {path}")
return payload
def safetensors_header(path: Path) -> tuple[int, dict[str, Any]]:
with path.open("rb") as handle:
raw_size = handle.read(8)
if len(raw_size) != 8:
raise ValueError(f"truncated Safetensors size header: {path}")
size = struct.unpack("<Q", raw_size)[0]
if size < 2 or size > 256 * 1024 * 1024:
raise ValueError(f"implausible Safetensors header size {size}: {path}")
raw_header = handle.read(size)
if len(raw_header) != size:
raise ValueError(f"truncated Safetensors JSON header: {path}")
header = json.loads(raw_header)
if not isinstance(header, dict):
raise ValueError(f"Safetensors header is not an object: {path}")
return 8 + size, header
@dataclass(frozen=True)
class BankValidation:
bank_id: str
tensor_count: int
payload_bytes: int
dtypes: tuple[str, ...]
layers: tuple[int, ...]
def as_dict(self) -> dict[str, Any]:
return {
"bankId": self.bank_id,
"tensorCount": self.tensor_count,
"payloadBytes": self.payload_bytes,
"dtypes": list(self.dtypes),
"layers": list(self.layers),
}
def selected_expert_ids(bank: dict[str, Any], layer: int) -> list[int]:
raw = bank.get("selectedExperts", {}).get(str(layer))
if not isinstance(raw, list):
raise ValueError(f"bank {bank.get('id')} has no selected expert list for layer {layer}")
ids = [int(item) for item in raw]
if len(ids) != 32 or len(set(ids)) != 32:
raise ValueError(f"bank {bank.get('id')} layer {layer} must select 32 unique experts")
return ids
def expected_tensor_names(bank: dict[str, Any]) -> Iterable[tuple[int, int, str, tuple[int, int]]]:
for layer in range(30):
for expert in selected_expert_ids(bank, layer):
for projection, shape in EXPECTED_PROJECTIONS.items():
yield layer, expert, f"model.layers.{layer}.mlp.experts.{expert}.{projection}", shape
def validate_bank_header_entries(
header: dict[str, Any], file_payload: int, bank: dict[str, Any]
) -> BankValidation:
tensor_entries = {key: value for key, value in header.items() if key != "__metadata__"}
expected = list(expected_tensor_names(bank))
expected_names = {row[2] for row in expected}
actual_names = set(tensor_entries)
missing = sorted(expected_names - actual_names)
extra = sorted(actual_names - expected_names)
if missing or extra:
raise ValueError(
f"bank tensor identity mismatch: missing={missing[:3]} ({len(missing)}), "
f"extra={extra[:3]} ({len(extra)})"
)
dtypes: set[str] = set()
payload_bytes = 0
intervals: list[tuple[int, int, str]] = []
for layer, expert, name, expected_shape in expected:
entry = tensor_entries[name]
shape = tuple(int(item) for item in entry.get("shape", []))
if shape != expected_shape:
raise ValueError(
f"{name} has shape {shape}, expected {expected_shape} "
f"(layer={layer}, expert={expert})"
)
dtype = str(entry.get("dtype"))
if dtype not in DTYPE_BYTES:
raise ValueError(f"{name} has unsupported training dtype {dtype}")
offsets = entry.get("data_offsets")
if not isinstance(offsets, list) or len(offsets) != 2:
raise ValueError(f"{name} has malformed data offsets")
start, end = map(int, offsets)
expected_bytes = expected_shape[0] * expected_shape[1] * DTYPE_BYTES[dtype]
if start < 0 or end <= start or end - start != expected_bytes:
raise ValueError(
f"{name} has invalid data offsets {offsets}; expected {expected_bytes} bytes"
)
intervals.append((start, end, name))
payload_bytes += end - start
dtypes.add(dtype)
# Safetensors does not require tensor entries (or our selected-expert
# manifest) to be ordered by their payload offsets. Validate the physical
# layout independently from semantic tensor identity.
previous_end = 0
for start, end, name in sorted(intervals):
if start != previous_end:
relation = "overlap" if start < previous_end else "gap"
raise ValueError(
f"bank payload has a {relation} before {name}: "
f"expected offset {previous_end}, found {start}"
)
previous_end = end
if previous_end != file_payload or payload_bytes != file_payload:
raise ValueError(
f"bank payload coverage mismatch: last={previous_end}, summed={payload_bytes}, "
f"file={file_payload}"
)
return BankValidation(
bank_id=str(bank["id"]),
tensor_count=len(expected),
payload_bytes=payload_bytes,
dtypes=tuple(sorted(dtypes)),
layers=tuple(range(30)),
)
def validate_bank_header(bank_path: Path, bank: dict[str, Any]) -> BankValidation:
data_start, header = safetensors_header(bank_path)
return validate_bank_header_entries(header, bank_path.stat().st_size - data_start, bank)
def validate_curriculum_row(row: dict[str, Any], expected_split: str) -> None:
if row.get("schema") != "AutonomaFableRouterRecord.v2":
raise ValueError(f"unexpected curriculum schema: {row.get('schema')}")
if row.get("split") != expected_split:
raise ValueError(f"row split {row.get('split')} does not match {expected_split}")
if row.get("lane") not in {
"host_preservation",
"verified_expert",
"interaction_pattern",
}:
raise ValueError(f"unexpected curriculum lane: {row.get('lane')}")
messages = row.get("messages")
if not isinstance(messages, list) or not messages:
raise ValueError("curriculum row has no messages")
if not any(message.get("role") == "assistant" for message in messages if isinstance(message, dict)):
raise ValueError("curriculum row has no assistant target")
def iter_jsonl(path: Path) -> Iterable[dict[str, Any]]:
with path.open("r", encoding="utf-8") as handle:
for line_number, line in enumerate(handle, 1):
try:
payload = json.loads(line)
except json.JSONDecodeError as exc:
raise ValueError(f"invalid JSONL at {path}:{line_number}: {exc}") from exc
if not isinstance(payload, dict):
raise ValueError(f"non-object JSONL row at {path}:{line_number}")
yield payload
def verify_file(path: Path, expected_bytes: int, expected_sha256: str) -> dict[str, Any]:
actual_bytes = path.stat().st_size
actual_sha256 = sha256(path)
if actual_bytes != expected_bytes or actual_sha256 != expected_sha256:
raise ValueError(
f"artifact mismatch for {path}: bytes={actual_bytes}/{expected_bytes}, "
f"sha256={actual_sha256}/{expected_sha256}"
)
return {"path": str(path), "bytes": actual_bytes, "sha256": actual_sha256}
|