| """Load the release locally or from a pinned Hugging Face dataset revision.""" |
| from __future__ import annotations |
|
|
| import hashlib |
| import json |
| import re |
| from pathlib import Path |
|
|
| import pandas as pd |
| import pyarrow.parquet as pq |
|
|
| SOURCES = { |
| "lmarena100k": ("lmarena-ai/arena-human-preference-100k", "question_id"), |
| "lmarena140k": ("lmarena-ai/arena-human-preference-140k", "id"), |
| "comparia": ("ministere-culture/comparia-votes", "id"), |
| } |
| SCORE_COLUMNS = ["scores_a", "scores_b", "scores_a_original", "scores_b_original", |
| "scores_a_swapped", "scores_b_swapped"] |
| PREF_COLUMNS = ["human_pref", "judge_pref", "preference_original", "preference_swapped"] |
|
|
|
|
| def battle_id(corpus, source_id, model_a, model_b): |
| """A source record plus unordered model pair, independent of judge/order.""" |
| value = [corpus, str(source_id), *sorted([str(model_a), str(model_b)])] |
| return hashlib.sha256(json.dumps(value, ensure_ascii=False, separators=(",", ":")).encode()).hexdigest() |
|
|
|
|
| def resolve_release(path_or_repo, revision=None): |
| path = Path(path_or_repo).expanduser() |
| if path.is_dir(): |
| return path |
| if not revision or not re.fullmatch(r"[0-9a-f]{40}", revision): |
| raise ValueError("Pass a full 40-character Hugging Face commit as revision for remote reproduction") |
| from huggingface_hub import snapshot_download |
| return Path(snapshot_download(repo_id=str(path_or_repo), repo_type="dataset", revision=revision)) |
|
|
|
|
| def load_annotations(path_or_repo, *, corpus, judge=None, subset="paper_valid", revision=None, |
| collapse_preferences=True): |
| """Return rows in original per-judge order; scores are Python dictionaries. |
| |
| subset: all / paper_valid / shared_valid. Shared valid means the range-checked |
| intersection across the released judges for this corpus, with matching human |
| preferences. It is distinct from the per-judge Table 2 filtering. |
| """ |
| if corpus not in SOURCES or subset not in {"all", "paper_valid", "shared_valid"}: |
| raise ValueError("Unknown corpus or subset") |
| root = resolve_release(path_or_repo, revision) |
| files = sorted((root / "data" / corpus).glob("*.parquet")) |
| if not files: |
| raise FileNotFoundError(f"No annotation files for {corpus} under {root}") |
| frames = [] |
| for file in files: |
| table = pq.read_table(file) |
| df = table.to_pandas() |
| if judge is not None: |
| df = df[df.judge == judge] |
| if len(df): |
| frames.append(df) |
| if not frames: |
| raise ValueError(f"No annotations for judge {judge!r} in {corpus}") |
| df = pd.concat(frames, ignore_index=True) |
| if subset == "paper_valid": |
| df = df[df.paper_valid] |
| elif subset == "shared_valid": |
| ids = set(pq.read_table(root / "subsets" / f"{corpus}_shared_valid.parquet")["battle_id"].to_pylist()) |
| df = df[df.shared_eligible & df.battle_id.isin(ids)] |
| for col in SCORE_COLUMNS: |
| df[col] = df[col].map(lambda value: json.loads(value) if value is not None else None) |
| if collapse_preferences: |
| for col in PREF_COLUMNS: |
| df[col] = df[col].map(lambda v: .5 if pd.notna(v) and abs(v - .5) <= .26 else v) |
| |
| df["human_preference"] = df.human_pref |
| df["preference"] = df.judge_pref |
| return df.sort_values(["judge", "row_index"], kind="stable").reset_index(drop=True) |
|
|
|
|
| def load_source_rows(corpus, source_ids, *, revision): |
| """Retrieve original rows through upstream access controls (including ComparIA). |
| |
| Original text is downloaded locally, never republished by this function. |
| Authenticate with Hugging Face and accept the upstream terms if required. |
| """ |
| if not revision or not re.fullmatch(r"[0-9a-f]{40}", revision): |
| raise ValueError("Upstream source retrieval requires a full commit hash") |
| from huggingface_hub import snapshot_download |
| repo, id_col = SOURCES[corpus] |
| root = Path(snapshot_download(repo_id=repo, repo_type="dataset", revision=revision, |
| allow_patterns="*.parquet")) |
| wanted = set(map(str, source_ids)) |
| found = [] |
| for file in sorted(root.rglob("*.parquet")): |
| for batch in pq.ParquetFile(file).iter_batches(batch_size=256): |
| found.extend(row for row in batch.to_pylist() if str(row[id_col]) in wanted) |
| missing = wanted - {str(row[id_col]) for row in found} |
| if missing: |
| raise ValueError(f"{len(missing)} source IDs absent from pinned upstream snapshot") |
| return found |
|
|
