from __future__ import annotations import argparse from collections import defaultdict import hashlib import json from pathlib import Path import sys ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT / "src")) from anima_style_probe.factor_interventions import ( # noqa: E402 FACTORS, INTERVENTION_VERSION, LEVELS, TRAIN_FAMILIES, VALIDATION_FAMILIES, ) def stable_int(*values: object) -> int: text = "|".join(map(str, values)) return int.from_bytes(hashlib.blake2b(text.encode(), digest_size=8).digest(), "little") def read_records(paths: list[Path]) -> list[dict]: records: list[dict] = [] seen: set[str] = set() for path in paths: payload = json.loads(path.read_text(encoding="utf-8")) for row in payload["records"]: record_id = str(row["record_id"]) if record_id in seen: raise RuntimeError(f"duplicate packed record: {record_id}") seen.add(record_id) records.append(row) return records def intensity_for(key: object) -> tuple[str, int]: value = stable_int("intensity", key) % 10 level = "weak" if value < 4 else "medium" if value < 8 else "strong" sign = 1 if stable_int("sign", key) % 2 else -1 return level, sign def intervention_row( source: dict, factor: str, family: str, level: str, sign: int, *, anchor_kind: str, repeat_of: str | None = None, validation: bool = False, ) -> dict: suffix = f"{factor}-{family}-{level}-{'p' if sign > 0 else 'n'}" if repeat_of is not None: suffix += "-repeat" intervention_id = f"{source['record_id']}__{suffix}" return { "record_id": intervention_id, "source_record_id": source["record_id"], "style_id": source["style_id"], "source": source["source"], "split": "validation" if validation else "train", "shard": source["shard"], "factor": factor, "factor_index": FACTORS.index(factor), "family": family, "level": level, "sign": sign, "signed_intensity": sign * LEVELS[level], "operation_seed": stable_int("operation", intervention_id) & ((1 << 63) - 1), "transform_version": INTERVENTION_VERSION, "anchor_kind": anchor_kind, "repeat_of": repeat_of, "panel": False, "anima_pilot": False, } def build_training(records: list[dict]) -> list[dict]: by_style: dict[str, list[dict]] = defaultdict(list) for row in records: by_style[str(row["style_id"])].append(row) if len(by_style) != 8_000: raise RuntimeError(f"expected 8,000 train identities, found {len(by_style)}") output: list[dict] = [] for style_id, rows in sorted(by_style.items()): if len(rows) != 40: raise RuntimeError(f"{style_id} has {len(rows)} optimization records, expected 40") ordered = sorted(rows, key=lambda row: stable_int("anchor", row["record_id"])) shared = ordered[0] specific = iter(ordered[1:9]) factor_rows: dict[str, list[dict]] = defaultdict(list) for factor in FACTORS: families = list(TRAIN_FAMILIES[factor]) rotation = stable_int("family", style_id, factor) % len(families) families = families[rotation:] + families[:rotation] anchors = [shared, next(specific), next(specific)] for index, (source, family) in enumerate(zip(anchors, families, strict=True)): level, sign = intensity_for((style_id, factor, family)) row = intervention_row( source, factor, family, level, sign, anchor_kind="shared" if index == 0 else "factor_specific", ) output.append(row) factor_rows[factor].append(row) repeat_factor = FACTORS[stable_int("repeat-factor", style_id) % len(FACTORS)] base = factor_rows[repeat_factor][stable_int("repeat-row", style_id) % 3] second_level = {"weak": "medium", "medium": "strong", "strong": "medium"}[base["level"]] source = next(row for row in rows if row["record_id"] == base["source_record_id"]) output.append( intervention_row( source, base["factor"], base["family"], second_level, base["sign"], anchor_kind="intensity_repeat", repeat_of=base["record_id"], ) ) if len(output) != 104_000: raise RuntimeError(f"expected 104,000 train variants, found {len(output)}") by_stratum: dict[tuple[str, str], list[dict]] = defaultdict(list) for row in output: if row["anchor_kind"] != "intensity_repeat": by_stratum[(row["source"], row["factor"])].append(row) for rows in by_stratum.values(): for row in sorted(rows, key=lambda item: stable_int("panel", item["record_id"]))[:128]: row["panel"] = True if sum(row["panel"] for row in output) != 1_024: raise RuntimeError("failed to build balanced 1,024-record panel") return output def build_validation(records: list[dict]) -> list[dict]: by_source_style: dict[str, dict[str, list[dict]]] = defaultdict(lambda: defaultdict(list)) for row in records: if row.get("split") == "validation": by_source_style[row["source"]][row["style_id"]].append(row) output: list[dict] = [] for source in ("synthetic", "human"): styles = sorted( by_source_style[source], key=lambda style: stable_int("validation-style", style) )[:256] if len(styles) != 256: raise RuntimeError(f"{source} has only {len(styles)} unseen validation identities") for style_id in styles: base = min( by_source_style[source][style_id], key=lambda row: stable_int("validation-record", row["record_id"]), ) for factor in FACTORS: family = VALIDATION_FAMILIES[factor] sign = 1 if stable_int("validation-sign", style_id, factor) % 2 else -1 for level in ("weak", "strong"): output.append( intervention_row( base, factor, family, level, sign, anchor_kind="validation_intensity", validation=True, ) ) if len(output) != 4_096: raise RuntimeError(f"expected 4,096 validation variants, found {len(output)}") for row in output: row["anima_pilot"] = True return output def main() -> int: parser = argparse.ArgumentParser(description="Build the factor-intervention subset manifest.") parser.add_argument("--packed-root", type=Path, required=True) parser.add_argument("--output", type=Path, required=True) args = parser.parse_args() train_paths = sorted(args.packed_root.glob("train-rank*/features-*.json")) validation_paths = sorted(args.packed_root.glob("validation-*/features-*.json")) if not train_paths or not validation_paths: raise FileNotFoundError("packed train or validation metadata is missing") train = build_training(read_records(train_paths)) validation = build_validation(read_records(validation_paths)) rows = train + validation if len({row["record_id"] for row in rows}) != len(rows): raise RuntimeError("duplicate intervention record IDs") args.output.parent.mkdir(parents=True, exist_ok=True) temporary = args.output.with_suffix(args.output.suffix + ".tmp") with temporary.open("w", encoding="utf-8", newline="\n") as handle: for row in rows: handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n") temporary.replace(args.output) summary = { "status": "complete", "train_variants": len(train), "validation_variants": len(validation), "unique_train_anchors": len({row["source_record_id"] for row in train}), "panel": sum(row["panel"] for row in train), "anima_pilot": sum(row["anima_pilot"] for row in validation), "transform_version": INTERVENTION_VERSION, "output": str(args.output), } args.output.with_suffix(".summary.json").write_text( json.dumps(summary, indent=2) + "\n", encoding="utf-8" ) print(json.dumps(summary, indent=2)) return 0 if __name__ == "__main__": raise SystemExit(main())