| """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] |
| DOMAIN=os.environ['M2RL_RETRAIN_DOMAIN'] |
| assert DOMAIN in ('math','code') |
| CONFIG=BASE/'configs/math-sp-freqinit-v1.json' |
| assert DOMAIN == 'math', 'Only Math FREQINIT is authorized' |
|
|
| 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(): |
| from retrain_balanced_train_v1 import config as baseline_config |
| cfg=read(CONFIG);baseline=baseline_config() |
| if sha256(cfg['source_config'])!=cfg['source_config_sha256'] or cfg['source_config_sha256']!='faceebfad55bbdac11b5477a7154c0c83fc462d5e41982c2498c913a3cb03261': |
| raise ValueError('Frozen baseline config changed') |
| if sha256(cfg['experiment_authorization'])!=cfg['experiment_authorization_sha256']: |
| raise ValueError('Direct user authorization changed') |
| allowed={'schema','learning_rate','prompt_initialization','evaluation_updates','output','local_backup','source_config','source_config_sha256','experiment_authorization','experiment_authorization_sha256'} |
| for key in set(cfg)|set(baseline): |
| if key not in allowed and cfg.get(key)!=baseline.get(key): |
| raise ValueError('Unrequested configuration change: '+key) |
| if cfg['learning_rate']!=0.01 or cfg['evaluation_updates']!=[120,140,160,180,200]: |
| raise ValueError('User-approved LR or evaluation grid changed') |
| if cfg['output']!='/data/users/zhenzhang/projects/m2rl-issue18-execution/math-freqinit-v1/train-math' or cfg['local_backup']!='/data/users/zhenzhang/projects/m2rl-issue18-execution/local-backups/math-freqinit-v1/math': |
| raise ValueError('Refuse writes outside the isolated new run') |
| return cfg |
|
|
| def initialize_frequency_prompt(student,tokenizer,cfg): |
| import torch |
| spec=cfg['prompt_initialization'] |
| assert spec['method']=='training_token_frequency' and cfg['prompt_length']==256 |
| assert sha256(spec['manifest'])==spec['manifest_sha256'] |
| manifest=read(spec['manifest']) |
| assert sha256(Path(cfg['model_path'])/'tokenizer.json')==manifest['tokenizer_sha256'] |
| ids=manifest['token_ids'] |
| assert len(ids)==len(set(ids))==256 |
| assert not(set(ids)&set(tokenizer.all_special_ids)) |
| assert manifest['ordering']=='frequency descending, token ID ascending for ties' |
| assert manifest['packed_manifest_sha256']==sha256(Path(cfg['packed_data'])/'manifest.json') |
| weight=student.get_input_embeddings().weight |
| prompt=weight.detach().index_select(0,torch.tensor(ids,device=weight.device)).float().clone() |
| receipt=read(BASE/'reports/math-freqinit-v1/INITIAL-TENSOR.json') |
| assert list(prompt.shape)==receipt['shape'] |
| assert hashlib.sha256(prompt.cpu().contiguous().numpy().tobytes()).hexdigest()==receipt['fp32_bytes_sha256'] |
| return prompt |
|
|
| 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 validate_data(cfg): |
| directory=Path(cfg['packed_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-freqinit-gpu-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') |
| preflight=read(BASE/'reports/math-freqinit-v1/PREFLIGHT.json') |
| if preflight['status']!='PASS' or preflight['configs'][DOMAIN]!=sha256(CONFIG): |
| raise ValueError('CPU preflight is not current') |
| import numpy as np |
| import torch |
| import torch.distributed as dist |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
| from types import SimpleNamespace |
| from soft_prompt_distillation.training import SoftPromptModel,TrainingBatch,batch_indices_for_update,accumulate_response_loss,finish_prompt_update,initialize_prompt_embeddings |
| 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) |
| tokenizer=AutoTokenizer.from_pretrained(cfg['model_path'],local_files_only=True) |
| prompt=initialize_frequency_prompt(student,tokenizer,cfg) |
| wrapper=SoftPromptModel(student,prompt,activation_checkpointing=True,cross_entropy_backend='liger_fused',loss_normalization='sequence') |
| 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] |
| expected_tokens=sum(entries[i]['supervised_tokens'] for i in global_indices) |
| denominator=len(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=len(local_indices),learning_rate=cfg['learning_rate'],max_grad_norm=cfg['max_grad_norm']) |
| if result.response_tokens!=expected_tokens: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,loss_normalization='sequence',gradient_norm_after_clip=float(torch.linalg.vector_norm(wrapper.prompt_parameter.grad)),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-freqinit-gpu-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=['smoke','train']);args=parser.parse_args() |
| train(smoke=args.mode=='smoke') |
|
|
| if __name__=='__main__':main() |
|
|
