| """Reproduce v2 using current pinned v1 payloads and historical Instruct/Coder counts. |
| |
| Selection content_sha256 and pass_counts hashes identify the evaluated version; |
| current_content_sha256 identifies the published task payload. Traces are unchanged.""" |
| import argparse |
| import hashlib |
| import json |
| from pathlib import Path |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
| from huggingface_hub import hf_hub_download |
|
|
| def main(): |
| ap=argparse.ArgumentParser(description=__doc__) |
| ap.add_argument('--out',type=Path,required=True) |
| ap.add_argument('--source',type=Path) |
| args=ap.parse_args() |
| args.out.mkdir(parents=True,exist_ok=True) |
| assert not any((args.out/name).exists() for name in ['tasks.parquet','archive.parquet','pass_counts.parquet']) |
| selection=json.loads((Path(__file__).parent/'metadata/selection.json').read_text()) |
| source=args.source or Path(hf_hub_download(selection['repo_id'],selection['source_folder']+'/tasks.parquet', |
| revision=selection['source_revision'],repo_type='dataset',cache_dir=args.out/'.source-cache')) |
| assert hashlib.sha256(source.read_bytes()).hexdigest()==selection['source_sha256'] |
| pf=pq.ParquetFile(source) |
| fields=['instruct_successes','instruct_graded_attempts','instruct_missing_attempts', |
| 'coder_successes','coder_graded_attempts','coder_missing_attempts', |
| 'target_attempts_per_model','instruct_target_attempts','coder_target_attempts'] |
| schema=pf.schema_arrow.remove_metadata() |
| for field in fields:schema=schema.append(pa.field(field,pa.int64())) |
| kept=[];excluded=[];counts=[];seen=set() |
| for batch in pf.iter_batches(batch_size=32): |
| for row in batch.to_pylist(): |
| task=row['path'];v=selection['tasks'][task] |
| assert task not in seen and row['content_sha256']==v['current_content_sha256'] |
| seen.add(task) |
| retain=v['instruct_successes']>0 or v['coder_successes']>0 |
| assert retain==v['kept'] |
| row.update({field:v[field] for field in fields}) |
| if retain:kept.append(row) |
| else: |
| row.update(archive_stage=6,archive_reason=v['exclusion_reason'],archive_labels=[v['exclusion_reason']]) |
| excluded.append(row) |
| for model,budget in selection['target_attempts'].items(): |
| if v[model+'_graded_attempts']==budget: |
| counts.append({'path':task,'content_sha256':v['content_sha256'],'model':selection['models'][model], |
| 'attempts':budget,'graded':budget,'solved':v[model+'_successes'],'retained_v2':retain}) |
| assert seen==set(selection['tasks']) |
| assert len(kept)==selection['summary']['solved'] and len(excluded)==selection['summary']['excluded'] |
| def metadata(rows): |
| image=json.loads(pf.schema_arrow.metadata[b'ot.images.v1']);names={r['path'] for r in rows} |
| image['tasks']={k:v for k,v in image['tasks'].items() if k in names} |
| bundles={e['bundle'] for task in image['tasks'].values() for e in task['environments']} |
| image['bundles']={k:v for k,v in image['bundles'].items() if k in bundles} |
| if 'uncached_task_ids' in image:image['uncached_task_ids']=sorted(names-set(image['tasks'])) |
| image['coverage']={'cached_tasks':len(image['tasks']),'total_tasks':len(names)} |
| assert len(image['tasks'])==len(names) |
| return {b'ot.images.v1':json.dumps(image).encode(), |
| b'ot.release.v2':json.dumps({k:v for k,v in selection.items() if k!='tasks'}).encode()} |
| pq.write_table(pa.Table.from_pylist(kept,schema=schema).replace_schema_metadata(metadata(kept)),args.out/'tasks.parquet',compression='zstd') |
| archive_schema=schema |
| for name,kind in [('archive_stage',pa.int64()),('archive_reason',pa.string()),('archive_labels',pa.list_(pa.string()))]: |
| archive_schema=archive_schema.set(archive_schema.get_field_index(name),pa.field(name,kind)) |
| pq.write_table(pa.Table.from_pylist(excluded,schema=archive_schema).replace_schema_metadata(metadata(excluded)),args.out/'archive.parquet',compression='zstd') |
| |
| counts.sort(key=lambda r:(list(selection['models'].values()).index(r['model']),r['path'])) |
| pq.write_table(pa.Table.from_pylist(counts),args.out/'pass_counts.parquet',compression='zstd') |
| print(json.dumps({'kept':len(kept),'excluded':len(excluded),'pass_count_rows':len(counts)})) |
|
|
| if __name__=='__main__':main() |
|
|
