| """Frozen, user-authorized 80/23 task final run; native Prime schemas and checks.""" |
| from copy import deepcopy |
| import hashlib |
| import json |
| from pathlib import Path |
|
|
| ROOT = Path(__file__).resolve().parent |
| MODEL_REVISION = 'c202236235762e1c871ad0ccb60c8ee5ba337b9a' |
| COMMITS = ('ced9c90b75b5a13263265089091c11dc136dfbfd', 'ed74dad125d77dcc339c6ff07e67cbdb0cc90607') |
|
|
|
|
| def digest(value): |
| return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(',', ':')).encode()).hexdigest() |
|
|
|
|
| def freeze(): |
| import tomllib |
| plan = json.loads((ROOT/'plans/training103-plan.json').read_text()) |
| template = json.loads((ROOT/'calibration/validation11-c64-20261029-01-frozen.json').read_text()) |
| available = [json.loads((ROOT/'calibration'/name).read_text()) for name in |
| ('screening-all116-manifest.json', 'screening-round2-manifest.json')] |
| train = list(plan['split']['train']) |
| heldout = list(plan['split']['validation']) + list(plan['split']['test']) |
| all_manifest = {name: records[name] for records in available for name in train+heldout if name in records} |
|
|
| def sources(names, training=False): |
| result = [] |
| for index, source in enumerate(template['evaluation']['source']): |
| selected = [name for name in names if name in available[index]] |
| if not selected: |
| continue |
| item = deepcopy(source) |
| item['name'] = ('final-train-' if training else 'final-heldout-')+str(index+1) |
| item['env']['taskset']['tasks'] = selected |
| item['select'] = {'limit':len(selected), 'shuffle':bool(training)} |
| if training: |
| item['select']['seed'] = 42 |
| item['serve']['max_concurrent'] = 128 if training else 64 |
| item['env']['agent']['harness']['env'] = {'VF_BASH_LENGTH_RECOVERY':'1'} |
| item['env']['interception']['tunnel']['port'] = 8001+len(result) |
| if training: |
| item['ratio'] = len(selected) |
| result.append(item) |
| return result |
|
|
| config = tomllib.loads((ROOT/'train.toml').read_text()) |
| config.update(max_steps=10, output_dir='/outputs/prime/FINAL', dashboard=False, run={'name':'training'}) |
| config['deployment'].update(gpus_per_node=3, num_train_gpus=1, num_infer_gpus=2) |
| config['ckpt'] = {'interval':5, 'keep_interval':5} |
| config['orchestrator'].update(batch_size=64, max_off_policy_steps=1, constant_trainer_batch_size=True, |
| eval=None, concurrency={key:128 for key in ('initial_inflight','min_inflight','max_inflight')}) |
| config['orchestrator']['train'].update(group_size=8, source=sources(train, training=True)) |
| config['orchestrator']['train']['sampling']['temperature'] = 0.6 |
| config['inference'].update(router=None) |
| config['inference']['vllm'].update(max_num_seqs=64, tensor_parallel_size=1, data_parallel_size=2, api_server_count=1) |
| runtime = {name:hashlib.sha256((ROOT/name).read_bytes()).hexdigest() |
| for name in ('bash_timeout.py','compaction_task.py','bash_recovery.py')} |
| shards = [] |
| for shard, names in enumerate((heldout[:11], heldout[11:])): |
| evaluation = deepcopy(template) |
| evaluation['evaluation'].update(source=sources(names), select={'limit':len(names),'shuffle':False}) |
| evaluation['evaluation']['sampling']['temperature'] = 0.6 |
| evaluation['experiment'].update(purpose='final_heldout', task_count=len(names), total_attempts=len(names)*8, |
| replicas=1, inference_seeds=[5100+shard], task_git_commits=list(COMMITS), |
| profile='rl-next', workspace='susindra-turtlelabs', split='merged_heldout', shard=shard) |
| evaluation['inference'].update(router=None) |
| evaluation['inference']['vllm'].update(enable_lora=True, max_lora_rank=16, max_num_seqs=64, |
| data_parallel_size=1, tensor_parallel_size=1) |
| evaluation['task_manifest'] = {name:all_manifest[name] for name in names} |
| evaluation['runtime_sha256'] = runtime |
| evaluation['split_note'] = 'Frozen existing 11+12 heldout tasks; previously examined, not a blind test.' |
| shards.append(evaluation) |
| frozen = {'purpose':'final-training-80-23', 'profile':'rl-next', 'workspace':'susindra-turtlelabs', |
| 'training':config, 'train_tasks':train, 'heldout_tasks':heldout, 'task_manifest':all_manifest, |
| 'runtime_sha256':runtime, 'evaluation_shards':shards, |
| 'accepted_trace_target':640, 'post_training_eval_attempts':368, |
| 'watchdog_seconds':32400, 'function_timeout_seconds':33000, |
| 'provenance':{'prime_commit':'9e15490dcab1d506ce3462e69b8aa5dde45c6b3a', |
| 'task_commits':list(COMMITS), 'source_plan_sha256':hashlib.sha256((ROOT/'plans/training103-plan.json').read_bytes()).hexdigest(), |
| 'split_note':'User merged existing validation/test into one 23-task heldout; selection and task bytes unchanged.'}} |
| validate(frozen) |
| return frozen |
|
|
|
|
| def validate(frozen): |
| from prime_rl.configs.rl import RLConfig |
| from prime_rl.configs.eval import EvalConfig |
| from prime_rl.configs.inference import InferenceConfig |
| assert frozen['purpose'] == 'final-training-80-23' |
| assert frozen['profile']=='rl-next' and frozen['workspace']=='susindra-turtlelabs' |
| train, heldout = frozen['train_tasks'], frozen['heldout_tasks'] |
| assert len(train)==len(set(train))==80 and len(heldout)==len(set(heldout))==23 |
| assert not set(train)&set(heldout) and set(train+heldout)==set(frozen['task_manifest']) |
| assert frozen['accepted_trace_target']==640 and frozen['post_training_eval_attempts']==368 |
| assert frozen['watchdog_seconds']==32400 and frozen['function_timeout_seconds']==33000 |
| config = frozen['training'] |
| parsed = RLConfig.model_validate(deepcopy(config)) |
| assert parsed.max_steps==10 and parsed.orchestrator.batch_size==64 |
| assert parsed.orchestrator.train.group_size==8 and parsed.orchestrator.eval is None |
| assert parsed.orchestrator.constant_trainer_batch_size and parsed.orchestrator.max_off_policy_steps==1 |
| assert parsed.orchestrator.concurrency.model_dump()==dict(initial_inflight=128,min_inflight=128,max_inflight=128) |
| assert parsed.deployment.type=='single_node' |
| assert (parsed.deployment.gpus_per_node, parsed.deployment.num_train_gpus, parsed.deployment.num_infer_gpus)==(3,1,2) |
| assert parsed.inference.router is None and parsed.inference.vllm.api_server_count==1 |
| assert (parsed.inference.vllm.data_parallel_size,parsed.inference.vllm.tensor_parallel_size,parsed.inference.vllm.max_num_seqs)==(2,1,64) |
| assert parsed.trainer.model.compile.model_dump()=={'fullgraph':False,'mode':None} |
| assert parsed.trainer.model.lora.rank==16 and parsed.trainer.model.lora.alpha==32 |
| assert parsed.trainer.optim.lr==1e-5 and parsed.seq_len==50000 |
| assert config['model']['name']=='Qwen/Qwen3.5-9B' and config['inference']['vllm']['revision']==MODEL_REVISION |
| assert config['inference']['vllm']['quantization']=='fp8_per_block' |
| assert config['ckpt']=={'interval':5,'keep_interval':5} |
| assert parsed.resume is None and parsed.weight_broadcast.type=='filesystem' |
| sampling=config['orchestrator']['train']['sampling'] |
| assert sampling=={'temperature':0.6,'top_p':0.95,'top_k':20,'max_completion_tokens':8192, |
| 'extra_body':{'min_p':0.0,'chat_template_kwargs':{'enable_thinking':True}}} |
| assert config['orchestrator']['renderer']['enable_thinking'] is True |
| selected=[] |
| for raw, source in zip(config['orchestrator']['train']['source'],parsed.orchestrator.train.source): |
| names=raw['env']['taskset']['tasks'];selected+=names |
| assert source.group_size==8 and raw['ratio']==len(names) |
| assert raw['select']=={'limit':len(names),'shuffle':True,'seed':42} |
| _validate_source(raw,128) |
| assert len(selected)==80 and set(selected)==set(train) |
| shard_names=[] |
| for shard in frozen['evaluation_shards']: |
| count=shard['experiment']['task_count'] |
| assert count in (11,12) and shard['experiment']['purpose']=='final_heldout' |
| assert shard['experiment']['total_attempts']==count*8 and shard['evaluation']['group_size']==8 |
| assert shard['runtime_sha256']==frozen['runtime_sha256'] |
| assert shard['evaluation']['sampling']=={'temperature':0.6,'top_p':0.95,'top_k':20,'min_p':0.0, |
| 'max_tokens':8192,'extra_body':{'chat_template_kwargs':{'enable_thinking':True}}} |
| assert shard['evaluation']['concurrency']==dict(initial_inflight=64,min_inflight=64,max_inflight=64) |
| names=[name for source in shard['evaluation']['source'] for name in source['env']['taskset']['tasks']] |
| assert len(names)==count and set(names)==set(shard['task_manifest']) |
| assert shard['task_manifest']=={name:frozen['task_manifest'][name] for name in names} |
| for source in shard['evaluation']['source']:_validate_source(source,64) |
| EvalConfig.model_validate(deepcopy(shard['evaluation'])) |
| serving=InferenceConfig.model_validate(deepcopy(shard['inference'])) |
| assert serving.router is None and serving.vllm.enable_lora and serving.vllm.max_num_seqs==64 |
| shard_names+=names |
| assert len(shard_names)==23 and set(shard_names)==set(heldout) |
| return parsed |
|
|
|
|
| def _validate_source(source, capacity): |
| assert source['env']['taskset']['repo'].rsplit('@',1)[1] in COMMITS |
| assert source['serve']['max_concurrent']==capacity |
| agent=source['env']['agent'] |
| assert agent['max_turns']==50 |
| assert agent['harness']=={'id':'bash','edit':True,'search':False, |
| 'compaction':{'summarize_at_tokens':30000},'env':{'VF_BASH_LENGTH_RECOVERY':'1'}} |
| assert source['env']['retries']['max_retries']==agent['retries']['max_retries']==source['env']['verifier']['retries']==0 |
|
|
|
|
| def verify_runtime(frozen): |
| import ast |
| import importlib.util |
| import bash_recovery, bash_timeout, compaction_task |
| for name, expected in frozen['runtime_sha256'].items(): |
| assert hashlib.sha256((Path(bash_recovery.__file__).parent/name).read_bytes()).hexdigest()==expected, name |
| result=bash_recovery.verify_runtime(frozen['runtime_sha256']['bash_recovery.py']) |
| core=Path(result['core_path']).read_text() |
| own=Path(bash_timeout.__file__).read_text() |
| def executor(text): |
| a,b=bash_timeout.function_span(text) |
| return ''.join(text.splitlines(keepends=True)[a:b]) |
| assert executor(core)==executor(own) |
| compaction=Path(importlib.util.find_spec('verifiers.v1.harnesses.utils.compaction').origin).read_text() |
| assert compaction_task.patch_source(compaction)==compaction |
| from verifiers.v1.harnesses.utils.launch import CHAT_PROGRAM_SOURCE |
| assert 'original_task = next(' in CHAT_PROGRAM_SOURCE and executor(core).strip() in CHAT_PROGRAM_SOURCE |
| ast.parse(CHAT_PROGRAM_SOURCE) |
| return result |
|
|
|
|
| def audit_evaluation(directory, expected_tasks): |
| """Run the official Prime readers in the same Python environment as native eval.""" |
| import subprocess |
| result=subprocess.run(['/app/.venv/bin/python', '/workspace-smoke/final_training.py', |
| str(directory), json.dumps(sorted(expected_tasks))],capture_output=True,text=True,timeout=600) |
| if result.returncode: |
| raise RuntimeError('Native trace audit failed: '+result.stderr[-8000:]) |
| return json.loads(result.stdout.splitlines()[-1]) |
|
|
|
|
| def _audit_native(directory, expected_tasks): |
| """Cohort assertions only; Prime owns layout, index and compressed record reads.""" |
| import collections |
| from prime_rl.dashboard import server |
| from prime_rl.monitors.file.traces.index import summarize_episode |
| assert hashlib.sha256(Path(server.__file__).read_bytes()).hexdigest() == '51123d837fad119b8fa74fa5592476f561839b40356b4c16545e6d09b6e00d4a' |
| run=Path(directory)/'evaluation' |
| stream=server.require_stream(run) |
| index=server.written_index(run) |
| expected=len(expected_tasks)*8 |
| assert index is not None and len(index)==len({row['id'] for row in index})==expected |
| counts=collections.Counter(); stops=collections.Counter(); ids=set() |
| for row in index: |
| record=server.read_episode_at(stream,row['line'],(row['chunk'],row['offset'])) |
| summary=summarize_episode(row['line'],record) |
| assert record['id']==row['id'] and record['id'] not in ids |
| ids.add(record['id']) |
| for key in ('kind','ok','num_errors','reward','truncated','timeout','stop_condition'): |
| assert summary[key]==row[key], (row['id'],key) |
| assert summary['kind']=='eval' and summary['ok'] and summary['num_errors']==0 |
| assert not summary['timeout'] and summary['reward'] in (0,1) |
| counts[record['task']['data']['name']]+=1 |
| stops[summary['stop_condition']]+=1 |
| assert counts=={name:8 for name in expected_tasks} |
| return {'attempts':expected,'task_counts':dict(counts),'passed':sum(row['reward']==1 for row in index), |
| 'errors':0,'timeouts':0,'truncated':sum(bool(row['truncated']) for row in index), |
| 'stop_conditions':dict(stops),'native_index':str(server.stream_index_file(run)), |
| 'reader':'prime_rl.dashboard.server.read_episode_at','native_python':__import__('sys').executable} |
|
|
|
|
| if __name__ == '__main__': |
| import sys |
| print(json.dumps(_audit_native(sys.argv[1],json.loads(sys.argv[2])))) |
|
|
