Download code/tests/test_config_storage.py from jisue/robottt-pi05-base-comparison: direct link, hf CLI and curl.
- Browser
- Download file 4.68 kB
-
https://huggingface.co/jisue/robottt-pi05-base-comparison/resolve/main/code/tests/test_config_storage.py
- Command line
-
hf download hf://jisue/robottt-pi05-base-comparison/code/tests/test_config_storage.py
-
curl -L -o test_config_storage.py https://huggingface.co/jisue/robottt-pi05-base-comparison/resolve/main/code/tests/test_config_storage.py
4.68 kB
| 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() | |