| """Decoder capacity/routing variants for strict local-wrist Stereo-ACT. |
| |
| Both variants retain frozen DINOv3 + DeFM and the 30x40 RGB->depth |
| cross_relbias front end from StereoACT. They use only current local wrist |
| RGB-D tokens and local qpos; no task/agent ID, language, peer, or global view. |
| """ |
| from __future__ import annotations |
| import math |
| import torch |
| import torch.nn as nn |
| import torch.nn.functional as F |
| from train_stereo_act import StereoACT |
|
|
|
|
| class _Expert(nn.Module): |
| def __init__(self, d_model, ffn_dim, dropout): |
| super().__init__() |
| self.net = nn.Sequential(nn.Linear(d_model, ffn_dim), nn.GELU(), nn.Dropout(dropout), |
| nn.Linear(ffn_dim, d_model), nn.Dropout(dropout)) |
| def forward(self, x): return self.net(x) |
|
|
|
|
| class Top2SparseMoE(nn.Module): |
| """Four FFN experts; each local decoder token selects exactly top-2.""" |
| def __init__(self, d_model, ffn_dim, experts=4, dropout=.1): |
| super().__init__(); self.experts_n = experts |
| self.router = nn.Linear(d_model, experts, bias=False) |
| self.experts = nn.ModuleList([_Expert(d_model, ffn_dim, dropout) for _ in range(experts)]) |
|
|
| def forward(self, x): |
| shape, flat = x.shape, x.reshape(-1, x.shape[-1]) |
| logits = self.router(flat) |
| top_logits, top_ids = logits.topk(2, dim=-1) |
| gates = top_logits.softmax(-1) |
| out = torch.zeros_like(flat) |
| for expert_id, expert in enumerate(self.experts): |
| chosen = (top_ids == expert_id).nonzero(as_tuple=False) |
| if chosen.numel() == 0: continue |
| token_ids, slots = chosen[:, 0], chosen[:, 1] |
| y = expert(flat.index_select(0, token_ids)) |
| out.index_add_(0, token_ids, y * gates[token_ids, slots].unsqueeze(-1)) |
| |
| importance = logits.softmax(-1).mean(0) |
| load = torch.bincount(top_ids.reshape(-1), minlength=self.experts_n).to(flat.dtype) / (2.0 * flat.shape[0]) |
| aux = self.experts_n * (importance * load).sum() |
| return out.reshape(shape), aux |
|
|
|
|
| class MoEDecoderLayer(nn.Module): |
| def __init__(self, d_model, heads=8, ffn_dim=None, dropout=.1, experts=4): |
| super().__init__(); ffn_dim = ffn_dim or 4*d_model |
| self.self_attn = nn.MultiheadAttention(d_model, heads, dropout=dropout, batch_first=True) |
| self.cross_attn = nn.MultiheadAttention(d_model, heads, dropout=dropout, batch_first=True) |
| self.norm1, self.norm2, self.norm3 = nn.LayerNorm(d_model), nn.LayerNorm(d_model), nn.LayerNorm(d_model) |
| self.drop1, self.drop2 = nn.Dropout(dropout), nn.Dropout(dropout) |
| self.moe = Top2SparseMoE(d_model, ffn_dim, experts=experts, dropout=dropout) |
|
|
| def forward(self, x, memory): |
| x = x + self.drop1(self.self_attn(self.norm1(x), self.norm1(x), self.norm1(x), need_weights=False)[0]) |
| x = x + self.drop2(self.cross_attn(self.norm2(x), memory, memory, need_weights=False)[0]) |
| ff, aux = self.moe(self.norm3(x)); return x + ff, aux |
|
|
|
|
| class MoEDecoder(nn.Module): |
| def __init__(self, d_model, layers=7, experts=4, dropout=.1): |
| super().__init__(); self.layers = nn.ModuleList([MoEDecoderLayer(d_model, dropout=dropout, experts=experts) for _ in range(layers)]) |
| def forward(self, x, memory): |
| aux = x.new_zeros(()) |
| for layer in self.layers: |
| x, value = layer(x, memory); aux = aux + value |
| return x, aux / len(self.layers) |
|
|
|
|
| class StereoFFNMoE(StereoACT): |
| """Stereo front end + top-2 four-expert FFN replacement in every decoder block.""" |
| def __init__(self, *args, experts=4, **kwargs): |
| super().__init__(*args, **kwargs) |
| self.experts_n = experts |
| self.decoder = MoEDecoder(self.query.shape[-1], layers=len(self.decoder.layers), experts=experts) |
|
|
| def forward(self, image, depth_mm, qpos, actions=None): |
| x = self._rgbd_tokens(image, depth_mm); state = self.state(qpos).unsqueeze(1) |
| if actions is not None: |
| h = self.posterior(self.action(actions) + self.pos) |
| mu, logvar = self.latent(h.mean(1)).chunk(2, -1); z = mu + torch.randn_like(mu) * torch.exp(.5 * logvar) |
| else: |
| mu = logvar = None; z = torch.zeros((image.shape[0], self.z_proj.in_features), device=image.device) |
| memory = torch.cat((state, self.z_proj(z).unsqueeze(1), x), dim=1) |
| decoded, aux = self.decoder(self.query.expand(image.shape[0], -1, -1), memory) |
| return self.out(decoded), mu, logvar, aux |
|
|
|
|
| class RoleCrossAdapter(nn.Module): |
| """Small role-specific cross-attention from one action query to current observation tokens.""" |
| def __init__(self, d_model, rank=32): |
| super().__init__() |
| self.q = nn.Linear(d_model, rank, bias=False); self.k = nn.Linear(d_model, rank, bias=False) |
| self.v = nn.Linear(d_model, rank, bias=False); self.out = nn.Linear(rank, d_model, bias=False) |
| self.rank = rank |
| def forward(self, query, observation): |
| scores = torch.matmul(self.q(query), self.k(observation).transpose(-1, -2)) / math.sqrt(self.rank) |
| return self.out(torch.matmul(scores.softmax(-1), self.v(observation))) |
|
|
|
|
| class ARCADecoderLayer(nn.Module): |
| def __init__(self, d_model, roles=4, rank=32, heads=8, dropout=.1): |
| super().__init__(); ffn = 4*d_model |
| self.self_attn = nn.MultiheadAttention(d_model, heads, dropout=dropout, batch_first=True) |
| self.cross_attn = nn.MultiheadAttention(d_model, heads, dropout=dropout, batch_first=True) |
| self.norm1, self.norm2, self.norm3 = nn.LayerNorm(d_model), nn.LayerNorm(d_model), nn.LayerNorm(d_model) |
| self.drop1, self.drop2 = nn.Dropout(dropout), nn.Dropout(dropout) |
| self.ff = _Expert(d_model, ffn, dropout) |
| self.adapters = nn.ModuleList([RoleCrossAdapter(d_model, rank) for _ in range(roles)]) |
|
|
| def forward(self, x, memory, observation, gates): |
| x = x + self.drop1(self.self_attn(self.norm1(x), self.norm1(x), self.norm1(x), need_weights=False)[0]) |
| h = self.norm2(x) |
| base = self.cross_attn(h, memory, memory, need_weights=False)[0] |
| role = torch.zeros_like(base) |
| for role_id, adapter in enumerate(self.adapters): |
| role = role + gates[..., role_id:role_id+1] * adapter(h, observation) |
| x = x + self.drop2(base + role) |
| return x + self.ff(self.norm3(x)) |
|
|
|
|
| class ARCADecoder(nn.Module): |
| def __init__(self, d_model, layers=7, roles=4, rank=32, dropout=.1): |
| super().__init__(); self.layers = nn.ModuleList([ARCADecoderLayer(d_model, roles, rank, dropout=dropout) for _ in range(layers)]) |
| def forward(self, x, memory, observation, gates): |
| for layer in self.layers: x = layer(x, memory, observation, gates) |
| return x |
|
|
|
|
| class StereoARCA(StereoACT): |
| """Action-role conditioned observation cross-attention inside every decoder layer.""" |
| def __init__(self, *args, roles=4, role_rank=32, **kwargs): |
| super().__init__(*args, **kwargs) |
| d = self.query.shape[-1]; self.roles_n, self.role_rank = roles, role_rank |
| self.decoder = ARCADecoder(d, layers=len(self.decoder.layers), roles=roles, rank=role_rank) |
| self.route_state, self.route_observation = nn.Linear(d, d, bias=False), nn.Linear(d, d, bias=False) |
| self.route_mlp = nn.Sequential(nn.LayerNorm(d), nn.Linear(d, d), nn.GELU(), nn.Linear(d, d, bias=False)) |
| self.role_prototypes = nn.Parameter(torch.randn(roles, d) * .02) |
|
|
| def _route(self, state, observation, batch): |
| |
| q = self.query.expand(batch, -1, -1) |
| context = self.route_state(state) + self.route_observation(observation.mean(1)) |
| features = self.route_mlp(q + context.unsqueeze(1)) |
| logits = torch.matmul(features, self.role_prototypes.t()) / math.sqrt(features.shape[-1]) |
| values, ids = logits.topk(2, dim=-1); gates = torch.zeros_like(logits).scatter_(-1, ids, values.softmax(-1).to(logits.dtype)) |
| importance = logits.softmax(-1).mean((0, 1)) |
| load = (gates.gt(0).to(logits.dtype).mean((0, 1)) / 2.0) |
| aux = self.roles_n * (importance * load).sum() |
| return gates, aux |
|
|
| def forward(self, image, depth_mm, qpos, actions=None): |
| x = self._rgbd_tokens(image, depth_mm); state_vec = self.state(qpos); state = state_vec.unsqueeze(1) |
| gates, aux = self._route(state_vec, x, image.shape[0]) |
| if actions is not None: |
| h = self.posterior(self.action(actions) + self.pos) |
| mu, logvar = self.latent(h.mean(1)).chunk(2, -1); z = mu + torch.randn_like(mu) * torch.exp(.5 * logvar) |
| else: |
| mu = logvar = None; z = torch.zeros((image.shape[0], self.z_proj.in_features), device=image.device) |
| memory = torch.cat((state, self.z_proj(z).unsqueeze(1), x), dim=1) |
| decoded = self.decoder(self.query.expand(image.shape[0], -1, -1), memory, x, gates) |
| return self.out(decoded), mu, logvar, aux |
|
|
|
|
| class StereoSyncARCA(StereoARCA): |
| """Stereo-ARCA with a training-only synchronized action-stage teacher. |
| |
| At inference ``phase_target`` is never provided. Each local policy predicts |
| the phase from its own current wrist RGB-D tokens and qpos, then conditions |
| action-query routing on that *predicted* soft phase. The optional target is |
| used only for the CE loss in the trainer. |
| """ |
| def __init__(self, *args, phases=8, **kwargs): |
| super().__init__(*args, **kwargs) |
| d = self.query.shape[-1] |
| self.phases_n = phases |
| self.phase_head = nn.Sequential(nn.LayerNorm(d), nn.Linear(d, d), nn.GELU(), nn.Linear(d, phases)) |
| self.phase_embed = nn.Parameter(torch.randn(phases, d) * .02) |
|
|
| def _sync_route(self, state, observation, phase_probs, batch): |
| q = self.query.expand(batch, -1, -1) |
| context = self.route_state(state) + self.route_observation(observation.mean(1)) |
| phase_context = torch.matmul(phase_probs, self.phase_embed) |
| features = self.route_mlp(q + (context + phase_context).unsqueeze(1)) |
| logits = torch.matmul(features, self.role_prototypes.t()) / math.sqrt(features.shape[-1]) |
| values, ids = logits.topk(2, dim=-1) |
| gates = torch.zeros_like(logits).scatter_(-1, ids, values.softmax(-1).to(logits.dtype)) |
| importance = logits.softmax(-1).mean((0, 1)) |
| load = gates.gt(0).to(logits.dtype).mean((0, 1)) / 2.0 |
| aux = self.roles_n * (importance * load).sum() |
| return gates, aux |
|
|
| def forward(self, image, depth_mm, qpos, actions=None): |
| x = self._rgbd_tokens(image, depth_mm) |
| state_vec = self.state(qpos) |
| local_context = self.route_state(state_vec) + self.route_observation(x.mean(1)) |
| phase_logits = self.phase_head(local_context) |
| phase_probs = phase_logits.softmax(-1) |
| gates, aux = self._sync_route(state_vec, x, phase_probs, image.shape[0]) |
| state = state_vec.unsqueeze(1) |
| if actions is not None: |
| h = self.posterior(self.action(actions) + self.pos) |
| mu, logvar = self.latent(h.mean(1)).chunk(2, -1) |
| z = mu + torch.randn_like(mu) * torch.exp(.5 * logvar) |
| else: |
| mu = logvar = None |
| z = torch.zeros((image.shape[0], self.z_proj.in_features), device=image.device) |
| memory = torch.cat((state, self.z_proj(z).unsqueeze(1), x), dim=1) |
| decoded = self.decoder(self.query.expand(image.shape[0], -1, -1), memory, x, gates) |
| return self.out(decoded), mu, logvar, aux, phase_logits, gates |
|
|
