| """One deterministic generation per task, followed by isolated execution.""" |
| import argparse |
| import hashlib |
| import json |
| from pathlib import Path |
| import sys |
| from validators.dataset import load |
| from runners import get_runner,LANGUAGES |
| from runners.common import extract_code |
| from runners.sandbox import Sandbox |
| from metrics import aggregate |
| ROOT=Path(__file__).resolve().parent |
| from completion import prompt,assemble,PROMPT_VERSION |
| from generation_settings import PROTOCOL,DEFAULT_BATCH_SIZE,token_budget |
|
|
| def save(path,value): |
| path.parent.mkdir(parents=True,exist_ok=True);temp=path.with_suffix('.tmp');temp.write_text(json.dumps(value,indent=2,allow_nan=False)+'\n');temp.replace(path) |
|
|
| def main(): |
| p=argparse.ArgumentParser(description=__doc__);p.add_argument('--model');p.add_argument('--revision',default='main');p.add_argument('--output',type=Path,required=True) |
| p.add_argument('--language',nargs='+',choices=LANGUAGES);p.add_argument('--difficulty',nargs='+',choices=('easy','medium','moderate')) |
| p.add_argument('--resume',action='store_true');p.add_argument('--predictions',type=Path,help='JSONL with id and code; bypass model inference') |
| p.add_argument('--image',default='smolscript-runtime:0.1.0');p.add_argument('--engine',default='docker');p.add_argument('--max-new-tokens',type=int,default=None);p.add_argument('--device',default='auto');p.add_argument('--batch-size',type=int,default=DEFAULT_BATCH_SIZE);a=p.parse_args() |
| if not a.model and not a.predictions:p.error('--model or --predictions required') |
| if a.max_new_tokens is not None and a.max_new_tokens<1:p.error('--max-new-tokens must be positive') |
| if a.batch_size<1:p.error('--batch-size must be positive') |
| sandbox=Sandbox(a.image,a.engine) |
| rows=[r for r in load(ROOT/'data/smolscript.jsonl') if (not a.language or r['language'] in a.language) and (not a.difficulty or r['difficulty'] in a.difficulty)] |
| hidden={r['id']:r for r in load(ROOT/'private_tests/hidden.jsonl')} |
| files=['data/smolscript.jsonl','private_tests/hidden.jsonl','evaluate.py','metrics.py','generation_settings.py','completion.py']+[str(p.relative_to(ROOT)) for p in sorted((ROOT/'runners').glob('*.py'))]+['sandbox/worker.py','sandbox/supervisor.py'] |
| fingerprint={f:hashlib.sha256((ROOT/f).read_bytes()).hexdigest() for f in files} |
| settings={'model':a.model,'requested_revision':a.revision,'language':a.language,'difficulty':a.difficulty, |
| 'max_new_tokens':a.max_new_tokens,'batch_size':a.batch_size,'decode_protocol':PROTOCOL,'prompt_version':PROMPT_VERSION,'dataset':fingerprint,'sandbox':sandbox.identity, |
| 'predictions_sha':hashlib.sha256(a.predictions.read_bytes()).hexdigest() if a.predictions else None} |
| if a.output.exists() and not a.resume:p.error('Output exists; use --resume or a new path') |
| state=json.loads(a.output.read_text()) if a.output.exists() else {'settings':settings,'results':[],'complete':False} |
| if state['settings']!=settings:p.error('Resume settings mismatch') |
| if a.resume and not a.output.exists():p.error('Resume output missing') |
| |
| import fcntl |
| lock=a.output.with_suffix(a.output.suffix+'.lock');lock.parent.mkdir(parents=True,exist_ok=True) |
| with lock.open('a') as stream: |
| fcntl.flock(stream,fcntl.LOCK_EX|fcntl.LOCK_NB) |
| codes={} |
| if a.predictions:codes={r['id']:r['code'] for r in load(a.predictions)} |
| else: |
| import torch |
| from transformers import AutoTokenizer,AutoModelForCausalLM,AutoConfig |
| from huggingface_hub import snapshot_download |
| snapshot=snapshot_download(a.model,revision=state.get('resolved_revision') or a.revision) |
| revision=Path(snapshot).name |
| state['resolved_revision']=revision |
| tokenizer=AutoTokenizer.from_pretrained(snapshot,trust_remote_code=True) |
| model=AutoModelForCausalLM.from_pretrained(snapshot,trust_remote_code=True,torch_dtype='auto',device_map=a.device) |
| model.eval();torch.manual_seed(0) |
| import importlib.metadata |
| state['environment']={'python':sys.version,'packages':{n:importlib.metadata.version(n) for n in ('torch','transformers','huggingface-hub')},'device':str(model.device)} |
| done={r['id'] for r in state['results']} |
| if len(done)!=len(state['results']) or done-set(r['id'] for r in rows):raise ValueError('Corrupt resume IDs') |
| save(a.output,state) |
| if not a.predictions: |
| from runners.hf_runtime import Progress,generate_batches |
| generated=state.setdefault('generations',{}) |
| if state.get('pending'):generated[state['pending']['id']]=state['pending']['generation'] |
| pending=[r for r in rows if r['id'] not in done and r['id'] not in generated] |
| if tokenizer.pad_token_id is None:tokenizer.pad_token=tokenizer.eos_token |
| tokenizer.padding_side='left' |
| encoded=tokenizer([prompt(r) for r in pending],return_token_type_ids=False) if pending else {'input_ids':[],'attention_mask':[]} |
| compiled={r['id']:{'input_ids':encoded['input_ids'][i],'attention_mask':encoded['attention_mask'][i]} for i,r in enumerate(pending)} |
| budgets={r['id']:a.max_new_tokens or token_budget(r) for r in pending} |
| native=getattr(model.config,'max_position_embeddings',getattr(model.config,'n_positions',4096)) |
| for r in pending: |
| if len(compiled[r['id']]['input_ids'])+budgets[r['id']]>native: |
| raise ValueError('Insufficient context for generation: '+r['id']) |
| def emit(batch): |
| generated.update({rid:text for rid,text,_ in batch});save(a.output,state) |
| with Progress('SmolScript',len(pending)) as progress: |
| state['generation_stats']=generate_batches(model,tokenizer,compiled,pending, |
| lambda r:budgets[r['id']],a.batch_size,emit,progress,stream_tokens=False) |
| for row in rows: |
| if row['id'] in done:continue |
| if a.predictions: |
| if row['id'] not in codes:raise ValueError('Missing prediction '+row['id']) |
| text=codes[row['id']] |
| else:text=state['generations'][row['id']] |
| state['pending']={'id':row['id'],'generation':text};save(a.output,state) |
| code=None |
| try:code=extract_code(text) if a.predictions else assemble(row,text) |
| except ValueError as e:result={'passed':False,'syntax_success':False,'tests':[],'error':str(e)} |
| else:result=get_runner(row['language']).evaluate(row,code,hidden[row['id']],sandbox) |
| state['results'].append({'id':row['id'],'language':row['language'],'difficulty':row['difficulty'],'generation':text,'evaluated_code':code,**result}) |
| state.pop('pending',None) |
| save(a.output,state);print(f"{len(state['results'])}/{len(rows)} {row['id']} {'PASS' if result['passed'] else 'FAIL'}",flush=True) |
| state['metrics']=aggregate(state['results'],[r['id'] for r in rows],full_run=not(a.language or a.difficulty));state['complete']=True;save(a.output,state) |
| print(json.dumps(state['metrics'],indent=2)) |
|
|
| if __name__=='__main__':main() |
|
|
