| import ast |
| from collections import Counter |
| from concurrent.futures import ThreadPoolExecutor |
| from copy import deepcopy |
| from dataclasses import dataclass |
| import hashlib |
| import json |
| from pathlib import Path |
| import random |
| import re |
| import shutil |
|
|
| from huggingface_hub import hf_hub_download |
| from omegaconf import OmegaConf |
| import pyarrow.parquet as pq |
| from rich import print |
| from tqdm import tqdm |
|
|
| from functional_rl import v2 |
| from hinted_rl.teacher_programs import canonical |
| from refined_v4.data import load_rows,write_rows,signature,atomic_json |
| from . import ROOT,TASKS |
| from .audit import authentic |
| from .data import annotate,documents,gold_passes |
| from .envs import Pool |
| from .named_data import styles_for |
|
|
| REPO='google-research-datasets/mbpp' |
| REVISION='4bb6404fdc6cacfda99d4ac4205087b89d32030c' |
|
|
|
|
| @dataclass |
| class Config: |
| source: str=str(ROOT/'variants/consistent-natural-names-pilot-v1') |
| root: str=str(ROOT/'variants/full-mbpp-seeds-pilot-v2') |
| tokens: int=2097152 |
| benchmark_fraction: float=.5 |
| seed: int=6719 |
| workers: int=8 |
|
|
|
|
| def native(raw: dict,task: str): |
| question=raw['text'].strip() |
| tree=ast.parse(raw['code']) |
| functions=[n for n in tree.body if isinstance(n,ast.FunctionDef)] |
| if len(functions)!=1 or any(not isinstance(n,(ast.Import,ast.ImportFrom,ast.FunctionDef)) for n in tree.body): |
| raise ValueError('Require one standalone entry function and imports') |
| setup=raw.get('test_setup_code') or '' |
| setup_tree=ast.parse(setup) |
| if any(not isinstance(n,(ast.Import,ast.ImportFrom)) for n in setup_tree.body): |
| raise ValueError('Setup must contain imports only') |
| tests=list(raw['test_list'])+list(raw.get('challenge_test_list') or []) |
| if len(tests)<3 or not question:raise ValueError('Require instruction and three published tests') |
| function=deepcopy(functions[0]) |
| if ast.get_docstring(function) is not None:function.body.pop(0) |
| example=ast.parse(tests[0]).body |
| if not example or not isinstance(example[0],ast.Assert):raise ValueError('Require assertion examples') |
| expression=example[0].test |
| documentation=question+'\n\nExample:\n '+tests[0] |
| if task.startswith('humaneval'): |
| left,expected=ast.unparse(expression),'True' |
| if isinstance(expression,ast.Compare) and len(expression.ops)==1 and isinstance(expression.ops[0],ast.Eq): |
| try: |
| expected=repr(ast.literal_eval(expression.comparators[0]));left=ast.unparse(expression.left) |
| except (ValueError,TypeError):pass |
| documentation=question+'\n\n>>> '+left+'\n'+expected |
| if task.endswith('_docstring'):function.body.insert(0,ast.Expr(value=ast.Constant(value=documentation))) |
| imports=[];seen=set() |
| for node in setup_tree.body+[n for n in tree.body if isinstance(n,(ast.Import,ast.ImportFrom))]: |
| key=ast.dump(node) |
| if key not in seen:imports.append(deepcopy(node));seen.add(key) |
| reference=ast.unparse(ast.fix_missing_locations(ast.Module(body=imports+[function],type_ignores=[]))) |
| if task=='humaneval':reference=''.join('# '+line+'\n' if line else '#\n' for line in documentation.splitlines())+reference |
| identity=str(raw['task_id']) |
| row=annotate(dict(task=task,source_id='mbpp-extra-'+identity, |
| group=hashlib.sha256(('full-mbpp/'+identity).encode()).hexdigest(),question=question, |
| reference=reference,answer=reference,tests=tests,setup=setup, |
| provenance=dict(source=REPO,revision=REVISION,upstream_config='full',upstream_split=raw['upstream_split'], |
| upstream_task_id=raw['task_id'],license='cc-by-4.0',sft_origin='additional_original_mbpp'))) |
| if len(v2.ENC.encode_ordinary(v2.render(row)))>850:raise ValueError('Too long for few-shot packing') |
| return row |
|
|
|
|
| def build(config: Config): |
| source,root=Path(config.source),Path(config.root) |
| if (root/'dataset.json').exists():raise ValueError('Full-source dataset already frozen') |
| cache=ROOT/'inputs/mbpp-full';sanitized=set();raw=[] |
| for split in tqdm(('train','validation','test','prompt'),desc='Read pinned original MBPP files',colour='cyan'): |
| def download(flavor): |
| return hf_hub_download(REPO,flavor+'/'+split+'-00000-of-00001.parquet',repo_type='dataset',revision=REVISION,cache_dir=cache) |
| sanitized.update(pq.read_table(download('sanitized'),columns=['task_id'])['task_id'].to_pylist()) |
| raw.extend(dict(row,upstream_split=split) for row in pq.read_table(download('full')).to_pylist()) |
| blocked=set();questions=set();known_ids=set();stats=Counter() |
| verified=ROOT/'variants/verified-reference-pilot-v1' |
| practice=ROOT/'variants/clear-practice-rl-v1' |
| for task in tqdm(TASKS,desc='Index existing training and held-out solutions',colour='cyan'): |
| for split in ('sft','rl','calibration','dev','test'): |
| rows=load_rows(verified,task,split) |
| if split=='rl':rows+=load_rows(practice,task,'rl') |
| for row in rows: |
| match=re.match(r'mbpp-(\d+)(?:\D|$)',row['source_id']) |
| if match:known_ids.add(int(match.group(1))) |
| blocked.add(canonical(row['reference'])) |
| if row['question']:questions.add(' '.join(row['question'].casefold().split())) |
| for item in raw: |
| if item['task_id'] not in sanitized|known_ids:continue |
| questions.add(' '.join(item['text'].casefold().split())) |
| try:blocked.add(canonical(item['code'])) |
| except (SyntaxError,ValueError):pass |
| try:blocked.add(canonical(native(item,'mbpp')['reference'])) |
| except (SyntaxError,ValueError,TypeError,KeyError):pass |
| candidates=[];seen=set(blocked) |
| for item in tqdm(sorted(raw,key=lambda r:r['task_id']),desc='Exclude original IDs and known solutions',colour='cyan',mininterval=5): |
| if item['task_id'] in sanitized:stats['original_sanitized_id']+=1;continue |
| if item['task_id'] in known_ids:stats['existing_task_id']+=1;continue |
| if ' '.join(item['text'].casefold().split()) in questions:stats['known_question']+=1;continue |
| try: |
| row=native(item,'mbpp');keys={canonical(item['code']),canonical(row['reference'])} |
| if keys&seen:stats['known_solution']+=1;continue |
| native_rows={task:native(item,task) for task in TASKS} |
| except (ValueError,SyntaxError,TypeError,KeyError):stats['format_or_context']+=1;continue |
| seen.update(keys);candidates.append((item,native_rows)) |
| with ThreadPoolExecutor(max_workers=config.workers) as pool: |
| passed=list(tqdm(pool.map(gold_passes,[rows['mbpp'] for item,rows in candidates]),total=len(candidates), |
| desc='Check additional published MBPP tests once',colour='green',mininterval=5)) |
| accepted=[item for item,ok in zip(candidates,passed,strict=True) if ok] |
| stats['published_test_failure']=len(candidates)-len(accepted) |
| if len(accepted)<100:raise ValueError('Insufficient additional original problems') |
| is_rl=lambda item:int(hashlib.sha256(f'{config.seed}/{item["task_id"]}'.encode()).hexdigest()[:8],16)%5==0 |
| report=json.loads((source/'dataset.json').read_text()) |
| report.update(revision='full-mbpp-seeds-v2',source=str(source),sft_tokens=config.tokens,seed=config.seed, |
| benchmark_draw_probability=config.benchmark_fraction,upstream=dict(repo=REPO,revision=REVISION,license='cc-by-4.0'), |
| extra_source_filtering=dict(stats),extra_sft_ids=[item['task_id'] for item,rows in accepted if not is_rl(item)], |
| extra_rl_ids=[item['task_id'] for item,rows in accepted if is_rl(item)], |
| extra_source_policy='Additional original full-MBPP problems only. Exclude EVERY original sanitized task ID and every known existing upstream task ID. Also exclude original RAW upstream solutions/questions for those IDs, alongside current rewritten references. Deterministic80/20 SFT/RL split. Every admitted reference passes its published tests. No rewritten expected values.', |
| sft_policy='Sample body band from ORIGINAL authentic SFT-training frequencies, then source origin at the declared benchmark fraction, then source group, then a natural local-name variant. Two to four complete native examples per document.', |
| rl_policy='Uniform missing length1..16 first, then uniform original-benchmark/additional-MBPP origin, then eligible source. No synthetic practice contracts in this variant. Calibration/development/test stay byte-identical.') |
| for task in TASKS: |
| shutil.copytree(source/'data'/task,root/'data'/task,dirs_exist_ok=True) |
| rows=load_rows(source,task,'sft') |
| old_auth={r['group']:r for r in load_rows(verified,task,'sft') if authentic(r)} |
| bands=Counter(r['provenance']['difficulty'] for r in old_auth.values()) |
| weights={band:count/sum(bands.values()) for band,count in bands.items()} |
| original=load_rows(verified,task,'rl') |
| rl=[dict(row,sampling_origin='benchmark') for row in original] |
| for item,native_rows in tqdm(accepted,desc=task+' original-source styles',colour='cyan',mininterval=5): |
| row=native_rows[task] |
| if is_rl(item): |
| try:rl.append(annotate(dict(row,demonstrations=original[0]['demonstrations'],sampling_origin='full_mbpp'))) |
| except ValueError:stats['rl_context_rejected']+=1 |
| else: |
| variants,filtered=styles_for(row,4,config.seed);rows.extend(variants) |
| assert not {r['group'] for r in rows}&{r['group'] for r in rl} |
| Pool(rl) |
| write_rows(root/'data'/task/'sft.jsonl.gz',rows);write_rows(root/'data'/task/'rl.jsonl.gz',rl) |
| corpus=documents(rows,config.tokens,random.Random(config.seed),config.benchmark_fraction,True,weights) |
| target=root/'sft'/task/'train.jsonl.gz';write_rows(target,corpus) |
| info=report['tasks'][task] |
| info.update(rows=dict(info['rows'],sft=len(rows),rl=len(rl)),documents=len(corpus),sft_sha256=signature(target), |
| source_groups=len({r['group'] for r in rows}),sft_body_band_target=weights, |
| admitted_extra_rl_ids=[r['provenance']['upstream_task_id'] for r in rl if r['sampling_origin']=='full_mbpp'], |
| unique_sft_programs_used=len({r['source_id'] for doc in corpus for r in doc['examples']}), |
| document_example_counts=dict(Counter(len(d['examples']) for d in corpus))) |
| for fold in ('sft','rl'): |
| relative='data/'+task+'/'+fold+'.jsonl.gz';info['assets'][relative]=signature(root/relative) |
| pool_rows=rows if fold=='sft' else rl |
| info.setdefault('hint_coverage',{})[fold]={str(n):sum(n in r['hint_levels'] for r in pool_rows) for n in range(1,17)} |
| for fold in ('calibration','dev','test'): |
| assert signature(root/'data'/task/(fold+'.jsonl.gz'))==signature(source/'data'/task/(fold+'.jsonl.gz')) |
| atomic_json(root/'build-progress.json',report) |
| report['extra_source_filtering']=dict(stats) |
| atomic_json(root/'dataset.json',report) |
| print('[green]Additional original MBPP SFT/RL sources ready[/green]',len(report['extra_sft_ids']),len(report['extra_rl_ids']),flush=True) |
|
|
|
|
| if __name__=='__main__': |
| build(OmegaConf.to_object(OmegaConf.merge(OmegaConf.structured(Config),OmegaConf.from_cli()))) |
|
|
