run_orc_model_sample.py

"""
run_libero_eval.py

Runs a model in a LIBERO simulation environment.

Usage:
    # OpenVLA:
    # IMPORTANT: Set `center_crop=True` if model is fine-tuned with augmentations
    oc slot
    CUDA_VISIBLE_DEVICES=0 python run_orc_model_sample.py \
        --model_family openvla \
        --saved_dir output_orc
"""

import random
import os
import sys
from dataclasses import dataclass
from pathlib import Path
from typing import Optional, Union
import torch
import draccus
import numpy as np
import tqdm
from transformers import AutoConfig, AutoImageProcessor, AutoModelForVision2Seq, AutoProcessor

# import wandb

# Append current directory so that interpreter can find experiments.robot
# from libero_utils import (
#     get_libero_env,
#     get_libero_image,
#     save_rollout_video,
# )
from robot_utils import (
    DATE_TIME,
)

from prismatic.extern.hf.configuration_prismatic import OpenVLAConfig
from prismatic.extern.hf.modeling_prismatic import OpenVLAForActionPrediction, EmbodiedObjectSlot, EmbodiedRelationSlot, EmbodiedObject_LangSlot, EmbodiedRelation_LangSlot
from prismatic.extern.hf.processing_prismatic import PrismaticImageProcessor, PrismaticProcessor
from peft import PeftModel
from safetensors.torch import load_file

import json

def get_processor(cfg):
    """Get VLA model's Hugging Face processor."""
    processor = AutoProcessor.from_pretrained(os.path.dirname(cfg.custom_param_checkpoint), trust_remote_code=False)
    return processor

def get_vla(cfg):
    """Loads and returns a VLA model from checkpoint."""
    # Load VLA checkpoint.
    print("[*] Instantiating Pretrained VLA model")
    # print("[*] Loading in F16 with Flash-Attention Enabled")
    print("[*] Loading in BF16 with Flash-Attention Enabled")

    AutoConfig.register("openvla", OpenVLAConfig)
    AutoImageProcessor.register(OpenVLAConfig, PrismaticImageProcessor)
    AutoProcessor.register(OpenVLAConfig, PrismaticProcessor)
    AutoModelForVision2Seq.register(OpenVLAConfig, OpenVLAForActionPrediction)

    base_vla = AutoModelForVision2Seq.from_pretrained(
        'output_hf_model_openx', 
        attn_implementation="flash_attention_2",
        torch_dtype=torch.bfloat16,
        # torch_dtype=torch.float16,
        load_in_8bit=cfg.load_in_8bit,
        load_in_4bit=cfg.load_in_4bit,
        low_cpu_mem_usage=True,
        trust_remote_code=False,
    ).to('cuda')
    print("Loaded base.")
    
    base_vla = PeftModel.from_pretrained(base_vla, cfg.pretrained_checkpoint)
    base_vla = base_vla.merge_and_unload()
    print("Merged CustomOpenVLA LLM LoRA.")

    if cfg.slot_type == 'oc':
        vla = EmbodiedObject_LangSlot(base_model=base_vla, number_of_slots = cfg.number_of_slots)
    elif cfg.slot_type == 'orc':
        vla = EmbodiedRelation_LangSlot(base_model=base_vla, number_of_slots = cfg.number_of_slots)
    
    weights = load_file(cfg.custom_param_checkpoint)
    vla.load_state_dict(weights, strict=False)
    vla.object_centric_tokenizer.requires_grad_(False)
    vla.object_centric_bbox_head.requires_grad_(False)
    vla.object_centric_mask_head.requires_grad_(False)
    vla.requires_grad_(False)
    vla = vla.to('cuda')

    # Move model to device.
    # Note: `.to()` is not supported for 8-bit or 4-bit bitsandbytes models, but the model will
    #       already be set to the right devices and casted to the correct dtype upon loading.
    if not cfg.load_in_8bit and not cfg.load_in_4bit:
        vla = vla.to('cuda')

    # Load dataset stats used during finetuning (for action un-normalization).
    dataset_statistics_path = os.path.join(os.path.dirname(cfg.custom_param_checkpoint), "dataset_statistics.json")
    if os.path.isfile(dataset_statistics_path):
        with open(dataset_statistics_path, "r") as f:
            norm_stats = json.load(f)
        vla.norm_stats = norm_stats
    else:
        print(
            "WARNING: No local dataset_statistics.json file found for current checkpoint.\n"
            "You can ignore this if you are loading the base VLA (i.e. not fine-tuned) checkpoint."
            "Otherwise, you may run into errors when trying to call `predict_action()` due to an absent `unnorm_key`."
        )

    return vla

