|
|
| 'Build zero-shot and jointly supervised cross-dataset training and evaluation manifests.'
|
|
|
| from __future__ import annotations
|
|
|
| import argparse
|
| import csv
|
| import hashlib
|
| import json
|
| import sys
|
| from collections import defaultdict
|
| from pathlib import Path
|
| from typing import Any
|
|
|
|
|
| PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
| SPLIT_DIR = PROJECT_ROOT / "artifacts" / "metadata" / "fixed_split"
|
| DEFAULT_OUTPUT_DIR = PROJECT_ROOT / "artifacts" / "metadata" / "transfer"
|
| TRAINING_SPLIT = PROJECT_ROOT / "artifacts" / "metadata" / "training" / "splits" / "training_split_n900_realratio_0p1_seed42.json"
|
| N_GRID = [900, 90, 18]
|
| ALLOWED_EXTS = {".jpg", ".jpeg", ".png", ".webp"}
|
|
|
| csv.field_size_limit(min(sys.maxsize, 2_147_483_647))
|
|
|
|
|
| def stable_rank(seed: int, group_key: str, sample_id: str) -> int:
|
| key = f"{seed}:{group_key}:{sample_id}".encode("utf-8")
|
| return int(hashlib.sha256(key).hexdigest(), 16)
|
|
|
|
|
| def read_csv(path: Path) -> list[dict[str, str]]:
|
| with path.open("r", newline="", encoding="utf-8") as f:
|
| return list(csv.DictReader(f))
|
|
|
|
|
| def write_json(path: Path, data: Any) -> None:
|
| path.parent.mkdir(parents=True, exist_ok=True)
|
| with path.open("w", encoding="utf-8") as f:
|
| json.dump(data, f, indent=2, ensure_ascii=False)
|
|
|
|
|
| def ratio_tag(value: float) -> str:
|
| return str(value).replace(".", "p")
|
|
|
|
|
| def ranked_rows(rows: list[dict[str, str]], seed: int, group: str) -> list[dict[str, str]]:
|
| def key(row: dict[str, str]) -> tuple[int, int, str]:
|
| split_rank = row.get("split_rank")
|
| if split_rank not in (None, ""):
|
| return (0, int(split_rank), row["sample_id"])
|
| return (1, stable_rank(seed, group, row["sample_id"]), row["sample_id"])
|
|
|
| return sorted(rows, key=key)
|
|
|
|
|
| def group_ai(rows: list[dict[str, str]]) -> dict[str, list[dict[str, str]]]:
|
| grouped: dict[str, list[dict[str, str]]] = defaultdict(list)
|
| for row in rows:
|
| grouped[row["source_model_id"]].append(row)
|
| return grouped
|
|
|
|
|
| def manifest_row(path: str, label: int, source: str, source_type: str) -> dict[str, Any]:
|
| return {"path": path, "label": label, "source": source, "source_type": source_type}
|
|
|
|
|
| def to_manifest_rows(rows: list[dict[str, str]], label: int, source: str, source_type: str) -> list[dict[str, Any]]:
|
| return [manifest_row(row["image_path"], label, source, source_type) for row in rows]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| def image_files(path: Path) -> list[str]:
|
| if not path.is_dir():
|
| return []
|
| return [str(p) for p in sorted(path.iterdir()) if p.is_file() and p.suffix.lower() in ALLOWED_EXTS]
|
|
|
|
|
| def collect_genimage(root: Path) -> dict[str, dict[str, list[str]]]:
|
| data: dict[str, dict[str, list[str]]] = {}
|
| for gen_dir in sorted([p for p in root.iterdir() if p.is_dir()]):
|
| if gen_dir.name.startswith("_"):
|
| continue
|
| fake = image_files(gen_dir / "val" / "ai")
|
| real = image_files(gen_dir / "val" / "nature")
|
| if fake and real:
|
| data[gen_dir.name] = {"fake": fake, "real": real}
|
| return data
|
|
|
|
|
| def collect_forensynths(root: Path) -> dict[str, dict[str, list[str]]]:
|
| data: dict[str, dict[str, list[str]]] = {}
|
| for gen_dir in sorted([p for p in root.iterdir() if p.is_dir()]):
|
| fake: list[str] = []
|
| real: list[str] = []
|
| if (gen_dir / "0_real").is_dir() and (gen_dir / "1_fake").is_dir():
|
| real.extend(image_files(gen_dir / "0_real"))
|
| fake.extend(image_files(gen_dir / "1_fake"))
|
| else:
|
| for class_dir in sorted([p for p in gen_dir.iterdir() if p.is_dir()]):
|
| real.extend(image_files(class_dir / "0_real"))
|
| fake.extend(image_files(class_dir / "1_fake"))
|
| if fake and real:
|
| data[gen_dir.name] = {"fake": fake, "real": real}
|
| return data
|
|
|
|
|
| def build_external_manifests(
|
| name: str,
|
| data: dict[str, dict[str, list[str]]],
|
| seed: int,
|
| output_dir: Path,
|
| real_ratio: float = 0.1,
|
| exclude_insufficient_k900: bool = False,
|
| ) -> dict[int, Path]:
|
| paths: dict[int, Path] = {}
|
| for k in [0]:
|
| sources = sorted(data)
|
| if exclude_insufficient_k900 and k == 900:
|
| sources = [source for source in sources if len(data[source]["fake"]) >= 1000 and len(data[source]["real"]) >= 900]
|
| train_rows: list[dict[str, Any]] = []
|
| test_rows: list[dict[str, Any]] = []
|
| source_summary: dict[str, dict[str, int]] = {}
|
| for source in sources:
|
| fake = sorted(data[source]["fake"], key=lambda p: stable_rank(seed, f"{name}:fake:{source}", p))
|
| real = sorted(data[source]["real"], key=lambda p: stable_rank(seed, f"{name}:real:{source}", p))
|
| fake_train_count = min(k, len(fake)) if k > 0 else 0
|
| real_train_count = min(int(real_ratio * fake_train_count), len(real)) if k > 0 else 0
|
| if k > 0:
|
| train_rows.extend(manifest_row(p, 1, source, name) for p in fake[:fake_train_count])
|
| train_rows.extend(manifest_row(p, 0, f"real:{source}", "real") for p in real[:real_train_count])
|
| test_rows.extend(manifest_row(p, 1, source, name) for p in fake[fake_train_count:])
|
| test_rows.extend(manifest_row(p, 0, f"real:{source}", "real") for p in real[real_train_count:])
|
| source_summary[source] = {
|
| "fake_total": len(fake),
|
| "real_total": len(real),
|
| "fake_train": fake_train_count,
|
| "real_train": real_train_count,
|
| "fake_test": max(0, len(fake) - fake_train_count),
|
| "real_test": max(0, len(real) - real_train_count),
|
| }
|
|
|
| path = output_dir / "manifests" / f"{name}_k{k}_realratio_{ratio_tag(real_ratio)}_seed{seed}.json"
|
| write_json(
|
| path,
|
| {
|
| "name": name,
|
| "k_per_source": k,
|
| "real_ratio": real_ratio,
|
| "sources": sources,
|
| "source_summary": source_summary,
|
| "train": train_rows,
|
| "test": test_rows,
|
| },
|
| )
|
| paths[k] = path
|
| return paths
|
|
|
|
|
| def load_wildgen_balanced_rows(training_split: Path, k: int, real_ratio: float) -> list[dict[str, Any]]:
|
| """Take K images per WildGen source (+ real_ratio*K*num_sources pooled real) from the
|
| Phase-2 binary training split. Paths are kept in the split's deterministic order, so the
|
| first K per source is a nested subset across K values."""
|
| with training_split.open("r", encoding="utf-8") as f:
|
| split = json.load(f)
|
| train = split["train"]
|
| ai_ids = sorted([mid for mid in train if mid != "0"], key=int)
|
| rows: list[dict[str, Any]] = []
|
| for mid in ai_ids:
|
| for path in train[mid][:k]:
|
| rows.append(manifest_row(path, 1, f"wildgen:{mid}", "wildgen"))
|
| real_needed = int(real_ratio * k * len(ai_ids))
|
| for path in train["0"][:real_needed]:
|
| rows.append(manifest_row(path, 0, "real:wildgen", "real"))
|
| return rows
|
|
|
|
|
| def build_joint_external_manifests(
|
| name: str,
|
| data: dict[str, dict[str, list[str]]],
|
| training_split: Path,
|
| seed: int,
|
| output_dir: Path,
|
| real_ratio: float = 0.1,
|
| exclude_insufficient_k900: bool = False,
|
| target_real_ratio: float | None = None,
|
| ) -> dict[int, Path]:
|
| """Balanced joint few-shot manifests: K images per source from BOTH the target benchmark
|
| and the WildGen training pool are mixed into the train set; the test set stays target-only
|
| so the reported metric is comparable to the zero-shot/cross-benchmark numbers.
|
|
|
| real_ratio controls the WildGen real anchor (real = real_ratio*K per WildGen source pooled).
|
| target_real_ratio, if given, independently controls the target real anchor (real =
|
| target_real_ratio*K per target source); this lets the target real distribution be aligned
|
| with the WildGen real pool rather than left as a tiny fraction."""
|
| trr = target_real_ratio if target_real_ratio is not None else real_ratio
|
| tag = f"_tr{ratio_tag(trr)}" if target_real_ratio is not None and trr != real_ratio else ""
|
| paths: dict[int, Path] = {}
|
| for k in N_GRID:
|
| sources = sorted(data)
|
| if exclude_insufficient_k900 and k == 900:
|
| sources = [s for s in sources if len(data[s]["fake"]) >= 1000 and len(data[s]["real"]) >= 900]
|
| target_train: list[dict[str, Any]] = []
|
| test_rows: list[dict[str, Any]] = []
|
| source_summary: dict[str, dict[str, int]] = {}
|
| for source in sources:
|
| fake = sorted(data[source]["fake"], key=lambda p: stable_rank(seed, f"{name}:fake:{source}", p))
|
| real = sorted(data[source]["real"], key=lambda p: stable_rank(seed, f"{name}:real:{source}", p))
|
| fake_train_count = min(k, len(fake))
|
| real_train_count = min(int(trr * fake_train_count), len(real))
|
| target_train.extend(manifest_row(p, 1, source, name) for p in fake[:fake_train_count])
|
| target_train.extend(manifest_row(p, 0, f"real:{source}", "real") for p in real[:real_train_count])
|
| test_rows.extend(manifest_row(p, 1, source, name) for p in fake[fake_train_count:])
|
| test_rows.extend(manifest_row(p, 0, f"real:{source}", "real") for p in real[real_train_count:])
|
| source_summary[source] = {
|
| "fake_total": len(fake),
|
| "real_total": len(real),
|
| "fake_train": fake_train_count,
|
| "real_train": real_train_count,
|
| "fake_test": max(0, len(fake) - fake_train_count),
|
| "real_test": max(0, len(real) - real_train_count),
|
| }
|
|
|
| wildgen_rows = load_wildgen_balanced_rows(training_split, k, real_ratio)
|
| train_rows = wildgen_rows + target_train
|
|
|
| path = output_dir / "manifests" / f"{name}_joint{tag}_k{k}_realratio_{ratio_tag(real_ratio)}_seed{seed}.json"
|
| write_json(
|
| path,
|
| {
|
| "name": f"{name}_joint",
|
| "k_per_source": k,
|
| "real_ratio": real_ratio,
|
| "target_real_ratio": trr,
|
| "init": "warm_start",
|
| "wildgen_train_rows": len(wildgen_rows),
|
| "target_train_rows": len(target_train),
|
| "sources": sources,
|
| "source_summary": source_summary,
|
| "train": train_rows,
|
| "test": test_rows,
|
| },
|
| )
|
| paths[k] = path
|
| return paths
|
|
|
|
|
| def main() -> None:
|
| parser = argparse.ArgumentParser(description="Build the configured zero-shot and joint cross-benchmark manifests.")
|
| parser.add_argument("--genimage-root", type=Path, required=True)
|
| parser.add_argument("--forensynths-root", type=Path, required=True)
|
| parser.add_argument("--training-split", type=Path, required=True)
|
| parser.add_argument("--output-dir", type=Path, required=True)
|
| parser.add_argument("--seed", type=int, default=42)
|
| args = parser.parse_args()
|
| summary = {"seed": args.seed, "target_real_ratio": 1.0, "datasets": {}}
|
| for name, root, collect in [("genimage", args.genimage_root, collect_genimage), ("forensynths", args.forensynths_root, collect_forensynths)]:
|
| data = collect(root)
|
| if not data:
|
| raise ValueError(f"No benchmark images found under {root}")
|
| zero = build_external_manifests(name, data, args.seed, args.output_dir, exclude_insufficient_k900=(name == "forensynths"))
|
| joint = build_joint_external_manifests(name, data, args.training_split, args.seed, args.output_dir, exclude_insufficient_k900=(name == "forensynths"), target_real_ratio=1.0)
|
| summary["datasets"][name] = {"zero_shot": str(zero[0]), "joint": {str(k): str(v) for k, v in joint.items()}}
|
| write_json(args.output_dir / "cross_benchmark_manifest_summary.json", summary)
|
| print(json.dumps(summary, indent=2))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
