| """Math-only SP admission, exact-token packing and replicated prompt-only training.""" |
| import argparse |
| import array |
| from dataclasses import asdict |
| import datetime |
| import fcntl |
| import hashlib |
| import importlib.metadata |
| import json |
| import os |
| from pathlib import Path |
| import random |
| import shutil |
| import signal |
| import sys |
| import time |
|
|
| from runtime import atomic_json, require_allocation, sha256 |
|
|
| BASE=Path(__file__).resolve().parents[1] |
| REPO=BASE.parents[1] |
| CONFIG=BASE/'configs/math-sp-training-v1.json' |
|
|
| def read(path): return json.loads(Path(path).read_text()) |
| def digest(value): return hashlib.sha256(json.dumps(value,sort_keys=True,separators=(',',':')).encode()).hexdigest() |
| def config(): |
| cfg=read(CONFIG) |
| for key in ('data_manifest','scientific_contract','student_readiness'): |
| if sha256(cfg[key])!=cfg[key+'_sha256']: raise ValueError(key+' changed') |
| auth=cfg['authorization'] |
| if not auth['data_manifest_accepted'] or sha256(auth['delivery_path'])!=auth['delivery_sha256']: |
| raise ValueError('Math data authorization binding changed') |
| contract=read(cfg['scientific_contract'])['our_experiment'] |
| for key,old in [('prompt_length','sp_length_each'),('updates','updates'),('effective_batch','effective_batch'),('checkpoint_every','checkpoint_every'),('learning_rate','learning_rate'),('seed','seed')]: |
| if cfg[key]!=contract[old]: raise ValueError('scientific training contract changed: '+key) |
| if cfg['model_path']!=read(cfg['student_readiness'])['model']['path']:raise ValueError('student path differs from pinned readiness') |
| return cfg |
|
|
| def system_scaffold(tokenizer): |
| header=tokenizer.encode('<|im_start|>system\n',add_special_tokens=False) |
| close=tokenizer.encode('<|im_end|>\n',add_special_tokens=False) |
| example=[{'role':'user','content':'scaffold-check'}] |
| kw=dict(tokenize=True,add_generation_prompt=True,enable_thinking=True) |
| original=tokenizer.apply_chat_template(example,**kw) |
| empty=tokenizer.apply_chat_template([{'role':'system','content':''},*example],**kw) |
| if empty!=header+close+original: raise ValueError('empty system scaffold does not match pinned chat template') |
| return header,close |
|
|
| def add_system(input_ids,prefix_tokens,header,close): |
| ids=list(input_ids) |
| if ids[:len(header)]==header: return ids,prefix_tokens,len(header),False |
| |
| if ids[:3]!=[151644,872,198]: raise ValueError('expected original user or system role header') |
| return header+close+ids,prefix_tokens+len(header)+len(close),len(header),True |
|
|
| def prepare(): |
| allocation=require_allocation(); cfg=config() |
| from transformers import AutoTokenizer |
| tokenizer=AutoTokenizer.from_pretrained(cfg['model_path'],local_files_only=True) |
| header,close=system_scaffold(tokenizer) |
| manifest=read(cfg['data_manifest']); directory=Path(cfg['output'])/'data';directory.mkdir(parents=True,exist_ok=True) |
| with (directory/'.prepare.lock').open('w') as lock: |
| fcntl.flock(lock,fcntl.LOCK_EX|fcntl.LOCK_NB) |
| if (directory/'manifest.json').exists(): |
| validate_data(cfg); return read(directory/'manifest.json') |
| entries=[]; position=0; seen=set(); counts={'existing_system':0,'added_empty_system':0} |
| with (directory/'tokens.uint32.tmp').open('wb') as stream: |
| for source in manifest['candidate_files']: |
| if sha256(source['path'])!=source['sha256']:raise ValueError('candidate file changed') |
| count=0 |
| with open(source['path']) as rows: |
| for line in rows: |
| row=json.loads(line); prefix=row['prefix_tokens']; original=row['input_ids'];labels=row['labels'] |
| if row['request_id'] in seen or labels!=[-100]*prefix+original[prefix:]:raise ValueError('candidate identity/mask mismatch') |
| if not original[prefix:] or row['supervised_tokens']!=len(original)-prefix or original[-1] not in (151645,151643):raise ValueError('incomplete or empty candidate supervision') |
| seen.add(row['request_id']) |
| ids,prefix,insert,added=add_system(original,prefix,header,close) |
| if len(ids)+256>65534:raise ValueError('whole training sequence exceeds context') |
| counts['added_empty_system' if added else 'existing_system']+=1 |
| values=array.array('I',ids) |
| if sys.byteorder!='little':values.byteswap() |
| stream.write(values.tobytes()) |
| entries.append(dict(request_id=row['request_id'],question_id=row['question_id'],sample_index=row['sample_index'],offset=position,length=len(ids),prefix_tokens=prefix,supervised_tokens=len(ids)-prefix,insert_at=insert,source_response_sha256=row['response_sha256'])) |
| position+=len(ids);count+=1 |
| if count!=source['count']:raise ValueError('candidate count changed') |
| stream.flush();os.fsync(stream.fileno()) |
| if len(entries)!=10499 or len(entries)!=manifest['candidate_answers']:raise ValueError('unexpected Math data count') |
| (directory/'tokens.uint32.tmp').replace(directory/'tokens.uint32') |
| atomic_json(directory/'index.json',entries) |
| result=dict(schema='m2rl-math-sp-packed-data-v1',status='PASS_EXACT_SOURCE_TOKENS_RESPONSE_MASKS_AND_SYSTEM_PLACEMENT',allocation=allocation,config_sha256=sha256(CONFIG),source_manifest_sha256=sha256(cfg['data_manifest']),records=len(entries),tokens=position,max_length=max(e['length']+256 for e in entries),system_header_ids=header,system_close_ids=close,system_counts=counts,tokens_sha256=sha256(directory/'tokens.uint32'),index_sha256=sha256(directory/'index.json'),source_files=manifest['candidate_files'],producer_sha256=sha256(__file__)) |
| atomic_json(directory/'manifest.json',result) |
| backup=Path(cfg['local_backup'])/'data';backup.mkdir(parents=True,exist_ok=True) |
| files={} |
| for name in ('tokens.uint32','index.json','manifest.json'): |
| shutil.copy2(directory/name,backup/name) |
| if sha256(directory/name)!=sha256(backup/name):raise ValueError('packed data backup mismatch') |
| files[name]=sha256(backup/name) |
| atomic_json(backup/'receipt.json',dict(status='PASS_LOCAL_DATA_COPY_RESTORED_SHA256',files=files)) |
| atomic_json(BASE/'evidence/math-sp-training-admission-v1.json',dict(status='MATH_DATA_ACCEPTED_TRAINING_AUTHORIZED_GPU_SMOKE_PENDING',authorization=cfg['authorization'],allocation=allocation,config_path=str(CONFIG),config_sha256=sha256(CONFIG),packed_data_path=str(directory/'manifest.json'),packed_data_sha256=sha256(directory/'manifest.json'),candidate_answers=len(entries),baseline_scores_preserved=True,initialization=cfg['prompt_initialization'],system_insertion=cfg['system_insertion'])) |
| print(json.dumps(result),flush=True);return result |
|
|
| def validate_data(cfg): |
| directory=Path(cfg['output'])/'data';manifest=read(directory/'manifest.json') |
| if manifest['source_manifest_sha256']!=cfg['data_manifest_sha256']:raise ValueError('packed dataset identity changed') |
| for name,key in [('tokens.uint32','tokens_sha256'),('index.json','index_sha256')]: |
| if sha256(directory/name)!=manifest[key]:raise ValueError('packed data changed '+name) |
| return directory,manifest |
|
|
| def balanced_ranks(indices,entries,world): |
| groups=[[] for _ in range(world)];loads=[0]*world;cap=len(indices)//world |
| if len(indices)%world:raise ValueError('global batch must divide DP size') |
| for index in sorted(indices,key=lambda i:(-entries[i]['length'],i)): |
| rank=min((r for r in range(world) if len(groups[r])<cap),key=lambda r:(loads[r],r)) |
| groups[rank].append(index);loads[rank]+=entries[index]['length'] |
| return groups |
|
|
| def code_identity(): |
| files=[Path(__file__),BASE/'scripts/runtime.py',REPO/'src/soft_prompt_distillation/training.py',REPO/'src/soft_prompt_distillation/m2rl_training.py',REPO/'src/soft_prompt_distillation/objective.py'] |
| return {str(p.relative_to(REPO)):sha256(p) for p in files} |
|
|
| def checkpoint_copy(cfg,path): |
| target=Path(cfg['local_backup'])/'checkpoints'/path.name |
| if target.exists(): |
| if sha256(target/'state.pt')!=sha256(path/'state.pt'):raise ValueError('backup identity conflict') |
| else: |
| temporary=target.with_name('.'+target.name+'.tmp');temporary.parent.mkdir(parents=True,exist_ok=True) |
| shutil.copytree(path,temporary) |
| for name in ('state.pt','commit.json'): |
| if sha256(temporary/name)!=sha256(path/name):raise ValueError('checkpoint backup verification failed') |
| temporary.rename(target) |
| atomic_json(path/'backup-receipt.json',dict(status='PASS_LOCAL_COMPLETE_STATE_COPY_SHA256',path=str(target),state_sha256=sha256(target/'state.pt'),commit_sha256=sha256(target/'commit.json'))) |
|
|
| def train(smoke=False): |
| allocation=require_allocation();cfg=config() |
| if not smoke: |
| training_proof=read(BASE/'evidence/math-sp-gpu-training-smoke-v1.json') |
| evaluation_proof=read(BASE/'evidence/math-sp-gpu-evaluation-smoke-v1.json') |
| if training_proof['hashes']['code']!=digest(code_identity()) or training_proof['hashes']['config']!=sha256(CONFIG):raise ValueError('GPU training smoke code/config no longer current') |
| if evaluation_proof['config_sha256']!=sha256(CONFIG) or evaluation_proof['producer_sha256']!=sha256(BASE/'scripts/math_sp_eval_v1.py'):raise ValueError('GPU SP evaluation adapter is not validated') |
| import numpy as np |
| import torch |
| import torch.distributed as dist |
| from transformers import AutoModelForCausalLM |
| from soft_prompt_distillation.training import SoftPromptModel,TrainingBatch,batch_indices_for_update,accumulate_response_loss,finish_prompt_update |
| from soft_prompt_distillation.m2rl_training import make_m2rl_optimizer,capture_rank_state,gather_rank_states,save_checkpoint,restore_checkpoint |
| local_rank=int(os.environ['LOCAL_RANK']);rank=int(os.environ['RANK']);world=int(os.environ['WORLD_SIZE']) |
| if world!=cfg['training_dp']:raise ValueError('training topology must be DP4 TP1') |
| torch.cuda.set_device(local_rank);device=torch.device('cuda',local_rank) |
| dist.init_process_group('nccl',device_id=device,timeout=datetime.timedelta(minutes=45)) |
| directory,manifest=validate_data(cfg);entries=read(directory/'index.json');tokens=np.memmap(directory/'tokens.uint32',dtype='<u4',mode='r') |
| run=Path(cfg['output'])/('smoke' if smoke else 'production');run.mkdir(parents=True,exist_ok=True) |
| lock=None |
| if rank==0: |
| lock=(run/'.trainer.lock').open('w');fcntl.flock(lock,fcntl.LOCK_EX|fcntl.LOCK_NB) |
| seed=cfg['seed'];random.seed(seed);np.random.seed(seed);torch.manual_seed(seed);torch.cuda.manual_seed_all(seed) |
| student=AutoModelForCausalLM.from_pretrained(cfg['model_path'],local_files_only=True,torch_dtype=torch.bfloat16,attn_implementation=cfg['attention_implementation']).to(device) |
| generator=torch.Generator(device=device).manual_seed(seed) |
| prompt=torch.randn((256,student.config.hidden_size),dtype=torch.float32,device=device,generator=generator)*cfg['prompt_initialization']['std'] |
| wrapper=SoftPromptModel(student,prompt,activation_checkpointing=True,cross_entropy_backend='liger_fused',loss_normalization='token') |
| optimizer=make_m2rl_optimizer(wrapper.prompt_parameter) |
| identities=dict(code=digest(code_identity()),config=sha256(CONFIG),data=sha256(directory/'manifest.json'),topology=digest(dict(dp=world,tp=1,micro_batch=1,gradient_reduction='sum'))) |
| versions={p:importlib.metadata.version(p) for p in ('torch','transformers','liger-kernel')} |
| start=1 |
| committed=sorted((run/'checkpoints').glob('update-*')) if (run/'checkpoints').exists() else [] |
| if committed: |
| restored=restore_checkpoint(committed[-1],prompt=wrapper.prompt_parameter,optimizer=optimizer,hashes=identities,rank=rank,world_size=world) |
| start=restored['update']+1 |
| if rank==0: |
| atomic_json(run/'run.json',dict(status='GPU_SMOKE_RUNNING' if smoke else 'TRAINING',allocation=allocation,started_at=time.time(),start_update=start,hashes=identities,code=code_identity(),versions=versions,world_size=world,trainable_parameters=wrapper.prompt_parameter.numel(),backbone_trainable=0,config=cfg)) |
| |
| |
| updates=1 if smoke else cfg['updates'] |
| began=time.monotonic();stop=[False] |
| signal.signal(signal.SIGTERM,lambda *_:stop.__setitem__(0,True)) |
| signal.signal(signal.SIGINT,lambda *_:stop.__setitem__(0,True)) |
| for update in range(start,updates+1): |
| global_indices=batch_indices_for_update(dataset_size=len(entries),effective_batch_size=64,batch_seed=seed,update=update) |
| if smoke: |
| longest=max(range(len(entries)),key=lambda i:entries[i]['length']) |
| if longest not in global_indices:global_indices[0]=longest |
| groups=balanced_ranks(global_indices,entries,world);local_indices=groups[rank] |
| denominator=sum(entries[i]['supervised_tokens'] for i in global_indices) |
| optimizer.zero_grad(set_to_none=True);loss_sum=0.0;response_tokens=0;step_start=time.monotonic() |
| for index in local_indices: |
| entry=entries[index];ids=torch.tensor(np.asarray(tokens[entry['offset']:entry['offset']+entry['length']],dtype=np.int64),device=device).unsqueeze(0) |
| labels=ids.clone();labels[:,:entry['prefix_tokens']]=-100 |
| batch=TrainingBatch(ids,torch.ones_like(ids),labels,torch.tensor([entry['insert_at']],device=device)) |
| from torch.nn.attention import sdpa_kernel,SDPBackend |
| with sdpa_kernel(SDPBackend.FLASH_ATTENTION): |
| value,count=accumulate_response_loss(wrapper,batch,global_loss_denominator=denominator) |
| if count!=entry['supervised_tokens']:raise ValueError('supervised tokens changed during model alignment') |
| loss_sum+=value;response_tokens+=count |
| del ids,labels,batch |
| result=finish_prompt_update(wrapper,optimizer,local_loss_sum=loss_sum,local_response_tokens=response_tokens,local_loss_denominator=response_tokens,learning_rate=cfg['learning_rate'],max_grad_norm=None) |
| if result.response_tokens!=denominator:raise ValueError('global token denominator changed') |
| |
| if wrapper.prompt_parameter.dtype!=torch.float32 or wrapper.prompt_parameter.grad.dtype!=torch.float32:raise ValueError('SP precision changed') |
| if any(p.grad is not None or p.requires_grad for p in student.parameters()):raise ValueError('backbone received gradients') |
| event=dict(update=update,**asdict(result),effective_batch=64,seconds=time.monotonic()-step_start,elapsed_seconds=time.monotonic()-began,global_batch_sha256=digest(global_indices),gpu_max_memory_bytes=torch.cuda.max_memory_allocated(device)) |
| if rank==0: |
| with (run/'metrics.jsonl').open('a') as stream:stream.write(json.dumps(event)+'\n');stream.flush();os.fsync(stream.fileno()) |
| atomic_json(run/'progress.json',dict(status='TRAINING',**event));print(json.dumps(event),flush=True) |
| flag=torch.tensor(int(stop[0]),device=device);dist.all_reduce(flag,op=dist.ReduceOp.MAX) |
| save=smoke or update%20==0 or bool(flag.item()) |
| if save: |
| states=gather_rank_states(capture_rank_state(rank=rank,data_cursor=dict(completed_update=update,next_update=update+1,shuffle_recipe=cfg['shuffle'],dataset_records=len(entries),global_batch_sha256=digest(global_indices),rank_indices=local_indices))) |
| path=run/'checkpoints'/f'update-{update:04d}' |
| if rank==0: |
| receipt=save_checkpoint(path,prompt=wrapper.prompt_parameter,optimizer=optimizer,rank_states=states,update=update,hashes=identities,world_size=world,reason='predeadline' if smoke or update%20 else 'scheduled') |
| checkpoint_copy(cfg if not smoke else dict(cfg,local_backup=cfg['local_backup']+'/smoke'),path) |
| dist.barrier() |
| if smoke: |
| before=wrapper.prompt_parameter.detach().clone();state=optimizer.state_dict() |
| restored=restore_checkpoint(path,prompt=wrapper.prompt_parameter,optimizer=optimizer,hashes=identities,rank=rank,world_size=world) |
| if not torch.equal(before,wrapper.prompt_parameter) or restored['update']!=1:raise ValueError('real GPU full-state checkpoint restore changed prompt') |
| adam=optimizer.state[wrapper.prompt_parameter] |
| if not torch.equal(adam['exp_avg'],state['state'][0]['exp_avg']) or not torch.equal(adam['exp_avg_sq'],state['state'][0]['exp_avg_sq']):raise ValueError('optimizer restore changed moments') |
| if rank==0: |
| atomic_json(BASE/'evidence/math-sp-gpu-training-smoke-v1.json',dict(status='PASS_REAL_DP4_GLOBAL_BATCH64_LONGEST_RECORD_BACKWARD_FP32_ADAM_AND_RESUME',allocation=allocation,hashes=identities,checkpoint=str(path),checkpoint_sha256=sha256(path/'state.pt'),metric=event,longest_sequence_tokens=manifest['max_length'],all_ranks=4,versions=versions)) |
| if flag.item(): |
| if rank==0:atomic_json(run/'terminal.json',dict(status='STOPPED_AT_RECOVERABLE_UPDATE',update=update)) |
| break |
| else: |
| if rank==0:atomic_json(run/'terminal.json',dict(status='SMOKE_COMPLETE' if smoke else 'TRAINING_COMPLETE',update=updates,finished_at=time.time(),config_sha256=sha256(CONFIG),data_sha256=identities['data'])) |
| dist.barrier();dist.destroy_process_group() |
| if lock:lock.close() |
|
|
| def main(): |
| parser=argparse.ArgumentParser();parser.add_argument('mode',choices=['prepare','smoke','train']);args=parser.parse_args() |
| if args.mode=='prepare':prepare() |
| else:train(smoke=args.mode=='smoke') |
|
|
| if __name__=='__main__':main() |
|
|
