| import ast |
| from collections import defaultdict |
| from copy import deepcopy |
| from dataclasses import dataclass |
| import hashlib |
| import json |
| from pathlib import Path |
| import random |
| import symtable |
| import textwrap |
|
|
| from omegaconf import OmegaConf |
| from rich import print |
| from tqdm import tqdm |
|
|
| from refined_v4.data import load_rows,write_rows,atomic_json,signature |
| from functional_rl import v2 |
|
|
| from . import ROOT,TASKS |
| from .data import annotate |
|
|
|
|
| @dataclass |
| class Config: |
| source: str=str(ROOT/'variants/clear-reference-v1') |
| root: str=str(ROOT/'variants/clear-focused-v1') |
| tokens: int=2097152 |
| variants: int=16 |
| seed: int=6719 |
|
|
|
|
| class Rename(ast.NodeTransformer): |
| def __init__(self,mapping: dict[str,str]): |
| self.mapping=mapping |
|
|
| def visit_Name(self,node): |
| node.id=self.mapping.get(node.id,node.id) |
| return node |
|
|
| def visit_Nonlocal(self,node): |
| node.names=[self.mapping.get(name,name) for name in node.names] |
| return node |
|
|
|
|
| def aliases(name: str): |
| lower=name.lower() |
| if lower in ('i','j','k','idx','index','pos','position'): |
| return [name,'index','position','offset','item_index','current_index'] |
| if lower in ('res','result','out','output','answer','ans'): |
| return [name,'result','output','answer','computed_result','return_value'] |
| if lower=='total': |
| return [name,'running_total','total_value','aggregate','result'] |
| if 'count' in lower or lower in ('cnt','tally'): |
| return [name,'count','total','tally','item_count','total_count'] |
| if any(word in lower for word in ('length','size')): |
| return [name,'length','size','item_count','sequence_length'] |
| if any(word in lower for word in ('largest','maximum','max_')): |
| return [name,'largest','maximum','max_value','current_max'] |
| if any(word in lower for word in ('smallest','minimum','min_')): |
| return [name,'smallest','minimum','min_value','current_min'] |
| if lower in ('x','value','val','item','element','elt'): |
| return [name,'value','item','element','entry','current_value'] |
| base=name.removeprefix('current_') |
| return [name,base+'_value','current_'+base,base+'_result'] |
|
|
|
|
| def augment(row: dict,limit: int,rng: random.Random): |
| tree=ast.parse(row['reference']) |
| function=next(n for n in tree.body if isinstance(n,ast.FunctionDef)) |
| occupied={n.id for n in ast.walk(tree) if isinstance(n,ast.Name)} |
| excluded={n.arg for n in ast.walk(tree) if isinstance(n,ast.arg)} |
| excluded|={n.name for n in ast.walk(tree) if isinstance(n,(ast.FunctionDef,ast.ClassDef))} |
| excluded|={n.name for n in ast.walk(tree) if isinstance(n,ast.ExceptHandler) and n.name} |
| scopes=[symtable.symtable(row['reference'],'<augmentation>','exec')] |
| while scopes: |
| scope=scopes.pop() |
| occupied.update(symbol.get_name() for symbol in scope.get_symbols()) |
| excluded|={s.get_name() for s in scope.get_symbols() if s.is_imported() or (scope.get_type()!='module' and s.is_global())} |
| scopes.extend(scope.get_children()) |
| names=sorted({n.id for n in ast.walk(function) if isinstance(n,ast.Name) and isinstance(n.ctx,ast.Store)}-excluded) |
| result=[dict(row)] |
| if not names or any(isinstance(n,ast.Call) and isinstance(n.func,ast.Name) and n.func.id in ('locals','globals','eval','exec','vars') for n in ast.walk(function)): |
| return result |
| seen={hashlib.sha256(row['reference'].encode()).hexdigest()} |
| for attempt in range(limit*8): |
| mapping={} |
| used=set(occupied) |
| for name in names: |
| choices=[value for value in aliases(name) if value==name or value not in used] |
| chosen=rng.choice(choices) |
| used.add(chosen) |
| if chosen!=name:mapping[name]=chosen |
| if not mapping:continue |
| variant=Rename(mapping).visit(deepcopy(tree)) |
| restored=Rename({v:k for k,v in mapping.items()}).visit(deepcopy(variant)) |
| if ast.dump(restored)!=ast.dump(tree):raise ValueError('Identifier transformation is not reversible') |
| changed=next(n for n in variant.body if isinstance(n,ast.FunctionDef)) |
| statements=changed.body[1:] if ast.get_docstring(changed) is not None else changed.body |
| body='\n'.join(ast.unparse(statement) for statement in statements) |
| code=row['protected_prefix']+textwrap.indent(body,' ') |
| digest=hashlib.sha256(code.encode()).hexdigest() |
| if digest in seen:continue |
| seen.add(digest) |
| try: |
| value=annotate(dict(row,source_id=row['source_id']+'/locals-'+digest[:16],reference=code,answer=code, |
| provenance=dict(row['provenance'],augmentation='Scope-safe reversible local identifier renaming', |
| parent_source_id=row['source_id'],aliases=mapping))) |
| except ValueError:continue |
| result.append(value) |
| if len(result)==limit:break |
| return result |
|
|
|
|
| def pack(rows: list[dict],budget: int,rng: random.Random): |
| groups=defaultdict(list) |
| for row in rows:groups[row['group']].append(row) |
| keys=list(groups) |
| rendered={r['source_id']:v2.render(r) for r in rows} |
| sizes={k:len(v2.ENC.encode_ordinary(v)) for k,v in rendered.items()} |
| shortest=[] |
| short_groups=set() |
| for row in sorted(rows,key=lambda r:sizes[r['source_id']]): |
| if row['group'] not in short_groups: |
| shortest.append(row) |
| short_groups.add(row['group']) |
| if len(shortest)==32:break |
| result=[] |
| tokens=0 |
| with tqdm(total=budget,desc='Pack source-balanced native SFT',unit='tok',colour='cyan',mininterval=5) as progress: |
| while tokens<budget: |
| row=rng.choice(groups[rng.choice(keys)]) |
| selected=[row] |
| count=sizes[row['source_id']] |
| candidates=[rng.choice(groups[key]) for key in rng.sample(keys,min(64,len(keys)))]+shortest |
| for candidate in candidates: |
| if candidate['group'] in {r['group'] for r in selected}:continue |
| extra=sizes[candidate['source_id']]+2 |
| if count+extra<=1024: |
| selected.append(candidate) |
| count+=extra |
| if len(selected)==4:break |
| if len(selected)<2:raise ValueError('Cannot fit two independent focused SFT functions') |
| text='\n\n'.join(rendered[r['source_id']] for r in selected) |
| size=len(v2.ENC.encode_ordinary(text)) |
| 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) |
| if (root/'dataset.json').exists():return json.loads((root/'dataset.json').read_text()) |
| report=deepcopy(json.loads((source/'dataset.json').read_text())) |
| report.update(source=str(source),sft_tokens=config.tokens,source_revision='focused-local-names-v1', |
| sft_policy='Authentic SFT-fold benchmark functions, reversible natural local-name variants, and the original two SFT demonstration sources. Sample source groups uniformly before choosing a variant. RL/dev/test files stay byte-identical to the clear-reference control.') |
| for task in TASKS: |
| original=load_rows(source,task,'sft') |
| rows=[] |
| authentic=[r for r in original if r['source_id'].startswith(('mbpp-','HumanEval/'))] |
| for row in tqdm(authentic,desc=task+' local-name variants',colour='cyan',mininterval=5): |
| rows.extend(augment(row,config.variants,random.Random(f'{config.seed}/{row["group"]}'))) |
| demos=load_rows(source,task,'rl')[0]['demonstrations'] |
| lookup={r['source_id']:r for r in original} |
| for demo in demos: |
| if demo['source_id'] not in {r['source_id'] for r in rows}:rows.append(lookup[demo['source_id']]) |
| sizes={r['source_id']:len(v2.ENC.encode_ordinary(v2.render(r))) for r in rows} |
| shortest=sorted(rows,key=lambda r:sizes[r['source_id']]) |
| excluded=[] |
| retained=[] |
| for row in rows: |
| other=next(r for r in shortest if r['group']!=row['group']) |
| if sizes[row['source_id']]+sizes[other['source_id']]+2<=1024: |
| retained.append(row) |
| else:excluded.append(dict(source_id=row['source_id'],rendered_tokens=sizes[row['source_id']])) |
| rows=retained |
| if len({r['source_id'] for r in rows})!=len(rows):raise ValueError('Duplicate focused implementation IDs') |
| write_rows(root/'data'/task/'sft.jsonl.gz',rows) |
| for split in ('rl','calibration','dev','test'): |
| path=root/'data'/task/(split+'.jsonl.gz') |
| if not path.exists():path.symlink_to(source/'data'/task/(split+'.jsonl.gz')) |
| corpus=pack(rows,config.tokens,random.Random(config.seed)) |
| path=root/'sft'/task/'train.jsonl.gz' |
| write_rows(path,corpus) |
| report['tasks'][task].update(rows={split:len(load_rows(root,task,split)) for split in ('sft','rl','calibration','dev','test')}, |
| source_groups=len({r['group'] for r in rows}),authentic_sources=len(authentic),documents=len(corpus),sft_sha256=signature(path), |
| excluded_context_variants=excluded, |
| 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(root/'dataset.json',report) |
| print('[green]Focused benchmark SFT ready[/green]',flush=True) |
| return report |
|
|
|
|
| if __name__=='__main__': |
| build(OmegaConf.to_object(OmegaConf.merge(OmegaConf.structured(Config),OmegaConf.from_cli()))) |
|
|
