|
|
| 'Build seeded binary and source-classification training subsets from fixed image pools.'
|
|
|
| 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]
|
| DEFAULT_SPLIT_DIR = PROJECT_ROOT / "artifacts" / "metadata" / "fixed_split"
|
| DEFAULT_OUTPUT_DIR = PROJECT_ROOT / "artifacts" / "metadata" / "training"
|
| DEFAULT_N_GRID = [900, 90, 45, 18]
|
|
|
| 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 parse_n_grid(value: str) -> list[int]:
|
| n_grid = [int(part.strip()) for part in value.split(",") if part.strip()]
|
| if not n_grid:
|
| raise ValueError("N grid cannot be empty")
|
| return sorted(n_grid, reverse=True)
|
|
|
|
|
| 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 group_real_sources(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["real_source_id"]].append(row)
|
| return grouped
|
|
|
|
|
| def ranked_rows(rows: list[dict[str, str]], seed: int, group: str) -> list[dict[str, str]]:
|
| """Independent seeded training ranks; validation order is seed-independent."""
|
| if "train" in group:
|
| return sorted(rows, key=lambda row: (stable_rank(seed, group, row["sample_id"]), row["sample_id"]))
|
| return sorted(rows, key=lambda row: (int(row.get("split_rank") or 0), row["sample_id"]))
|
|
|
|
|
|
|
| def select_real_rows(
|
| rows: list[dict[str, str]],
|
| total: int,
|
| seed: int,
|
| ) -> list[dict[str, str]]:
|
| ranked = sorted(
|
| rows,
|
| key=lambda row: (
|
| stable_rank(seed, f"real_train:{row.get('source_dataset', 'unknown')}", row["sample_id"]),
|
| row["sample_id"],
|
| ),
|
| )
|
| if total > len(ranked):
|
| raise RuntimeError(f"Requested {total} real rows, but only {len(ranked)} are available")
|
| return ranked[:total]
|
|
|
|
|
| def real_source_counts(total: int, source_ids: list[str]) -> dict[str, int]:
|
| base_count = total // len(source_ids)
|
| remainder = total % len(source_ids)
|
| return {
|
| source_id: base_count + (1 if i < remainder else 0)
|
| for i, source_id in enumerate(source_ids)
|
| }
|
|
|
|
|
| def to_path_list(rows: list[dict[str, str]]) -> list[str]:
|
| return [row["image_path"] for row in rows]
|
|
|
|
|
| def build_split(
|
| ai_train_rows: list[dict[str, str]],
|
| ai_val_rows: list[dict[str, str]],
|
| real_train_rows: list[dict[str, str]],
|
| real_val_rows: list[dict[str, str]],
|
| n_grid: list[int],
|
| real_ratio: float,
|
| seed: int,
|
| ) -> tuple[dict[str, dict[str, list[str]]], dict[str, Any]]:
|
| max_n = max(n_grid)
|
| ai_train_by_model = group_ai(ai_train_rows)
|
| ai_val_by_model = group_ai(ai_val_rows)
|
|
|
| train: dict[str, list[str]] = {}
|
| test: dict[str, list[str]] = {}
|
| model_summaries: list[dict[str, Any]] = []
|
|
|
| for model_id in sorted(ai_train_by_model, key=lambda x: int(x)):
|
| ranked_train = ranked_rows(ai_train_by_model[model_id], seed, f"ai_train:{model_id}")
|
| ranked_val = ranked_rows(ai_val_by_model.get(model_id, []), seed, f"ai_val:{model_id}")
|
| if len(ranked_train) < max_n:
|
| raise RuntimeError(f"Model {model_id} has {len(ranked_train)} train rows, expected at least {max_n}")
|
| train[model_id] = to_path_list(ranked_train[:max_n])
|
| test[model_id] = to_path_list(ranked_val)
|
| model_summaries.append(
|
| {
|
| "source_model_id": int(model_id),
|
| "train_images": len(train[model_id]),
|
| "validation_images": len(test[model_id]),
|
| }
|
| )
|
|
|
| max_real_train = int(real_ratio * max_n * len(model_summaries))
|
| selected_real_train = select_real_rows(real_train_rows, max_real_train, seed)
|
| train["0"] = to_path_list(selected_real_train)
|
| test["0"] = to_path_list(real_val_rows)
|
|
|
| split = {"train": train, "test": test, "protocol": {"seed": seed, "version": "release-v1-resampled", "checkpoint": "final"}}
|
| summary = {
|
| "seed": seed,
|
| "n_grid": n_grid,
|
| "max_n": max_n,
|
| "real_ratio": real_ratio,
|
| "ai_model_count": len(model_summaries),
|
| "ai_train_images_at_max_n": max_n * len(model_summaries),
|
| "real_train_images_at_max_n": max_real_train,
|
| "ai_validation_images": sum(len(v) for k, v in test.items() if k != "0"),
|
| "real_validation_images": len(test["0"]),
|
| "models": model_summaries,
|
| "per_n": [
|
| {
|
| "n": n,
|
| "ai_train_images": n * len(model_summaries),
|
| "real_train_images": int(real_ratio * n * len(model_summaries)),
|
| "total_train_images": n * len(model_summaries) + int(real_ratio * n * len(model_summaries)),
|
| }
|
| for n in n_grid
|
| ],
|
| }
|
| return split, summary
|
|
|
|
|
| def build_source_multiclass_split(
|
| ai_train_rows: list[dict[str, str]],
|
| ai_val_rows: list[dict[str, str]],
|
| real_train_rows: list[dict[str, str]],
|
| real_val_rows: list[dict[str, str]],
|
| n_grid: list[int],
|
| real_ratio: float,
|
| seed: int,
|
| ) -> tuple[dict[str, dict[str, list[str]]], dict[str, Any]]:
|
| max_n = max(n_grid)
|
| ai_train_by_model = group_ai(ai_train_rows)
|
| ai_val_by_model = group_ai(ai_val_rows)
|
| real_train_by_source = group_real_sources(real_train_rows)
|
| real_val_by_source = group_real_sources(real_val_rows)
|
|
|
| train: dict[str, list[str]] = {}
|
| test: dict[str, list[str]] = {}
|
| model_summaries: list[dict[str, Any]] = []
|
|
|
| for model_id in sorted(ai_train_by_model, key=lambda x: int(x)):
|
| ranked_train = ranked_rows(ai_train_by_model[model_id], seed, f"ai_train:{model_id}")
|
| ranked_val = ranked_rows(ai_val_by_model.get(model_id, []), seed, f"ai_val:{model_id}")
|
| if len(ranked_train) < max_n:
|
| raise RuntimeError(f"Model {model_id} has {len(ranked_train)} train rows, expected at least {max_n}")
|
| train[model_id] = to_path_list(ranked_train[:max_n])
|
| test[model_id] = to_path_list(ranked_val)
|
| model_summaries.append(
|
| {
|
| "source_model_id": int(model_id),
|
| "train_images": len(train[model_id]),
|
| "validation_images": len(test[model_id]),
|
| }
|
| )
|
|
|
| real_source_ids = sorted(real_train_by_source, key=lambda x: int(x))
|
| max_real_train = int(real_ratio * max_n * len(model_summaries))
|
| per_source_max_counts = real_source_counts(max_real_train, real_source_ids)
|
| real_source_summaries: list[dict[str, Any]] = []
|
| for source_id in real_source_ids:
|
| ranked_train = ranked_rows(
|
| real_train_by_source[source_id],
|
| seed,
|
| f"real_train_source:{source_id}",
|
| )
|
| limit = per_source_max_counts[source_id]
|
| if len(ranked_train) < limit:
|
| raise RuntimeError(
|
| f"Real source {source_id} has {len(ranked_train)} train rows, expected at least {limit}"
|
| )
|
| train[source_id] = to_path_list(ranked_train[:limit])
|
| test[source_id] = to_path_list(
|
| ranked_rows(real_val_by_source.get(source_id, []), seed, f"real_val_source:{source_id}")
|
| )
|
| real_source_summaries.append(
|
| {
|
| "real_source_id": int(source_id),
|
| "train_images": len(train[source_id]),
|
| "validation_images": len(test[source_id]),
|
| }
|
| )
|
|
|
| split = {"train": train, "test": test, "protocol": {"seed": seed, "version": "release-v1-resampled", "checkpoint": "final"}}
|
| summary = {
|
| "seed": seed,
|
| "n_grid": n_grid,
|
| "max_n": max_n,
|
| "real_ratio": real_ratio,
|
| "ai_model_count": len(model_summaries),
|
| "real_source_count": len(real_source_summaries),
|
| "source_class_count": len(model_summaries) + len(real_source_summaries),
|
| "ai_train_images_at_max_n": max_n * len(model_summaries),
|
| "real_train_images_at_max_n": max_real_train,
|
| "ai_validation_images": sum(len(v) for k, v in test.items() if int(k) > 0),
|
| "real_validation_images": sum(len(v) for k, v in test.items() if int(k) < 0),
|
| "models": model_summaries,
|
| "real_sources": real_source_summaries,
|
| "per_n": [
|
| {
|
| "n": n,
|
| "ai_train_images": n * len(model_summaries),
|
| "real_train_images": int(real_ratio * n * len(model_summaries)),
|
| "total_train_images": n * len(model_summaries) + int(real_ratio * n * len(model_summaries)),
|
| }
|
| for n in n_grid
|
| ],
|
| }
|
| return split, summary
|
|
|
|
|
| def main() -> None:
|
| parser = argparse.ArgumentParser(description="Build WildGen training split configs.")
|
| parser.add_argument("--ai-train", type=Path, default=DEFAULT_SPLIT_DIR / "ai_train_pool.csv")
|
| parser.add_argument("--ai-val", type=Path, default=DEFAULT_SPLIT_DIR / "ai_validation.csv")
|
| parser.add_argument("--real-train", type=Path, default=DEFAULT_SPLIT_DIR / "real_train_pool.csv")
|
| parser.add_argument("--real-val", type=Path, default=DEFAULT_SPLIT_DIR / "real_validation.csv")
|
| parser.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT_DIR / "splits")
|
| parser.add_argument("--n-grid", type=str, default=",".join(str(n) for n in DEFAULT_N_GRID))
|
| parser.add_argument("--real-ratio", type=float, default=0.1)
|
| parser.add_argument("--seed", type=int, default=42)
|
| args = parser.parse_args()
|
|
|
| n_grid = parse_n_grid(args.n_grid)
|
| ai_train_rows = read_csv(args.ai_train)
|
| ai_val_rows = read_csv(args.ai_val)
|
| real_train_rows = read_csv(args.real_train)
|
| real_val_rows = read_csv(args.real_val)
|
|
|
| split, summary = build_split(
|
| ai_train_rows,
|
| ai_val_rows,
|
| real_train_rows,
|
| real_val_rows,
|
| n_grid=n_grid,
|
| real_ratio=args.real_ratio,
|
| seed=args.seed,
|
| )
|
| source_split, source_summary = build_source_multiclass_split(
|
| ai_train_rows,
|
| ai_val_rows,
|
| real_train_rows,
|
| real_val_rows,
|
| n_grid=n_grid,
|
| real_ratio=args.real_ratio,
|
| seed=args.seed,
|
| )
|
|
|
| ratio_tag = str(args.real_ratio).replace(".", "p")
|
| split_path = args.output_dir / f"training_split_n{max(n_grid)}_realratio_{ratio_tag}_seed{args.seed}.json"
|
| summary_path = args.output_dir / f"training_split_n{max(n_grid)}_realratio_{ratio_tag}_seed{args.seed}_summary.json"
|
| source_split_path = args.output_dir / f"source_split_n{max(n_grid)}_realratio_{ratio_tag}_seed{args.seed}.json"
|
| source_summary_path = args.output_dir / f"source_split_n{max(n_grid)}_realratio_{ratio_tag}_seed{args.seed}_summary.json"
|
| write_json(split_path, split)
|
| summary["split_file"] = str(split_path)
|
| write_json(summary_path, summary)
|
| write_json(source_split_path, source_split)
|
| source_summary["split_file"] = str(source_split_path)
|
| write_json(source_summary_path, source_summary)
|
| print(json.dumps({
|
| "binary_split_file": str(split_path),
|
| "binary_summary_file": str(summary_path),
|
| "source_split_file": str(source_split_path),
|
| "source_summary_file": str(source_summary_path),
|
| "binary": summary,
|
| "source_multiclass": source_summary,
|
| }, indent=2))
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
