Datasets:
Modalities:
Text
Formats:
json
Languages:
English
Size:
< 1K
Tags:
reinforcement-learning
policy-optimization
klpo
exact-moment-replay
score-centering
stratified-sampling
License:
File size: 3,109 Bytes
f95cbd4 | 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 60 61 62 63 64 65 66 | import pytest
import torch
from celestis_rl import selected_linear_scores, draw_correction, token_loss, selected_token_loss
@pytest.mark.parametrize("chunk",[1,3,17,30])
@pytest.mark.parametrize("temperature",[.7,1.,2.])
def test_selected_backward_matches_dense(chunk,temperature):
torch.manual_seed(4)
h=torch.randn(4,6,dtype=torch.float64,requires_grad=True)
w=torch.randn(17,6,dtype=torch.float64,requires_grad=True)
bias=torch.randn(17,dtype=torch.float64,requires_grad=True)
q=(torch.randn(2,2,17,dtype=torch.float64)*2).softmax(-1)
mask=torch.ones(2,2,dtype=torch.bool)
actions=torch.tensor([[1,7],[8,9]])
corr=draw_correction(q,mask,5,generator=torch.Generator().manual_seed(8))
ids=torch.cat([actions[...,None],corr.ids],-1).reshape(4,-1)
scores=selected_linear_scores(h,w,ids,bias=bias,chunk_size=chunk,temperature=temperature)
logits=scores.logits.reshape(2,2,-1); lp=scores.log_probs.reshape(2,2,-1)
qlog=q.gather(-1,actions[...,None]).squeeze(-1).log()
reward=torch.tensor([1.,.2],dtype=torch.float64)
loss,_=selected_token_loss(logits[...,0],logits[...,1:],corr,lp[...,0],qlog,reward)
gs=torch.autograd.grad(loss,(h,w,bias))
dense=((h@w.T+bias)/temperature).reshape(2,2,-1)
dl,_=token_loss(dense,actions,q,mask,reward,correction=corr)
gd=torch.autograd.grad(dl,(h,w,bias))
assert torch.allclose(scores.log_probs, dense.detach().reshape(4,17).log_softmax(-1).gather(-1,ids),atol=1e-13,rtol=1e-13)
for a,b in zip(gs,gd):
assert torch.allclose(a,b,atol=2e-13,rtol=2e-13)
def test_tied_input_output_embedding_gradient():
torch.manual_seed(23)
w=torch.randn(11,4,dtype=torch.float64,requires_grad=True)
input_ids=torch.tensor([2,6]); a=torch.tensor([[1],[4]])
q=torch.randn(2,1,11,dtype=torch.float64).softmax(-1)
m=torch.ones(2,1,dtype=torch.bool)
rec=draw_correction(q,m,3,generator=torch.Generator().manual_seed(9))
ids=torch.cat((a[...,None],rec.ids),-1).reshape(2,-1)
reward=torch.tensor([1.,-.1],dtype=torch.float64)
h=w[input_ids]*.4
scores=selected_linear_scores(h,w,ids,chunk_size=3)
z=scores.logits[:,None]; lp=scores.log_probs[:,None]
qlog=q.gather(-1,a[...,None]).squeeze(-1).log()
l,_=selected_token_loss(z[...,0],z[...,1:],rec,lp[...,0],qlog,reward)
g1=torch.autograd.grad(l,w)[0]
dense=(w[input_ids]*.4@w.T)[:,None]
l2,_=token_loss(dense,a,q,m,reward,correction=rec)
g2=torch.autograd.grad(l2,w)[0]
assert torch.allclose(g1,g2,atol=1e-13)
def test_extreme_scores_and_float32_precision():
h=torch.tensor([[100.,-100.]],requires_grad=True)
w=torch.tensor([[100.,100.],[-100.,100.],[100.,-100.]],requires_grad=True)
s=selected_linear_scores(h,w,torch.tensor([[0,2]]),chunk_size=1)
assert torch.isfinite(s.log_probs).all()
assert s.log_probs[0,1] == 0
assert not s.log_probs.requires_grad
@pytest.mark.parametrize("bad", [0,-1,1.5])
def test_bad_chunk_size(bad):
with pytest.raises(ValueError):
selected_linear_scores(torch.ones(1,2),torch.ones(3,2),torch.tensor([[1]]),chunk_size=bad)
|