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()