Download code/verify_factor_intervention_cache.py from ij/anima-style-factor-intervention-v4: direct link, hf CLI and curl.
- Browser
- Download file 13.5 kB
-
https://huggingface.co/datasets/ij/anima-style-factor-intervention-v4/resolve/main/code/verify_factor_intervention_cache.py
- Command line
-
hf download hf://datasets/ij/anima-style-factor-intervention-v4/code/verify_factor_intervention_cache.py
-
curl -L -o verify_factor_intervention_cache.py https://huggingface.co/datasets/ij/anima-style-factor-intervention-v4/resolve/main/code/verify_factor_intervention_cache.py
13.5 kB
| 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()) | |