| """Annotation-free state rollout and clean-video transition supervision.""" |
| import math |
|
|
| import torch |
| from torch import nn |
| from torch.nn import functional as F |
|
|
|
|
| def _mlp(in_dim, hidden_dim, out_dim, dropout=0.0): |
| return nn.Sequential(nn.Linear(in_dim, hidden_dim), nn.GELU(), |
| nn.Dropout(dropout), nn.Linear(hidden_dim, out_dim)) |
|
|
|
|
| class CrossAttentionBlock(nn.Module): |
| def __init__(self, dim, num_heads, mlp_ratio=4.0, dropout=0.0): |
| super().__init__() |
| self.query_norm = nn.LayerNorm(dim) |
| self.key_norm = nn.LayerNorm(dim) |
| self.attention = nn.MultiheadAttention(dim, num_heads, dropout=dropout, batch_first=True) |
| self.norm = nn.LayerNorm(dim) |
| self.mlp = _mlp(dim, int(dim * mlp_ratio), dim, dropout) |
|
|
| def forward(self, queries, source): |
| update, _ = self.attention(self.query_norm(queries), self.key_norm(source), |
| source, need_weights=False) |
| queries = queries + update |
| return queries + self.mlp(self.norm(queries)) |
|
|
|
|
| class SelfAttentionBlock(nn.Module): |
| def __init__(self, dim, num_heads, mlp_ratio=4.0, dropout=0.0): |
| super().__init__() |
| self.norm1 = nn.LayerNorm(dim) |
| self.attention = nn.MultiheadAttention(dim, num_heads, dropout=dropout, batch_first=True) |
| self.norm2 = nn.LayerNorm(dim) |
| self.mlp = _mlp(dim, int(dim * mlp_ratio), dim, dropout) |
|
|
| def forward(self, x): |
| normalized = self.norm1(x) |
| update, _ = self.attention(normalized, normalized, normalized, need_weights=False) |
| x = x + update |
| return x + self.mlp(self.norm2(x)) |
|
|
|
|
| class LatentStateInitializer(nn.Module): |
| def __init__(self, visual_hidden_dim=3072, num_tokens=4, dim=256, |
| num_layers=2, num_heads=8, mlp_ratio=4.0, dropout=0.0): |
| super().__init__() |
| self.input_projection = nn.Linear(visual_hidden_dim, dim) |
| self.queries = nn.Parameter(torch.randn(num_tokens, dim) / math.sqrt(dim)) |
| self.blocks = nn.ModuleList([ |
| CrossAttentionBlock(dim, num_heads, mlp_ratio, dropout) for _ in range(num_layers) |
| ]) |
| self.norm = nn.LayerNorm(dim) |
|
|
| def forward(self, first_frame_tokens): |
| source = self.input_projection(first_frame_tokens) |
| state = self.queries.unsqueeze(0).expand(source.shape[0], -1, -1) |
| for block in self.blocks: |
| state = block(state, source) |
| return self.norm(state) |
|
|
|
|
| class LatentStateTransition(nn.Module): |
| def __init__(self, dim=256, action_dim=11, num_layers=2, num_heads=8, |
| mlp_ratio=4.0, dropout=0.0, max_frames=64): |
| super().__init__() |
| self.action_embedding = nn.Linear(action_dim, dim) |
| self.step_embedding = nn.Embedding(max_frames, dim) |
| self.blocks = nn.ModuleList([ |
| SelfAttentionBlock(dim, num_heads, mlp_ratio, dropout) for _ in range(num_layers) |
| ]) |
| self.delta = nn.Linear(dim, dim) |
| nn.init.zeros_(self.delta.weight) |
| nn.init.zeros_(self.delta.bias) |
| self.norm = nn.LayerNorm(dim) |
|
|
| def forward(self, G_i, action_i, step_idx=None): |
| state = G_i |
| if step_idx is not None: |
| if not 0 <= step_idx < self.step_embedding.num_embeddings: |
| raise ValueError("Rollout exceeds latent_state_max_frames") |
| state = state + self.step_embedding.weight[step_idx] |
| action = self.action_embedding(action_i.to(G_i.dtype)).unsqueeze(1) |
| tokens = torch.cat((state, action), dim=1) |
| for block in self.blocks: |
| tokens = block(tokens) |
| return self.norm(G_i + self.delta(tokens[:, :G_i.shape[1]])) |
|
|
|
|
| class LatentStateRollout(nn.Module): |
| def __init__(self, visual_hidden_dim=3072, num_tokens=4, dim=256, action_dim=11, |
| initializer_layers=2, transition_layers=2, num_heads=8, |
| mlp_ratio=4.0, dropout=0.0, max_frames=64): |
| super().__init__() |
| self.initializer = LatentStateInitializer( |
| visual_hidden_dim, num_tokens, dim, initializer_layers, num_heads, mlp_ratio, dropout) |
| self.transition = LatentStateTransition( |
| dim, action_dim, transition_layers, num_heads, mlp_ratio, dropout, max_frames) |
| self.output_projection = nn.Linear(dim, visual_hidden_dim) |
| self.max_frames = max_frames |
|
|
| def forward(self, first_frame_tokens, action_seq): |
| if action_seq.ndim != 3 or not 1 <= action_seq.shape[1] <= self.max_frames: |
| raise ValueError("action_seq must be [B,f,K] with 1 <= f <= max_frames") |
| state = self.initializer(first_frame_tokens) |
| states = [state] |
| for i in range(action_seq.shape[1] - 1): |
| state = self.transition(state, action_seq[:, i], step_idx=i) |
| states.append(state) |
| low = torch.stack(states, dim=1) |
| return low, self.output_projection(low.flatten(1, 2)) |
|
|
|
|
| class LatentStateToVisualAttention(nn.Module): |
| def __init__(self, visual_hidden_dim=3072, dim=256, num_heads=8): |
| super().__init__() |
| self.video_norm = nn.LayerNorm(visual_hidden_dim) |
| self.state_norm = nn.LayerNorm(visual_hidden_dim) |
| self.q = nn.Linear(visual_hidden_dim, dim) |
| self.k = nn.Linear(visual_hidden_dim, dim) |
| self.v = nn.Linear(visual_hidden_dim, dim) |
| self.out = nn.Linear(dim, visual_hidden_dim) |
| self.num_heads = num_heads |
| if dim % num_heads: |
| raise ValueError("Latent attention dim must be divisible by num_heads") |
| self.gate = nn.Parameter(torch.zeros(())) |
|
|
| def forward(self, video_tokens, latent_state_tokens): |
| def heads(x): |
| return x.unflatten(-1, (self.num_heads, -1)).transpose(1, 2) |
| q = heads(self.q(self.video_norm(video_tokens))) |
| k = heads(self.k(self.state_norm(latent_state_tokens))) |
| v = heads(self.v(latent_state_tokens)) |
| update = F.scaled_dot_product_attention(q, k, v).transpose(1, 2).flatten(2) |
| return video_tokens + self.gate * self.out(update) |
|
|
|
|
| class FiniteScalarQuantizer(nn.Module): |
| def __init__(self, levels=(8, 8, 8)): |
| super().__init__() |
| if not levels or any(int(level) < 2 for level in levels): |
| raise ValueError("FSQ levels must be integers >= 2") |
| self.vocab_size = math.prod(levels) |
| self.register_buffer("levels", torch.tensor(levels, dtype=torch.long)) |
| self.register_buffer("basis", torch.tensor([ |
| math.prod(levels[i + 1:]) for i in range(len(levels))], dtype=torch.long)) |
|
|
| def forward(self, u): |
| if u.shape[-1] != self.levels.numel(): |
| raise ValueError("FSQ input dimension must equal number of levels") |
| bounded = u.float().tanh() |
| bins = ((bounded + 1) * (self.levels - 1) / 2).round().long() |
| centers = 2 * bins.float() / (self.levels - 1) - 1 |
| quantized = bounded + (centers - bounded).detach() |
| indices = (bins * self.basis).sum(dim=-1) |
| return quantized.to(u.dtype), indices |
|
|
|
|
| class GameTransitionTokenizer(nn.Module): |
| def __init__(self, visual_hidden_dim=3072, num_tokens=4, dim=256, |
| num_layers=2, num_heads=8, mlp_ratio=4.0, dropout=0.0, |
| fsq_levels=(8, 8, 8)): |
| super().__init__() |
| self.input_projection = nn.Linear(visual_hidden_dim, dim) |
| self.queries = nn.Parameter(torch.randn(num_tokens, dim) / math.sqrt(dim)) |
| |
| self.pair_embedding = nn.Parameter(torch.randn(2, dim) / math.sqrt(dim)) |
| self.blocks = nn.ModuleList([ |
| CrossAttentionBlock(dim, num_heads, mlp_ratio, dropout) for _ in range(num_layers) |
| ]) |
| self.to_codes = nn.Linear(dim, len(fsq_levels)) |
| self.quantizer = FiniteScalarQuantizer(fsq_levels) |
| self.from_codes = nn.Linear(len(fsq_levels), dim) |
| self.reconstruction_head = _mlp(2 * dim, int(dim * mlp_ratio), dim, dropout) |
|
|
| def forward(self, clean_visual_tokens, latent_frames=None): |
| x = clean_visual_tokens |
| if x.ndim == 3: |
| if latent_frames is None or latent_frames < 2 or x.shape[1] % latent_frames: |
| raise ValueError("Supply latent_frames >= 2 dividing the clean token sequence") |
| x = x.unflatten(1, (latent_frames, -1)) |
| if x.ndim != 4 or x.shape[1] < 2: |
| raise ValueError("Clean tokens must describe at least two frames: [B,f,P,C]") |
| if latent_frames is not None and latent_frames != x.shape[1]: |
| raise ValueError("latent_frames disagrees with clean tokens") |
| low = self.input_projection(x) |
| batch, frames, _, dim = low.shape |
| pairs = torch.cat((low[:, :-1] + self.pair_embedding[0], |
| low[:, 1:] + self.pair_embedding[1]), dim=2).flatten(0, 1) |
| queries = self.queries.unsqueeze(0).expand(batch * (frames - 1), -1, -1) |
| for block in self.blocks: |
| queries = block(queries, pairs) |
| quantized, indices = self.quantizer(self.to_codes(queries)) |
| embs = self.from_codes(quantized).reshape(batch, frames - 1, -1, dim) |
| pooled = low.mean(dim=2) |
| target = (pooled[:, 1:] - pooled[:, :-1]).detach() |
| prediction = self.reconstruction_head(torch.cat((pooled[:, :-1], embs.mean(dim=2)), dim=-1)) |
| return {"z_indices": indices.reshape(batch, frames - 1, -1), "z_embs": embs, |
| "loss_tok": F.smooth_l1_loss(prediction.float(), target.float()), |
| "pred_delta": prediction, "target_delta": target} |
|
|
|
|
| class LatentTransitionPredictor(nn.Module): |
| def __init__(self, dim=256, action_dim=11, vocab_size=512, mlp_ratio=4.0): |
| super().__init__() |
| self.action_embedding = nn.Linear(action_dim, dim) |
| self.norm = nn.LayerNorm(dim) |
| self.mlp = _mlp(dim, int(dim * mlp_ratio), vocab_size) |
|
|
| def forward(self, G_seq_low, action_seq): |
| if G_seq_low.shape[:2] != action_seq.shape[:2]: |
| raise ValueError("State and action sequences must share [B,f]") |
| action = self.action_embedding(action_seq[:, :-1].to(G_seq_low.dtype)).unsqueeze(2) |
| return self.mlp(self.norm(G_seq_low[:, :-1] + action)) |
|
|
