| """Rebuild SETA v3 tasks.parquet and archive.parquet from the pinned v1 Parquet and metadata/selection.json. |
| |
| pip install pyarrow huggingface_hub |
| python patch.py --out rebuilt |
| Optional --source is a local copy of seta_v1/tasks.parquet at the pinned revision. |
| """ |
| import argparse, hashlib, json |
| from pathlib import Path |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
|
|
| |
| OFF = ['qwen38_graded_attempts', 'qwen38_successes', 'qwen38_missing_attempts', 'qwen38_same_payload', 'kept_from_v2'] |
| ON = ['qwen38_thinking_graded_attempts', 'qwen38_thinking_successes', 'qwen38_thinking_verifier_graded_attempts', |
| 'qwen38_thinking_retry_attempts', 'qwen38_thinking_retry_successes', 'qwen38_thinking_config'] |
| EXTRA = [pa.field('qwen38_graded_attempts', pa.int64()), pa.field('qwen38_successes', pa.int64()), |
| pa.field('qwen38_missing_attempts', pa.int64()), pa.field('qwen38_same_payload', pa.bool_()), |
| pa.field('kept_from_v2', pa.bool_()), |
| *[pa.field(c, pa.int64()) for c in ON[:-1]], pa.field('qwen38_thinking_config', pa.string())] |
|
|
|
|
| def build(out, source=None): |
| m = json.loads((Path(__file__).parent / 'metadata/selection.json').read_text()) |
| if source is None: |
| from huggingface_hub import hf_hub_download |
| source = Path(hf_hub_download(m['repo_id'], m['source_folder'] + '/tasks.parquet', repo_type='dataset', |
| revision=m['source_revision'], cache_dir=out / '.source-cache')) |
| with open(source, 'rb') as f: |
| assert hashlib.file_digest(f, 'sha256').hexdigest() == m['source_sha256'] |
| out.mkdir(parents=True, exist_ok=True) |
| assert not any((out / n).exists() for n in ['tasks.parquet', 'archive.parquet']) |
| tasks, cols, s = m['tasks'], m['result_columns'], m['summary'] |
| v1 = pq.ParquetFile(source) |
| base = v1.schema_arrow.remove_metadata() |
|
|
| def qcols(t): |
| e = tasks[t] |
| r = {'qwen38_graded_attempts': 0, 'qwen38_successes': None, 'qwen38_missing_attempts': None, |
| 'qwen38_same_payload': None, 'kept_from_v2': e['kept_from_v2'], 'qwen38_thinking_graded_attempts': 0, |
| **{c: None for c in ON[1:]}} |
| r.update({k: e[k] for k in OFF + ON if k in e}) |
| return r |
|
|
| def images(names): |
| im = json.loads(v1.schema_arrow.metadata[b'ot.images.v1']) |
| im['tasks'] = {k: v for k, v in im['tasks'].items() if k in names} |
| used = {e['bundle'] for v in im['tasks'].values() for e in v['environments']} |
| im['bundles'] = {k: v for k, v in im['bundles'].items() if k in used} |
| if 'missing' in im: |
| im['missing'] = [x for x in im['missing'] if x.get('task') in names] |
| if 'uncached_task_ids' in im: |
| im['uncached_task_ids'] = sorted(set(names) - set(im['tasks'])) |
| if 'coverage' in im: |
| im['coverage'] = {'cached_tasks': len(im['tasks']), 'total_tasks': len(names)} |
| return json.dumps(im).encode() |
| release = json.dumps(s['release']).encode() |
| v2kept = {t for t, e in tasks.items() if e['kept_from_v2']} |
| off_new = {t for t, e in tasks.items() if e['kept_thinking_off'] and not e['kept_from_v2']} |
| on_new = {t for t, e in tasks.items() if e['kept'] and not e['kept_thinking_off']} |
| excluded = sorted(t for t, e in tasks.items() if not e['kept']) |
| kept = off_new | on_new |
|
|
| tschema = pa.schema([*base, *[pa.field(c, pa.int64()) for c in cols], *EXTRA]) |
| tschema = tschema.with_metadata({b'ot.images.v1': images(kept), b'ot.release.v3': release}) |
| aschema = tschema |
| for name, kind in [('archive_stage', pa.int64()), ('archive_reason', pa.string()), ('archive_labels', pa.list_(pa.string()))]: |
| aschema = aschema.set(aschema.get_field_index(name), pa.field(name, kind)) |
| aschema = aschema.with_metadata({b'ot.images.v1': images(excluded), b'ot.release.v3': release}) |
|
|
| def rows(select): |
| for batch in v1.iter_batches(batch_size=16): |
| chosen = [r for r in batch.to_pylist() if select(r['path'])] |
| for r in chosen: |
| assert r['content_sha256'] == tasks[r['path']]['content_sha256'] |
| r.update({c: tasks[r['path']].get(c) for c in cols}) |
| r.update(qcols(r['path'])) |
| yield chosen |
| n = 0 |
| with pq.ParquetWriter(out / 'tasks.parquet', tschema, compression='zstd') as w: |
| |
| for group in (off_new, on_new): |
| for chosen in rows(group.__contains__): |
| if chosen: |
| w.write_table(pa.Table.from_pylist(chosen, schema=tschema)) |
| n += len(chosen) |
| assert n == s['kept'] |
| n = 0 |
| with pq.ParquetWriter(out / 'archive.parquet', aschema, compression='zstd') as w: |
| for chosen in rows(lambda t: not tasks[t]['kept']): |
| for r in chosen: |
| e = tasks[r['path']] |
| assert 'qwen38_thinking_graded_attempts' in e |
| reason = ('zero_success_v2_and_qwen38_both_configs' if 'qwen38_graded_attempts' in e |
| else 'zero_success_v2_and_qwen38_thinking_on') |
| r.update(archive_stage=6, archive_reason=reason, archive_labels=[reason]) |
| if chosen: |
| w.write_table(pa.Table.from_pylist(chosen, schema=aschema)) |
| n += len(chosen) |
| assert n == s['excluded'] |
| print(json.dumps({'kept': s['kept'], 'excluded': n})) |
|
|
|
|
| if __name__ == '__main__': |
| p = argparse.ArgumentParser(description=__doc__) |
| p.add_argument('--out', type=Path, required=True) |
| p.add_argument('--source', type=Path) |
| a = p.parse_args() |
| build(a.out, a.source) |
|
|
