File size: 6,488 Bytes
3fd7410 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 | """Build deterministic proportional test/train splits from hybrid references."""
from __future__ import annotations
import argparse
import csv
import hashlib
import json
from collections import Counter, defaultdict
from datetime import date
from pathlib import Path
from typing import Any
from build_dataset_splits import SOURCE_RELATIVE_PATH, SOURCE_SHA256, sha256_file
CANONICAL_TASK_COUNT = 676
TEST_COUNT = 100
MIN_TEST_STEPS = 4
SELECTION_SEED = "hybrid-proportional-test-v2"
def read_jsonl(path: Path) -> list[dict[str, Any]]:
with path.open(encoding="utf-8") as handle:
return [json.loads(line) for line in handle if line.strip()]
def write_json(path: Path, payload: Any) -> None:
path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
def proportional_quotas(counts: Counter[int], sample_count: int) -> dict[int, int]:
total = sum(counts.values())
exact = {step: count * sample_count / total for step, count in counts.items()}
quotas = {step: int(value) for step, value in exact.items()}
remaining = sample_count - sum(quotas.values())
order = sorted(counts, key=lambda step: (-(exact[step] - quotas[step]), step))
for step in order[:remaining]:
quotas[step] += 1
return dict(sorted(quotas.items()))
def stable_rank(sample_id: str) -> str:
return hashlib.sha256(f"{SELECTION_SEED}:{sample_id}".encode()).hexdigest()
def main() -> None:
parser = argparse.ArgumentParser(description="Build proportional test/train splits")
parser.add_argument(
"--source-dir",
default="dataset_splits/hybrid_beam256_exact30_v1",
)
parser.add_argument(
"--output-dir",
default="dataset_splits/hybrid_beam256_exact30_proportional_v2",
)
args = parser.parse_args()
root = Path.cwd().resolve()
source_dir = root / args.source_dir
output_dir = root / args.output_dir
tasks_path = root / SOURCE_RELATIVE_PATH
results_path = source_dir / "hybrid_reference_results.jsonl"
if sha256_file(tasks_path) != SOURCE_SHA256:
raise RuntimeError("Canonical task SHA-256 mismatch")
rows = read_jsonl(results_path)
ids = [str(row["sample_id"]) for row in rows]
if len(rows) != CANONICAL_TASK_COUNT or len(set(ids)) != CANONICAL_TASK_COUNT:
raise RuntimeError("Hybrid references must contain exactly 676 unique tasks")
by_step: dict[int, list[str]] = defaultdict(list)
rows_by_id = {}
for row in rows:
sample_id = str(row["sample_id"])
rows_by_id[sample_id] = row
by_step[int(row["best_known_reference_steps"])].append(sample_id)
overall = Counter({step: len(step_ids) for step, step_ids in by_step.items()})
eligible = Counter({step: count for step, count in overall.items() if step >= MIN_TEST_STEPS})
quotas = proportional_quotas(eligible, TEST_COUNT)
test = sorted(
sample_id
for step, step_ids in by_step.items()
if step >= MIN_TEST_STEPS
for sample_id in sorted(step_ids, key=stable_rank)[: quotas[step]]
)
train = sorted(set(ids) - set(test))
splits = {"test": test, "train": train}
if len(test) != TEST_COUNT or len(train) != CANONICAL_TASK_COUNT - TEST_COUNT:
raise RuntimeError("Split counts are incorrect")
if set(test) & set(train) or set(test) | set(train) != set(ids):
raise RuntimeError("Splits must cover every task exactly once")
output_dir.mkdir(parents=True, exist_ok=True)
split_version = "hybrid_beam256_exact30_proportional_v2"
for name, sample_ids in splits.items():
write_json(output_dir / f"{name}.json", {
"split_version": split_version,
"split_name": name,
"count": len(sample_ids),
"sample_ids": sample_ids,
})
assignment = {sample_id: name for name, sample_ids in splits.items() for sample_id in sample_ids}
with (output_dir / "assignments.csv").open("w", encoding="utf-8", newline="") as handle:
writer = csv.writer(handle)
writer.writerow(["sample_id", "split", "best_known_reference_steps", "reference_source"])
for sample_id in sorted(ids):
row = rows_by_id[sample_id]
writer.writerow([
sample_id, assignment[sample_id], row["best_known_reference_steps"], row["reference_source"]
])
split_distribution = {
name: dict(sorted(Counter(
int(rows_by_id[sample_id]["best_known_reference_steps"]) for sample_id in sample_ids
).items()))
for name, sample_ids in splits.items()
}
manifest = {
"split_version": split_version,
"created_at": date.today().isoformat(),
"canonical_tasks_file": SOURCE_RELATIVE_PATH,
"canonical_tasks_sha256": SOURCE_SHA256,
"canonical_task_count": CANONICAL_TASK_COUNT,
"reference_results": str(results_path.relative_to(root)).replace("\\", "/"),
"reference_results_sha256": sha256_file(results_path),
"difficulty_name": "best_known_reference_steps; not a global optimality proof",
"selection": {
"test": "Hamilton largest-remainder proportional allocation across eligible reference-step strata",
"test_eligibility": f"best_known_reference_steps >= {MIN_TEST_STEPS}",
"within_stratum": "deterministic SHA-256 rank of selection seed and sample_id",
"selection_seed": SELECTION_SEED,
"train": "all remaining tasks",
"challenge": "not used",
"near_duplicate_policy": "ignored by design",
},
"split_counts": {name: len(sample_ids) for name, sample_ids in splits.items()},
"overall_step_distribution": dict(sorted(overall.items())),
"eligible_step_distribution": dict(sorted(eligible.items())),
"test_step_quotas": quotas,
"split_step_distribution": split_distribution,
"files": {},
}
for path in sorted(output_dir.iterdir()):
if path.name != "manifest.json":
manifest["files"][path.name] = sha256_file(path)
write_json(output_dir / "manifest.json", manifest)
print(json.dumps({
"split_counts": manifest["split_counts"],
"overall_step_distribution": manifest["overall_step_distribution"],
"test_step_quotas": quotas,
"split_step_distribution": split_distribution,
}, ensure_ascii=False, indent=2))
if __name__ == "__main__":
main()
|