def get_model(cfg, wrap_diffusion_policy_for_droid=False):
    """Load model for evaluation."""
    if cfg.model_family == "openvla" or cfg.model_family == "customvla" or cfg.model_family == 'objectvla':
        model = get_vla(cfg)
    else:
        raise ValueError("Unexpected `model_family` found in config.")
    print(f"Loaded model: {type(model)}")
    return model

def visualize_all(visuals):
    # Get the corresponding visualizations
    row1 = [
        visuals['exo_rgb'],  # 'exo rgb'
        visuals['exo_rgb_boxed'],  # 'exo rgb'
        visuals['exo_rgb_boxed_contact'],  # 'exo rgb'
        visuals['exo_depth'],  # 'exo depth'
        visuals['exo_seg'],  # 'exo seg'
    ]

    row2 = [
        visuals['ego_rgb'],  # 'ego rgb'
        visuals['ego_rgb_boxed'],  # 'ego rgb'
        visuals['ego_rgb_boxed_contact'],  # 'ego rgb'
        visuals['ego_depth'],  # 'ego depth'
        visuals['ego_seg'],  # 'ego seg'
    ]

    # Function to preprocess images (convert grayscale to RGB and resize)
    def preprocess_image(image, target_size=(300, 300)):
        if len(image.shape) == 2:  # Convert grayscale to RGB
            image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        image = cv2.resize(image, target_size)
        return image

    # Process all images to uniform size and color format and concatenate horizontally
    row1_concat = np.hstack([preprocess_image(img) for img in row1])
    row2_concat = np.hstack([preprocess_image(img) for img in row2])

    # Concatenate vertically to form a 2x4 grid
    final_image = np.vstack([row1_concat, row2_concat])
    cv2.imshow('data', final_image)

from dataclasses import dataclass, field

def get_libero_dummy_action(model_family: str):
    """Get dummy/no-op action, used to roll out the simulation while the robot does nothing."""
    return [0, 0, 0, 0, 0, 0, -1]

@dataclass
class GenerateConfig:
    # fmt: off

    #################################################################################################################
    # Model-specific parameters
    #################################################################################################################
    model_family: str = "openvla"                    # Model family
    slot_type: str = "orc"                            # orc
    number_of_slots: int = 16                        # number of slots in the model
    pretrained_checkpoint: Union[str, Path] = "./orc_model"     # Pretrained checkpoint path
    custom_param_checkpoint: Union[str, Path] = "./orc_model/relate_object_bboxes_w_mask_actionable_s16h1.safetensors"   # Pretrained checkpoint path
    load_in_8bit: bool = False                       # (For OpenVLA only) Load with 8-bit quantization
    load_in_4bit: bool = False                       # (For OpenVLA only) Load with 4-bit quantization
    
    center_crop: bool = False                         # Center crop? (if trained w/ random crop image aug)

    #################################################################################################################
    # LIBERO environment-specific parameters
    #################################################################################################################
    task_suite_name: str = "real_data"            # Task suite. Options: libero_spatial, libero_object, libero_goal, libero_10, libero_90
    num_steps_wait: int = 20                        # Number of steps to wait for objects to stabilize in sim
    num_trials_per_task: int = 20                   # Number of rollouts per task

    #################################################################################################################
    # Utils
    #################################################################################################################
    run_id_note: Optional[str] = None                # Extra note to add in run ID for logging
    local_log_dir: str = "./experiments/logs"        # Local directory for eval logs
    saved_dir: str = "libero_goal_01_slots"             # Libero goal slots

    use_wandb: bool = False                          # Whether to also log results in Weights & Biases
    wandb_project: str = "YOUR_WANDB_PROJECT"        # Name of W&B project to log to (use default!)
    wandb_entity: str = "YOUR_WANDB_ENTITY"          # Name of entity to log under

    seed: int = 7                                    # Random Seed (for reproducibility)

    writing_extra_waits: bool = False
    # fmt: on

import re

