File size: 3,593 Bytes
add1d5f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 | 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()
|