tools/make_configs.py

import argparse
import json
import random
import zlib
from pathlib import Path
from typing import Dict, List

from make_master_configs import (
    build_light_index,
    build_master_configs,
    rows_from_files,
    write_rows_to_parquet,
)


def _stable_seed(base_seed: int, cfg_name: str, tag: str) -> int:
    h = zlib.adler32(f"{cfg_name}::{tag}".encode("utf-8")) & 0xFFFFFFFF
    return (base_seed * 1_000_003 + h * 97) & 0xFFFFFFFF


def _sample_k(items: List[str], k: int, seed: int) -> List[str]:
    if k <= 0:
        return []
    if k >= len(items):
        return sorted(items)
    rng = random.Random(seed)
    return sorted(rng.sample(sorted(items), k))


def build_fewshot_split_map(
    base_split_map: Dict[str, Dict[str, List[str]]],
    seed: int,
) -> Dict[str, Dict[str, List[str]]]:
    out: Dict[str, Dict[str, List[str]]] = {}

    for base_cfg, splits in base_split_map.items():
        base_train = sorted(splits["train"])
        base_id_test = sorted(splits["id_test"])
        base_ood_train = sorted(splits["ood_train"])
        base_ood_test = sorted(splits["ood_test"])  # never changes across few-shot variants

        # Build a single deterministic ordering of ood_train so that few-shot sets
        # are guaranteed to be progressive subsets: fs1 ⊂ fs10 ⊂ fs100 ⊂ fsall
        ordering_seed = _stable_seed(seed, base_cfg, "fsordering")
        ordered_ood_train = list(base_ood_train)
        rng = random.Random(ordering_seed)
        rng.shuffle(ordered_ood_train)

        for label, k in [("1", 1), ("10", 10), ("100", 100)]:
            k_actual = min(k, len(ordered_ood_train))
            chosen = ordered_ood_train[:k_actual]
            chosen_set = set(chosen)

            fs_cfg_name = f"{base_cfg}__fs{label}"
            out[fs_cfg_name] = {
                "train": sorted(set(base_train) | chosen_set),
                "id_test": list(base_id_test),
                "ood_train": sorted(set(base_ood_train) - chosen_set),
                "ood_test": list(base_ood_test),  # unchanged
            }

        # fsall: move all ood_train into train; ood_test still unchanged
        fs_cfg_name = f"{base_cfg}__fsall"
        out[fs_cfg_name] = {
            "train": sorted(set(base_train) | set(base_ood_train)),
            "id_test": list(base_id_test),
            "ood_train": [],  # all moved to train
            "ood_test": list(base_ood_test),  # unchanged
        }

    return out


def write_configs_from_split_map(
    split_map: Dict[str, Dict[str, List[str]]],
    out_configs_dir: Path,
    rows_per_shard: int,
    light_index: Dict[str, Dict],
    images_root: Path,
) -> None:
    out_configs_dir.mkdir(parents=True, exist_ok=True)
    total = len(split_map)
    print(f"[make_configs] Writing {total} configs to {out_configs_dir}")
    for cfg_name, splits in split_map.items():
        cfg_dir = out_configs_dir / cfg_name
        cfg_dir.mkdir(parents=True, exist_ok=True)
        train_n = len(splits["train"])
        id_n = len(splits["id_test"])
        ood_train_n = len(splits.get("ood_train", []))
        ood_n = len(splits["ood_test"])
        print(f"[make_configs] -> {cfg_name} (train={train_n}, id_test={id_n}, ood_train={ood_train_n}, ood_test={ood_n})")
        for split in ("train", "id_test", "ood_train", "ood_test"):
            if split not in splits or not splits[split]:
                continue
            write_rows_to_parquet(
                rows_from_files(splits[split], light_index, images_root),
                cfg_dir,
                split,
                rows_per_shard,
            )
        print(f"[make_configs] <- {cfg_name} done")


def main() -> None:
    ap = argparse.ArgumentParser()
    ap.add_argument("--src_root", required=True, help="root containing metadata.csv and world_images/")
    ap.add_argument("--master_dir", required=True, help="hf_repo/data/master (parquet shards)")
    ap.add_argument("--out_configs_dir", required=True, help="hf_repo/data/configs")
    ap.add_argument("--train_ratio", type=float, default=0.9)
    ap.add_argument("--ood_train_ratio", type=float, default=0.7,
                    help="Fraction of OOD pool used for ood_train (few-shot source); remainder is ood_test")
    ap.add_argument("--seed", type=int, default=42)
    ap.add_argument("--rows_per_shard", type=int, default=16)
    ap.add_argument("--scan_batch_size", type=int, default=32)
    ap.add_argument("--min_pool", type=int, default=200)
    ap.add_argument("--manifest_path", default=None, help="optional path to write JSON manifest")
    args = ap.parse_args()

    src_root = Path(args.src_root)
    out_configs_dir = Path(args.out_configs_dir)
    images_root = src_root / "world_images"

    base_split_map = build_master_configs(
        src_root=src_root,
        master_dir=Path(args.master_dir),
        out_configs_dir=out_configs_dir,
        train_ratio=args.train_ratio,
        seed=args.seed,
        rows_per_shard=args.rows_per_shard,
        scan_batch_size=args.scan_batch_size,
        min_pool=args.min_pool,
        ood_train_ratio=args.ood_train_ratio,
        write_parquet=False,
    )

    fewshot_split_map = build_fewshot_split_map(base_split_map, seed=args.seed)

    all_split_map = {}
    all_split_map.update(base_split_map)
    all_split_map.update(fewshot_split_map)
    print(
        f"[make_configs] Prepared split plans: base={len(base_split_map)} "
        f"fewshot={len(fewshot_split_map)} total={len(all_split_map)}"
    )

    print("[make_configs] Building lightweight master index...")
    light_index = build_light_index(str(args.master_dir), args.scan_batch_size)
    print(f"[make_configs] Indexed {len(light_index)} master rows")
    write_configs_from_split_map(
        split_map=all_split_map,
        out_configs_dir=out_configs_dir,
        rows_per_shard=args.rows_per_shard,
        light_index=light_index,
        images_root=images_root,
    )

    base_cfgs = sorted(base_split_map.keys())
    fs_cfgs = sorted(fewshot_split_map.keys())
    manifest = {
        "base_config_count": len(base_cfgs),
        "fewshot_per_base": ["fs1", "fs10", "fs100", "fsall"],
        "total_config_count": len(all_split_map),
        "splits": ["train", "id_test", "ood_train", "ood_test"],
        "split_notes": {
            "train": "ID training set (90% of ID pool)",
            "id_test": "ID test set (10% of ID pool, fixed across all configs)",
            "ood_train": "OOD training pool (70% of OOD pool); source for few-shot images",
            "ood_test": "OOD test set (30% of OOD pool, fixed across all configs including few-shot variants)",
        },
        "base_configs": base_cfgs,
        "fewshot_configs": fs_cfgs,
        "all_configs": sorted(all_split_map.keys()),
    }

    if args.manifest_path:
        manifest_path = Path(args.manifest_path)
        manifest_path.parent.mkdir(parents=True, exist_ok=True)
        manifest_path.write_text(json.dumps(manifest, indent=2))

    print(json.dumps(manifest, indent=2))


if __name__ == "__main__":
    main()