| """Re-attach benchmark item text to the Laghu evaluation release from pinned public dataset revisions, and check it. |
| |
| python join_items.py DATASET_DIR --out OUT_DIR [--what math500,base] [--models laghu-base,smollm2-135m] [--cache DIR] |
| |
| The release ships some benchmarks as ids and scores only, because their text may not be re-published by us (MATH-500, |
| HellaSwag, PIQA) or would change the dataset's licence (ARC is CC-BY-SA-4.0), or to keep one rule for every |
| multiple-choice benchmark (MMLU, WinoGrande). This script puts the text back on your machine: |
| |
| - math500: downloads HuggingFaceH4/MATH-500 `test.jsonl` at a pinned revision, rebuilds |
| `chat_suite/prompts/math500_l123.jsonl` (id, problem, gold, level, subject; levels 1-3, in dataset order) and checks |
| its sha256 against `chat_suite/prompts/ITEMS.json`. It then fills every ⟦MATH500#k⟧ marker (a model's verbatim copy |
| of MATH-500 problem text, removed from the release; `math500_spans[k]` says which problem, which words and which |
| whitespace) in `chat_suite/generations/*/*/*.jsonl.gz` and in the GSM8K outputs of `base_suite/*/gsm8k.jsonl.gz`, and |
| checks each restored output against its `raw_sha256` / `resps_sha256`. |
| - base: for every `base_suite/<model>/<task>.jsonl.gz` and `long_context/gate_base_suite/<model>/<task>.jsonl.gz`, adds |
| `doc`, the document exactly as lm-eval 0.4.13 saw it, and checks lm-eval's own `doc_hash` on every row. |
| |
| Writes only under OUT_DIR (same relative paths). Needs: huggingface_hub, pyarrow. Each source keeps its own licence. |
| """ |
| import argparse |
| import collections |
| import glob |
| import gzip |
| import hashlib |
| import json |
| import os |
| import re |
| import sys |
|
|
| PINS = { |
| "math500": ("HuggingFaceH4/MATH-500", "6e4ed1a2a79af7d8630a6b768ec859cb5af4d3be", "test.jsonl"), |
| "arc_easy": ("allenai/ai2_arc", "210d026faf9955653af8916fad021475a3f00453", "ARC-Easy/test-00000-of-00001.parquet"), |
| "arc_challenge": ("allenai/ai2_arc", "210d026faf9955653af8916fad021475a3f00453", "ARC-Challenge/test-00000-of-00001.parquet"), |
| "arc_easy_val": ("allenai/ai2_arc", "210d026faf9955653af8916fad021475a3f00453", "ARC-Easy/validation-00000-of-00001.parquet"), |
| "arc_challenge_val": ("allenai/ai2_arc", "210d026faf9955653af8916fad021475a3f00453", "ARC-Challenge/validation-00000-of-00001.parquet"), |
| "hellaswag": ("Rowan/hellaswag", "218ec52e09a7e7462a5400043bb9a69a41d06b76", "data/validation-00000-of-00001.parquet"), |
| "piqa": ("baber/piqa", "142f6d7367fd9877f0fb3b5734ea6a545f54cdd1", "piqa_validation.parquet"), |
| "winogrande": ("allenai/winogrande", "01e74176c63542e6b0bcb004dcdea22d94fb67b5", "winogrande_xl/validation-00000-of-00001.parquet"), |
| "mmlu": ("cais/mmlu", "c30699e8356da336a370243923dbaf21066bb9fe", "{subject}/test-00000-of-00001.parquet"), |
| } |
| MARK = re.compile("\u27e6MATH500#(\\d+)\u27e7") |
|
|
|
|
| def fetch(key, cache, subject=None): |
| from huggingface_hub import hf_hub_download |
| repo, rev, path = PINS[key] |
| return hf_hub_download(repo, path.format(subject=subject), repo_type="dataset", revision=rev, cache_dir=cache) |
|
|
|
|
| def read_parquet(p): |
| import pyarrow.parquet as pq |
| return pq.read_table(p).to_pylist() |
|
|
|
|
| def rjsonl(path): |
| op = gzip.open if path.endswith(".gz") else open |
| with op(path, "rt", encoding="utf-8") as f: |
| return [json.loads(l) for l in f] |
|
|
|
|
| def wjsonl(path, rows): |
| os.makedirs(os.path.dirname(path), exist_ok=True) |
| op = gzip.open if path.endswith(".gz") else open |
| with op(path, "wt", encoding="utf-8") as f: |
| for r in rows: |
| f.write(json.dumps(r, ensure_ascii=False) + "\n") |
|
|
|
|
| def sha(s): |
| return hashlib.sha256(s.encode("utf-8")).hexdigest() |
|
|
|
|
| |
| def hs_preprocess(text): |
| text = text.strip() |
| text = text.replace(" [title]", ". ") |
| text = re.sub("\\[.*?\\]", "", text) |
| text = text.replace(" ", " ") |
| return text |
|
|
|
|
| def hs_doc(doc): |
| ctx = doc["ctx_a"] + " " + doc["ctx_b"].capitalize() |
| return dict(doc, query=hs_preprocess(doc["activity_label"] + ": " + ctx), |
| choices=[hs_preprocess(e) for e in doc["endings"]], gold=int(doc["label"])) |
|
|
|
|
| def join_math(ds, out, cache): |
| rows = [json.loads(l) for l in open(fetch("math500", cache), encoding="utf-8")] |
| items = [dict(id=r["unique_id"], problem=r["problem"], gold=r["answer"], level=int(r["level"]), subject=r["subject"]) |
| for r in rows if int(r["level"]) <= 3] |
| ids = [r["id"] for r in rjsonl(os.path.join(ds, "chat_suite", "prompts", "math500_l123_ids.jsonl"))] |
| assert [r["id"] for r in items] == ids, "MATH-500 ids differ from the release" |
| p = os.path.join(out, "chat_suite", "prompts", "math500_l123.jsonl") |
| os.makedirs(os.path.dirname(p), exist_ok=True) |
| with open(p, "w", encoding="utf-8") as f: |
| for r in items: |
| f.write(json.dumps(r, ensure_ascii=False) + "\n") |
| want = json.load(open(os.path.join(ds, "chat_suite", "prompts", "ITEMS.json")))["math"]["sha256"] |
| got = hashlib.sha256(open(p, "rb").read()).hexdigest() |
| print(f"math500: {len(items)} items; sha256 {'matches' if got == want else 'DIFFERS from'} ITEMS.json") |
| words = [r["problem"].split() for r in items] |
|
|
| def fill(text, spans): |
| def one(m): |
| s = spans[int(m.group(1))] |
| if "a" in s: |
| return items[s["item"]]["problem"][s["a"]:s["b"]] |
| w = words[s["item"]][s["w"]:s["w"] + s["n"]] |
| seps = s["seps"] or [" "] * (len(w) - 1) |
| return w[0] + "".join(a + b for a, b in zip(seps, w[1:])) |
| return MARK.sub(one, text) |
|
|
| n_rows = n_spans = bad = 0 |
| files = sorted(glob.glob(os.path.join(ds, "chat_suite", "generations", "*", "*", "*.jsonl.gz")) + |
| glob.glob(os.path.join(ds, "base_suite", "*", "gsm8k.jsonl.gz"))) |
| for f in files: |
| rows, changed = [], False |
| for r in rjsonl(f): |
| if r.get("math500_spans"): |
| changed = True |
| n_rows += 1 |
| n_spans += len(r["math500_spans"]) |
| if "raw" in r: |
| r["raw"] = fill(r["raw"], r["math500_spans"]) |
| bad += sha(r["raw"]) != r.pop("raw_sha256") |
| else: |
| r["resps"][0][0] = fill(r["resps"][0][0], r["math500_spans"]) |
| bad += sha(r["resps"][0][0]) != r.pop("resps_sha256") |
| del r["math500_spans"] |
| rows.append(r) |
| if changed: |
| wjsonl(os.path.join(out, os.path.relpath(f, ds)), rows) |
| print(f"math500: {n_rows} outputs with spans, {n_spans} spans restored, {bad} outputs failing their sha256") |
| return got == want and bad == 0 |
|
|
|
|
| def join_base(ds, out, cache, models): |
| docs = {} |
|
|
| def get(task): |
| if task in docs: |
| return docs[task] |
| if task.startswith("mmlu_"): |
| subject = task[5:].removesuffix("_continuation") |
| docs[task] = read_parquet(fetch("mmlu", cache, subject)) |
| elif task == "hellaswag": |
| docs[task] = [hs_doc(d) for d in read_parquet(fetch("hellaswag", cache))] |
| else: |
| docs[task] = read_parquet(fetch(task, cache)) |
| return docs[task] |
|
|
| files = sorted(glob.glob(os.path.join(ds, "base_suite", "*", "*.jsonl.gz")) + |
| glob.glob(os.path.join(ds, "long_context", "gate_base_suite", "*", "*.jsonl.gz"))) |
| ok = True |
| for f in files: |
| model = os.path.basename(os.path.dirname(f)) |
| if models and model not in models: |
| continue |
| if f.endswith("gsm8k.jsonl.gz"): |
| continue |
| rows, c = [], collections.Counter() |
| for r in rjsonl(f): |
| doc = get(r["task"])[r["doc_id"]] |
| same = sha(json.dumps(doc, indent=2, ensure_ascii=False)) == r["doc_hash"] |
| c["match" if same else "mismatch"] += 1 |
| rows.append(dict(r, doc=doc)) |
| wjsonl(os.path.join(out, os.path.relpath(f, ds)), rows) |
| ok &= c["mismatch"] == 0 |
| print(f"{os.path.relpath(f, ds)}: {c['match']} rows, doc_hash matches; {c['mismatch']} mismatches") |
| return ok |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("dataset_dir") |
| ap.add_argument("--out", required=True) |
| ap.add_argument("--what", default="math500,base") |
| ap.add_argument("--models", default="") |
| ap.add_argument("--cache", default=None, help="Hugging Face download cache (default: the usual HF cache)") |
| a = ap.parse_args() |
| ok = True |
| if "math500" in a.what: |
| ok &= join_math(a.dataset_dir, a.out, a.cache) |
| if "base" in a.what: |
| ok &= join_base(a.dataset_dir, a.out, a.cache, set(filter(None, a.models.split(",")))) |
| sys.exit(0 if ok else 1) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
