Download code/tests/test_runner.py from jisue/robottt-pi05-base-comparison: direct link, hf CLI and curl.
- Browser
- Download file 6.39 kB
-
https://huggingface.co/jisue/robottt-pi05-base-comparison/resolve/main/code/tests/test_runner.py
- Command line
-
hf download hf://jisue/robottt-pi05-base-comparison/code/tests/test_runner.py
-
curl -L -o test_runner.py https://huggingface.co/jisue/robottt-pi05-base-comparison/resolve/main/code/tests/test_runner.py
6.39 kB
| """CPU synthetic end-to-end orchestration, explicitly not a VLA optimizer smoke.""" | |
| import json,tempfile,unittest | |
| from contextlib import ExitStack | |
| from pathlib import Path | |
| from unittest.mock import patch | |
| import torch | |
| from robottt_pi05 import runner | |
| from robottt_pi05.config import ExperimentConfig | |
| from robottt_pi05.modeling import extension | |
| from robottt_pi05.checkpoint import capture_rng | |
| from robottt_pi05.eval_io import atomic_tensor,sha | |
| class CPUModel(torch.nn.Module): | |
| def __init__(self):super().__init__();self.frozen=torch.nn.Parameter(torch.tensor(1.),requires_grad=False) | |
| def denoise_step(self,state,pm,cache,x,time):return x*.25 | |
| class EmptyAdapter: | |
| def __init__(self,slow):self.ttt=slow.ttt;self.registers=slow.registers;self.history=[];self.call_contracts=[] | |
| class CPURunnerTests(unittest.TestCase): | |
| def test_generation_orchestration_without_targets_and_completed_reuse(self): | |
| with tempfile.TemporaryDirectory() as tmp: | |
| d=Path(tmp);(d/'config.json').write_text(json.dumps(ExperimentConfig().to_dict())) | |
| (d/'assets.json').write_text(json.dumps({'train_ids':[1],'dev_ids':[],'prefixes':{}})) | |
| (d/'plan.json').write_text(json.dumps([{'key':'synthetic_original','episode':1,'noise_id':0,'mode':'persistent','timesteps':list(range(16))}])) | |
| atomic_tensor(d/'bank.pt',{'evaluation_noise':torch.ones(2,1,16,10,32)}) | |
| paths={'output':'eval_output','experiment_config':'config.json','asset_index':'assets.json','bank':'bank.pt','evaluation_plan':'plan.json','openpi_source':'unused','model_checkpoint':'unused','prefix_root':'.'} | |
| r={'paths':paths,'hashes':{k:sha(d/paths[k]) for k in ['bank','evaluation_plan']},'limits':{'model_load':1,'expert':160,'inner':0,'rollout':16},'original':True,'gpu_uuid':'synthetic'} | |
| run=d/'eval.json';run.write_text(json.dumps(r)) | |
| class Prefix: | |
| def __init__(self,*a,**k):pass | |
| def get(self,*a):return (torch.zeros(1,1,1),torch.ones(1,1,dtype=torch.bool),torch.zeros(1,1),torch.zeros(1,32),()) | |
| class Guard: | |
| def __call__(self,*a):pass | |
| with ExitStack() as stack: | |
| for name,value in [('_gpu_preflight',lambda *_:None),('load_model',lambda **_:CPUModel()),('FrozenPrefixStore',Prefix),('SafetyGuard',Guard)]:stack.enter_context(patch.object(runner,name,value)) | |
| stack.enter_context(patch.object(torch.Tensor,'cuda',lambda self,*a,**k:self)) | |
| with patch.object(runner,'ProcessedSequenceSource',side_effect=AssertionError('generation must not load targets')): | |
| result=runner.evaluate(run) | |
| self.assertEqual(result['completed']['expert'],160);self.assertEqual(result['completed']['rollout'],16) | |
| with patch.object(runner,'load_model',side_effect=AssertionError('completed eval must not reload model')): | |
| self.assertEqual(result,runner.evaluate(run)) | |
| self.assertFalse(torch.cuda.is_initialized()) | |
| def test_durable_step_and_completed_skip_without_model_reload(self): | |
| self.assertFalse(torch.cuda.is_initialized()) | |
| with tempfile.TemporaryDirectory() as tmp: | |
| d=Path(tmp);cfg=ExperimentConfig();slow=extension(cfg) | |
| (d/'config.json').write_text(json.dumps(cfg.to_dict())) | |
| (d/'assets.json').write_text(json.dumps({'train_ids':[1],'dev_ids':[],'episodes':{},'prefixes':{}})) | |
| initial=d/'initial.pt';atomic_tensor(initial,{'slow':slow.state_dict(),'rng':capture_rng(),'parameter_names':[],'source_initial':'synthetic','source_step0':'synthetic','source_step0_sha256':'synthetic','not_smoke':True}) | |
| schedule=[{'index':0,'episode':1,'split':'train','start':0,'key':'synthetic','source_rows':list(range(0,160,10))}] | |
| (d/'schedule.json').write_text(json.dumps(schedule));bank=d/'bank.pt' | |
| atomic_tensor(bank,{'training_epsilon':torch.zeros(1,1,16,10,32),'training_time':torch.full((1,1,16,1,1),.5)}) | |
| limits={'model_load':1,'optimizer_update':1,'backward':4,'expert':0,'inner':0,'rollout':0} | |
| paths={'output':'output','experiment_config':'config.json','asset_index':'assets.json','initial_extension':'initial.pt','schedule':'schedule.json','bank':'bank.pt','openpi_source':'unused','model_checkpoint':'unused','data_root':'.','prefix_root':'.'} | |
| r={'paths':paths,'hashes':{k:sha(d/paths[k]) for k in ['initial_extension','schedule','bank']},'limits':limits,'updates':1,'gpu_uuid':'synthetic','milestones':[1]} | |
| run=d/'run.json';run.write_text(json.dumps(r)) | |
| class Prefix: | |
| def __init__(self,*args,**kwargs):pass | |
| def sequence(self,*args):return [] | |
| class Data: | |
| def __init__(self,*args,**kwargs):pass | |
| def targets(self,*args):return torch.zeros(1,16,10,32) | |
| class Guard: | |
| def __call__(self,*args):pass | |
| def learning_rates(self,*args):pass | |
| def synthetic_train(adapter,config,prepared,a,e,t,*,backward): | |
| # Four shared-parameter synthetic segments exercise actual accumulation/save. | |
| loss=0. | |
| for _ in range(4): | |
| v=sum(p.square().sum() for p in slow.parameters() if p.requires_grad)/4 | |
| loss+=float(v.detach());backward(v) | |
| return {'loss':loss} | |
| with ExitStack() as stack: | |
| for name,value in [('_gpu_preflight',lambda *_:None),('load_model',lambda **_:CPUModel()),('create_adapter',lambda *a,**k:(EmptyAdapter(slow),slow)),('FrozenPrefixStore',Prefix),('ProcessedSequenceSource',Data),('SafetyGuard',Guard),('train_sequence',synthetic_train)]:stack.enter_context(patch.object(runner,name,value)) | |
| stack.enter_context(patch.object(torch.Tensor,'cuda',lambda self,*a,**k:self)) | |
| result=runner.train(run) | |
| self.assertEqual(result['completed']['optimizer_update'],1);self.assertEqual(result['completed']['backward'],4) | |
| with patch.object(runner,'load_model',side_effect=AssertionError('must not reload completed run')): | |
| reused=runner.train(run);self.assertEqual(result,reused) | |
| self.assertFalse(torch.cuda.is_initialized()) | |
| if __name__=='__main__':unittest.main() | |