import copy,json,tempfile,unittest from pathlib import Path import torch from robottt_pi05.config import ExperimentConfig,ADAMW_SETTINGS from robottt_pi05.modeling import extension,configure_trainables from robottt_pi05.smoke_optimizer import build_optimizer from robottt_pi05.checkpoint import save_boundary,restore_boundary,load_weights,digest,capture_rng,resume_step from robottt_pi05.training_io import RunLedger,finish_output from robottt_pi05.eval_io import atomic_tensor,atomic_json,completed_output,sha class ConfigStorageTests(unittest.TestCase): def test_modes_and_mapping(self): for cfg,count,objects in [(ExperimentConfig(active_layers=(17,)),152672,10),(ExperimentConfig(),561536,37),(ExperimentConfig(learn_inner_lr=True),561540,41),(ExperimentConfig(active_layers=tuple(range(18))),2469568,163),(ExperimentConfig(active_layers=tuple(range(18)),learn_inner_lr=True),2469586,181)]: module=extension(cfg);names,params=configure_trainables(module,cfg) self.assertEqual((sum(p.numel() for p in params),len(params)),(count,objects)) self.assertEqual(sum(n.endswith('.raw_lr') for n in names),len(cfg.active_layers) if cfg.learn_inner_lr else 0) for kw in [dict(active_layers=(17,4)),dict(segment_length=8),dict(full_policy_training=True),dict(learn_inner_lr=True,segment_length=16),dict(state_policy='none')]: with self.assertRaises((ValueError,NotImplementedError)):ExperimentConfig(**kw) def test_checkpoint_actual_optimizer_roundtrip(self): cfg=ExperimentConfig(learn_inner_lr=True);module=extension(cfg);names,params=configure_trainables(module,cfg) optimizer=build_optimizer(params,ADAMW_SETTINGS) # CPU synthetic optimizer unit test. No VLA, policy forward or research input. sum(p.square().sum() for p in params).backward();optimizer.step();optimizer.zero_grad(set_to_none=True) expected=copy.deepcopy(module.state_dict());moments=digest(optimizer.state_dict());rng=capture_rng() with tempfile.TemporaryDirectory() as tmp: path,data=save_boundary(tmp,step=1,slow=module,optimizer=optimizer,config=cfg,provenance={'fixture':'synthetic'},attempted={'optimizer_update':1},completed={'optimizer_update':1}) with torch.no_grad(): for p in params:p.add_(1) torch.rand(3) restored=restore_boundary(path,slow=module,optimizer=optimizer,config=cfg,provenance={'fixture':'synthetic'}) self.assertEqual(restored['next_schedule_index'],1);self.assertEqual(digest(optimizer.state_dict()),moments);self.assertEqual(digest(capture_rng()),digest(rng)) for name,value in module.state_dict().items():self.assertTrue(torch.equal(value,expected[name])) raw=[x.raw_lr.clone() for x in module.ttt.values()] configure_trainables(module,cfg,inference=True);module.eval();module.train();configure_trainables(module,cfg) for a,b in zip(raw,module.ttt.values()):self.assertTrue(torch.equal(a,b.raw_lr)) bad=copy.deepcopy(data);del bad['slow']['ttt.4.raw_lr'];bp=Path(tmp)/'bad.pt';atomic_tensor(bp,bad) with self.assertRaises(ValueError):load_weights(bp,module,cfg,expected_sha256=sha(bp)) bad=copy.deepcopy(data);bad['active_layers']=[17];bp=Path(tmp)/'bad2.pt';atomic_tensor(bp,bad) with self.assertRaises(ValueError):load_weights(bp,module,cfg,expected_sha256=sha(bp)) def test_durable_profile_failure_and_no_duplicate(self): with tempfile.TemporaryDirectory() as tmp: d=Path(tmp);ledger=RunLedger(d,{'optimizer_update':2,'case':1});path=d/'case.pt' ledger.reserve('case','once');atomic_tensor(path,{'key':'once','synthetic':True});ledger.complete('case','once') with self.assertRaises(ValueError):finish_output(ledger=ledger,key='once',path=path,profile={'scope':'collision'}) reopened=RunLedger(d,ledger.limits) self.assertTrue(completed_output(reopened,'once',path));self.assertEqual(reopened.attempted['case'],1) with self.assertRaises(ValueError):reopened.profile(scope='x',values={'x':float('nan')}) with self.assertRaises(ValueError):reopened.event('x',epoch=1) partial=d/'unfinished.pt.partial.1';partial.write_bytes(b'not a completed tensor') self.assertFalse(completed_output(reopened,'unfinished',partial)) reopened.reserve('optimizer_update','1') with self.assertRaises(RuntimeError):resume_step(d/'checkpoints',reopened) self.assertEqual(reopened.attempted['optimizer_update'],1) if __name__=='__main__':unittest.main()