inference/real_example/model_inference.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import os
import sys
import yaml
import time
import json

import numpy as np
import torch
import cv2
from PIL import Image as PImage

# Import model components - use relative path
current_dir = os.path.dirname(os.path.abspath(__file__))
project_root = os.path.abspath(os.path.join(current_dir, '../../..'))
sys.path.append(project_root)
from models.hrdt_runner import HRDTRunner
from models.encoder.dinosiglip_vit import DinoSigLIPViTBackbone


class HRDTInference:
    """H-RDT model inference class"""
    
    def __init__(self, args):
        self.args = args
        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        self.dtype = torch.bfloat16
        self.training_mode = args.training_mode
        
        # Load model config
        with open(args.config_path, 'r') as f:
            self.config = yaml.safe_load(f)
        
        # Load action normalization statistics
        if os.path.exists(args.stat_file_path):
            with open(args.stat_file_path, 'r') as file:
                stat = json.load(file)
            self.action_min = np.array(stat['aloha']['min'])
            self.action_max = np.array(stat['aloha']['max'])
        else:
            print(f"Warning: Statistics file not found at {args.stat_file_path}")
            self.action_min = None
            self.action_max = None
            
        # Load vision encoder
        self.load_vision_encoder()
        
        # Load H-RDT model
        self.load_hrdt_model()
        
        # Load language embeddings
        self.load_embeddings()
        
        # Initialize observation cache
        self.obs_cache = []
        self.max_obs_cache_size = self.config['common']['img_history_size']
        
        print(f"H-RDT inference initialized successfully in {self.training_mode} mode")
    
    def load_vision_encoder(self):
        """Load vision encoder"""
        # Use relative path for vision backbone
        vision_backbone_path = os.path.join(project_root, 'bak/dino-siglip')
        print(f"Loading vision encoder from: {vision_backbone_path}")
        
        self.vision_encoder = DinoSigLIPViTBackbone(
            vision_backbone_id="dino-siglip",
            image_resize_strategy="letterbox" 
                if self.config["dataset"]["image_aspect_ratio"] == "pad" 
                else "resize-naive",
            default_image_size=384
        )
        self.vision_encoder.to(self.device, dtype=self.dtype)
        self.vision_encoder.eval()
        self.image_transform = self.vision_encoder.get_image_transform()
        
    def load_hrdt_model(self):
        """Load H-RDT model"""
        state_dim = self.config["common"]["state_dim"]
        action_dim = self.config["common"]["action_dim"]
        pred_horizon = self.config["common"]["action_chunk_size"]
        
        # Create H-RDT model
        self.policy = HRDTRunner.from_pretrained(
            pretrained_model_name_or_path=self.args.pretrained_model_path,
            state_dim=state_dim,
            action_dim=action_dim,
            pred_horizon=pred_horizon,
            config=self.config["model"],
            act_pos_emb_config=[
                ("state", 1),
                ("action", pred_horizon),
            ],
            img_pos_emb_config=[
                ("image", (self.config["common"]["img_history_size"], 
                          3,  # 3 separate camera views
                          -self.vision_encoder.num_patches)),
            ],
            lang_pos_emb_config=[
                ("lang", -self.config["dataset"]["tokenizer_max_length"]),
            ],
            max_img_len=self.config["common"]["img_history_size"] * 3 * self.vision_encoder.num_patches,
            max_lang_len=self.config["dataset"]["tokenizer_max_length"],
            training_mode=self.training_mode,
            dtype=self.dtype,
        )
        
        self.policy.to(self.device, dtype=self.dtype).eval()
        print("H-RDT model loaded successfully")
    
    def load_embeddings(self):
        """Load languageembeddings"""
        self.lang_tokens = None
        self.lang_attn_mask = None
        
        if self.training_mode == 'lang':
            # Load pre-encoded language embeddings
            if hasattr(self.args, 'lang_embeddings_path') and self.args.lang_embeddings_path:
                lang_embed_path = self.args.lang_embeddings_path
            else:
                # Use relative path for default embeddings location
                lang_embed_path = os.path.join(project_root, f'utils/lang_embeddings/{self.args.task_name}.pt')
            
            if os.path.exists(lang_embed_path):
                embedding_data = torch.load(lang_embed_path, map_location=self.device)
                embeddings = embedding_data.get('embeddings', None)
                if embeddings is not None:
                    if embeddings.dim() == 3:
                        embeddings = embeddings.squeeze(0)
                    self.lang_tokens = embeddings.to(dtype=self.dtype)
                    self.lang_attn_mask = torch.ones(self.lang_tokens.shape[:1], dtype=torch.bool, device=self.device)
                    print(f"Loaded language embeddings from: {lang_embed_path}")
                    print(f"Language token shape: {self.lang_tokens.shape}")
                else:
                    print(f"No 'embeddings' key found in {lang_embed_path}")
            else:
                print(f"Language embedding not found: {lang_embed_path}")
    
    def update_obs(self, observation):
        """Update observation cache"""
        # Process observation
        processed_obs = {
            'agent_pos': None,
            'images': {'head_cam': None, 'left_cam': None, 'right_cam': None}
        }
        
        # Process state information
        if observation['puppet_left'] is not None and observation['puppet_right'] is not None:
            left_pos = np.array(observation['puppet_left'].position)
            right_pos = np.array(observation['puppet_right'].position)
            agent_pos = np.concatenate([left_pos, right_pos])
            
            # Normalize if statistics available
            if self.action_min is not None and self.action_max is not None:
                agent_pos = (agent_pos - self.action_min) / (self.action_max - self.action_min)
            processed_obs['agent_pos'] = agent_pos
        
        # Process images separately (no combining)
        if observation['images']['head_cam'] is not None:
            processed_obs['images']['head_cam'] = observation['images']['head_cam']
        if observation['images']['left_cam'] is not None:
            processed_obs['images']['left_cam'] = observation['images']['left_cam']
        if observation['images']['right_cam'] is not None:
            processed_obs['images']['right_cam'] = observation['images']['right_cam']
        
        self.obs_cache.append(processed_obs)
        if len(self.obs_cache) > self.max_obs_cache_size:
            self.obs_cache.pop(0)
    
    def create_three_view_image(self, head_cam, left_cam, right_cam):
        """Create three-view combined image for video saving"""
        # Resize images
        head_resized = cv2.resize(head_cam, (640, 480))  # Main view keeps original size
        left_resized = cv2.resize(left_cam, (320, 240))  # Left view
        right_resized = cv2.resize(right_cam, (320, 240))  # Right view
        
        # Create combined image: main view on top, left and right views on bottom
        # Total size: 640x720 (width x height)
        combined_image = np.zeros((720, 640, 3), dtype=np.uint8)
        
        # Place main view (top)
        combined_image[0:480, 0:640] = head_resized
        
        # Place left and right views (bottom)
        combined_image[480:720, 0:320] = left_resized
        combined_image[480:720, 320:640] = right_resized
        
        return combined_image

    @torch.no_grad()
    def predict_action(self, observation):
        """Predict action using H-RDT model"""
        if len(self.obs_cache) == 0:
            return None
        
        current_obs = self.obs_cache[-1]
        
        # Process state tokens
        state_tokens = None
        if current_obs['agent_pos'] is not None:
            state_tokens = torch.tensor(
                current_obs['agent_pos']
            ).unsqueeze(0).unsqueeze(0).to(self.device, dtype=self.dtype)
        
        # Process image tokens (separate camera views)
        image_tokens = None
        valid_images = []
        
        for cam_name in ['head_cam', 'left_cam', 'right_cam']:
            if current_obs['images'][cam_name] is not None:
                # Convert to PIL image
                img_pil = PImage.fromarray(current_obs['images'][cam_name])
                
                # Apply image transform
                transformed = self.image_transform(img_pil)
                valid_images.append(transformed)
        
        if len(valid_images) > 0:
            # Stack images for batch processing
            image_inputs = {}
            for k in valid_images[0].keys():
                image_inputs[k] = torch.stack([img[k] for img in valid_images])
                image_inputs[k] = image_inputs[k].unsqueeze(0).to(self.device, dtype=self.dtype)
            
            # Use vision encoder
            with torch.no_grad():
                k = next(iter(image_inputs))
                batch_size, seq_len, C, H, W = image_inputs[k].shape
                # Reshape to (batch_size * seq_len, C, H, W)
                for k in image_inputs:
                    image_inputs[k] = image_inputs[k].view(-1, C, H, W)
                # Get features using vision encoder
                image_features = self.vision_encoder(image_inputs)
                # Reshape features to correct dimensions
                image_tokens = image_features.view((batch_size, -1, self.vision_encoder.embed_dim))
        
        if image_tokens is None:
            return None
        
        # Prepare language tokens
        lang_tokens = None
        lang_attn_mask = None
        
        if self.training_mode == 'lang' and self.lang_tokens is not None:
            lang_tokens = self.lang_tokens.unsqueeze(0)  # Add batch dimension
            lang_attn_mask = self.lang_attn_mask.unsqueeze(0) if self.lang_attn_mask is not None else None

        # Model inference
        start_time = time.time()
        
        action_pred = self.policy.predict_action(
            state_tokens=state_tokens,
            image_tokens=image_tokens,
            lang_tokens=lang_tokens,
            lang_attn_mask=lang_attn_mask,
        )
        
        inference_time = time.time() - start_time
        print(f"Model inference time: {inference_time:.3f}s")
        
        # Convert to numpy array
        normalized_actions = action_pred.float().cpu().numpy()[0]
        
        # Denormalize actions if statistics available
        if self.action_min is not None and self.action_max is not None:
            joint_actions = normalized_actions * (self.action_max - self.action_min) + self.action_min
        else:
            joint_actions = normalized_actions
        
        # Apply gripper adjustment: subtract 0.3 from 7th dimension (index 6) and 14th dimension (index 13)
        joint_actions[:, 6] -= 0.3   # Left arm gripper (7th dimension)
        joint_actions[:, 13] -= 0.3  # Right arm gripper (14th dimension)
        print(f"Applied gripper adjustment: -0.3 to dimensions 7 and 14")
        
        return joint_actions