wenjieshu's picture
Add files using upload-large-folder tool
b8ea052 verified
Raw History Blame Contribute Delete
9.11 kB
"""Build a leakage-separated Common-264 experiment bundle."""
from __future__ import annotations
import json
import shutil
from collections import defaultdict
from pathlib import Path
from typing import Any
from .schema import validate_planner_input
def read_jsonl(path: Path) -> list[dict[str, Any]]:
return [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]
def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
path.parent.mkdir(parents=True, exist_ok=True)
with path.open("w", encoding="utf-8") as handle:
for row in rows:
handle.write(json.dumps(row, ensure_ascii=False) + "\n")
def load(path: Path) -> dict[str, Any]:
return json.loads(path.read_text(encoding="utf-8"))
def _dependency_index(path: Path) -> dict[str, dict[str, Any]]:
grouped: dict[str, list[dict[str, Any]]] = defaultdict(list)
for row in read_jsonl(path):
grouped[str(row["case_id"])].append(row)
return {case_id: rows[0] for case_id, rows in grouped.items() if len(rows) == 1}
def _balanced_sample(rows: list[dict[str, Any]], per_level: int) -> list[dict[str, Any]]:
result: list[dict[str, Any]] = []
for level in ("L1", "L2", "L3"):
families: dict[str, list[dict[str, Any]]] = defaultdict(list)
for row in rows:
if row.get("dependency_prelabel") == level:
families[str(row["case_family"])].append(row)
for values in families.values():
values.sort(key=lambda item: (int(item["position"]), str(item["uid"])))
names = sorted(families)
selected: list[dict[str, Any]] = []
cursor = 0
while len(selected) < per_level and names:
name = names[cursor % len(names)]
if families[name]:
selected.append(families[name].pop(0))
names = [item for item in names if families[item]]
cursor += 1
if len(selected) != per_level:
raise ValueError(f"insufficient {level} cases: wanted {per_level}, found {len(selected)}")
result.extend(selected)
return sorted(result, key=lambda item: int(item["position"]))
def build_bundle(
*,
common_cases_path: Path,
portable_dir: Path,
dependency_path: Path,
output_dir: Path,
) -> dict[str, Any]:
common = read_jsonl(common_cases_path)
source_generation = read_jsonl(portable_dir / "generation_manifest.jsonl")
generation_by_uid = {str(row["uid"]): row for row in source_generation}
source_batch = load(portable_dir / "batch_manifest.json")
batch_by_uid = {str(row["uid"]): row for row in source_batch["cases"]}
source_contract_manifest = load(portable_dir / "contract_manifest.json")
contract_by_uid = {str(row["uid"]): row for row in source_contract_manifest["cases"]}
dependency = _dependency_index(dependency_path)
frozen = output_dir / "frozen"
assets = frozen / "assets"
contracts = frozen / "contracts"
assets.mkdir(parents=True, exist_ok=True)
contracts.mkdir(parents=True, exist_ok=True)
generation_rows: list[dict[str, Any]] = []
batch_rows: list[dict[str, Any]] = []
contract_rows: list[dict[str, Any]] = []
planner_rows: list[dict[str, Any]] = []
selection_rows: list[dict[str, Any]] = []
for index, common_row in enumerate(common, 1):
uid = str(common_row["uid"])
source_gen = generation_by_uid[uid]
source_asset = (portable_dir / source_gen["input_image"]).resolve()
suffix = source_asset.suffix.lower() or ".jpg"
asset_name = f"{index:03d}{suffix}"
destination = assets / asset_name
shutil.copy2(source_asset, destination)
contract_item = contract_by_uid[uid]
source_contract = (portable_dir / contract_item["contract_path"]).resolve()
contract_name = f"{index:03d}.json"
shutil.copy2(source_contract, contracts / contract_name)
relative_image = f"assets/{asset_name}"
instruction = str(source_gen["instruction"])
base_meta = {
key: source_gen.get(key)
for key in (
"position", "uid", "source_uid", "case_id", "case_family", "source", "top_level",
"approval_batch", "reasoning_depth", "primary_operator", "analysis_weight",
)
}
generation_rows.append({**base_meta, "input_image": relative_image, "instruction": instruction})
source_batch_item = batch_by_uid[uid]
batch_rows.append({**source_batch_item, "input_image": relative_image, "gt_image": None})
contract_rows.append({**contract_item, "contract_path": f"contracts/{contract_name}"})
planner_row = {
**base_meta,
"input_image": f"frozen/assets/{asset_name}",
"instruction": instruction,
}
issues = validate_planner_input(planner_row)
if issues:
raise ValueError(f"planner input leakage/schema failure for {uid}: {issues}")
planner_rows.append(planner_row)
prelabel = dependency.get(str(source_gen["case_id"]))
selection_rows.append(
{
**base_meta,
"dependency_prelabel": prelabel.get("level") if prelabel else None,
"dependency_prelabel_confidence": prelabel.get("confidence") if prelabel else None,
"dependency_prelabel_status": "single_model_sampling_only" if prelabel else "unavailable",
}
)
if len(generation_rows) != 264 or len({row["uid"] for row in generation_rows}) != 264:
raise ValueError("Common bundle must contain exactly 264 unique UIDs")
write_jsonl(frozen / "generation_manifest.jsonl", generation_rows)
write_jsonl(output_dir / "planner_inputs.jsonl", planner_rows)
write_jsonl(output_dir / "selection_manifest.jsonl", selection_rows)
(frozen / "batch_manifest.json").write_text(
json.dumps({"schema_version": "solveedit.common264_batch.v1", "case_count": 264, "cases": batch_rows}, ensure_ascii=False, indent=2) + "\n"
)
(frozen / "contract_manifest.json").write_text(
json.dumps({"schema_version": "solveedit.common264_contracts.v1", "case_count": 264, "cases": contract_rows}, ensure_ascii=False, indent=2) + "\n"
)
eligible = [row for row in selection_rows if row.get("dependency_prelabel") in {"L1", "L2", "L3"}]
pilot = _balanced_sample(eligible, 16)
pilot_uids = {row["uid"] for row in pilot}
pilot_planner = [row for row in planner_rows if row["uid"] in pilot_uids]
by_level: dict[str, list[dict[str, Any]]] = defaultdict(list)
for row in pilot:
by_level[str(row["dependency_prelabel"])].append(row)
smoke_selection = []
for level in ("L1", "L2", "L3"):
smoke_selection.extend(by_level[level][:4])
smoke_uids = {row["uid"] for row in smoke_selection}
smoke_planner = [row for row in planner_rows if row["uid"] in smoke_uids]
write_jsonl(output_dir / "pilot48_selection.jsonl", pilot)
write_jsonl(output_dir / "pilot48_planner_inputs.jsonl", pilot_planner)
write_jsonl(output_dir / "smoke12_selection.jsonl", smoke_selection)
write_jsonl(output_dir / "smoke12_planner_inputs.jsonl", smoke_planner)
def write_subset(prefix: str, wanted: set[str]) -> None:
subset_generation = [row for row in generation_rows if row["uid"] in wanted]
subset_batch = [row for row in batch_rows if row["uid"] in wanted]
subset_contracts = [row for row in contract_rows if row["uid"] in wanted]
if not (len(subset_generation) == len(subset_batch) == len(subset_contracts) == len(wanted)):
raise ValueError(f"incomplete {prefix} frozen subset")
write_jsonl(frozen / f"{prefix}_direct_manifest.jsonl", subset_generation)
(frozen / f"{prefix}_batch_manifest.json").write_text(
json.dumps(
{"schema_version": f"solveedit.{prefix}_batch.v1", "case_count": len(wanted), "cases": subset_batch},
ensure_ascii=False,
indent=2,
)
+ "\n"
)
(frozen / f"{prefix}_contract_manifest.json").write_text(
json.dumps(
{
"schema_version": f"solveedit.{prefix}_contracts.v1",
"case_count": len(wanted),
"cases": subset_contracts,
},
ensure_ascii=False,
indent=2,
)
+ "\n"
)
write_subset("smoke12", smoke_uids)
write_subset("pilot48", pilot_uids)
summary = {
"schema_version": "solveedit.harness_common264_bundle.v1",
"common_cases": 264,
"prelabel_matched": len(eligible),
"prelabel_note": "single-model metadata used only for stratified sampling; not human gold",
"pilot48": len(pilot),
"smoke12": len(smoke_selection),
"output_dir": str(output_dir.resolve()),
}
(output_dir / "bundle_summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n")
return summary