Datasets:
Modalities:
Text
Formats:
json
Languages:
English
Size:
< 1K
Tags:
reinforcement-learning
policy-optimization
klpo
exact-moment-replay
score-centering
stratified-sampling
License:
| """Recomputed first-order linear-head VJPs for centered policy scores. | |
| Exact mode removes auxiliary sampling noise; sampled mode preserves the | |
| selected estimator. Neither stores an [N,K,D] autograd activation. Both still | |
| need an exact forward softmax normalizer. These are portable PyTorch kernels, | |
| not fused CUDA, and produce dense parameter gradients. Higher-order AD is | |
| intentionally unsupported. q, correction weights, and temperature are fixed. | |
| """ | |
| from dataclasses import dataclass | |
| import math | |
| import torch | |
| from torch import Tensor | |
| from torch.autograd.function import once_differentiable | |
| from .estimators import canonical_q, Correction | |
| from .losses import _prepare, _reduce | |
| class CenteredScores: | |
| centered_logits: Tensor | |
| action_log_probs: Tensor # detached, only for coefficients | |
| def _check(h,w,a,bias,chunk,temperature): | |
| if h.ndim!=2 or w.ndim!=2 or h.shape[1]!=w.shape[1] or min(*h.shape,*w.shape)<1: | |
| raise ValueError('nonempty hidden [N,D] and weight [V,D] required') | |
| if not h.is_floating_point() or not w.is_floating_point(): | |
| raise ValueError('floating point model tensors required') | |
| if a.shape!=(len(h),) or a.dtype!=torch.long: | |
| raise ValueError('actions [N] must be int64') | |
| if h.device!=w.device or a.device!=h.device or ((a<0)|(a>=len(w))).any(): | |
| raise ValueError('invalid actions/devices') | |
| if bias is not None and (bias.shape!=(len(w),) or bias.device!=w.device or not bias.is_floating_point()): | |
| raise ValueError('invalid bias') | |
| if isinstance(chunk,bool) or not isinstance(chunk,int) or chunk<1: | |
| raise ValueError('chunk size must be positive integer') | |
| if not math.isfinite(temperature) or temperature<=0: | |
| raise ValueError('temperature must be positive finite') | |
| if not torch.isfinite(h).all() or not torch.isfinite(w).all() or (bias is not None and not torch.isfinite(bias).all()): | |
| raise ValueError('nonfinite active model tensor') | |
| class _Centered(torch.autograd.Function): | |
| def forward(ctx,h,w,a,bias,q,ids,coeff,chunk,rows,temperature,exact): | |
| dtype=torch.float64 if any(x is not None and x.dtype==torch.float64 for x in (h,w,bias)) else torch.float32 | |
| ctx.dtype=dtype;ctx.chunk=chunk;ctx.rows=rows;ctx.temperature=temperature;ctx.exact=exact | |
| ctx.has_bias=bias is not None | |
| empty=torch.empty(0,device=h.device,dtype=dtype) | |
| qsum=q.sum(-1,keepdim=True,dtype=torch.float64) if exact else empty | |
| ctx.save_for_backward(h,w,a,bias if bias is not None else empty,q,ids,coeff,qsum) | |
| with torch.autocast(device_type=h.device.type,enabled=False): | |
| x=h.to(dtype) | |
| za=(x*w[a].to(dtype)).sum(-1) | |
| if bias is not None:za=za+bias[a].to(dtype) | |
| za=za/temperature | |
| normal=torch.full((len(h),),-torch.inf,device=h.device,dtype=dtype) | |
| expected=torch.zeros_like(normal) | |
| for start in range(0,len(w),chunk): | |
| end=min(start+chunk,len(w)) | |
| z=x@w[start:end].to(dtype).T | |
| if bias is not None:z=z+bias[start:end].to(dtype) | |
| z=z/temperature | |
| normal=torch.logaddexp(normal,torch.logsumexp(z,-1)) | |
| if exact: | |
| qc=(q[:,start:end].double()/qsum).to(dtype) | |
| expected=expected+(qc*z).sum(-1) | |
| if exact: | |
| centered=za-expected | |
| else: | |
| centered=torch.zeros_like(normal) | |
| for start in range(0,len(h),rows): | |
| end=min(start+rows,len(h));ii=ids[start:end] | |
| z=(x[start:end,None,:]*w[ii].to(dtype)).sum(-1) | |
| if bias is not None:z=z+bias[ii].to(dtype) | |
| centered[start:end]=(z*coeff[start:end].to(dtype)).sum(-1)/temperature | |
| lp=za-normal | |
| if not torch.isfinite(centered).all() or not torch.isfinite(lp).all(): | |
| raise FloatingPointError('nonfinite centered linear scores') | |
| ctx.mark_non_differentiable(lp) | |
| return centered,lp | |
| def backward(ctx,gcenter,glogp): | |
| h,w,a,bias,q,ids,coeff,qsum=ctx.saved_tensors | |
| dtype=ctx.dtype;temp=ctx.temperature | |
| if gcenter is None:gcenter=torch.zeros(len(h),device=h.device,dtype=dtype) | |
| with torch.autocast(device_type=h.device.type,enabled=False): | |
| x=h.to(dtype);g=gcenter.to(dtype)/temp | |
| gh=torch.zeros_like(x) if ctx.needs_input_grad[0] else None | |
| gw=torch.zeros(w.shape,device=w.device,dtype=dtype) if ctx.needs_input_grad[1] else None | |
| gb=torch.zeros(len(w),device=w.device,dtype=dtype) if ctx.has_bias and ctx.needs_input_grad[3] else None | |
| if ctx.exact: | |
| for start in range(0,len(w),ctx.chunk): | |
| end=min(start+ctx.chunk,len(w)) | |
| c=-(q[:,start:end].double()/qsum).to(dtype) | |
| active=(a>=start)&(a<end) | |
| rr=active.nonzero().flatten() | |
| c[rr,a[rr]-start]+=1 | |
| c=c*g[:,None] | |
| if gh is not None:gh.add_(c@w[start:end].to(dtype)) | |
| if gw is not None:gw[start:end]=c.T@x | |
| if gb is not None:gb[start:end]=c.sum(0) | |
| else: | |
| for start in range(0,len(h),ctx.rows): | |
| end=min(start+ctx.rows,len(h));ii=ids[start:end] | |
| c=coeff[start:end].to(dtype)*g[start:end,None] | |
| if gh is not None:gh[start:end]=(c[:,:,None]*w[ii].to(dtype)).sum(1) | |
| if gw is not None: | |
| contributions=(c[:,:,None]*x[start:end,None,:]).reshape(-1,w.shape[1]) | |
| gw.index_add_(0,ii.reshape(-1),contributions) | |
| if gb is not None:gb.index_add_(0,ii.reshape(-1),c.reshape(-1)) | |
| return (None if gh is None else gh.to(h.dtype),None if gw is None else gw.to(w.dtype),None, | |
| None if gb is None else gb.to(bias.dtype),None,None,None,None,None,None,None) | |
| def centered_linear_scores(hidden: Tensor,weight: Tensor,actions: Tensor,*,q: Tensor | None=None, | |
| ids: Tensor | None=None,coefficients: Tensor | None=None, | |
| bias: Tensor | None=None,chunk_size: int=4096,row_chunk_size: int=64, | |
| temperature: float=1.) -> CenteredScores: | |
| """Compute z(a)-E_q[z], or sum_j coefficients_j*z(ids_j). | |
| Provide q for exact mode OR ids/coefficients for a sampled zero-sum | |
| measure (typically one action weight +1 and auxiliary weights summing -1). | |
| The action-normalization pass remains exact. No gradient is returned for | |
| the fixed measure, sampler, IDs, temperature, or detached log probabilities. | |
| """ | |
| _check(hidden,weight,actions,bias,chunk_size,temperature) | |
| if isinstance(row_chunk_size,bool) or not isinstance(row_chunk_size,int) or row_chunk_size<1: | |
| raise ValueError('row_chunk_size must be positive integer') | |
| exact=q is not None | |
| empty=torch.empty(0,device=hidden.device) | |
| if exact: | |
| if ids is not None or coefficients is not None:raise ValueError('choose exact OR sampled measure') | |
| if q.shape!=(len(hidden),len(weight)) or q.device!=hidden.device or not q.is_floating_point(): | |
| raise ValueError('q shape/device/type mismatch') | |
| if not torch.isfinite(q).all() or (q<0).any() or not torch.allclose(q.double().sum(-1),torch.ones(len(hidden),device=q.device,dtype=torch.float64),atol=2e-6,rtol=0): | |
| raise ValueError('invalid actual sampler probabilities') | |
| q=q.detach();ids=empty.long();coefficients=empty | |
| else: | |
| if ids is None or coefficients is None or ids.ndim!=2 or ids.shape!=coefficients.shape or ids.shape[0]!=len(hidden) or ids.shape[1]<1: | |
| raise ValueError('selected ids and coefficients [N,K] required') | |
| if ids.dtype!=torch.long or not coefficients.is_floating_point() or ids.device!=hidden.device or coefficients.device!=hidden.device: | |
| raise ValueError('invalid selected measure devices/types') | |
| if ((ids<0)|(ids>=len(weight))).any() or not torch.isfinite(coefficients).all(): | |
| raise ValueError('invalid selected measure') | |
| if (coefficients.double().sum(-1).abs()>2e-6).any(): | |
| raise ValueError('centered measure must have zero total mass') | |
| q=empty;coefficients=coefficients.detach() | |
| c,lp=_Centered.apply(hidden,weight,actions,bias,q,ids,coefficients,chunk_size,row_chunk_size,float(temperature),exact) | |
| return CenteredScores(c,lp) | |
| def linear_token_loss(hidden: Tensor,weight: Tensor,actions: Tensor,q: Tensor,mask: Tensor, | |
| returns: Tensor,*,correction: Correction | None=None,bias: Tensor | None=None, | |
| beta: float=.1,baseline: Tensor | None=None,outer_weights: Tensor | None=None, | |
| normalizer: float | None=None,temperature: float=1.,chunk_size: int=4096, | |
| row_chunk_size: int=64) -> tuple[Tensor,dict]: | |
| """Memory-bounded full or sampled token update with inherited normalization. | |
| hidden [B,T,D], q [B,T,V]. None correction selects exact streaming. | |
| Masked hidden/return entries are sanitized BEFORE any arithmetic. | |
| """ | |
| if hidden.ndim!=3 or actions.shape!=hidden.shape[:2] or q.shape!=(*hidden.shape[:2],len(weight)): | |
| raise ValueError('hidden [B,T,D], actions [B,T], q [B,T,V] required') | |
| if actions.dtype!=torch.long or mask.shape!=actions.shape or mask.dtype!=torch.bool or mask.device!=hidden.device: | |
| raise ValueError('invalid actions/mask') | |
| _,r=_prepare(hidden[...,0],mask,returns,beta) | |
| h=hidden.masked_fill(~mask[...,None],0);a=actions.masked_fill(~mask,0) | |
| if a.device!=h.device:raise ValueError('action device mismatch') | |
| sampler=canonical_q(q,mask) | |
| qa=sampler.gather(-1,a[...,None]).squeeze(-1) | |
| if (qa[mask]<=0).any():raise ValueError('observed action absent from behavior support') | |
| b,t,d=h.shape | |
| opts={'bias':bias,'temperature':temperature,'chunk_size':chunk_size,'row_chunk_size':row_chunk_size} | |
| if correction is None: | |
| scores=centered_linear_scores(h.reshape(-1,d),weight,a.reshape(-1),q=sampler.reshape(b*t,-1),**opts) | |
| route='exact_streaming' | |
| else: | |
| if not torch.equal(correction.mask,mask):raise ValueError('correction mask mismatch') | |
| if not torch.isfinite(correction.weights).all() or (correction.weights<0).any():raise ValueError('invalid correction weights') | |
| sums=correction.weights.sum(-1) | |
| if not torch.allclose(sums[mask],torch.ones_like(sums[mask]),atol=2e-6,rtol=0):raise ValueError('correction mass mismatch') | |
| ids=torch.cat((a[...,None],correction.ids),-1) | |
| coeff=torch.cat((mask[...,None].to(correction.weights.dtype),-correction.weights),-1) | |
| scores=centered_linear_scores(h.reshape(-1,d),weight,a.reshape(-1),ids=ids.reshape(b*t,-1),coefficients=coeff.reshape(b*t,-1),**opts) | |
| route='sampled_recomputed' | |
| lp=scores.action_log_probs.reshape(b,t).masked_fill(~mask,0) | |
| lq=qa.log().masked_fill(~mask,0) | |
| coefficient=r-beta*(lp-lq) | |
| if baseline is not None: | |
| if baseline.shape!=(b,t) or baseline.device!=h.device:raise ValueError('baseline [B,T] required') | |
| base=baseline.detach().masked_fill(~mask,0) | |
| if not torch.isfinite(base).all():raise ValueError('nonfinite active baseline') | |
| coefficient=coefficient-base | |
| coefficient=coefficient.detach().masked_fill(~mask,0) | |
| per=-(coefficient*scores.centered_logits.reshape(b,t)).sum(-1) | |
| loss=_reduce(per,outer_weights,normalizer) | |
| if not torch.isfinite(loss):raise FloatingPointError('nonfinite linear loss') | |
| return loss,{'route':route,'coefficient':coefficient,'per_response_surrogate':per.detach()} | |