def natural_key(s):
    return [int(text) if text.isdigit() else text for text in re.split(r'(\d+)', s)]

import cv2
import pickle

IMAGE_RESOLUTION = 256
from PIL import Image

def process_inputs(processor, pixel_values, device):
    image = Image.fromarray(pixel_values)
    image = image.convert("RGB")
    
    # Build VLA prompt
    action_dim = 7; future_horizon = 5
    prompt = f"In: What action should the robot take?\nOut: "
    placeholder_seg = "_ _ _ _ _ _ _ _"
    for fidx in range(future_horizon-1):
        placeholder_seg += " _ _ _ _ _ _ _"
    prompt = prompt + placeholder_seg + "</s>"

    # Process inputs.
    inputs = processor(prompt, image).to(device, dtype=torch.float16)
    inputs['input_ids'][0][-2-(action_dim*future_horizon)] = 29871
    # for key, value in inputs.items():
    #     print(key, value.shape)
    # 1/0
    return inputs

def set_seed_everywhere(seed: int):
    """Sets the random seed for Python, NumPy, and PyTorch functions."""
    torch.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
    np.random.seed(seed)
    random.seed(seed)
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False
    os.environ["PYTHONHASHSEED"] = str(seed)


def get_image_resize_size(cfg):
    """
    Gets image resize size for a model class.
    If `resize_size` is an int, then the resized image will be a square.
    Else, the image will be a rectangle.
    """
    if cfg.model_family == "openvla" or cfg.model_family == "customvla" or cfg.model_family == 'objectvla':
        resize_size = 224
    else:
        raise ValueError("Unexpected `model_family` found in config.")
    return resize_size


def get_current_slots(vla, batch, task_texts, in_past_tokens, device_id='cuda'):
    pixel_values = batch["pixel_values"].to(torch.bfloat16).to(device_id)
    outputs = vla.get_obj_slots(pixel_values, task_texts, in_past_tokens)
    return outputs

def get_normalized_actions(vla, batch, slot_outputs, device_id):
    # get object-centric dynamics
    patch_features = slot_outputs['patch_features']
    slotted_features = slot_outputs['visual_tokens']
    if 'interactable_features' in slot_outputs:
        slotted_features, _ = vla.select_top_k_slots(
                            slotted_features, slot_outputs['interactable_features'], k=4)
    clip_embeddings = slot_outputs['texts']
    clip_attention_mask = torch.logical_not(slot_outputs['texts_attn'])
    llama_input_ids = batch["input_ids"].to(device_id)
    llama_attention_mask = batch["attention_mask"].to(device_id)

    continuous_actions_pred = vla.decode_continuous_actions(
        patch_features=patch_features,
        slotted_features=slotted_features,
        clip_embeddings=clip_embeddings,
        clip_attention_mask=clip_attention_mask,
        llama_input_ids=llama_input_ids,
        llama_attention_mask=llama_attention_mask,
        llama_labels=None
    ) # will return output of [cross-modality-slots, cross-modality-bboxes]
    action_chunk, action_dim = continuous_actions_pred.shape[1:]

    return continuous_actions_pred[:,0,:]

def denormalize_actions(model, unnorm_key, normalized_actions):
    # Unnormalize actions
    action_norm_stats = model.get_action_stats(unnorm_key)
    mask = action_norm_stats.get("mask", np.ones_like(action_norm_stats["q01"], dtype=bool))
    action_high, action_low = np.array(action_norm_stats["q99"]), np.array(action_norm_stats["q01"])
    actions = np.where(
        mask,
        0.5 * (normalized_actions + 1) * (action_high - action_low) + action_low,
        normalized_actions,
    )
    return actions

def normalize_gripper_action(action, binarize=True):
    """
    Changes gripper action (last dimension of action vector) from [0,1] to [-1,+1].
    Necessary for some environments (not Bridge) because the dataset wrapper standardizes gripper actions to [0,1].
    Note that unlike the other action dimensions, the gripper action is not normalized to [-1,+1] by default by
    the dataset wrapper.

    Normalization formula: y = 2 * (x - orig_low) / (orig_high - orig_low) - 1
    """
    # Just normalize the last action to [-1,+1].
    orig_low, orig_high = 0.0, 1.0
    action[..., -1] = 2 * (action[..., -1] - orig_low) / (orig_high - orig_low) - 1

    if binarize:
        # Binarize to -1 or +1.
        action[..., -1] = np.sign(action[..., -1])

    return action

