from __future__ import annotations import argparse from collections import Counter import hashlib import json from pathlib import Path import time import torch from safetensors.torch import load_file EXPECTED_ROWS = 108_096 EXPECTED_TRAIN = 104_000 EXPECTED_VALIDATION = 4_096 EXPECTED_ANCHORS = 72_000 EXPECTED_VERSION = "lens-safe-v4" COMPARE_FIELDS = ( "source_record_id", "style_id", "source", "split", "shard", "factor", "factor_index", "family", "level", "sign", "signed_intensity", "operation_seed", "transform_version", "anchor_kind", "repeat_of", "panel", "anima_pilot", ) def read_json(path: Path) -> dict: return json.loads(path.read_text(encoding="utf-8")) def read_jsonl(path: Path) -> list[dict]: with path.open(encoding="utf-8") as handle: return [json.loads(line) for line in handle if line.strip()] def distribution(rows: list[dict]) -> dict[str, dict[str, int]]: output = {} for field in ("split", "source", "factor", "family", "level", "anchor_kind"): output[field] = dict(sorted(Counter(str(row[field]) for row in rows).items())) return output def read_packed_sources(root: Path, needed: set[str], errors: list[str]) -> dict[str, dict]: sources: dict[str, dict] = {} paths = sorted(root.glob("train-rank*/features-*.json")) + sorted( root.glob("validation-*/features-*.json") ) if not paths: add_error(errors, f"packed metadata is missing under {root}") return sources for path in paths: try: rows = read_json(path).get("records", []) except (OSError, json.JSONDecodeError) as error: add_error(errors, f"invalid packed metadata {path}: {error}") continue for row in rows: record_id = str(row.get("record_id")) if record_id not in needed: continue if record_id in sources: add_error(errors, f"duplicate source record in packed metadata: {record_id}") sources[record_id] = row return sources def add_error(errors: list[str], message: str) -> None: if len(errors) < 100: errors.append(message) def main() -> int: parser = argparse.ArgumentParser(description="Verify the factor-intervention feature cache.") parser.add_argument("--run-root", type=Path, required=True) parser.add_argument("--packed-root", type=Path, required=True) parser.add_argument("--output", type=Path) args = parser.parse_args() started = time.perf_counter() manifest_path = args.run_root / "manifest.jsonl" cache = args.run_root / "full_external" output = args.output or args.run_root / "verification.json" errors: list[str] = [] manifest_rows = read_jsonl(manifest_path) manifest_sha256 = hashlib.sha256(manifest_path.read_bytes()).hexdigest() manifest_by_id = {str(row["record_id"]): row for row in manifest_rows} if len(manifest_by_id) != len(manifest_rows): add_error(errors, "manifest contains duplicate record IDs") if len(manifest_rows) != EXPECTED_ROWS: add_error(errors, f"manifest row count {len(manifest_rows)} != {EXPECTED_ROWS}") if sum(row["split"] == "train" for row in manifest_rows) != EXPECTED_TRAIN: add_error(errors, "manifest train count mismatch") if sum(row["split"] == "validation" for row in manifest_rows) != EXPECTED_VALIDATION: add_error(errors, "manifest validation count mismatch") train_anchors = {row["source_record_id"] for row in manifest_rows if row["split"] == "train"} if len(train_anchors) != EXPECTED_ANCHORS: add_error(errors, f"unique train anchors {len(train_anchors)} != {EXPECTED_ANCHORS}") if {row.get("transform_version") for row in manifest_rows} != {EXPECTED_VERSION}: add_error(errors, "manifest transform version mismatch") train_rows = [row for row in manifest_rows if row["split"] == "train"] validation_rows = [row for row in manifest_rows if row["split"] == "validation"] train_source_ids = {row["source_record_id"] for row in train_rows} validation_source_ids = {row["source_record_id"] for row in validation_rows} if train_source_ids & validation_source_ids: add_error(errors, "train and validation source records overlap") train_style_ids = {row["style_id"] for row in train_rows} validation_style_ids = {row["style_id"] for row in validation_rows} if train_style_ids & validation_style_ids: add_error(errors, "train and validation style identities overlap") for row in train_rows: repeat_of = row.get("repeat_of") if repeat_of is None: continue base = manifest_by_id.get(str(repeat_of)) if base is None: add_error(errors, f"repeat base is missing: {repeat_of}") continue for field in ("source_record_id", "style_id", "source", "factor", "family", "sign"): if row.get(field) != base.get(field): add_error(errors, f"repeat pair differs in {field}: {row['record_id']}") break if row.get("level") == base.get("level"): add_error(errors, f"repeat pair has identical intensity: {row['record_id']}") source_ids = {row["source_record_id"] for row in manifest_rows} packed_sources = read_packed_sources(args.packed_root, source_ids, errors) missing_sources = source_ids - set(packed_sources) if missing_sources: add_error(errors, f"source IDs absent from packed metadata: {len(missing_sources)}") for row in manifest_rows: source = packed_sources.get(row["source_record_id"]) if source is None: continue for field in ("style_id", "source", "split", "shard"): if row.get(field) != source.get(field): add_error(errors, f"{row['record_id']}: source {field} alignment mismatch") break summaries = [] for worker in range(4): path = cache / f"intervention-worker-{worker}.json" try: summary = read_json(path) except (FileNotFoundError, OSError, json.JSONDecodeError) as error: add_error(errors, f"invalid worker summary {worker}: {error}") continue summaries.append(summary) if summary.get("status") != "complete" or summary.get("mode") != "full": add_error(errors, f"worker {worker} is not complete/full") if summary.get("manifest_sha256") != manifest_sha256: add_error(errors, f"worker {worker} manifest hash mismatch") if sum(int(row.get("records", 0)) for row in summaries) != EXPECTED_ROWS: add_error(errors, "worker summary row total mismatch") json_parts = sorted(cache.glob("intervention-w*-p*.json")) tensor_parts = sorted(cache.glob("intervention-w*-p*.safetensors")) json_stems = {path.stem for path in json_parts} tensor_stems = {path.name.removesuffix(".safetensors") for path in tensor_parts} if json_stems != tensor_stems: add_error(errors, "JSON/safetensors part pairing mismatch") temporary_files = sorted(cache.glob(".*.tmp")) if temporary_files: add_error(errors, f"temporary part files remain: {temporary_files[0].name}") cached_ids: set[str] = set() cached_rows: list[dict] = [] part_indices: dict[int, list[int]] = {worker: [] for worker in range(4)} finite_tensors = 0 tensor_bytes = 0 for metadata_path in json_parts: try: metadata = read_json(metadata_path) except (OSError, json.JSONDecodeError) as error: add_error(errors, f"invalid part metadata {metadata_path.name}: {error}") continue worker = int(metadata.get("worker_index", -1)) part_index = int(metadata.get("part_index", -1)) if worker not in part_indices: add_error(errors, f"invalid worker index in {metadata_path.name}") continue part_indices[worker].append(part_index) if metadata.get("manifest_sha256") != manifest_sha256: add_error(errors, f"manifest hash mismatch in {metadata_path.name}") if metadata.get("kind") != "factor_intervention_full_face": add_error(errors, f"feature kind mismatch in {metadata_path.name}") if metadata.get("backbone") != "siglip2_so400m" or metadata.get("layer_indices") != [6, 14, 26]: add_error(errors, f"backbone metadata mismatch in {metadata_path.name}") records = metadata.get("records", []) tensor_path = metadata_path.with_suffix(".safetensors") try: tensors = load_file(tensor_path, device="cpu") except Exception as error: add_error(errors, f"cannot load {tensor_path.name}: {error}") continue tensor_bytes += tensor_path.stat().st_size expected = { "full": ((len(records), 30, 1152), torch.bfloat16), "face": ((len(records), 30, 1152), torch.bfloat16), "face_mask": ((len(records),), torch.bool), } if set(tensors) != set(expected): add_error(errors, f"tensor keys mismatch in {tensor_path.name}") valid_contract = True for name, (shape, dtype) in expected.items(): tensor = tensors.get(name) if tensor is None or tuple(tensor.shape) != shape or tensor.dtype != dtype: add_error(errors, f"{name} contract mismatch in {tensor_path.name}") valid_contract = False continue if not torch.isfinite(tensor).all().item(): add_error(errors, f"non-finite {name} tensor in {tensor_path.name}") valid_contract = False if valid_contract: finite_tensors += len(expected) if "face_mask" in tensors and len(records) == tensors["face_mask"].shape[0]: declared = torch.tensor([bool(row.get("face_present")) for row in records]) if not torch.equal(declared, tensors["face_mask"]): add_error(errors, f"face mask/metadata mismatch in {tensor_path.name}") for row in records: record_id = str(row.get("record_id")) if record_id in cached_ids: add_error(errors, f"duplicate cached record ID: {record_id}") cached_ids.add(record_id) cached_rows.append(row) manifest_row = manifest_by_id.get(record_id) if manifest_row is None: add_error(errors, f"cached ID absent from manifest: {record_id}") continue for field in COMPARE_FIELDS: if row.get(field) != manifest_row.get(field): add_error(errors, f"{record_id}: {field} differs from manifest") break if row.get("source_shard") != row.get("shard"): add_error(errors, f"{record_id}: source shard alignment mismatch") for worker, indices in part_indices.items(): if sorted(indices) != list(range(len(indices))): add_error(errors, f"worker {worker} part indices are not contiguous") missing_ids = set(manifest_by_id) - cached_ids extra_ids = cached_ids - set(manifest_by_id) if missing_ids: add_error(errors, f"missing cached IDs: {len(missing_ids)}") if extra_ids: add_error(errors, f"extra cached IDs: {len(extra_ids)}") if len(cached_rows) != EXPECTED_ROWS: add_error(errors, f"cached row count {len(cached_rows)} != {EXPECTED_ROWS}") manifest_distribution = distribution(manifest_rows) cache_distribution = distribution(cached_rows) if cache_distribution != manifest_distribution: add_error(errors, "cached distribution differs from manifest") expected_pilot_ids = { row["record_id"] for row in manifest_rows if bool(row.get("anima_pilot")) } pilot_dir = args.run_root / "anima_pilot_images" actual_pilot_ids = {path.stem for path in pilot_dir.glob("*.webp")} if actual_pilot_ids != expected_pilot_ids: add_error( errors, f"Anima pilot image IDs differ: missing={len(expected_pilot_ids - actual_pilot_ids)}, extra={len(actual_pilot_ids - expected_pilot_ids)}", ) report = { "status": "pass" if not errors else "fail", "transform_version": EXPECTED_VERSION, "manifest_sha256": manifest_sha256, "manifest_rows": len(manifest_rows), "cached_rows": len(cached_rows), "unique_cached_ids": len(cached_ids), "parts": len(json_parts), "finite_tensor_contracts": finite_tensors, "tensor_bytes": tensor_bytes, "worker_summaries": summaries, "unique_train_anchors": len(train_anchors), "packed_sources_found": len(packed_sources), "train_style_identities": len(train_style_ids), "validation_style_identities": len(validation_style_ids), "anima_pilot_images": len(actual_pilot_ids), "distribution": cache_distribution, "elapsed_seconds": time.perf_counter() - started, "errors": errors, } output.parent.mkdir(parents=True, exist_ok=True) temporary = output.with_suffix(output.suffix + ".tmp") temporary.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8") temporary.replace(output) print(json.dumps(report, indent=2)) return 0 if not errors else 1 if __name__ == "__main__": raise SystemExit(main())