jisue's picture
Experiment backup 2026-11-10T06:11:22.386926+00:00
add1d5f verified
Raw History Blame Contribute Delete
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()