| from collections import Counter,defaultdict |
| from concurrent.futures import ThreadPoolExecutor |
| from dataclasses import dataclass |
| import gzip |
| import hashlib |
| import json |
| from pathlib import Path |
| import random |
|
|
| from omegaconf import OmegaConf |
| from rich import print |
| from tqdm import tqdm |
|
|
| from functional_rl import v2 |
| from hinted_rl.code import execute |
| from hinted_rl.teacher_programs import canonical |
| from refined_v4.data import atomic_json,load_rows,write_rows,signature |
|
|
| from . import ROOT,SOURCE,TASKS |
| from .audit import authentic |
| from .envs import REVISION,ENC,Pool,available_hints,protected_prefix |
|
|
|
|
| @dataclass |
| class Config: |
| source: str=str(SOURCE) |
| root: str=str(ROOT) |
| tokens: int=2097152 |
| seed: int=6719 |
| workers: int=8 |
|
|
|
|
| def gold_passes(row: dict) -> bool: |
| return execute(row['reference'],tuple(row['tests']),row.get('setup','')) |
|
|
|
|
| def annotate(row: dict) -> dict: |
| value=dict(row) |
| value['revision']=REVISION |
| value['protected_prefix']=protected_prefix(value) |
| body=value['reference'][len(value['protected_prefix']):] |
| count=len(ENC.encode_ordinary(body)) |
| band='body_1_32' if count<=32 else 'body_33_96' if count<=96 else 'body_97_plus' |
| value['provenance']=dict(row.get('provenance',{}),difficulty=band,body_tokens=count, |
| reference_sha256=hashlib.sha256(row['reference'].encode()).hexdigest(), |
| source_family='mbpp' if value['task'].startswith('mbpp') else 'humaneval') |
| value['hint_levels']=available_hints(value) |
| if not value['hint_levels']: |
| raise ValueError('Benchmark source has no protected implementation completion') |
| return value |
|
|
|
|
| def documents(rows: list[dict],budget: int,rng: random.Random,benchmark_fraction: float|None=None,balance_groups: bool=False,body_weights: dict[str,float]|None=None) -> list[dict]: |
| result=[] |
| tokens=0 |
| rendered={r['source_id']:v2.render(r) for r in rows} |
| if len(rendered)!=len(rows): |
| raise ValueError('SFT source IDs must identify individual implementations uniquely') |
| lengths={key:len(ENC.encode_ordinary(text)) for key,text in rendered.items()} |
| shortest=sorted(rows,key=lambda r:lengths[r['source_id']])[:16] |
| benchmark=[r for r in rows if authentic(r)] |
| synthetic=[r for r in rows if not authentic(r)] |
| grouped=defaultdict(list) |
| for row in rows:grouped[row['group']].append(row) |
| keys=list(grouped) |
| origins={kind:[key for key in keys if authentic(grouped[key][0])==kind] for kind in (False,True)} |
| bands={band:[key for key in keys if grouped[key][0]['provenance']['difficulty']==band] |
| for band in body_weights} if body_weights is not None else {} |
| band_origins={band:{kind:[key for key in eligible if authentic(grouped[key][0])==kind] |
| for kind in (False,True)} for band,eligible in bands.items()} |
| if body_weights is not None: |
| if not balance_groups or not body_weights or any(weight<=0 for weight in body_weights.values()): |
| raise ValueError('Positive body-band weights require source-group sampling') |
| if any(not keys for keys in bands.values()) or benchmark_fraction is not None and any( |
| not keys for origins_in_band in band_origins.values() for keys in origins_in_band.values()): |
| raise ValueError('Every requested body/origin combination requires eligible sources') |
| if benchmark_fraction is not None and (not 0<benchmark_fraction<1 or not benchmark or not synthetic): |
| raise ValueError('Benchmark mixture requires both source pools and a fraction strictly between zero and one') |
| def choose(): |
| if balance_groups: |
| if body_weights is None: |
| eligible=keys if benchmark_fraction is None else origins[rng.random()<benchmark_fraction] |
| else: |
| band=rng.choices(list(body_weights),weights=list(body_weights.values()))[0] |
| eligible=bands[band] if benchmark_fraction is None else band_origins[band][rng.random()<benchmark_fraction] |
| return rng.choice(grouped[rng.choice(eligible)]) |
| pool=rows if benchmark_fraction is None else benchmark if rng.random()<benchmark_fraction else synthetic |
| return rng.choice(pool) |
| if any(n>1024 for n in lengths.values()): |
| raise ValueError('A source function exceeds the context on its own') |
| with tqdm(total=budget,desc='Pack benchmark-native few-shot SFT',unit='tok',colour='cyan',mininterval=5) as progress: |
| while tokens<budget: |
| first=choose() |
| selected=[first] |
| count=lengths[first['source_id']] |
| candidates=(rng.sample(rows,min(64,len(rows))) if benchmark_fraction is None and not balance_groups else [choose() for _ in range(64)])+shortest |
| for other in candidates: |
| if other['group'] in {r['group'] for r in selected}: |
| continue |
| extra=lengths[other['source_id']]+2 |
| if count+extra<=1000: |
| selected.append(other) |
| count+=extra |
| if len(selected)==4: |
| break |
| if len(selected)<2: |
| raise ValueError('Cannot fit two independent native examples in one document') |
| text='\n\n'.join(rendered[r['source_id']] for r in selected) |
| size=len(ENC.encode_ordinary(text)) |
| if size>1024: |
| raise ValueError('Packed document exceeds the model context') |
| usable=min(size,budget-tokens) |
| result.append(dict(text=text,tokens=size,budget_tokens=usable,examples=[dict( |
| source_id=r['source_id'],group=r['group'],reference_sha256=r['provenance']['reference_sha256']) for r in selected])) |
| tokens+=usable |
| progress.update(usable) |
| return result |
|
|
|
|
| def build(config: Config): |
| source,root=Path(config.source),Path(config.root) |
| root.mkdir(parents=True,exist_ok=True) |
| receipt=root/'dataset.json' |
| if receipt.exists(): |
| saved=json.loads(receipt.read_text()) |
| if saved['sft_tokens']!=config.tokens: |
| raise ValueError('A frozen dataset has a different SFT budget') |
| return saved |
| original={task:{split:load_rows(source,task,split) for split in ('sft','rl','calibration','dev','test')} for task in TASKS} |
| blocked={canonical(row['reference']) for pools in original.values() for split,rows in pools.items() |
| if split!='sft' for row in rows if authentic(row)} |
| paired={family:set(r['source_id'] for r in original[family]['sft'] if authentic(r))& |
| set(r['source_id'] for r in original[family+'_docstring']['sft'] if authentic(r)) |
| for family in ('mbpp','humaneval')} |
| report=dict(revision=REVISION,source=str(source),sft_tokens=config.tokens,seed=config.seed,tasks={}) |
| for task in TASKS: |
| family='mbpp' if task.startswith('mbpp') else 'humaneval' |
| pools={split:[r for r in rows if authentic(r)] for split,rows in original[task].items()} |
| pools['sft']=[r for r in pools['sft'] if r['source_id'] in paired[family] and canonical(r['reference']) not in blocked] |
| selected=[(split,row) for split,rows in pools.items() for row in rows] |
| with ThreadPoolExecutor(max_workers=config.workers) as pool: |
| valid=list(tqdm(pool.map(gold_passes,[row for split,row in selected]),total=len(selected), |
| desc=task+' trusted reference checks',colour='green',mininterval=5)) |
| failures=[dict(split=split,source_id=row['source_id']) for (split,row),ok in zip(selected,valid,strict=True) if not ok] |
| if failures: |
| atomic_json(root/(task+'-gold-failures.json'),dict(failures=failures)) |
| raise ValueError('Original benchmark references failed; investigate before excluding any source') |
| for split,rows in pools.items(): |
| pools[split]=[annotate({k:v for k,v in r.items() if k!='demonstrations'} if split=='sft' else r) for r in rows] |
| if split!='sft': |
| Pool(pools[split]) |
| write_rows(root/'data'/task/(split+'.jsonl.gz'),pools[split]) |
| corpus=documents(pools['sft'],config.tokens,random.Random(config.seed)) |
| target=root/'sft'/task/'train.jsonl.gz' |
| write_rows(target,corpus) |
| report['tasks'][task]=dict(rows={s:len(rows) for s,rows in pools.items()}, |
| original_rows={s:len(rows) for s,rows in original[task].items()}, |
| documents=len(corpus),document_example_counts=dict(Counter(len(d['examples']) for d in corpus)), |
| sft_sha256=signature(target),source_groups=len({r['group'] for r in pools['sft']}), |
| heldout_questions_tests_implementations='Original dev/test references, questions and executable tests retained verbatim.', |
| rl_change='Authentic benchmark sources only; synthetic task-survey additions removed.', |
| hint_coverage={split:{str(n):sum(n in r['hint_levels'] for r in rows) for n in range(1,17)} for split,rows in pools.items()}, |
| assets={str(p.relative_to(root)):signature(p) for p in sorted((root/'data'/task).glob('*.gz'))}) |
| atomic_json(root/'data-build-progress.json',report) |
| atomic_json(receipt,report) |
| print('[green]Four benchmark-native task datasets ready[/green]') |
| return report |
|
|
|
|
| if __name__=='__main__': |
| build(OmegaConf.to_object(OmegaConf.merge(OmegaConf.structured(Config),OmegaConf.from_cli()))) |
|
|
