inference/robotwin2_example/H-RDT/models/hrdt/model.py

from collections import OrderedDict
from typing import List, Tuple, Optional

import re
import torch
import torch.nn as nn
import torch.nn.functional as F

from models.hrdt.blocks import ActionDecoder, HRDTBlock, TimestepEmbedder
from models.hrdt.pos_emb import get_multimodal_pos_embed


class HRDT(nn.Module):
    """
    Robotics Diffusion Transformer model
    
    Modified to:
    1. State and noisy action chunk are processed together as input
    2. AdaLN now uses timestep only (no sentence token)
    3. Image features directly fed to cross-attention in blocks
    4. Training mode controls which cross-attention layers to use
    """
    def __init__(
        self,
        horizon: int,
        config: dict,
        x_pos_emb_config: List[Tuple],
        img_pos_emb_config: List[Tuple] = None,
        lang_pos_emb_config: List[Tuple] = None,
        max_img_len: int = None,
        max_lang_len: int = None,
        training_mode: str = 'lang',
        dtype=torch.bfloat16,
    ):
        super().__init__()
        self.horizon = horizon
        self.hidden_size = config["hidden_size"]
        self.n_heads = config["num_heads"]
        self.dtype = dtype
        self.gradient_checkpointing = False
        self.training_mode = training_mode

        # Validate training mode
        if training_mode not in ['lang']:
            raise ValueError(f"training_mode must be 'lang', got {training_mode}")

        # Remove AdaLN adapter - timestep embedding goes directly to blocks

        # Timestep embedder
        self.t_embedder = TimestepEmbedder(self.hidden_size, dtype=dtype)

        # Create H-RDT layers with training mode
        self.depth = config["depth"]
        self.blocks = nn.ModuleList([
            HRDTBlock(layer_idx, config=config, training_mode=training_mode)
            for layer_idx in range(self.depth)
        ])
        self.action_decoder = ActionDecoder(config=config)

        # Position embeddings
        self.x_pos_emb_config = x_pos_emb_config
        self.lang_pos_emb_config = lang_pos_emb_config
        self.img_pos_emb_config = img_pos_emb_config
        self.x_pos_emb = nn.Parameter(torch.zeros(
            1, 1 + self.horizon, self.hidden_size)) # state + action
        self.lang_pos_emb = nn.Parameter(torch.zeros(
            1, max_lang_len, self.hidden_size))
        self.img_pos_emb = nn.Parameter(torch.zeros(
            1, max_img_len, self.hidden_size))

        self.initialize_weights()

    def build_condition_adapter(
        self, projector_type, in_features, out_features):
        projector = None
        if projector_type == 'linear':
            projector = nn.Linear(in_features, out_features)
        else:
            mlp_silu_match = re.match(r'^mlp(\d+)x_silu$', projector_type)
            if mlp_silu_match:
                mlp_depth = int(mlp_silu_match.group(1))
                modules = [nn.Linear(in_features, out_features)]
                for _ in range(1, mlp_depth):
                    modules.append(nn.SiLU())
                    modules.append(nn.Linear(out_features, out_features))
                projector = nn.Sequential(*modules)

        if projector is None:
            raise ValueError(f'Unknown projector type: {projector_type}')

        return projector

    def initialize_weights(self):
        # Initialize linear layers
        def _basic_init(module):
            if isinstance(module, nn.Linear):
                torch.nn.init.xavier_uniform_(module.weight)
                if module.bias is not None:
                    nn.init.constant_(module.bias, 0)
        self.apply(_basic_init)

        # Initialize position embeddings with sincos
        x_pos_emb = get_multimodal_pos_embed(
            embed_dim=self.hidden_size,
            mm_lens=OrderedDict(self.x_pos_emb_config)
        )
        self.x_pos_emb.data.copy_(
            torch.from_numpy(x_pos_emb).float().unsqueeze(0))

        lang_pos_emb = get_multimodal_pos_embed(
            embed_dim=self.hidden_size,
            mm_lens=OrderedDict(self.lang_pos_emb_config)
        )
        self.lang_pos_emb.data.copy_(
            torch.from_numpy(lang_pos_emb).float().unsqueeze(0))

        img_pos_embed = get_multimodal_pos_embed(
            embed_dim=self.hidden_size,
            mm_lens=OrderedDict(self.img_pos_emb_config)
        )
        self.img_pos_emb.data.copy_(
            torch.from_numpy(img_pos_embed).float().unsqueeze(0))

        # Initialize timestep embedding MLP
        nn.init.normal_(self.t_embedder.mlp[0].weight, std=0.02)
        nn.init.normal_(self.t_embedder.mlp[2].weight, std=0.02)

        # Zero-out adaLN modulation layers
        for block in self.blocks:
            nn.init.constant_(block.adaLN_modulation[-1].weight, 0)
            nn.init.constant_(block.adaLN_modulation[-1].bias, 0)

        # Zero-out output layers
        nn.init.constant_(self.action_decoder.adaLN_modulation[-1].weight, 0)
        nn.init.constant_(self.action_decoder.adaLN_modulation[-1].bias, 0)
        nn.init.constant_(self.action_decoder.ffn.fc2.weight, 0)
        nn.init.constant_(self.action_decoder.ffn.fc2.bias, 0)

        # Move all params to specified dtype
        self.to(self.dtype)

    def gradient_checkpointing_enable(self, value: bool = True):
        """Enable gradient checkpointing to save memory"""
        self.gradient_checkpointing = value

    def forward(self, x, t, img_c=None, lang_c=None, sentence_c=None, task_c=None, lang_attn_mask=None):
        """
        Forward pass of H-RDT

        Args:
            x: (B, 1 + T, D), state and action token sequence, T = horizon
            t: (B,) or (1,), diffusion timesteps
            img_c: (B, S_img, D), image features for cross-attention, optional
            lang_c: (B, S_lang, D), language tokens for cross-attention, optional
            sentence_c: ignored (for backward compatibility)
            lang_attn_mask: (B, S_lang), attention mask for language tokens, optional
        Returns:
            x: (B, T, D_out), predicted denoised action tokens
        """
        # Embed timestep using sinusoidal embeddings
        t_emb = self.t_embedder(t)  # (B, D) or (1, D)
        if t_emb.shape[0] == 1:
            t_emb = t_emb.expand(x.shape[0], -1)  # (B, D)

        # Add position embeddings
        x = x + self.x_pos_emb
        
        if img_c is not None:
            img_c = img_c + self.img_pos_emb[:, :img_c.shape[1]]
        
        if lang_c is not None:
            lang_c = lang_c + self.lang_pos_emb[:, :lang_c.shape[1]]
        
        # Pass timestep embedding directly to blocks (no sentence token)
        for i, block in enumerate(self.blocks):
            cross_contexts = {
                'img_c': img_c,
                'lang_c': lang_c,
                'lang_attn_mask': lang_attn_mask
            }
            if self.gradient_checkpointing and self.training:
                x = torch.utils.checkpoint.checkpoint(block, x, t_emb, cross_contexts, use_reentrant=False)
            else:
                x = block(x, t_emb, cross_contexts)

        # Final layer only uses timestep (no cross-attention)
        x = self.action_decoder(x, t_emb)

        # Extract action predictions
        x = x[:, -self.horizon:]

        return x