File size: 5,506 Bytes
fe8c15f | 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 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 | """Aligned local RGB-D patch fusion used by wrist-only Stereo-ACT.
This module intentionally operates on tokens only. Camera geometry is handled
by the single native RGB-D sensor; no global view, peer observation, or second
camera image can enter this fusion block.
"""
from __future__ import annotations
import torch
import torch.nn as nn
import torch.nn.functional as F
class RelativePositionBias2D(nn.Module):
"""Per-head B(i,j)=b_row(delta_row)+b_col(delta_col) attention bias."""
def __init__(self, heads: int, grid_h: int, grid_w: int):
super().__init__()
self.heads, self.grid_h, self.grid_w = heads, grid_h, grid_w
self.row = nn.Parameter(torch.zeros(2 * grid_h - 1, heads))
self.col = nn.Parameter(torch.zeros(2 * grid_w - 1, heads))
nn.init.trunc_normal_(self.row, std=0.02)
nn.init.trunc_normal_(self.col, std=0.02)
def forward(self) -> torch.Tensor:
rows = torch.arange(self.grid_h, device=self.row.device)
cols = torch.arange(self.grid_w, device=self.col.device)
rb = self.row[rows[:, None] - rows[None, :] + self.grid_h - 1]
cb = self.col[cols[:, None] - cols[None, :] + self.grid_w - 1]
# [query_row, query_col, key_row, key_col, heads] -> [heads, query, key]
return (rb[:, None, :, None, :] + cb[None, :, None, :, :]).permute(4, 0, 1, 2, 3).reshape(
self.heads, self.grid_h * self.grid_w, self.grid_h * self.grid_w
)
class RelativeBiasCrossAttention(nn.Module):
"""RGB-query/depth-key attention over a matched H×W grid."""
def __init__(self, d_model: int, heads: int, grid_h: int, grid_w: int, dropout: float = 0.1):
super().__init__()
if d_model % heads:
raise ValueError("d_model must be divisible by heads")
self.heads, self.head_dim = heads, d_model // heads
self.q, self.k, self.v, self.out = (nn.Linear(d_model, d_model) for _ in range(4))
self.bias = RelativePositionBias2D(heads, grid_h, grid_w)
self.dropout = dropout
def forward(self, rgb_query: torch.Tensor, depth_key_value: torch.Tensor) -> torch.Tensor:
batch, tokens, dim = rgb_query.shape
if depth_key_value.shape != (batch, tokens, dim):
raise ValueError("cross_relbias requires identical RGB/depth token grids")
q = self.q(rgb_query).view(batch, tokens, self.heads, self.head_dim).transpose(1, 2)
k = self.k(depth_key_value).view(batch, tokens, self.heads, self.head_dim).transpose(1, 2)
v = self.v(depth_key_value).view(batch, tokens, self.heads, self.head_dim).transpose(1, 2)
# SDPA keeps this 30×40 full-grid operation on the 5090 fused-attention
# path where available; the bias is an additive per-head attention mask.
mask = self.bias().to(dtype=q.dtype, device=q.device).unsqueeze(0)
output = F.scaled_dot_product_attention(q, k, v, attn_mask=mask, dropout_p=self.dropout if self.training else 0.0)
return self.out(output.transpose(1, 2).reshape(batch, tokens, dim))
class RGBDRegionFusionBlock(nn.Module):
"""RGB self-attention, depth self-attention, then relative-biased cross fusion."""
def __init__(self, d_model: int, heads: int, grid_h: int, grid_w: int, ffn_dim: int, dropout: float = 0.1):
super().__init__()
self.rgb_norm, self.depth_norm, self.cross_norm, self.ffn_norm = (nn.LayerNorm(d_model) for _ in range(4))
self.rgb_self = nn.MultiheadAttention(d_model, heads, dropout=dropout, batch_first=True)
self.depth_self = nn.MultiheadAttention(d_model, heads, dropout=dropout, batch_first=True)
self.cross = RelativeBiasCrossAttention(d_model, heads, grid_h, grid_w, dropout)
self.ffn = nn.Sequential(nn.Linear(d_model, ffn_dim), nn.GELU(), nn.Dropout(dropout), nn.Linear(ffn_dim, d_model))
self.dropout = nn.Dropout(dropout)
def forward(self, rgb: torch.Tensor, depth: torch.Tensor, position: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
rgb_q, depth_q = self.rgb_norm(rgb + position), self.depth_norm(depth + position)
rgb = rgb + self.dropout(self.rgb_self(rgb_q, rgb_q, rgb, need_weights=False)[0])
depth = depth + self.dropout(self.depth_self(depth_q, depth_q, depth, need_weights=False)[0])
rgb = rgb + self.dropout(self.cross(self.cross_norm(rgb + position), depth + position))
return rgb + self.dropout(self.ffn(self.ffn_norm(rgb))), depth
class RGBDPatchFusion(nn.Module):
"""Two-layer (by default) 30×40 region-aligned RGB-D fusion."""
def __init__(self, d_model: int = 384, heads: int = 8, grid_h: int = 30, grid_w: int = 40,
layers: int = 2, ffn_dim: int = 1536, dropout: float = 0.1):
super().__init__()
self.grid_h, self.grid_w = grid_h, grid_w
self.blocks = nn.ModuleList(
RGBDRegionFusionBlock(d_model, heads, grid_h, grid_w, ffn_dim, dropout) for _ in range(layers)
)
def forward(self, rgb_tokens: torch.Tensor, depth_tokens: torch.Tensor, position: torch.Tensor) -> torch.Tensor:
expected = self.grid_h * self.grid_w
if rgb_tokens.shape[1] != expected or depth_tokens.shape[1] != expected:
raise ValueError(f"expected aligned {self.grid_h}x{self.grid_w} tokens, got {rgb_tokens.shape[1]} and {depth_tokens.shape[1]}")
for block in self.blocks:
rgb_tokens, depth_tokens = block(rgb_tokens, depth_tokens, position)
return rgb_tokens
|