| """Extract unique OpenThoughts3 questions and remove benchmark overlaps.""" |
|
|
| from __future__ import annotations |
|
|
| import csv |
| import hashlib |
| import json |
| import re |
| import unicodedata |
| from collections import Counter, defaultdict |
| from pathlib import Path |
|
|
| import ahocorasick |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
| from rapidfuzz import fuzz |
|
|
|
|
| ROOT = Path(__file__).parent |
| BENCH = ROOT / "work" / "benchmarks" |
| SOURCE = ROOT / "work" / "source" / "data" |
| OUT = ROOT / "work" / "publish" |
|
|
|
|
| def normalized(text: str) -> str: |
| text = unicodedata.normalize("NFKC", text).casefold() |
| text = re.sub(r"[^\w]+", " ", text, flags=re.UNICODE) |
| return " ".join(text.split()) |
|
|
|
|
| def benchmark_questions() -> tuple[list[dict], dict]: |
| specs = [ |
| ("MATH500", "HuggingFaceH4__MATH-500/test.jsonl", "problem"), |
| ("AIME25", "MathArena__aime_2025/data/train-00000-of-00001.parquet", "problem"), |
| ("AIME26", "MathArena__aime_2026/data/train-00000-of-00001.parquet", "problem"), |
| ("HMMT_Feb_2025", "MathArena__hmmt_feb_2025/data/train-00000-of-00001.parquet", "problem"), |
| ("HMMT_Feb_2026", "MathArena__hmmt_feb_2026/data/train-00000-of-00001.parquet", "problem"), |
| ("IMOAnswerBench_v2", "imo_answerbench_v2.csv", "Problem"), |
| ("OJBench", "He-Ren__OJBench_testdata/prompts/full.jsonl", "prompt"), |
| ] |
| for i in range(1, 7): |
| specs.append(("LiveCodeBench_v6", f"livecodebench__code_generation_lite/test{'' if i == 1 else i}.jsonl", "question_content")) |
|
|
| questions = [] |
| counts = Counter() |
| for name, rel, field in specs: |
| path = BENCH / rel |
| if path.suffix == ".parquet": |
| rows = pq.read_table(path, columns=[field]).to_pylist() |
| elif path.suffix == ".csv": |
| with path.open(newline="", encoding="utf-8-sig") as f: |
| rows = list(csv.DictReader(f)) |
| else: |
| with path.open(encoding="utf-8") as f: |
| rows = [json.loads(line) for line in f] |
| for row in rows: |
| value = row.get(field) |
| if isinstance(value, str) and value.strip(): |
| norm = normalized(value) |
| questions.append({"name": name, "norm": norm, "words": set(norm.split())}) |
| counts[name] += 1 |
| return questions, dict(counts) |
|
|
|
|
| def build_index(bench: list[dict]): |
| exact = defaultdict(set) |
| anchors = defaultdict(set) |
| for idx, item in enumerate(bench): |
| norm = item["norm"] |
| exact[norm].add(idx) |
| words = norm.split() |
| width = min(10, max(4, len(words) // 2)) |
| if len(words) < width: |
| continue |
| positions = list(range(0, len(words) - width + 1, max(1, width // 2))) |
| if len(positions) > 40: |
| positions = [positions[round(i * (len(positions) - 1) / 39)] for i in range(40)] |
| for pos in positions: |
| window = words[pos : pos + width] |
| if len(set(window)) < min(5, width) or not any(len(w) >= 6 for w in window): |
| continue |
| anchors[" " + " ".join(window) + " "].add(idx) |
| machine = ahocorasick.Automaton() |
| for pattern, ids in anchors.items(): |
| machine.add_word(pattern, tuple(ids)) |
| machine.make_automaton() |
| return exact, machine, len(anchors) |
|
|
|
|
| def matches(question: str, bench: list[dict], exact, machine): |
| norm = normalized(question) |
| if not norm: |
| return [] |
| hit = set(exact.get(norm, ())) |
| candidates = set() |
| for _, ids in machine.iter(" " + norm + " "): |
| candidates.update(ids) |
| source_words = set(norm.split()) |
| for idx in candidates - hit: |
| target = bench[idx]["norm"] |
| if not target: |
| continue |
| if (len(target) >= 50 and target in norm) or (len(norm) >= 100 and len(norm) >= 0.65 * len(target) and norm in target): |
| hit.add(idx) |
| continue |
| target_words = bench[idx]["words"] |
| coverage = len(target_words.intersection(source_words)) / max(1, len(target_words)) |
| if coverage < 0.55: |
| continue |
| ratio = fuzz.ratio(norm, target, score_cutoff=82) |
| partial = 0 |
| if not ratio and coverage >= 0.70 and len(target) <= 800 and len(norm) <= 3000: |
| partial = fuzz.partial_ratio(norm, target, score_cutoff=88) |
| if ratio or partial: |
| hit.add(idx) |
| return sorted(hit) |
|
|
|
|
| BOX = re.compile(r"\\+boxed\s*\{") |
| FENCE = re.compile(r"```([^\n`]*)\n(.*?)\n```", re.DOTALL) |
| ANSWER_LABEL = re.compile(r"(?im)(?:^|\n)\s*(?:\*\*)?(?:final answer|answer)(?:\*\*)?\s*[:：]\s*(.+)") |
|
|
|
|
| def last_box(text: str) -> str | None: |
| found = None |
| for match in BOX.finditer(text): |
| depth = 1 |
| i = match.end() |
| start = i |
| while i < len(text) and depth: |
| if text[i] == "{": |
| depth += 1 |
| elif text[i] == "}": |
| depth -= 1 |
| i += 1 |
| if depth == 0: |
| found = text[start : i - 1].strip() |
| return found |
|
|
|
|
| def extract_answer(response: str, domain: str) -> tuple[str, str] | None: |
| if not isinstance(response, str): |
| return None |
| marker = response.rfind("</think>") |
| if marker < 0: |
| return None |
| final = response[marker + len("</think>") :].strip() |
| if not final: |
| return None |
| if domain == "math": |
| box = last_box(final) |
| if box: |
| return box, "final_boxed" |
| labels = ANSWER_LABEL.findall(final) |
| if labels: |
| answer = labels[-1].strip().strip("*$ ") |
| if answer and len(answer) <= 300: |
| return answer, "final_answer_label" |
| return None |
| if domain == "code": |
| blocks = FENCE.findall(final) |
| if blocks: |
| language, code = blocks[-1] |
| if code.strip(): |
| return code.strip(), "final_code_block" |
| return None |
| if domain == "science": |
| if final.rstrip("* ").endswith((".", "!", "?", "}", "]", ")")): |
| return final, "completed_final_text" |
| return None |
|
|
|
|
| def main(): |
| OUT.mkdir(parents=True, exist_ok=True) |
| bench, benchmark_counts = benchmark_questions() |
| exact, machine, anchor_count = build_index(bench) |
| print(f"Benchmarks: {benchmark_counts}; anchors: {anchor_count}", flush=True) |
| files = sorted(SOURCE.glob("train-*-of-00120.parquet")) |
| if len(files) != 120: |
| raise RuntimeError(f"Expected 120 source shards, found {len(files)}") |
|
|
| records = {} |
| counts = Counter() |
| removed_by_benchmark = Counter() |
| audit = [] |
| rejected = set() |
| for n, path in enumerate(files, 1): |
| parquet = pq.ParquetFile(path) |
| for batch in parquet.iter_batches(batch_size=512, columns=["difficulty", "source", "domain", "conversations"]): |
| for row in batch.to_pylist(): |
| counts["source_rows"] += 1 |
| turns = row["conversations"] |
| if not turns or not isinstance(turns[0], dict) or not isinstance(turns[0].get("value"), str) or not turns[0]["value"].strip(): |
| counts["invalid_question"] += 1 |
| continue |
| question = turns[0]["value"] |
| if question in rejected: |
| counts["duplicate_question"] += 1 |
| continue |
| record = records.get(question) |
| if record is None: |
| hit = matches(question, bench, exact, machine) |
| if hit: |
| rejected.add(question) |
| counts["benchmark_overlap"] += 1 |
| names = sorted({bench[i]["name"] for i in hit}) |
| for name in names: |
| removed_by_benchmark[name] += 1 |
| audit.append({"question_sha256": hashlib.sha256(question.encode()).hexdigest(), "benchmarks": names, "benchmark_indices": hit}) |
| continue |
| record = {"difficulty": row["difficulty"], "source": row["source"], "domain": row["domain"], "conversations": [turns[0]], "answer_candidates": Counter(), "best_answer": None, "answer_method": None, "responses": 0} |
| records[question] = record |
| counts["published"] += 1 |
| else: |
| counts["duplicate_question"] += 1 |
| for turn in turns[1:]: |
| if turn.get("from") not in ("gpt", "assistant"): |
| continue |
| record["responses"] += 1 |
| candidate = extract_answer(turn.get("value"), record["domain"]) |
| if candidate is None: |
| continue |
| answer, method = candidate |
| if record["domain"] == "math": |
| record["answer_candidates"][answer] += 1 |
| elif record["best_answer"] is None or (record["domain"] == "science" and len(answer) < len(record["best_answer"])): |
| record["best_answer"] = answer |
| record["answer_method"] = method |
| print(f"{n}/120: {dict(counts)}", flush=True) |
|
|
| question_schema = pa.schema([("difficulty", pa.int64()), ("source", pa.string()), ("domain", pa.string()), ("conversations", pa.list_(pa.struct([("from", pa.string()), ("value", pa.string())])))]) |
| answer_schema = question_schema.append(pa.field("answer", pa.string())).append(pa.field("answer_method", pa.string())).append(pa.field("answer_confidence", pa.string())).append(pa.field("response_count", pa.int64())).append(pa.field("answer_support", pa.int64())) |
| question_dir = OUT / "data" / "questions" |
| answer_dir = OUT / "data" / "with_answers" |
| question_dir.mkdir(parents=True, exist_ok=True) |
| answer_dir.mkdir(parents=True, exist_ok=True) |
| qwriter = pq.ParquetWriter(question_dir / "train.parquet", question_schema, compression="zstd") |
| awriter = pq.ParquetWriter(answer_dir / "train.parquet", answer_schema, compression="zstd") |
| qbatch, abatch = [], [] |
| domain_counts = Counter() |
| answer_counts = Counter() |
| try: |
| for record in records.values(): |
| basic = {key: record[key] for key in ("difficulty", "source", "domain", "conversations")} |
| domain_counts[record["domain"]] += 1 |
| answer = record["best_answer"] |
| method = record["answer_method"] |
| support = 1 if answer is not None else 0 |
| confidence = "medium" if answer is not None else "none" |
| if record["domain"] == "math": |
| votes = record["answer_candidates"].most_common() |
| if votes and (len(votes) == 1 or votes[0][1] > votes[1][1]): |
| answer, support = votes[0] |
| method = "final_boxed_or_labeled" |
| confidence = "high" if support >= 2 else "medium" |
| elif votes: |
| answer, method, support, confidence = None, "conflicting_answers", 0, "none" |
| if answer is None and method is None: |
| method = "no_explicit_final_answer" |
| answer_counts[record["domain"] + ":" + ("answered" if answer is not None else "null")] += 1 |
| qbatch.append(basic) |
| abatch.append({**basic, "answer": answer, "answer_method": method, "answer_confidence": confidence, "response_count": record["responses"], "answer_support": support}) |
| if len(qbatch) >= 2000: |
| qwriter.write_table(pa.Table.from_pylist(qbatch, schema=question_schema)) |
| awriter.write_table(pa.Table.from_pylist(abatch, schema=answer_schema)) |
| qbatch.clear(); abatch.clear() |
| if qbatch: |
| qwriter.write_table(pa.Table.from_pylist(qbatch, schema=question_schema)) |
| awriter.write_table(pa.Table.from_pylist(abatch, schema=answer_schema)) |
| finally: |
| qwriter.close(); awriter.close() |
| report = {"source_repo": "open-thoughts/OpenThoughts3-1.2M", "source_revision": "61bcf9d4eb38b30295efc2021227a63cc5bb34c8", "benchmark_counts": benchmark_counts, "anchor_count": anchor_count, "counts": dict(counts), "domain_counts": dict(domain_counts), "answer_counts": dict(answer_counts), "removed_by_benchmark": dict(removed_by_benchmark), "method": "Exact question deduplication; casefolded NFKC alphanumeric exact matching; 4-10 word anchor candidate retrieval followed by normalized containment or RapidFuzz ratio >=82 (benchmark token coverage >=0.55), or partial ratio >=88 (coverage >=0.70, benchmark <=800 characters, source <=3000 characters). Answers are extracted only from completed final response sections after </think>; no correctness guarantee."} |
| (OUT / "processing_report.json").write_text(json.dumps(report, indent=2, ensure_ascii=False) + "\n") |
| (ROOT / "work" / "removed_audit.jsonl").write_text("".join(json.dumps(x, ensure_ascii=False) + "\n" for x in audit)) |
| print(json.dumps(report, indent=2), flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
