Download code/tests/test_sequence.py from jisue/robottt-pi05-base-comparison: direct link, hf CLI and curl.
- Browser
- Download file 3.59 kB
-
https://huggingface.co/jisue/robottt-pi05-base-comparison/resolve/main/code/tests/test_sequence.py
- Command line
-
hf download hf://jisue/robottt-pi05-base-comparison/code/tests/test_sequence.py
-
curl -L -o test_sequence.py https://huggingface.co/jisue/robottt-pi05-base-comparison/resolve/main/code/tests/test_sequence.py
3.59 kB
| import inspect,unittest | |
| import torch | |
| from robottt_pi05.core import FastState | |
| from robottt_pi05.sequence_trainer import SequenceTrainer,full_masks,bridge,sequential_generate | |
| from robottt_pi05.engine import generate_chunk | |
| class TinyRecurrent: | |
| GPU_full_valid_only=False | |
| def __init__(self):self.w=torch.tensor(.2,dtype=torch.float64,requires_grad=True) | |
| def initial_state(self,b=1):return {'0':FastState((self.w.reshape(1,1,1).expand(b,1,1).clone(),),torch.zeros(b,dtype=torch.long))} | |
| def reset_state(self,s,mask): | |
| fresh=self.initial_state(len(mask));return {'0':FastState((torch.where(mask[:,None,None],fresh['0'].weights[0],s['0'].weights[0]),),torch.where(mask,0,s['0'].updates))} | |
| def detach_state(self,s):return {k:FastState(tuple(x.detach().clone() for x in v.weights),v.updates.clone()) for k,v in s.items()} | |
| def velocity(self,prepared,x,time,state,**kwargs): | |
| w=state['0'].weights[0];next_w=w*.8+x.mean((1,2))[:,None,None]*self.w | |
| return x*.5+next_w,{'0':FastState((next_w,),state['0'].updates+1)} | |
| class SequenceTests(unittest.TestCase): | |
| def test_global_denominator_short_segment(self): | |
| a=torch.arange(20,dtype=torch.float64).reshape(1,5,2,2)/20 | |
| eps=a.flip(1);s=torch.linspace(.1,.9,5,dtype=torch.float64).reshape(1,5,1,1) | |
| m=full_masks(1,5,2);m.supervision[:,1]=False | |
| m.observation[:,-1]=False;m.action_slot[:,-1]=False | |
| outputs=[] | |
| for segment in [None,5,2]: | |
| ad=TinyRecurrent();out=SequenceTrainer(ad).run([None]*5,a,eps,s,m,segment_length=segment,backward=lambda x:x.backward()) | |
| outputs.append((out,ad.w.grad.clone())) | |
| _,u=bridge(a,eps,s,m);valid=m.scalar_mask(a.shape) | |
| expected=((out['prediction']-u)[valid].square().sum()/valid.sum()).item() | |
| self.assertAlmostEqual(out['loss'],expected,places=14) | |
| self.assertEqual(out['state']['0']['updates'].tolist(),[4]) | |
| for out,_ in outputs[1:]: | |
| self.assertTrue(torch.equal(out['prediction'],outputs[0][0]['prediction'])) | |
| self.assertTrue(torch.equal(out['state']['0']['weights'][0],outputs[0][0]['state']['0']['weights'][0])) | |
| self.assertTrue(torch.equal(outputs[0][1],outputs[1][1])) | |
| self.assertFalse(torch.equal(outputs[0][1],outputs[2][1])) | |
| def test_late_loss_boundary_and_W0_no_bypass(self): | |
| for S,linked in [(4,False),(16,True)]: | |
| ad=TinyRecurrent();probe=torch.tensor(.3,dtype=torch.float64,requires_grad=True) | |
| state=ad.initial_state();last=None | |
| for t in range(16): | |
| if t and t%S==0:state=ad.detach_state(state) | |
| x=probe.expand(1,2,2) if t==0 else torch.ones(1,2,2,dtype=torch.float64) | |
| last,state=ad.velocity(None,x,None,state) | |
| grad=torch.autograd.grad(last.sum(),probe,allow_unused=True)[0] | |
| self.assertEqual(grad is not None,linked) | |
| if linked:self.assertGreater(abs(float(grad)),0) | |
| def test_masks_and_target_free_API(self): | |
| self.assertNotIn('target',inspect.signature(generate_chunk).parameters) | |
| self.assertNotIn('actions',inspect.signature(sequential_generate).parameters) | |
| a=torch.ones(1,4,2,2,dtype=torch.float64);eps=torch.zeros_like(a) | |
| s=torch.tensor([.1,.2,.3,.4],dtype=torch.float64).reshape(1,4,1,1) | |
| x,u=bridge(a,eps,s,full_masks(1,4,2));self.assertTrue(torch.equal(u,-a));torch.testing.assert_close(x,1-s.expand_as(a)) | |
| with self.assertRaises(ValueError):bridge(a,eps,s[:,:1],full_masks(1,4,2)) | |
| if __name__=='__main__':unittest.main() | |