| import ast |
| import hashlib |
| import random |
|
|
| from functional_rl import v2 |
|
|
| REVISION='refined-code-v1' |
| ENC=v2.ENC |
| TASKS=('mbpp','mbpp_docstring','humaneval','humaneval_docstring') |
|
|
|
|
| def protected_prefix(row: dict) -> str: |
| if row.get('protected_prefix'): |
| return row['protected_prefix'] |
| tree=ast.parse(row['reference']) |
| functions=[node for node in tree.body if isinstance(node,ast.FunctionDef)] |
| if len(functions)!=1: |
| raise ValueError('Expected exactly one top-level entry-point function') |
| function=functions[0] |
| statements=function.body[1:] if ast.get_docstring(function) is not None else function.body |
| if not statements: |
| raise ValueError('The entry point needs an implementation') |
| return ''.join(row['reference'].splitlines(keepends=True)[:statements[0].lineno-1]) |
|
|
|
|
| def make_episode(row: dict, level: int): |
| if type(level) is not int or not 1<=level<=16 or row['task'] not in TASKS: |
| raise ValueError('Expected a code task and an integer missing length in 1..16') |
| groups={row['group']} |
| demos=row.get('demonstrations',()) |
| for demo in demos: |
| if demo['task']!=row['task'] or demo['group'] in groups: |
| raise ValueError('Demonstrations must use distinct same-task source groups') |
| groups.add(demo['group']) |
| context=''.join(v2.render(d).rstrip()+'\n\n' for d in demos) |
| header=context+v2.header(row) |
| document=header+row['reference'] |
| ids=ENC.encode_ordinary(document) |
| prompt_ids,completion_ids=ids[:-level],ids[-level:] |
| prompt,completion=ENC.decode(prompt_ids),ENC.decode(completion_ids) |
| if len(ids)>1024 or not prompt.startswith(header+row['protected_prefix']) or prompt+completion!=document: |
| raise ValueError('Missing tokens must stay in the implementation and preserve the instruction/signature') |
| return v2.Episode(row['task'],row['source_id'],row['group'],level,prompt,completion, |
| tuple(prompt_ids),tuple(completion_ids),prompt[len(header):],row['reference'],row['answer'], |
| tuple(row['tests']),row.get('setup',''),version=REVISION,question=row['question'], |
| provenance=(dict(row['provenance'],rl_origin=row['sampling_origin']) if row.get('sampling_origin') else row['provenance']), |
| demonstrations=tuple(dict(task=d['task'],source_id=d['source_id'], |
| group=d['group'],text=v2.render(d),split='sft') for d in demos)) |
|
|
|
|
| def available_hints(row: dict) -> list[int]: |
| demos=row.get('demonstrations',()) |
| groups=[row['group']]+[d['group'] for d in demos] |
| if row['task'] not in TASKS or len(set(groups))!=len(groups) or any(d['task']!=row['task'] for d in demos): |
| return [] |
| context=''.join(v2.render(d).rstrip()+'\n\n' for d in demos) |
| header=context+v2.header(row) |
| document=header+row['reference'] |
| ids=ENC.encode_ordinary(document) |
| if len(ids)>1024: |
| return [] |
| protected=header+row['protected_prefix'] |
| return [level for level in range(1,min(16,len(ids)-1)+1) |
| if ENC.decode(ids[:-level]).startswith(protected) |
| and ENC.decode(ids[:-level])+ENC.decode(ids[-level:])==document] |
|
|
|
|
| class Pool: |
| def __init__(self, rows: list[dict]): |
| self.by_hint={n:[r for r in rows if n in r['hint_levels']] for n in range(1,17)} |
| if any(not rows for rows in self.by_hint.values()): |
| raise ValueError('Each hint length requires eligible benchmark sources') |
| origins={row.get('sampling_origin') for row in rows} |
| if None in origins and len(origins)>1: |
| raise ValueError('An origin-balanced RL pool must label every source') |
| self.by_origin=({n:{origin:[r for r in eligible if r['sampling_origin']==origin] |
| for origin in sorted(origins) if any(r['sampling_origin']==origin for r in eligible)} |
| for n,eligible in self.by_hint.items()} if None not in origins else None) |
|
|
| def sample(self, rng: random.Random): |
| level=rng.randint(1,16) |
| eligible=self.by_hint[level] |
| if self.by_origin is not None: |
| groups=self.by_origin[level] |
| eligible=groups[rng.choice(list(groups))] |
| return make_episode(rng.choice(eligible),level) |
|
|
|
|
| def fixed_panel(rows: list[dict], queries: int, seed: int): |
| if queries<16 or queries%16: |
| raise ValueError('Evaluation draws must be a positive multiple of 16') |
| pool=Pool(rows) |
| ordered={n:sorted(pool.by_hint[n],key=lambda row:hashlib.sha256( |
| f'{seed}/{n}/{row["group"]}'.encode()).hexdigest()) for n in range(1,17)} |
| return [(ordered[i%16+1][(i//16)%len(ordered[i%16+1])],i%16+1) for i in range(queries)] |
|
|
