File size: 7,730 Bytes
f45837e | 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 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 | #!/usr/bin/env python3
"""Generate one error rubric per eligible observation, without dedup or a cap."""
from __future__ import annotations
import argparse
import itertools
import re
import sys
from collections import defaultdict
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from common import ModelRefusal, anthropic_text, append_jsonl, read_jsonl, short_id, truncate, write_json
from errors import prompts
from shared.protocol import CURATOR_MODEL
NULL_RE = re.compile(r"^\s*rubric:\s*null", re.I | re.M)
REASON_RE = re.compile(r"^\s*reason:\s*(\S+)", re.I | re.M)
HEADING_RE = re.compile(r"^###\s+(.+?)\s*$", re.M)
FIELD_RE = {
"input_condition": re.compile(r"^-\s*\*\*Input condition\*\*:\s*(.+)$", re.M),
"code_requirement": re.compile(r"^-\s*\*\*Code requirement\*\*:\s*(.+)$", re.M),
"prediction": re.compile(r"^-\s*\*\*Prediction\*\*:\s*(.+)$", re.M),
}
STOP_WORDS = set("a an the is are be to of in on for with and or as that this it its from by at into when where which".split())
def normalize(text: str) -> str:
words = [word for word in re.findall(r"[a-z0-9]+", (text or "").lower())
if word not in STOP_WORDS]
return " ".join(sorted(set(words)))
def parse_rubric(text: str) -> dict | None:
if not text or NULL_RE.search(text):
return None
heading = HEADING_RE.search(text)
if not heading:
return None
fields = {}
for key, pattern in FIELD_RE.items():
match = pattern.search(text)
if not match:
return None
fields[key] = match.group(1).strip()
return {"title": heading.group(1).strip(), **fields, "markdown": text.strip()}
def null_reason(text: str) -> str:
match = REASON_RE.search(text or "")
return match.group(1).strip() if match else ("empty" if not text else "unparsed")
def validate(rubric: dict, exception_class: str) -> list[str]:
problems = []
if not re.match(r"^`?(task|code)`?\s*:", rubric["input_condition"], re.I):
problems.append("input condition does not declare a `task`/`code` source")
if exception_class and exception_class.lower() not in rubric["prediction"].lower():
problems.append(f"prediction does not name the observed {exception_class}")
return problems
def fingerprint(rubric: dict, exception_class: str) -> str:
"""Reporting metadata only; never used to remove a rubric."""
return short_id(f"{exception_class}|{normalize(rubric['input_condition'])}")
def interleave(states: list[dict]) -> list[dict]:
by_competition: dict[str, list[dict]] = defaultdict(list)
for state in states:
by_competition[state["competition"]].append(state)
queues = [iter(rows) for _, rows in sorted(by_competition.items())]
return [state for group in itertools.zip_longest(*queues)
for state in group if state is not None]
def generate_one(state: dict, *, model: str, code_cap: int, error_cap: int) -> dict:
execution = state["execution"]
errors = truncate(f"{execution.get('stdout', '')}\n--- stderr ---\n{execution.get('stderr', '')}", error_cap)
user = prompts.build_user(
task=truncate(state.get("task_prompt", ""), 16000),
code=truncate(state["code"], code_cap), errors=errors)
try:
text = anthropic_text(prompt=user, system=prompts.SYSTEM, model=model,
max_tokens=6000, effort="high")
except ModelRefusal as exc:
return {"state_id": state["state_id"], "emitted": False,
"reason": "refusal", "detail": str(exc)[:200]}
rubric = parse_rubric(text)
row = {
"state_id": state["state_id"], "competition": state["competition"],
"trajectory": state.get("trajectory") or state.get("trajectory_id"),
"stage": state.get("stage"),
"exception_class": execution.get("exception_class"),
"exception_message": (execution.get("exception_message") or "")[:300],
"model": model, "raw": text[:20000],
}
if rubric is None:
row.update({"emitted": False, "reason": null_reason(text)})
return row
problems = validate(rubric, execution.get("exception_class") or "")
row.update({"emitted": not problems, "reason": "" if not problems else "invalid",
"problems": problems, "rubric": rubric,
"fingerprint": fingerprint(rubric, execution.get("exception_class") or "")})
return row
def slugify(text: str, cap: int = 60) -> str:
value = re.sub(r"[^a-z0-9]+", "-", (text or "").lower()).strip("-")
return value[:cap].rstrip("-") or "rubric"
def render(rubric: dict, row: dict, index: int) -> str:
return f"""---
id: E{index:03d}
family: error
exception_class: {row.get('exception_class') or 'unknown'}
competition: {row['competition']}
trajectory: {row.get('trajectory') or ''}
stage: {row.get('stage') or ''}
generator: {row['model']}
prompt_version: predictive_v6
split: source
fingerprint: {row['fingerprint']}
---
{rubric['markdown']}
"""
def main() -> int:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--states", default="data/states.jsonl")
parser.add_argument("--out", default="out/errors")
parser.add_argument("--log", default="data/error_curation_log.jsonl")
parser.add_argument("--model", default=CURATOR_MODEL)
parser.add_argument("--workers", type=int, default=16)
parser.add_argument("--code-cap", type=int, default=30000)
parser.add_argument("--error-cap", type=int, default=12000)
args = parser.parse_args()
states = interleave([row for row in read_jsonl(args.states)
if row.get("eligible_error")])
if not states:
print(f"no eligible error states in {args.states}")
return 1
prior = read_jsonl(args.log)
done = {row["state_id"] for row in prior}
pending = [row for row in states if row["state_id"] not in done]
with ThreadPoolExecutor(max_workers=args.workers) as pool:
futures = {pool.submit(generate_one, state, model=args.model,
code_cap=args.code_cap, error_cap=args.error_cap): state
for state in pending}
for future in as_completed(futures):
row = future.result()
append_jsonl(args.log, row)
print(f"[{len(done) + 1}/{len(states)}] {row.get('reason') or 'emitted'}", flush=True)
done.add(row["state_id"])
rows = read_jsonl(args.log)
by_state = {row["state_id"]: row for row in rows}
accepted = [by_state[state["state_id"]] for state in states
if by_state.get(state["state_id"], {}).get("emitted")]
out = Path(args.out)
out.mkdir(parents=True, exist_ok=True)
for old in out.glob("E*.md"):
old.unlink()
for index, row in enumerate(accepted, 1):
(out / f"E{index:03d}-{slugify(row['rubric']['title'])}.md").write_text(
render(row["rubric"], row, index))
reasons: dict[str, int] = {}
for row in rows:
if not row.get("emitted"):
reason = row.get("reason", "unknown")
reasons[reason] = reasons.get(reason, 0) + 1
write_json(out.parent / "error_summary.json", {
"arm": "errors", "prompt_version": "predictive_v6", "model": args.model,
"eligible_observations": len(states), "processed": len(by_state),
"written": len(accepted), "deduplication": "none",
"fingerprints": "metadata only", "null_reasons": reasons,
})
print(f"{len(accepted)} rubrics from {len(states)} eligible observations -> {out}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
|