#!/usr/bin/env python3 # -*- coding: utf-8 -*- """HermeneuticDive v3.0.0 — provenance / reproduction script. Rebuilds data//-*.parquet from the raw JSONL inputs in this repository, recomputes stats.json, and verifies build invariants: - qa_sft and qa_rl question sets are disjoint (no SFT/RL overlap) - message turns carry tool_call_id on every tool result, each referencing an earlier assistant tool call - trajectories and DPO pairs inherit their question's split - row counts match stats.json The decontamination hook now implements CONTAINMENT metrics (v2; replaces the v1 Jaccard-over-concatenated-fields check the audit found too dilute): 1. substring containment (normalised, >= 20 chars, either direction) 2. token-set containment >= 0.75 (stopwords removed, >= 6 tokens per side) 3. character-shingle (n=5) Jaccard >= 0.5 Usage: python create_dataset.py # rebuild parquet + stats python create_dataset.py --decontaminate benchmarks_dir_or.jsonl benchmarks: one JSON per line with a "question" field (or any text fields), or a directory of such .jsonl files. The release was checked against 7,900 questions from HotpotQA, 2WikiMultihopQA, MuSiQue and TriviaQA (fetched 2026-11-12 in v2; INHERITED, not re-run in v3 — see decontamination_report.json). Author pipeline: HermeneuticDive maintainers (independent project; LLM-assisted authoring under human direction). NOT affiliated with Z.ai or the original DeepDive authors. License: CC0-1.0 for all authored content (see LICENSE and README: Licensing). """ import argparse, json, re, sys, unicodedata from pathlib import Path from collections import defaultdict import pyarrow as pa import pyarrow.parquet as pq HERE = Path(__file__).parent CONFIGS = ["qa_sft", "qa_rl", "trajectories_sft", "dpo", "dpo_matched"] RAW_OF = {"qa_sft": "qa_sft_raw.jsonl", "qa_rl": "qa_rl_raw.jsonl", "trajectories_sft": "trajectories_raw.jsonl", "dpo": "dpo_raw.jsonl", "dpo_matched": "dpo_matched_raw.jsonl"} SPLITS = ["train", "validation", "test"] TYPE_MAP = {"string": pa.string(), "int32": pa.int32(), "float64": pa.float64(), "bool": pa.bool_(), "int64": pa.int64()} def spec_to_arrow(spec): t = spec.get("_type") if t == "Value": return TYPE_MAP[spec["dtype"]] if t == "List": return pa.list_(spec_to_arrow(spec["feature"])) if t == "struct": return pa.struct([(k, spec_to_arrow(v)) for k, v in spec["fields"].items()]) raise ValueError(f"unsupported spec: {spec}") def schema_for(features_json): return pa.schema([(name, spec_to_arrow(spec)) for name, spec in features_json.items()]) def load_rows(cfg): return [json.loads(l) for l in (HERE / RAW_OF[cfg]).read_text(encoding="utf-8").splitlines()] def clean(row, schema): return {name: row.get(name) for name in schema.names} def rebuild(): stats = {} for cfg in CONFIGS: rows = load_rows(cfg) features_json = json.loads((HERE / f"features_{cfg}.json").read_text()) schema = schema_for(features_json) out_dir = HERE / "data" / cfg out_dir.mkdir(parents=True, exist_ok=True) by_split = defaultdict(list) for r in rows: by_split[r["split"]].append(clean(r, schema)) cfg_stats = {} for split in SPLITS: srows = by_split.get(split, []) table = pa.Table.from_pylist(srows, schema=schema) path = out_dir / f"{split}-00000-of-00001.parquet" pq.write_table(table, path) cfg_stats[split] = {"num_examples": len(srows), "num_bytes": table.nbytes, "download_size": path.stat().st_size, "shards": [path.name]} print(f"{cfg}/{split}: {len(srows)} rows -> {path.name}") stats[cfg] = { "splits": cfg_stats, "download_size": sum(s["download_size"] for s in cfg_stats.values()), "dataset_size": sum(s["num_bytes"] for s in cfg_stats.values()), "num_examples": sum(s["num_examples"] for s in cfg_stats.values()), } (HERE / "stats.json").write_text(json.dumps(stats, indent=2, ensure_ascii=False)) verify(stats) print("stats.json written; invariants verified.") def verify(stats): # v2: SFT and RL pools disjoint sft_ids = {r["id"] for r in load_rows("qa_sft")} rl_ids = {r["id"] for r in load_rows("qa_rl")} assert not (sft_ids & rl_ids), f"SFT/RL question overlap: {sorted(sft_ids & rl_ids)[:5]}" # split integrity: a question id lives in exactly one split across configs split_of = {} for cfg in ["qa_sft", "qa_rl"]: for r in load_rows(cfg): if r["id"] in split_of: assert split_of[r["id"]] == r["split"], f"split leakage: {r['id']}" split_of[r["id"]] = r["split"] # trajectories + dpo inherit their question's split (question must be in qa_sft) qa = {r["id"]: r["split"] for r in load_rows("qa_sft")} for t in load_rows("trajectories_sft"): assert t["qa_id"] in qa, f"trajectory references non-SFT question: {t['qa_id']}" assert t["split"] == qa[t["qa_id"]], f"trajectory split mismatch: {t['id']}" for cfg_ in ("dpo", "dpo_matched"): for d in load_rows(cfg_): assert d["qa_id"] in qa, f"{cfg_} references non-SFT question: {d['qa_id']}" assert d["split"] == qa[d["qa_id"]], f"{cfg_} split mismatch: {d['id']}" # v2: tool_call_id integrity in every message list of every config def check_messages(msgs, ctx): for i, t in enumerate(msgs): if t.get("role") == "tool": assert t.get("tool_call_id"), f"{ctx}: tool turn without tool_call_id" ids = {c["id"] for tt in msgs[:i] if tt.get("role") == "assistant" for c in tt.get("tool_calls") or []} assert t["tool_call_id"] in ids, f"{ctx}: dangling tool_call_id {t['tool_call_id']}" for r in load_rows("qa_sft"): check_messages(r["messages"], f"qa_sft/{r['id']}") for t in load_rows("trajectories_sft"): check_messages(t["turns"], f"traj/{t['id']}") for cfg_ in ("dpo", "dpo_matched"): for d in load_rows(cfg_): check_messages(d["chosen"], f"{cfg_}/{d['id']}/chosen") check_messages(d["rejected"], f"{cfg_}/{d['id']}/rejected") # v3: a matched pair differs ONLY in the final answer line (no length/tool-call confound) for d in load_rows("dpo_matched"): assert d["chosen"][:-1] == d["rejected"][:-1], f"matched pair differs before the final turn: {d['id']}" assert d["chosen"][-1]["content"].rsplit("Final answer:", 1)[0] == d["rejected"][-1]["content"].rsplit("Final answer:", 1)[0], d["id"] # counts match stats for cfg, s in stats.items(): assert s["num_examples"] == len(load_rows(cfg)), cfg print("invariants OK: SFT/RL disjoint, split sync, tool_call_id integrity, linkage, counts.") # ── containment decontamination (v2) ──────────────────────────────────────── STOPWORDS = { "the", "a", "an", "of", "in", "on", "at", "to", "for", "and", "or", "is", "are", "was", "were", "be", "been", "by", "as", "that", "this", "these", "those", "it", "its", "his", "her", "their", "who", "what", "which", "when", "where", "how", "did", "do", "does", "name", "named", "called", "from", "with", "into", "about", "first", "one", "whom", "he", "she", "they", } def _norm(s): s = unicodedata.normalize("NFC", s).lower() s = re.sub(r"[^\w\u4e00-\u9fff\u0400-\u04ff\u0900-\u097f\u3040-\u30ff]+", " ", s) return re.sub(r"\s+", " ", s).strip() def _tokens(s): t = _norm(s) if re.search(r"[\u4e00-\u9fff\u3040-\u30ff]", t): return set(t.replace(" ", "")) return {w for w in t.split() if w not in STOPWORDS} def _shingles(s, n=5): t = _norm(s) return set(t[i:i+n] for i in range(len(t) - n + 1)) or {t} def decontaminate(target): p = Path(target) bench = [] sources = sorted(p.glob("*.jsonl")) if p.is_dir() else [p] assert sources, f"no benchmark files at {target}" for src in sources: for line in src.read_text(encoding="utf-8").splitlines(): if not line.strip(): continue obj = json.loads(line) q = obj.get("question") or " ".join(str(v) for v in obj.values() if isinstance(v, (str, int, float))) bench.append(q) assert bench, f"no benchmark questions loaded from {target}: a check against nothing is not a pass" b_pre = [(_norm(b), _tokens(b), _shingles(b)) for b in bench] hits = [] for cfg in ["qa_sft", "qa_rl"]: for r in load_rows(cfg): qn, qt, qs = _norm(r["question"]), _tokens(r["question"]), _shingles(r["question"]) for i, (bn, bt, bs) in enumerate(b_pre): if (len(qn) >= 20 and qn in bn) or (len(bn) >= 20 and bn in qn): hits.append((r["id"], i, "substring", 1.0)); continue if min(len(qt), len(bt)) >= 6: cont = len(qt & bt) / min(len(qt), len(bt)) if cont >= 0.75: hits.append((r["id"], i, "token_containment", round(cont, 3))); continue jac = len(qs & bs) / max(1, len(qs | bs)) if jac >= 0.5: hits.append((r["id"], i, "shingle_jaccard", round(jac, 3))) if hits: print(f"CONTAMINATION CANDIDATES ({len(hits)}):") for h in hits[:50]: print(" ", h) sys.exit(1) print(f"decontamination clean: 0 overlaps against {len(bench)} benchmark questions " f"(substring; token containment >= 0.75; shingle-5 Jaccard >= 0.5)") if __name__ == "__main__": ap = argparse.ArgumentParser() ap.add_argument("--decontaminate", metavar="BENCHMARKS", default=None, help="containment check of all questions vs benchmark dumps " "(.jsonl file or directory of .jsonl files)") args = ap.parse_args() if args.decontaminate: decontaminate(args.decontaminate) else: rebuild()