code/rubric_gen/make_split.py

#!/usr/bin/env python3
"""Emit a K-source / M-eval split manifest, with the leakage guards intact.

    python3 make_split.py --k 10 --m 10 --out splits/scale_10_10.json
    RUBRIC_GEN_SPLIT=splits/scale_10_10.json python3 collect_targeted.py ...

WHY THIS EXISTS. The frozen manifest is 5 source / 15 eval
(`splits/error_side_5_15.json`, revision 4, frozen 2026-08-05). Scaling the
mining side to K competitions means K-5 competitions must come from somewhere,
and there are exactly two places:

  (a) MOVE them out of the evaluation set. Cheap, local, and it INVALIDATES
      every previously reported eval number that used them -- v5, v6, v7,
      gated1, and the precision/recall results all evaluated on those 15. A
      competition that becomes a mining source can never again be eval, so the
      old and new numbers are not comparable on the moved competitions.
  (b) PREPARE new competitions from MLE-bench. No contamination, but each needs
      Kaggle rules accepted by hand on kaggle.com and tens of GB downloaded.
      The frozen manifest already records four candidates blocked on exactly
      this (`replacement_candidates_unavailable_without_manual_rules_accepted`).

This script supports BOTH, and makes the cost of (a) explicit rather than silent:
it refuses to run without `--acknowledge-invalidates`, records which competitions
moved, and writes the list of prior result files whose eval set is no longer clean.

The intended combination is `--k 10 --add-eval <5 new ids>`: promote 5 out of eval
into the mining set, and backfill eval with 5 newly prepared competitions so the
evaluation set keeps its size and statistical power. `--add-eval` cannot do the
downloading -- Kaggle rules acceptance is manual and per-competition -- so it
instead REFUSES any id whose prepared data is not actually on disk, with the exact
command needed to fix it.

WHAT IT WILL NOT DO. Move a competition into eval that has ever been mined.
That direction is unrecoverable contamination: rubrics derived from a program
would be scored against that same competition. `--strict` on the reader side
still refuses an unfrozen manifest, so a thaw cannot pass unnoticed.
"""

from __future__ import annotations

import argparse
import json
import os
import time
from pathlib import Path

HERE = Path(__file__).resolve().parent
FROZEN = HERE / "splits" / "error_side_5_15.json"


def _gcs_prepared_gb(cid: str, bucket: str) -> float | None:
    """Compressed-tarball size in GB of a fleet-prepared competition, or None."""
    from google.cloud import storage  # only reached with --gcs-bucket

    b = storage.Client(project=os.environ.get("GOOGLE_CLOUD_PROJECT",
                                              "edward-sun")).bucket(bucket)
    tar = b.get_blob(f"data/{cid}/prepared.tar.gz")
    if tar is None or not tar.size or b.get_blob(f"data/{cid}/meta.json") is None:
        return None
    return tar.size / 1e9


