Download code/tests/test_core.py from jisue/robottt-pi05-base-comparison: direct link, hf CLI and curl.
- Browser
- Download file 3.89 kB
-
https://huggingface.co/jisue/robottt-pi05-base-comparison/resolve/main/code/tests/test_core.py
- Command line
-
hf download hf://jisue/robottt-pi05-base-comparison/code/tests/test_core.py
-
curl -L -o test_core.py https://huggingface.co/jisue/robottt-pi05-base-comparison/resolve/main/code/tests/test_core.py
3.89 kB
| import copy,unittest | |
| import torch | |
| from robottt_pi05.core import TTTLayer,TTTConfig | |
| from robottt_pi05.layer_state import initial,reset,detach_all,clone,validate,parameter_storage_unique | |
| torch.set_num_threads(2) | |
| class CoreTests(unittest.TestCase): | |
| def setUp(self):torch.manual_seed(13) | |
| def test_lr_derivative_and_shared_forward(self): | |
| layer=TTTLayer(TTTConfig(dim=4,memory_dim=3,hidden_dim=6,base_lr=1e-4)).double() | |
| x=torch.randn(1,3,4,dtype=torch.float64) | |
| def objective(): | |
| state=layer.initial_state(1) | |
| y,state=layer.step(x,state) | |
| y,state=layer.step(x+.2*y,state) | |
| return y.square().mean(),y,state | |
| loss,y,state=objective();g=torch.autograd.grad(loss,layer.raw_lr)[0] | |
| original=layer.raw_lr.detach().clone();h=.001 | |
| with torch.no_grad():layer.raw_lr.copy_(original+h) | |
| plus=objective()[0].detach() | |
| with torch.no_grad():layer.raw_lr.copy_(original-h) | |
| minus=objective()[0].detach() | |
| with torch.no_grad():layer.raw_lr.copy_(original) | |
| fd=(plus-minus)/(2*h) | |
| torch.testing.assert_close(g,fd,atol=5e-11,rtol=2e-5) | |
| loss=objective()[0];params=[p for n,p in layer.named_parameters() if n!='raw_lr'];gs=torch.autograd.grad(loss,params) | |
| layer.raw_lr.requires_grad_(False);other,yp,st=objective();gf=torch.autograd.grad(other,params) | |
| self.assertTrue(torch.equal(y,yp));self.assertEqual(st.updates.tolist(),[2]) | |
| for a,b in zip(state.weights,st.weights):self.assertTrue(torch.equal(a,b)) | |
| for a,b in zip(gs,gf):self.assertTrue(torch.equal(a,b)) | |
| with torch.no_grad():out,infer=layer.step(x,layer.initial_state(1),differentiable=False) | |
| self.assertEqual(infer.updates.tolist(),[1]);self.assertFalse(out.requires_grad) | |
| def test_storage_episode_reset_detach(self): | |
| modules=torch.nn.ModuleDict({str(i):TTTLayer(TTTConfig()).double() for i in [0,1]}) | |
| self.assertTrue(parameter_storage_unique(modules));state=initial(modules,2);saved=clone(state,detach=True) | |
| copied=clone(state);copied['0'].weights[0][0].add_(1) | |
| self.assertTrue(torch.equal(state['0'].weights[0],saved['0'].weights[0])) | |
| self.assertTrue(torch.equal(copied['0'].weights[0][1],saved['0'].weights[0][1])) | |
| self.assertTrue(torch.equal(copied['1'].weights[0],saved['1'].weights[0])) | |
| detached=detach_all(modules,copied) | |
| self.assertFalse(any(w.requires_grad for s in detached.values() for w in s.weights)) | |
| partial=reset(modules,detached,torch.tensor([True,False]),selected=['0']) | |
| self.assertTrue(torch.equal(partial['0'].weights[0][0],state['0'].weights[0][0])) | |
| self.assertTrue(torch.equal(partial['1'].weights[0],detached['1'].weights[0])) | |
| self.assertIs(reset(modules,detached,torch.tensor([False,False])),detached) | |
| with self.assertRaises(ValueError):validate(modules,{'0':state['0']}) | |
| alias=dict(state);alias['1']=state['0'] | |
| with self.assertRaises(ValueError):validate(modules,alias) | |
| def test_inner_local_partial_not_total(self): | |
| # Independent analytical fast-weight derivative with K depending on incoming U. | |
| layer=TTTLayer(TTTConfig(dim=2,memory_dim=2,hidden_dim=2,base_lr=1e-4)).double() | |
| state=layer.initial_state(1) | |
| x=state.weights[0].sum().reshape(1,1,1).expand(1,2,2) | |
| trace={};_,candidate=layer.step(x,state,inner_trace=trace) | |
| local=tuple(w.detach().clone().requires_grad_() for w in state.weights) | |
| binding=(layer.fast(layer.k(x).detach(),local)-layer.v(x).detach()).square().mean() | |
| reference=torch.autograd.grad(binding,local) | |
| for a,b in zip(trace['grads'],reference):torch.testing.assert_close(a,b,atol=1e-14,rtol=1e-12) | |
| self.assertTrue(any(w.grad_fn is not None for w in candidate.weights)) | |
| if __name__=='__main__':unittest.main() | |