| """Build annotation-only Parquet exports from the paper's original JSON files.""" |
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import hashlib |
| import json |
| import math |
| import re |
| from pathlib import Path |
|
|
| import pyarrow as pa |
| import pyarrow.parquet as pq |
|
|
| from .data import SOURCES, SCORE_COLUMNS, PREF_COLUMNS, battle_id |
|
|
|
|
| def sha256(path): |
| h = hashlib.sha256() |
| with Path(path).open('rb') as f: |
| for chunk in iter(lambda: f.read(1024 * 1024), b''): |
| h.update(chunk) |
| return h.hexdigest() |
|
|
|
|
| def finite(value): |
| return isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(value) |
|
|
|
|
| def number(value): |
| if value is None: |
| return None |
| try: |
| value = float(value) |
| return value if math.isfinite(value) else None |
| except (TypeError, ValueError): |
| return None |
|
|
|
|
| def score_json(value): |
| if not isinstance(value, dict): |
| return None |
| |
| return json.dumps({str(k): number(v) for k, v in value.items()}, sort_keys=True, |
| separators=(',', ':'), allow_nan=False) |
|
|
|
|
| def paper_valid(row): |
| |
| return all(isinstance(row.get(k), dict) and all(v is not None and number(v) is not None |
| for v in row[k].values()) for k in ('scores_a', 'scores_b')) |
|
|
|
|
| def shared_eligible(row): |
| if row.get('parse_error'): |
| return False |
| a, b = row.get('scores_a'), row.get('scores_b') |
| if not isinstance(a, dict) or not isinstance(b, dict): |
| return False |
| dims = set(a) & set(b) |
| return bool(dims) and all(number(a[d]) is not None and number(b[d]) is not None |
| and 1 <= float(a[d]) <= 10 and 1 <= float(b[d]) <= 10 |
| for d in dims) and all(number(row.get(k)) in {0., .25, .5, .75, 1.} |
| for k in ('human_pref', 'judge_pref')) |
|
|
|
|
| def upstream_index(corpus, cache, revision=None): |
| repo, id_col = SOURCES[corpus] |
| snapshots = cache / ('datasets--' + repo.replace('/', '--')) / 'snapshots' |
| candidates = [p for p in snapshots.iterdir() if list(p.rglob('*.parquet')) and (revision is None or p.name == revision)] if snapshots.exists() else [] |
| if not candidates and revision: |
| return remote_upstream_index(corpus, revision) |
| if len(candidates) != 1: |
| raise ValueError(f'Expected one cached snapshot for {corpus}; found {len(candidates)}') |
| snapshot = candidates[0] |
| index = {} |
| a, b = ('model_a_name', 'model_b_name') if corpus == 'comparia' else ('model_a', 'model_b') |
| cols = [id_col, a, b] + (['chosen_model_name', 'both_equal'] if corpus == 'comparia' else ['winner']) |
| files = [] |
| for path in sorted(snapshot.rglob('*.parquet')): |
| files.append({'path': str(path.relative_to(snapshot)), 'sha256': sha256(path)}) |
| for batch in pq.ParquetFile(path).iter_batches(columns=cols, batch_size=10000): |
| for row in batch.to_pylist(): |
| sid = str(row[id_col]) |
| if corpus == 'comparia': |
| chosen = row['chosen_model_name'] |
| hp = .5 if row['both_equal'] or chosen is None else (0. if chosen == row[a] else 1. if chosen == row[b] else .5) |
| else: |
| hp = {'model_a': 0., 'model_b': 1.}.get(str(row['winner']).lower(), .5) |
| val = (str(row[a]), str(row[b]), hp) |
| if sid in index and index[sid] != val: |
| raise ValueError(f'Conflicting source ID {sid}') |
| index[sid] = val |
| return index, {'repo_id': repo, 'id_column': id_col, 'revision': snapshot.name, |
| 'revision_status': 'verified_join_snapshot; original annotation-run revision was not recorded', |
| 'files': files} |
|
|
|
|
| def remote_upstream_index(corpus, revision): |
| from huggingface_hub import HfApi, HfFileSystem |
| import tempfile |
| repo, id_col = SOURCES[corpus] |
| cached = Path(tempfile.gettempdir()) / 'softelo-source-index' / f'{corpus}-{revision}.json' |
| if cached.exists(): |
| data = json.loads(cached.read_text()) |
| return {k: tuple(v) for k, v in data['index'].items()}, data['source'] |
| info = HfApi().dataset_info(repo, revision=revision, files_metadata=True) |
| fs = HfFileSystem() |
| a, b = ('model_a_name', 'model_b_name') if corpus == 'comparia' else ('model_a', 'model_b') |
| cols = [id_col, a, b] + (['chosen_model_name', 'both_equal'] if corpus == 'comparia' else ['winner']) |
| index, files = {}, [] |
| for file in info.siblings: |
| if not file.rfilename.endswith('.parquet'): |
| continue |
| files.append({'path': file.rfilename, 'sha256': file.lfs.sha256 if file.lfs else None}) |
| with fs.open(f'datasets/{repo}@{revision}/{file.rfilename}', 'rb', block_size=1 << 20) as handle: |
| table = pq.ParquetFile(handle).read(columns=cols) |
| for row in table.to_pylist(): |
| if corpus == 'comparia': |
| chosen = row['chosen_model_name'] |
| hp = .5 if row['both_equal'] or chosen is None else (0. if chosen == row[a] else 1. if chosen == row[b] else .5) |
| else: |
| hp = {'model_a': 0., 'model_b': 1.}.get(str(row['winner']).lower(), .5) |
| sid = str(row[id_col]) |
| val = (str(row[a]), str(row[b]), hp) |
| if sid in index and index[sid] != val: |
| raise ValueError(f'Conflicting source ID {sid}') |
| index[sid] = val |
| source = {'repo_id':repo, 'id_column':id_col, 'revision':revision, |
| 'revision_status':'verified_join_snapshot; original annotation-run revision was not recorded', 'files':files} |
| write_json(cached, {'index':index, 'source':source}) |
| return index, source |
|
|
|
|
| def sanitize(row, *, corpus, judge, row_index, source_index, revision): |
| meta = row.get('metadata') or row.get('instruction_metadata') or {} |
| sid = str(meta.get('original_question_id', '')) |
| a, b = str(row['model_a']), str(row['model_b']) |
| hp = number(row.get('human_pref', row.get('human_preference'))) |
| jp = number(row.get('judge_pref', row.get('preference'))) |
| source = source_index.get(sid) |
| if source is None or (a, b) not in [source[:2], source[:2][::-1]]: |
| raise ValueError(f'{corpus}/{judge}/{row_index}: cannot join source ID and models') |
| expected_hp = source[2] if (a, b) == source[:2] else 1 - source[2] |
| if hp != expected_hp: |
| raise ValueError(f'{corpus}/{judge}/{row_index}: human preference differs from upstream') |
| normalized = dict(row, human_pref=hp, judge_pref=jp) |
| out = {'battle_id': battle_id(corpus, sid, a, b), 'source_dataset': corpus, |
| 'source_id': sid, 'source_revision': revision, 'judge': judge, 'row_index': row_index, |
| 'instruction_id': str(row.get('instruction_id', '')), 'model_a': a, 'model_b': b, |
| 'source_order_reversed': (a, b) != source[:2], 'human_pref': hp, 'judge_pref': jp, |
| 'language': str(meta.get('lang') or meta.get('language') or ''), |
| 'parse_error': bool(row.get('parse_error', False)), |
| 'paper_valid': paper_valid(normalized), 'shared_eligible': shared_eligible(normalized), |
| 'has_order_scores': all(isinstance(row.get(k), dict) for k in SCORE_COLUMNS[2:]), |
| 'has_order_preferences': all(number(row.get(k)) is not None for k in PREF_COLUMNS[2:])} |
| for key in SCORE_COLUMNS: |
| out[key] = score_json(row.get(key)) |
| for key in PREF_COLUMNS[2:]: |
| out[key] = number(row.get(key)) |
| for key in ('len_a', 'len_b'): |
| out[key] = number(row.get(key)) |
| return out |
|
|
|
|
| def arrow_schema(): |
| strings = ['battle_id','source_dataset','source_id','source_revision','judge','instruction_id', |
| 'model_a','model_b','language', *SCORE_COLUMNS] |
| flags = ['source_order_reversed','parse_error','paper_valid','shared_eligible', |
| 'has_order_scores','has_order_preferences'] |
| return pa.schema([(k, pa.string()) for k in strings] + [('row_index', pa.int64())] |
| + [(k, pa.bool_()) for k in flags] |
| + [(k, pa.float64()) for k in [*PREF_COLUMNS, 'len_a','len_b']]) |
|
|
|
|
| def safe_run_metadata(data): |
| meta = data.get('metadata') or {} |
| cfg = data.get('config_snapshot') or {} |
| |
| out = {k: meta.get(k) for k in ['judge_model','judge_mode','pairwise_prompt_style', |
| 'swap_debiasing','judge_temperature','n_trials','criteria_k','balance_by']} |
| out['sampling'] = {k: cfg.get(k) for k in ['dataset','n_instructions','seed','language','balance_by']} |
| out['criterion_names'] = data.get('criterion_names') |
| out['criteria_definition'] = data.get('criteria_definition') |
| out['system_prompt'] = data.get('system_prompt') |
| return out |
|
|
|
|
| def write_json(path, data): |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text(json.dumps(data, indent=2, ensure_ascii=False, allow_nan=False) + '\n') |
|
|
|
|
| def export(repo, cache, out, source_revisions): |
| manifest_path = repo / 'release_softelo_minimal/data/manifest.csv' |
| runs = list(csv.DictReader(manifest_path.open())) |
| if len(runs) != 22: |
| raise ValueError('Expected the 22 paper annotation sources') |
| if (out / 'manifest.json').exists(): |
| raise FileExistsError('Choose a new output directory; do not overwrite a frozen release') |
| manifest = {'schema_version': 1, 'sources': {}, 'annotations': [], 'subsets': {}} |
| for corpus in source_revisions: |
| manifest['sources'][corpus] = {'repo_id': SOURCES[corpus][0], 'snapshots': {}} |
| indices = {} |
| supports = [] |
| for run in [r for r in runs if r['source_dataset'] == corpus]: |
| path = repo / run['source_json'] |
| data = json.loads(path.read_text()) |
| judge = run['judge'] |
| revision = source_revisions[corpus].get(judge, source_revisions[corpus]['default']) |
| if revision not in indices: |
| indices[revision] = upstream_index(corpus, cache, revision) |
| source_index, source_info = indices[revision] |
| manifest['sources'][corpus]['snapshots'][revision] = source_info |
| rows = [sanitize(row, corpus=corpus, judge=judge, row_index=i, source_index=source_index, |
| revision=source_info['revision']) for i, row in enumerate(data['per_sample'])] |
| filename = Path(run['csv_path']).stem + '.parquet' |
| dest = out / 'data' / corpus / filename |
| dest.parent.mkdir(parents=True, exist_ok=True) |
| pq.write_table(pa.Table.from_pylist(rows, schema=arrow_schema()), dest, compression='zstd') |
| support = {} |
| for row in rows: |
| if row['shared_eligible']: |
| human_canonical = row['human_pref'] if row['model_a'] <= row['model_b'] else 1-row['human_pref'] |
| if row['battle_id'] in support: |
| raise ValueError(f'Duplicate eligible battle within {judge}') |
| support[row['battle_id']] = human_canonical |
| supports.append(support) |
| metadata_file = Path('metadata') / corpus / (filename.replace('.parquet', '.json')) |
| write_json(out / metadata_file, safe_run_metadata(data)) |
| record = {'corpus': corpus, 'judge': judge, 'file': str(dest.relative_to(out)), |
| 'rows': len(rows), 'paper_valid_rows': sum(r['paper_valid'] for r in rows), |
| 'shared_eligible_rows':len(support), 'order_score_rows':sum(r['has_order_scores'] for r in rows), |
| 'order_preference_rows':sum(r['has_order_preferences'] for r in rows), |
| 'source_json':run['source_json'], 'source_sha256':sha256(path), |
| 'sha256':sha256(dest), 'metadata':str(metadata_file)} |
| manifest['annotations'].append(record) |
| print(f"{corpus} {judge}: {len(rows)} rows, {record['paper_valid_rows']} paper-valid, " |
| f"{record['order_score_rows']} with separate presentation scores", flush=True) |
| del data, rows |
| common = set.intersection(*(set(s) for s in supports)) |
| common = {bid for bid in common if len({s[bid] for s in supports}) == 1} |
| dest = out / 'subsets' / f'{corpus}_shared_valid.parquet' |
| dest.parent.mkdir(parents=True, exist_ok=True) |
| pq.write_table(pa.table({'battle_id': sorted(common)}), dest, compression='zstd') |
| manifest['subsets'][corpus] = {'file': str(dest.relative_to(out)), 'battles':len(common), |
| 'judges':len(supports), 'sha256':sha256(dest)} |
| if corpus == 'lmarena100k' and len(common) != 18158: |
| raise ValueError(f'Paper shared-battle count differs: {len(common)} != 18158') |
| print(f'{corpus}: {len(common)} shared valid battles', flush=True) |
| write_json(out / 'manifest.json', manifest) |
| return manifest |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('--repo-root', type=Path, required=True) |
| parser.add_argument('--hf-cache', type=Path, default=Path.home()/'.cache/huggingface/hub') |
| parser.add_argument('--out', type=Path, required=True) |
| parser.add_argument('--source-revisions', type=Path, required=True) |
| args = parser.parse_args() |
| export(args.repo_root, args.hf_cache, args.out, json.loads(args.source_revisions.read_text())) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