# from libero.libero import benchmark

@draccus.wrap()
def eval_libero(cfg: GenerateConfig) -> None:
    assert cfg.pretrained_checkpoint is not None, "cfg.pretrained_checkpoint must not be None!"
    # if "image_aug" in cfg.pretrained_checkpoint:
    #     assert cfg.center_crop, "Expecting `center_crop==True` because model was trained with image augmentations!"
    assert not (cfg.load_in_8bit and cfg.load_in_4bit), "Cannot use both 8-bit and 4-bit quantization!"

    # Set random seed
    set_seed_everywhere(cfg.seed)

    # [OpenVLA] Set action un-normalization key
    cfg.unnorm_key = cfg.task_suite_name

    # # Load model
    model = get_model(cfg)

    # [OpenVLA] Check that the model contains the action un-normalization key
    if cfg.model_family == "openvla":
        # In some cases, the key must be manually modified (e.g. after training on a modified version of the dataset
        # with the suffix "_no_noops" in the dataset name)
        if cfg.unnorm_key not in model.norm_stats and f"{cfg.unnorm_key}_no_noops" in model.norm_stats:
            cfg.unnorm_key = f"{cfg.unnorm_key}_no_noops"
        assert cfg.unnorm_key in model.norm_stats, f"Action un-norm key {cfg.unnorm_key} not found in VLA `norm_stats`!"

    # [OpenVLA] Get Hugging Face processor
    processor = None
    if cfg.model_family == "openvla":
        processor = get_processor(cfg)

    # Initialize local logging
    run_id = f"EVAL-{cfg.task_suite_name}-{cfg.model_family}-{DATE_TIME}"
    if cfg.run_id_note is not None:
        run_id += f"--{cfg.run_id_note}"
    os.makedirs(cfg.local_log_dir, exist_ok=True)
    local_log_filepath = os.path.join(cfg.local_log_dir, run_id + ".txt")
    log_file = open(local_log_filepath, "w")
    print(f"Logging to local log file: {local_log_filepath}")

    # Initialize LIBERO task suite
    benchmark_dict = benchmark.get_benchmark_dict()
    task_suite = benchmark_dict[cfg.task_suite_name]()
    num_tasks_in_suite = task_suite.n_tasks
    print(f"Task suite: {cfg.task_suite_name}")
    log_file.write(f"Task suite: {cfg.task_suite_name}\n")

    # Get expected image dimensions
    resize_size = get_image_resize_size(cfg)

    # Start evaluation
    total_episodes, total_successes = 0, 0
    extra_waits_dict = {}
    for task_id in tqdm.tqdm(range(num_tasks_in_suite)):
        # Get task
        task = task_suite.get_task(task_id)

        # Get default LIBERO initial states
        initial_states = task_suite.get_task_init_states(task_id)

        # Initialize LIBERO environment and task description
        env, task_description = get_libero_env(task, cfg.model_family, resolution=256)

        # Start episodes
        task_episodes, task_successes = 0, 0
        extra_waits = []
        for episode_idx in tqdm.tqdm(range(cfg.num_trials_per_task)):
            print(f"\nTask: {task_description}")
            log_file.write(f"\nTask: {task_description}\n")

            # Reset environment
            env.reset()

            # Set initial states
            obs = env.set_init_state(initial_states[episode_idx])
            
            # Setup
            t = 0
            replay_images = []
            if cfg.task_suite_name == "libero_spatial":
                max_steps = 220  # longest training demo has 193 steps
            elif cfg.task_suite_name == "libero_object":
                max_steps = 280  # longest training demo has 254 steps
            elif cfg.task_suite_name == "libero_goal":
                max_steps = 300  # longest training demo has 270 steps
            elif cfg.task_suite_name == "libero_10":
                max_steps = 520  # longest training demo has 505 steps
            elif cfg.task_suite_name == "libero_90":
                max_steps = 400  # longest training demo has 373 steps

            t = 0
            while t < cfg.num_steps_wait:
                # try:
                # IMPORTANT: Do nothing for the first few timesteps because the simulator drops objects
                # and we need to wait for them to fall
                obs, reward, done, info = env.step(get_libero_dummy_action(cfg.model_family))
                t += 1
            
            # Process observations and task
            task_texts = [task_description]
            texts = ['robot ' + task_description]
            img = get_libero_image(obs, resize_size)
            img = img[:,::-1,:]
            batch_data = process_inputs(processor=processor, pixel_values=img, device='cuda')

            horizon = 1
            batch_data['pixel_values'] = batch_data['pixel_values'].unsqueeze(1).repeat(1,horizon,1,1,1)            
            # Replicate frames across temporal dimension for initialization purposes
            # Get the object-centric slot embeddings
            with torch.autocast("cuda", dtype=torch.bfloat16):
                slot_outputs = get_current_slots(model, batch_data, texts, in_past_tokens=None, device_id='cuda')
                    
            # Query model to get several prelim actions
            with torch.autocast("cuda", dtype=torch.bfloat16):
                actions = get_normalized_actions(model, batch_data, slot_outputs, device_id='cuda')
                actions = actions.detach().float().cpu().numpy()
                unnormalized_actions = denormalize_actions(model, cfg.unnorm_key, actions)

            ## Start running the rest of the model here
            while t < max_steps + cfg.num_steps_wait:
                # Get preprocessed image
                img = get_libero_image(obs, resize_size)
                img = img[:,::-1,:]
                batch_data = process_inputs(processor=processor, pixel_values=img, device='cuda')
                # pixel_values    = batch_data['pixel_values']    #  torch.Size([1, 6, 224, 224])
                # input_ids       = batch_data['input_ids']       #  torch.Size([1, 50])
                # attention_mask  = batch_data['attention_mask']  # torch.Size([1, 50])
                # Save preprocessed image for replay video
                replay_images.append(img)

                # Getting frames across temporal dimension for initialization purposes
                batch_data['pixel_values'] = batch_data['pixel_values'].unsqueeze(1)
                # Get the object-centric slot embeddings
                with torch.autocast("cuda", dtype=torch.bfloat16):
                    slot_outputs = get_current_slots(model, batch_data, texts, in_past_tokens=None, device_id='cuda')
                                        
                # Query model to get several prelim actions
                with torch.autocast("cuda", dtype=torch.bfloat16):
                    actions = get_normalized_actions(model, batch_data, slot_outputs, device_id='cuda')
                    actions = actions.detach().float().cpu().numpy()
                    unnormalized_actions = denormalize_actions(model, cfg.unnorm_key, actions)
                    action = unnormalized_actions[0]

                # Normalize gripper action [0,1] -> [-1,+1] because the environment expects the latter
                action = normalize_gripper_action(action, binarize=True)

                # [OpenVLA] The dataloader flips the sign of the gripper action to align with other datasets
                # (0 = close, 1 = open), so flip it back (-1 = open, +1 = close) before executing the action
                # if cfg.model_family == "openvla":
                #     action = invert_gripper_action(action)

                # Execute action in environment
                obs, reward, done, info = env.step(action.tolist())
                t += 1
                if done:
                    task_successes += 1
                    total_successes += 1
                    break

            task_episodes += 1
            total_episodes += 1

            # Save a replay video of the episode
            cv2.destroyAllWindows()
            save_rollout_video(
                replay_images, total_episodes, success=done, task_description=task_description, log_file=log_file, saved_dir=cfg.saved_dir
            )
            # # Log current results
            print(f"Success: {done}")
            print(f"# episodes completed so far: {total_episodes}")
            print(f"# successes: {total_successes} ({total_successes / total_episodes * 100:.1f}%)")
            log_file.write(f"Success: {done}\n")
            log_file.write(f"# episodes completed so far: {total_episodes}\n")
            log_file.write(f"# successes: {total_successes} ({total_successes / total_episodes * 100:.1f}%)\n")
            log_file.flush()
            # # 1/0
        # 1/0
            
        # Log final results
        print(f"Current task success rate: {float(task_successes) / float(task_episodes)}")
        print(f"Current total success rate: {float(total_successes) / float(total_episodes)}")
        log_file.write(f"Current task success rate: {float(task_successes) / float(task_episodes)}\n")
        log_file.write(f"Current total success rate: {float(total_successes) / float(total_episodes)}\n")
        log_file.flush()

    # Save local log file
    log_file.close()

if __name__ == "__main__":
    eval_libero()