def main() -> int:
    ap = argparse.ArgumentParser(description=__doc__,
                                 formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("--k", type=int, required=True, help="source (minable) competitions")
    ap.add_argument("--m", type=int, default=0,
                    help="evaluation competitions (default: all remaining)")
    ap.add_argument("--base", default=str(FROZEN))
    ap.add_argument("--out", required=True)
    ap.add_argument("--acknowledge-invalidates", action="store_true",
                    help="required: confirms that moving eval -> source voids "
                         "prior eval numbers on the moved competitions")
    ap.add_argument("--prefer-tier", default="low,medium,high",
                    help="order in which to promote eval competitions to source")
    ap.add_argument("--promote", default="",
                    help="comma-separated eval competition ids to promote to "
                         "source, overriding smallest-first. For DIRECTED "
                         "scaling: recall's domain gaps (audio, DICOM, "
                         "segmentation) are closed by promoting comps FROM "
                         "those domains, which smallest-first never picks.")
    ap.add_argument("--add-eval", default="",
                    help="comma-separated NEW competition ids to add to the "
                         "evaluation set, replacing the ones promoted to source "
                         "so eval keeps its size and statistical power")
    ap.add_argument("--data-dir", default="",
                    help="where prepared competition data lives; --add-eval ids "
                         "are refused unless their data is actually present")
    ap.add_argument("--gcs-bucket", default="",
                    help="fleet bucket (e.g. edward-sun-agent-cwm-evals): an "
                         "--add-eval id with no local data is accepted if "
                         "data/<id>/prepared.tar.gz and meta.json exist there. "
                         "The empty-shell hazard the local check guards against "
                         "cannot occur in the bucket: the prep job refuses to "
                         "upload a tarball whose prepared/public is empty.")
    args = ap.parse_args()

    base = json.loads(Path(args.base).read_text())
    src = list(base["source_competitions"])
    ev = list(base["evaluation_competitions"])
    if args.k < len(src):
        raise SystemExit(f"--k {args.k} is below the frozen source count "
                         f"{len(src)}; shrinking the source set is not supported "
                         f"(the extra rubrics already exist)")
    need = args.k - len(src)
    if need > len(ev):
        raise SystemExit(f"need {need} more source competitions but only "
                         f"{len(ev)} eval competitions exist. Preparing new "
                         f"competitions requires manual Kaggle rules acceptance; "
                         f"see this file's docstring.")
    if need and not args.acknowledge_invalidates:
        raise SystemExit(
            f"promoting {need} eval competitions to source will invalidate every\n"
            f"previously reported eval number on them (v5/v6/v7/gated1 and the\n"
            f"precision-recall runs all used the 15-competition eval set).\n"
            f"Re-run with --acknowledge-invalidates if that is intended.")

    # Promote smallest-dataset-first within the requested tier order: mining
    # cost scales with dataset size, and the eval set should keep the large,
    # expensive competitions where a single run is most informative.
    order = {t: i for i, t in enumerate(args.prefer_tier.split(","))}
    ev_sorted = sorted(ev, key=lambda c: (order.get(c.get("tier"), 9),
                                          c.get("dataset_size_gb", 0)))
    if args.promote:
        want = [x.strip() for x in args.promote.split(",") if x.strip()]
        by_id = {c["id"]: c for c in ev}
        missing = [w for w in want if w not in by_id]
        if missing:
            raise SystemExit(f"--promote ids not in the eval set: {missing}")
        if len(want) != need:
            raise SystemExit(f"--promote lists {len(want)} ids but --k "
                             f"{args.k} needs {need} promotions")
        promoted = [by_id[w] for w in want]
    else:
        promoted = ev_sorted[:need]
    remaining = [c for c in ev if c["id"] not in {p["id"] for p in promoted}]
    if args.m:
        if args.m > len(remaining):
            raise SystemExit(f"--m {args.m} exceeds the {len(remaining)} "
                             f"competitions left after promoting {need}. "
                             f"K + M cannot exceed {len(src) + len(ev)} without "
                             f"preparing new competitions.")
        remaining = remaining[: args.m]

    # --add-eval: replace what was promoted so eval does not shrink. Each new id
    # must have REAL prepared data. Measured reason for the guard: the local tree
    # contains a `detecting-insults-in-social-commentary` directory with
    # prepared/public and prepared/private present and ZERO files inside -- an
    # empty shell that would pass any existence check on the directory alone and
    # then fail at grading time, deep inside a fleet run.
    added = []
    if args.add_eval:
        import os as _os
        data = Path(args.data_dir or _os.environ.get("MLEBENCH_DATA_DIR")
                    or (HERE.parent / ".mlebench" / "data"))
        known = {c["id"] for c in src} | {c["id"] for c in ev}
        excluded = set(base.get("development_competitions_excluded") or [])
        for cid in [x.strip() for x in args.add_eval.split(",") if x.strip()]:
            if cid in known:
                raise SystemExit(f"--add-eval {cid} is already in the split")
            if cid in excluded:
                raise SystemExit(
                    f"--add-eval {cid} is in the frozen manifest's excluded "
                    f"list (documented preparation or rules defect); pick "
                    f"another competition")
            prep = data / cid / "prepared"
            files = sum(1 for _ in prep.rglob("*") if _.is_file()) if prep.exists() else 0
            if files == 0 and args.gcs_bucket:
                gb = _gcs_prepared_gb(cid, args.gcs_bucket)
                if gb is None:
                    raise SystemExit(
                        f"--add-eval {cid}: no local prepared data and no "
                        f"data/{cid}/prepared.tar.gz + meta.json in "
                        f"gs://{args.gcs_bucket}")
                added.append({"id": cid, "tier": "unknown", "category": "unknown",
                              "dataset_size_gb": round(gb, 2),
                              "prepared": f"gs://{args.gcs_bucket}/data/{cid}/"
                                          f"prepared.tar.gz",
                              "size_is_compressed_tarball": True})
                continue
            if files == 0:
                raise SystemExit(
                    f"--add-eval {cid}: no prepared data under {prep} "
                    f"({files} files). Prepare it first:\n"
                    f"  accept the competition rules on kaggle.com, then\n"
                    f"  mlebench prepare -c {cid} --data-dir {data}\n"
                    f"or, if the fleet already prepared it, pass --gcs-bucket.")
            if not (prep / "private").exists():
                raise SystemExit(f"--add-eval {cid}: prepared/private missing, "
                                 f"so it could never be graded")
            added.append({"id": cid, "tier": "unknown", "category": "unknown",
                          "dataset_size_gb": round(
                              sum(f.stat().st_size for f in prep.rglob("*")
                                  if f.is_file()) / 1e9, 2)})
        remaining = remaining + added
        print(f"added to eval: {[c['id'] for c in added]}")

    new_src = src + promoted
    ids_s = {c["id"] for c in new_src}
    ids_e = {c["id"] for c in remaining}
    overlap = ids_s & ids_e
    if overlap:
        raise SystemExit(f"source/eval overlap, refusing to write: {overlap}")

    out = {
        "experiment_id": f"scale-{len(new_src)}-{len(remaining)}",
        "frozen": True,
        "frozen_at_utc": time.strftime("%Y-%m-%d", time.gmtime()),
        "revision": int(base.get("revision", 0)) + 1,
        "revision_reason":
            f"Scaled the mining side from {len(src)} to {len(new_src)} source "
            f"competitions by promoting {[c['id'] for c in promoted]} out of the "
            f"evaluation set. Promotion order: smallest dataset first within "
            f"tier order {args.prefer_tier}. No new competitions were downloaded.",
        "derived_from": str(Path(args.base).name),
        "promoted_eval_to_source": [c["id"] for c in promoted],
        "added_to_eval": [c["id"] for c in added],
        "invalidates_prior_eval_on": [c["id"] for c in promoted],
        "benchmark": base.get("benchmark"),
        "selection": base.get("selection"),
        "source_competitions": new_src,
        "evaluation_competitions": remaining,
        "source_dataset_size_gb_total": round(
            sum(c.get("dataset_size_gb", 0) for c in new_src), 2),
        "evaluation_dataset_size_gb_total": round(
            sum(c.get("dataset_size_gb", 0) for c in remaining), 2),
    }
    p = Path(args.out)
    p.parent.mkdir(parents=True, exist_ok=True)
    p.write_text(json.dumps(out, indent=2) + "\n")

    print(f"source ({len(new_src)}): {[c['id'] for c in new_src]}")
    print(f"eval   ({len(remaining)}): {[c['id'] for c in remaining]}")
    if promoted:
        print(f"\nPROMOTED eval -> source: {[c['id'] for c in promoted]}")
        print("  prior eval numbers on these are now void:")
        print("    data/gke_runs/{v5A,v5B,v6,v7,gated1}.jsonl "
              "and results/*pr_results*.json")
    print(f"\n-> {p}")
    print(f"use with: RUBRIC_GEN_SPLIT={p} python3 collect_targeted.py ...")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())