File size: 13,483 Bytes
dfdaf38 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 | import asyncio
from collections import Counter
from concurrent.futures import ThreadPoolExecutor
from copy import deepcopy
from dataclasses import dataclass
import fcntl
import hashlib
import json
from pathlib import Path
import random
import textwrap
import time
import ast
import httpx
from openai import AsyncOpenAI,DefaultAioHttpClient,RateLimitError
from omegaconf import OmegaConf
from pydantic import BaseModel
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,atomic_json,signature
from refined_v4.fast_generate import Limiter
from . import ROOT,TASKS
from .data import annotate,documents,gold_passes
from .envs import Pool,available_hints
SPLITS=('sft','rl','calibration','dev','test')
@dataclass
class Config:
action: str='generate'
source: str=str(ROOT)
teacher: str=str(ROOT/'variants/diverse-completion-v2')
root: str=str(ROOT/'variants/clear-reference-v1')
model: str='gpt-6-luna'
concurrency: int=96
rpm: int=6000
tpm: int=3000000
limit: int=0
tokens: int=2097152
seed: int=6719
workers: int=8
class Body(BaseModel):
body: str
def jobs_for(config: Config):
jobs=[]
for family in ('mbpp','humaneval'):
for split in SPLITS:
for row in load_rows(Path(config.source),family,split):
jobs.append(dict(family=family,split=split,identity=row['source_id'],row=row))
if not config.limit or len(jobs)<config.limit:
for row in load_rows(Path(config.teacher),'mbpp','sft'):
if row['source_id'].startswith('diverse-contract/'):
jobs.append(dict(family='teacher',split='sft',identity=row['source_id'],row=row))
if config.limit and len(jobs)>=config.limit:break
if config.limit:jobs=jobs[:config.limit]
for job in jobs:
row=job['row']
payload=dict(revision='clear-implementations-v1',model=config.model,
family=job['family'],identity=job['identity'],question=row['question'],reference=row['reference'])
job['key']=hashlib.sha256(json.dumps(payload,sort_keys=True).encode()).hexdigest()
assert len({j['key'] for j in jobs})==len(jobs)
return jobs
def cached(root: Path):
path=root/'rewrites.jsonl'
result={}
if path.exists():
for line in path.read_text().splitlines():
try:
record=json.loads(line)
except json.JSONDecodeError:
continue
if record.get('body'):
result[record['key']]=record
return result
def prompt(job: dict):
row=job['row']
return ('Rewrite the implementation of this existing Python exercise in clear, ordinary, idiomatic Python. '
'Preserve the exact contract, signature and behavior on every valid input. '
'Use natural short local names and direct returns when an intermediate variable is unnecessary. '
'Prefer a simple builtin or comprehension when that is the clearest correct solution. '
'Keep loops when they make the algorithm clearer. Do not golf code or compress multiple statements onto a line. '
'Do not add padding, aliases, artificial final statements, redundant return variables, or comments chosen to make the ending predictable. '
'Return only the implementation body, with relative indentation, without the function signature, docstring, tests or Markdown. '
'Any newly needed standard-library import must be inside the function. Nested helpers are allowed when needed. '
'The existing instruction and signature prefix will be preserved verbatim.\n'+
json.dumps(dict(question=row['question'],original_program=row['reference'],tests=row['tests']),ensure_ascii=False))
async def generate(config: Config):
root=Path(config.root)
root.mkdir(parents=True,exist_ok=True)
jobs=jobs_for(config)
if config.limit:jobs=jobs[:config.limit]
done=cached(root)
pending=[j for j in jobs if j['key'] not in done]
limiter=Limiter(config.rpm,config.tpm)
stats=Counter()
lock=(root/'generation.lock').open('a')
fcntl.flock(lock,fcntl.LOCK_EX|fcntl.LOCK_NB)
stream=(root/'rewrites.jsonl').open('a',buffering=1024*1024)
semaphore=asyncio.Semaphore(config.concurrency)
progress=tqdm(total=len(pending),desc='Clear benchmark and SFT implementations',colour='cyan',mininterval=5)
limits=httpx.Limits(max_connections=config.concurrency+8,max_keepalive_connections=config.concurrency)
transport=DefaultAioHttpClient(limits=limits,timeout=60.)
try:
async with AsyncOpenAI(http_client=transport,max_retries=0,timeout=60.) as client:
async def one(job):
async with semaphore:
text=prompt(job)
body_tokens=len(v2.ENC.encode_ordinary(job['row']['reference'][len(job['row']['protected_prefix']):]))
output=max(256,min(1400,int(body_tokens*1.5)+128))
for attempt in range(3):
ticket=await limiter.acquire(len(v2.ENC.encode_ordinary(text))+min(output,body_tokens+64))
try:
response=await client.responses.parse(model=config.model,input=text,text_format=Body,
reasoning={'effort':'none'},max_output_tokens=output,store=False)
usage=response.usage.model_dump() if response.usage else {}
await limiter.settle(ticket,usage.get('total_tokens',0))
if response.output_parsed is None:
raise ValueError('No structured implementation body')
record=dict(key=job['key'],family=job['family'],source_id=job['row']['source_id'],
body=response.output_parsed.body,response_id=response.id,model=config.model,usage=usage)
stream.write(json.dumps(record,ensure_ascii=False)+'\n')
stats['success']+=1
stats['input_tokens']+=usage.get('input_tokens',0)
stats['output_tokens']+=usage.get('output_tokens',0)
break
except Exception as error:
await limiter.settle(ticket,0)
stats[type(error).__name__]+=1
if isinstance(error,RateLimitError):limiter.backoff(2.+attempt*2.)
if attempt<2:await asyncio.sleep(1.+attempt)
progress.update()
if stats['success']%50==0:
stream.flush()
atomic_json(root/'generation-progress.json',dict(stats=stats,requested=len(pending),updated=time.time()))
await asyncio.gather(*(one(job) for job in pending))
finally:
stream.close()
progress.close()
lock.close()
atomic_json(root/'generation-progress.json',dict(stats=stats,requested=len(pending),updated=time.time()))
if stats['success']<.9*len(pending):
raise RuntimeError('Too many API failures; resume missing cached bodies before building')
print('[green]Implementation rewrites cached[/green]',dict(stats),flush=True)
def proposed(row: dict,body: str):
code=row['protected_prefix']+textwrap.indent(textwrap.dedent(body).strip(),' ')
ast.parse(code)
if len(v2.ENC.encode_ordinary(v2.header(row)+code))>1000:
raise ValueError('Rewritten function exceeds context')
return annotate(dict(row,reference=code,answer=code,provenance=dict(row['provenance'],
reference_style='clear-implementations-v1',original_reference_sha256=hashlib.sha256(row['reference'].encode()).hexdigest())))
def build(config: Config):
if config.limit:
raise ValueError('A smoke-generation limit cannot build a completed task dataset')
root=Path(config.root)
if (root/'dataset.json').exists():return json.loads((root/'dataset.json').read_text())
records=cached(root)
jobs=jobs_for(config)
if sum(j['key'] in records for j in jobs)<.9*len(jobs):
raise ValueError('Generate the complete implementation cache before building')
accepted={}
stats=Counter()
candidates=[]
for job in tqdm(jobs,desc='Parse rewritten native functions',colour='cyan',mininterval=5):
try:
row=proposed(job['row'],records[job['key']]['body'])
if job['family']=='teacher':accepted[(job['family'],canonical(job['row']['reference']))]=records[job['key']]
else:candidates.append((job,row))
except (KeyError,SyntaxError,ValueError):stats['format_fallback']+=1
with ThreadPoolExecutor(max_workers=config.workers) as pool:
passed=list(tqdm(pool.map(gold_passes,[r for j,r in candidates]),total=len(candidates),
desc='Check unchanged benchmark tests once',colour='green',mininterval=5))
for (job,row),ok in zip(candidates,passed,strict=True):
if ok:
accepted[(job['family'],job['identity'])]=records[job['key']]
stats['benchmark_rewrites']+=1
else:stats['benchmark_test_fallback']+=1
report=dict(source=str(config.source),teacher=str(config.teacher),sft_tokens=config.tokens,seed=config.seed,
revision='clear-implementations-v1',tasks={},rewrites=dict(stats),
reference_policy='Original questions, protected signatures/instructions, tests and source split groups are preserved. Rewrite implementation bodies only; unchanged-test failures retain the original reference. No padding or artificial endings.',
sft_validation='Teacher SFT implementations receive syntax/context checks only; benchmark full programs execute unchanged tests once.')
for task in TASKS:
family='mbpp' if task.startswith('mbpp') else 'humaneval'
pools={split:load_rows(Path(config.source),task,split) for split in SPLITS}
pools['sft']+=[r for r in load_rows(Path(config.teacher),task,'sft') if r['source_id'].startswith('diverse-contract/')]
for split,rows in pools.items():
cleaned=[]
for row in rows:
origin='teacher' if row['source_id'].startswith('diverse-contract/') else family
identity=canonical(row['reference']) if origin=='teacher' else row['source_id']
record=accepted.get((origin,identity))
try:
value=proposed(row,record['body']) if record is not None else annotate(dict(row))
except (SyntaxError,ValueError):value=annotate(dict(row))
if record is not None:
value['provenance'].update(reference_teacher_model=record.get('model',config.model),
reference_response_id=record.get('response_id'),reference_rewrite_key=record['key'])
value.pop('demonstrations',None)
cleaned.append(value)
pools[split]=cleaned
heldout={canonical(r['reference']) for split in ('calibration','dev','test') for r in pools[split]}
pools['rl']=[r for r in pools['rl'] if canonical(r['reference']) not in heldout]
blocked=heldout|{canonical(r['reference']) for r in pools['rl']}
seen=set(blocked)
unique=[]
for row in pools['sft']:
identity=canonical(row['reference'])
if identity not in seen:
seen.add(identity)
unique.append(row)
pools['sft']=unique
short=sorted(unique,key=lambda r:len(v2.ENC.encode_ordinary(v2.render(r))))
for split in SPLITS:
if split!='sft':
for row in pools[split]:
groups={row['group']}
row['demonstrations']=[]
for demo in short:
if demo['group'] not in groups:
row['demonstrations'].append(demo)
groups.add(demo['group'])
if len(row['demonstrations'])==2:break
row['hint_levels']=available_hints(row)
if not row['hint_levels']:
raise ValueError('A rewritten benchmark source cannot fit its protected prefix and two demonstrations')
Pool(pools[split])
write_rows(root/'data'/task/(split+'.jsonl.gz'),pools[split])
corpus=documents(unique,config.tokens,random.Random(config.seed))
path=root/'sft'/task/'train.jsonl.gz'
write_rows(path,corpus)
report['tasks'][task]=dict(rows={s:len(r) for s,r in pools.items()},documents=len(corpus),
source_groups=len({r['group'] for r in unique}),sft_sha256=signature(path),
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]Clear-reference task control ready[/green]',dict(stats),flush=True)
return report
def main(config: Config):
if config.action in ('generate','all'):asyncio.run(generate(config))
if config.action in ('build','all'):build(config)
if __name__=='__main__':
main(OmegaConf.to_object(OmegaConf.merge(OmegaConf.structured(Config),OmegaConf.from_cli())))
|