Upload 264 files

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+VLA-Adapter-UAV/eval_logs/Inference--CALVIN_Pro--4.50.log filter=lfs diff=lfs merge=lfs -text

VLA-Adapter-UAV/eval_logs/Inference--CALVIN_Pro--4.50.log

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34b6827c00a51d32673100c0259341ba2e8e94d91e70daa054c2fd8025063ebe
+size 14522527

VLA-Adapter-UAV/experiments/robot/aloha/README.md

@@ -0,0 +1,251 @@
+<div align="center">
+
+## Demo
+
+<video src="https://github.com/user-attachments/assets/63538db5-c776-40d9-8909-802e4c599eef" controls width="80%"></video>
+
+<br>
+
+**Sandwich Assembly** &mdash; Pick bread from rack &rarr; place on tray &rarr; add lettuce &rarr; add ham &rarr; cover with bread
+
+<sub>Cobot Magic &nbsp;|&nbsp; Bimanual 14-DOF &nbsp;|&nbsp; 3-Camera &nbsp;|&nbsp; 2&times; Speed</sub>
+
+</div>
+
+---
+
+# ALOHA Real-World
+
+Training, deployment, and evaluation pipeline for the ALOHA bimanual robot. For base installation, see the project root [`README.md`](../../../README.md). Successfully verified on [Cobot Magic](https://global.agilex.ai/products/cobot-magic).
+
+## Directory Structure
+
+```
+experiments/robot/aloha/
+├── train_files/
+│   ├── train_aloha.sh              # Training launcher (4-GPU torchrun)
+│   ├── setup_training.sh           # Dataset registration + optional local model loading
+│   ├── download_models.sh          # Download pretrained models (Qwen, DINOv2, SigLIP, Prismatic VLM)
+│   ├── qwen25.py                   # Drop-in replacement for local Qwen loading
+│   ├── materialize_local_vision.py # Drop-in replacement for local vision model loading
+│   └── dinosiglip_vit_local_vision.py  # Drop-in replacement for local DINOv2+SigLIP loading
+├── eval_files/
+│   ├── deploy_server.sh            # Launch inference server (MsgPack HTTP)
+│   ├── run_eval_client.sh          # Real robot client (requires ROS)
+│   └── run_eval_client_fake.sh     # Fake-data client (no ROS needed, for sanity-checking the pipeline)
+├── run_cobot_client.py             # Real ROS inference loop (3 cameras + bimanual 14-DOF)
+├── run_fake_cobot_client.py        # Fake-data inference loop (generates synthetic observations)
+├── requirements_aloha.txt          # ALOHA-specific dependencies
+└── README.md
+```
+
+## Prerequisites
+
+After completing the base installation from the root directory, install the ALOHA-specific dependencies:
+
+```bash
+pip install -r experiments/robot/aloha/requirements_aloha.txt
+```
+
+> **Real-robot deployment only**: `run_cobot_client.py` depends on ROS (`rospy`, `cv_bridge`, `sensor_msgs`, etc.) and must be run inside a ROS environment on the robot machine. The fake client `run_fake_cobot_client.py` does not require ROS.
+
+## Sanity Check: Verify the Inference Pipeline
+
+To confirm the inference pipeline works end-to-end without training, download an example checkpoint and run the server + fake client.
+
+```bash
+# 1. Download the example checkpoint
+huggingface-cli download --resume-download SII-CDZ/test_aloha_adapter \
+  --local-dir /path/to/SII-CDZ/test_aloha_adapter
+
+# 2. Start the inference server (set PRETRAINED_CHECKPOINT in deploy_server.sh to the path above)
+bash experiments/robot/aloha/eval_files/deploy_server.sh
+
+# 3. In another terminal, run the fake-data client (no ROS / real robot required)
+bash experiments/robot/aloha/eval_files/run_eval_client_fake.sh
+```
+
+The fake client sends synthetic 480x640x3 images and 14-DOF joint states to the server and checks whether action sequences are returned correctly. See [Deployment](#deployment) for detailed configuration.
+
+## Pipeline
+
+```bash
+# 0. (Optional) Download pretrained models locally
+bash experiments/robot/aloha/train_files/download_models.sh
+
+# 1. Convert hdf5 real-robot data to TFDS format
+#    See: https://github.com/cheng-haha/rlds_sim/tree/main/aloha_realworld
+
+# 2. Register the dataset
+bash experiments/robot/aloha/train_files/setup_training.sh <dataset_name>
+
+# 3. Train
+bash experiments/robot/aloha/train_files/train_aloha.sh
+
+# 4. Launch the inference server
+bash experiments/robot/aloha/eval_files/deploy_server.sh
+
+# 5. Run client-side evaluation
+bash experiments/robot/aloha/eval_files/run_eval_client_fake.sh   # fake-data sanity check
+bash experiments/robot/aloha/eval_files/run_eval_client.sh         # real-robot evaluation
+```
+
+## Training
+
+<details>
+<summary><b>Local Model Download (Optional)</b></summary>
+
+If you cannot access the HF Hub or prefer fully offline training, download all pretrained models in advance:
+
+```bash
+bash experiments/robot/aloha/train_files/download_models.sh
+# Or specify an HF token for private repos
+HF_TOKEN=hf_xxx bash experiments/robot/aloha/train_files/download_models.sh
+```
+
+Models downloaded:
+
+| Model | Local Path |
+|-------|------------|
+| `timm/vit_large_patch14_reg4_dinov2.lvd142m` | `${ROOT_DIR}/ai_models/timm/...` |
+| `timm/ViT-SO400M-14-SigLIP` | `${ROOT_DIR}/ai_models/timm/...` |
+| `Qwen/Qwen2.5-0.5B` | `${ROOT_DIR}/ai_models/Qwen/Qwen2.5-0.5B` |
+| `Stanford-ILIAD/prism-qwen25-extra-dinosiglip-224px-0_5b` | `${ROOT_DIR}/ai_models/Stanford-ILIAD/...` |
+
+After using the `--local-models` flag, `setup_training.sh` patches the project source files (`qwen25.py`, `materialize.py`, `dinosiglip_vit.py`) with local paths. To revert to online loading:
+
+```bash
+cd <project_root>
+git restore prismatic/models/backbones/llm/qwen25.py
+git restore prismatic/models/materialize.py
+git restore prismatic/models/backbones/vision/dinosiglip_vit.py
+```
+
+</details>
+
+### Data Preparation
+
+ALOHA data must be converted to TFDS format. See [rlds_sim/aloha_realworld](https://github.com/cheng-haha/rlds_sim/tree/main/aloha_realworld) for the conversion tool.
+
+### Configuration
+
+Before training, update the default path variables in the following scripts.
+
+**Key variables in `train_aloha.sh`:**
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `ROOT_DIR` | `/path/to/root` | Storage root directory |
+| `DATA_ROOT_DIR` | `${ROOT_DIR}/datasets/cobot_aloha/tfds` | TFDS data directory |
+| `VLM_PATH` | `${ROOT_DIR}/ai_models/Stanford-ILIAD/prism-qwen25-extra-dinosiglip-224px-0_5b` | VLM weights path |
+| `DATASET_NAME` | `bowl_stack_and_shelf_aloha_realworld_50` | Dataset name |
+| `WANDB_ENTITY` | `your-wandb-entity` | W&B user / team |
+| `WANDB_PROJECT` | `vla_adapter` | W&B project name |
+
+**Key variables in `setup_training.sh`:**
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `ROOT_DIR` | `/path/to/root` | Storage root directory |
+| `LOCAL_QWEN_PATH` | `${ROOT_DIR}/ai_models/Qwen/Qwen2.5-0.5B` | Local Qwen model path |
+| `LOCAL_TIMM_PATH` | `${ROOT_DIR}/ai_models/timm` | Local timm vision model path |
+
+**Default training hyperparameters (built into `train_aloha.sh`):**
+
+| Parameter | Value | Description |
+|-----------|-------|-------------|
+| `batch_size` | 12 | Per-GPU batch size |
+| `nproc-per-node` | 4 | Number of GPUs |
+| `learning_rate` | 2e-4 | Learning rate |
+| `max_steps` | 10005 | Maximum training steps |
+| `lora_rank` | 64 | LoRA rank |
+| `num_images_in_input` | 3 | Number of input images (front + left wrist + right wrist) |
+| `use_pro_version` | True | Use the Pro version (recommended) |
+| `use_minivlm` | True | Use MiniVLM |
+| `image_aug` | True | Image augmentation |
+
+> To adjust hyperparameters (e.g., fewer GPUs or a different batch size), edit the corresponding variables directly in `train_aloha.sh`.
+
+### Dataset Registration
+
+`setup_training.sh` automatically registers a new dataset entry in `configs.py`, `mixtures.py`, and `transforms.py` (ALOHA bimanual config: 3 image observation keys + bimanual joint encoding).
+
+```bash
+# Register dataset only (models loaded from HF Hub)
+bash experiments/robot/aloha/train_files/setup_training.sh bowl_stack_and_shelf_aloha_realworld_50
+
+# Register dataset + enable local model loading (offline environment)
+bash experiments/robot/aloha/train_files/setup_training.sh bowl_stack_and_shelf_aloha_realworld_50 --local-models
+```
+
+### Launch Training
+
+```bash
+bash experiments/robot/aloha/train_files/train_aloha.sh
+```
+
+Training outputs are saved to `outputs/<dataset_name>/<MODE>-<timestamp>/`; logs go to the `logs/` directory. W&B runs in offline mode by default.
+
+## Deployment
+
+Deployment follows a **server–client** architecture: the server loads a checkpoint and exposes an inference API over MsgPack HTTP; the client collects observations and sends requests to obtain action sequences.
+
+### Server
+
+Update the following variables in `deploy_server.sh`:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `PRETRAINED_CHECKPOINT` | `/path/to/checkpoint_dir` | Trained checkpoint directory |
+| `PORT` | `8888` | Server port |
+| `DEVICE` | `0` | GPU device ID |
+| `MODEL_FAMILY` | `openvla` | Model family |
+
+```bash
+bash experiments/robot/aloha/eval_files/deploy_server.sh
+```
+
+### Fake-Data Client (No ROS Required)
+
+Verifies the inference pipeline using synthetic observations — no real robot or ROS environment needed. Generates 480x640x3 fake images and 14-DOF fake joint states.
+
+Update the following variables in `run_eval_client_fake.sh`:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `VLA_SERVER_URL` | `http://127.0.0.1:8888` | Server address |
+| `TASK_LABEL` | `Use the right arm to stack...` | Task instruction |
+| `UNNORM_KEY` | `bowl_stack_and_shelf_aloha_realworld_50` | Action un-normalization key (must match the training dataset) |
+
+```bash
+bash experiments/robot/aloha/eval_files/run_eval_client_fake.sh
+```
+
+### Real-Robot Client (Requires ROS)
+
+Subscribes to 3 camera topics and bimanual joint states via ROS, queries the server for a new action sequence every `num_open_loop_steps` (default 25) steps, and supports multi-trial evaluation with automatic success-rate tracking.
+
+**Default ROS topics:**
+
+| Topic | Type | Description |
+|-------|------|-------------|
+| `/camera_f/color/image_raw` | Image | Front camera |
+| `/camera_l/color/image_raw` | Image | Left wrist camera |
+| `/camera_r/color/image_raw` | Image | Right wrist camera |
+| `/puppet/joint_left` | JointState | Left arm joint state |
+| `/puppet/joint_right` | JointState | Right arm joint state |
+| `/master/joint_left` | JointState | Left arm joint command (published) |
+| `/master/joint_right` | JointState | Right arm joint command (published) |
+
+```bash
+bash experiments/robot/aloha/eval_files/run_eval_client.sh
+```
+
+> To adapt to different robot hardware, modify the `OpenVLAConfig` dataclass in [`run_cobot_client.py`](./run_cobot_client.py) to adjust topic names, control frequency, open-loop steps, and other parameters.
+
+## Notes
+
+- Training defaults to 4 GPUs (`nproc-per-node 4`). For single-GPU training, update that value in `train_aloha.sh` and adjust `batch_size` accordingly.
+- During real-robot evaluation, the operator is prompted to press Enter to start each trial; pressing Space + Enter stops the current trial early.
+- Trial results (JSON) are saved under `experiments/logs/<unnorm_key>/`.
+- For more ALOHA evaluation references, see [openvla-oft/experiments/robot/aloha](https://github.com/moojink/openvla-oft/tree/main/experiments/robot/aloha).

VLA-Adapter-UAV/experiments/robot/aloha/demo/sandwich_assembly_bimanual_demo.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:267930f056ca823f6d09ab7a1cc1f1676d4b663bcc202f7a4c8dc8ca8cc005d2
+size 20089886

VLA-Adapter-UAV/experiments/robot/aloha/eval_files/deploy_server.sh

@@ -0,0 +1,14 @@
+PROJECT_PATH=realworld_vla_adapter
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_ROOT="$(cd "${SCRIPT_DIR}/../../../.." && pwd)"
+export PYTHONPATH="${PROJECT_ROOT}"
+pretrained_checkpoint="${PRETRAINED_CHECKPOINT:-/path/to/checkpoint_dir}"
+port="${PORT:-8888}"
+model_family="${MODEL_FAMILY:-openvla}"
+device="${DEVICE:-0}"
+
+python experiments/robot/server_deploy/deploy.py \
+        --pretrained_checkpoint $pretrained_checkpoint \
+        --model_family $model_family \
+        --port $port \
+        --device $device

VLA-Adapter-UAV/experiments/robot/aloha/eval_files/run_eval_client.sh

@@ -0,0 +1,15 @@
+PROJECT_PATH=realworld_vla_adapter
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_ROOT="$(cd "${SCRIPT_DIR}/../../../.." && pwd)"
+export PYTHONPATH="${PROJECT_ROOT}"
+
+# Allow passing the server URL as an argument or via VLA_SERVER_URL env variable.
+VLA_SERVER_URL="${VLA_SERVER_URL:-http://127.0.0.1:8888}"
+TASK_LABEL="${TASK_LABEL:-Use the right arm to stack the red bowl on the blue one, then use the left arm to place the stack on the shelf.}"
+UNNORM_KEY="${UNNORM_KEY:-bowl_stack_and_shelf_aloha_realworld_50}"
+
+python experiments/robot/aloha/run_cobot_client.py \
+  --use_vla_server \
+  --vla_server_url "${VLA_SERVER_URL}" \
+  --unnorm_key "${UNNORM_KEY}" \
+  --task_label "${TASK_LABEL}"

VLA-Adapter-UAV/experiments/robot/aloha/eval_files/run_eval_client_fake.sh

@@ -0,0 +1,15 @@
+PROJECT_PATH=realworld_vla_adapter
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_ROOT="$(cd "${SCRIPT_DIR}/../../../.." && pwd)"
+export PYTHONPATH="${PROJECT_ROOT}"
+
+# Allow passing the server URL as an argument or via VLA_SERVER_URL env variable.
+VLA_SERVER_URL="${VLA_SERVER_URL:-http://127.0.0.1:8888}"
+TASK_LABEL="${TASK_LABEL:-Use the right arm to stack the red bowl on the blue one, then use the left arm to place the stack on the shelf.}"
+UNNORM_KEY="${UNNORM_KEY:-bowl_stack_and_shelf_aloha_realworld_50}"
+
+python experiments/robot/aloha/run_fake_cobot_client.py \
+  --use_vla_server \
+  --vla_server_url "${VLA_SERVER_URL}" \
+  --unnorm_key "${UNNORM_KEY}" \
+  --task_label "${TASK_LABEL}"

VLA-Adapter-UAV/experiments/robot/aloha/requirements_aloha.txt

@@ -0,0 +1,29 @@
+# Extra Python packages for `experiments/robot/aloha` after the base install in README:
+#   pip install torch==2.2.0 torchvision==0.17.0 torchaudio==2.2.0
+#   pip install -e .
+#   pip install packaging ninja
+#   pip install "flash-attn==2.5.5" --no-build-isolation
+#
+# Most training dependencies are already covered by the commands above.
+# This file only keeps the ALOHA-specific extras that are still needed.
+
+# Required by the msgpack HTTP client used in fake/real eval clients.
+msgpack
+msgpack-numpy
+
+# Required by real-world ALOHA eval modules importing `real_env.py`.
+dm-env
+ipython
+
+# Optional but recommended if you want rollout videos from `save_rollout_video()`.
+imageio[ffmpeg]
+
+# Not installable from pip here; these must come from your ROS / robot environment:
+#   rospy
+#   cv_bridge
+#   std_msgs
+#   sensor_msgs
+#   nav_msgs
+#   geometry_msgs
+#   interbotix_xs_modules
+#   interbotix_xs_msgs

VLA-Adapter-UAV/experiments/robot/aloha/run_cobot_client.py

@@ -0,0 +1,681 @@
+#!/usr/bin/python3
+"""
+inference_openvla_oft.py
+
+A hybrid inference system that combines local ROS data collection with remote OpenVLA server inference.
+This allows local robot control while leveraging cloud-based OpenVLA models.
+"""
+
+import torch
+import numpy as np
+import os
+import pickle
+import argparse
+import json
+import select
+from einops import rearrange
+import socket
+import sys
+import time
+import threading
+import math
+import logging
+from collections import deque
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Union
+
+import rospy
+from std_msgs.msg import Header
+from geometry_msgs.msg import Twist
+from sensor_msgs.msg import JointState, Image
+from nav_msgs.msg import Odometry
+from cv_bridge import CvBridge
+
+# Append current directory so that interpreter can find experiments.robot
+# sys.path.append("/home/agilex/openvla-oft")
+sys.path.append(".")
+
+from experiments.robot.aloha.aloha_utils import (
+    # get_aloha_env,
+    get_aloha_image,
+    get_aloha_wrist_images,
+    get_next_task_label,
+    # save_rollout_video,
+)
+from experiments.robot.openvla_utils import resize_image_for_policy
+from experiments.robot.robot_utils import (
+    DATE_TIME,
+    MsgPackHttpClientPolicy,
+    get_image_resize_size,
+    set_seed_everywhere,
+)
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    handlers=[logging.StreamHandler()],
+)
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class OpenVLAConfig:
+    # fmt: off
+    
+    #################################################################################################################
+    # Model-specific parameters
+    #################################################################################################################
+    model_family: str = "openvla"                    # Model family
+    center_crop: bool = True                         # Center crop? (if trained w/ random crop image aug)
+    num_open_loop_steps: int = 25                    # Number of actions to execute open-loop before requerying policy
+    unnorm_key: str = ""                             # Dataset key for action un-normalization
+
+    use_vla_server: bool = True                      # Whether to query remote VLA server for actions
+    vla_server_url: Union[str, Path] = "0.0.0.0"  # Remote VLA server URL
+
+    #################################################################################################################
+    # Robot control parameters
+    #################################################################################################################
+    max_publish_step: int = 500                      # Max number of steps per episode
+    publish_rate: int = 40                           # Control frequency (Hz)
+    num_trials: int = 10                             # Number of inference trials to record
+    use_relative_actions: bool = False               # Whether to use relative actions (delta joint angles)
+    pos_lookahead_step: int = 25                     # Number of steps to look ahead
+    
+    #################################################################################################################
+    # ROS topic parameters
+    #################################################################################################################
+    img_front_topic: str = '/camera_f/color/image_raw'
+    img_left_topic: str = '/camera_l/color/image_raw' 
+    img_right_topic: str = '/camera_r/color/image_raw'
+    puppet_arm_left_topic: str = '/puppet/joint_left'
+    puppet_arm_right_topic: str = '/puppet/joint_right'
+    puppet_arm_left_cmd_topic: str = '/master/joint_left'
+    puppet_arm_right_cmd_topic: str = '/master/joint_right'
+    robot_base_topic: str = '/odom_raw'
+    robot_base_cmd_topic: str = '/cmd_vel'
+    
+    #################################################################################################################
+    # Robot base and movement parameters  
+    #################################################################################################################
+    use_robot_base: bool = False                     # Whether to use robot base movement
+    arm_steps_length: list = None                    # Step sizes for each joint
+    use_actions_interpolation: bool = False          # Whether to use action interpolation
+    
+    #################################################################################################################
+    # Utils
+    #################################################################################################################
+    run_id_note: Optional[str] = None                # Extra note to add to end of run ID for logging
+    local_log_dir: str = "./experiments/logs"        # Local directory for eval logs
+    seed: int = 42                                    # Random Seed
+    task_label: str = ""                             # Default task label used when prompting operator
+    
+    # fmt: on
+    
+    def __post_init__(self):
+        if self.arm_steps_length is None:
+            self.arm_steps_length = [0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.2]
+
+
+class RosOperator:
+    """ROS interface for robot control and data collection."""
+    
+    def __init__(self, cfg: OpenVLAConfig):
+        self.cfg = cfg
+        self.robot_base_deque = None
+        self.puppet_arm_right_deque = None
+        self.puppet_arm_left_deque = None
+        self.img_front_deque = None
+        self.img_right_deque = None
+        self.img_left_deque = None
+        self.bridge = None
+        self.puppet_arm_left_publisher = None
+        self.puppet_arm_right_publisher = None
+        self.robot_base_publisher = None
+        self.puppet_arm_publish_thread = None
+        self.puppet_arm_publish_lock = None
+        self.ctrl_state = False
+        self.ctrl_state_lock = threading.Lock()
+        self.init()
+        self.init_ros()
+
+    def init(self):
+        """Initialize data structures."""
+        self.bridge = CvBridge()
+        self.img_left_deque = deque()
+        self.img_right_deque = deque()
+        self.img_front_deque = deque()
+        self.puppet_arm_left_deque = deque()
+        self.puppet_arm_right_deque = deque()
+        self.robot_base_deque = deque()
+        self.puppet_arm_publish_lock = threading.Lock()
+        self.puppet_arm_publish_lock.acquire()
+
+    def puppet_arm_publish(self, left, right):
+        """Publish joint commands to both arms."""
+        joint_state_msg = JointState()
+        joint_state_msg.header = Header()
+        joint_state_msg.header.stamp = rospy.Time.now()
+        joint_state_msg.name = ['joint0', 'joint1', 'joint2', 'joint3', 'joint4', 'joint5', 'joint6']
+        joint_state_msg.position = left
+        self.puppet_arm_left_publisher.publish(joint_state_msg)
+        joint_state_msg.position = right
+        self.puppet_arm_right_publisher.publish(joint_state_msg)
+
+    def robot_base_publish(self, vel):
+        """Publish base velocity commands."""
+        vel_msg = Twist()
+        vel_msg.linear.x = vel[0]
+        vel_msg.linear.y = 0
+        vel_msg.linear.z = 0
+        vel_msg.angular.x = 0
+        vel_msg.angular.y = 0
+        vel_msg.angular.z = vel[1]
+        self.robot_base_publisher.publish(vel_msg)
+
+    def get_observation(self):
+        """Get synchronized observation from all sensors."""
+        if (len(self.img_left_deque) == 0 or len(self.img_right_deque) == 0 or 
+            len(self.img_front_deque) == 0 or len(self.puppet_arm_left_deque) == 0 or 
+            len(self.puppet_arm_right_deque) == 0):
+            return None
+            
+        if self.cfg.use_robot_base and len(self.robot_base_deque) == 0:
+            return None
+
+        # Get the latest timestamp from all sensors
+        frame_time = min([
+            self.img_left_deque[-1].header.stamp.to_sec(),
+            self.img_right_deque[-1].header.stamp.to_sec(), 
+            self.img_front_deque[-1].header.stamp.to_sec()
+        ])
+
+        # Check if all data is synchronized
+        if (self.img_left_deque[-1].header.stamp.to_sec() < frame_time or
+            self.img_right_deque[-1].header.stamp.to_sec() < frame_time or
+            self.img_front_deque[-1].header.stamp.to_sec() < frame_time or
+            self.puppet_arm_left_deque[-1].header.stamp.to_sec() < frame_time or
+            self.puppet_arm_right_deque[-1].header.stamp.to_sec() < frame_time):
+            return None
+            
+        if (self.cfg.use_robot_base and 
+            self.robot_base_deque[-1].header.stamp.to_sec() < frame_time):
+            return None
+
+        # Pop old data and get synchronized frames
+        while self.img_left_deque[0].header.stamp.to_sec() < frame_time:
+            self.img_left_deque.popleft()
+        img_left = self.bridge.imgmsg_to_cv2(self.img_left_deque.popleft(), 'passthrough')
+
+        while self.img_right_deque[0].header.stamp.to_sec() < frame_time:
+            self.img_right_deque.popleft()
+        img_right = self.bridge.imgmsg_to_cv2(self.img_right_deque.popleft(), 'passthrough')
+
+        while self.img_front_deque[0].header.stamp.to_sec() < frame_time:
+            self.img_front_deque.popleft()
+        img_front = self.bridge.imgmsg_to_cv2(self.img_front_deque.popleft(), 'passthrough')
+
+        while self.puppet_arm_left_deque[0].header.stamp.to_sec() < frame_time:
+            self.puppet_arm_left_deque.popleft()
+        puppet_arm_left = self.puppet_arm_left_deque.popleft()
+
+        while self.puppet_arm_right_deque[0].header.stamp.to_sec() < frame_time:
+            self.puppet_arm_right_deque.popleft()
+        puppet_arm_right = self.puppet_arm_right_deque.popleft()
+
+        robot_base = None
+        if self.cfg.use_robot_base:
+            while self.robot_base_deque[0].header.stamp.to_sec() < frame_time:
+                self.robot_base_deque.popleft()
+            robot_base = self.robot_base_deque.popleft()
+
+        # Construct observation dict
+        observation = {
+            'images': {
+                'cam_high': img_front,
+                'cam_left_wrist': img_left, 
+                'cam_right_wrist': img_right
+            },
+            'qpos': np.concatenate((
+                np.array(puppet_arm_left.position), 
+                np.array(puppet_arm_right.position)
+            ), axis=0),
+            'qvel': np.concatenate((
+                np.array(puppet_arm_left.velocity),
+                np.array(puppet_arm_right.velocity) 
+            ), axis=0),
+            'effort': np.concatenate((
+                np.array(puppet_arm_left.effort),
+                np.array(puppet_arm_right.effort)
+            ), axis=0)
+        }
+        
+        if self.cfg.use_robot_base and robot_base is not None:
+            base_vel = [robot_base.twist.twist.linear.x, robot_base.twist.twist.angular.z]
+            observation['qpos'] = np.concatenate((observation['qpos'], base_vel), axis=0)
+            
+        return observation
+
+    # ROS callback functions
+    def img_left_callback(self, msg):
+        if len(self.img_left_deque) >= 2000:
+            self.img_left_deque.popleft()
+        self.img_left_deque.append(msg)
+
+    def img_right_callback(self, msg):
+        if len(self.img_right_deque) >= 2000:
+            self.img_right_deque.popleft()
+        self.img_right_deque.append(msg)
+
+    def img_front_callback(self, msg):
+        if len(self.img_front_deque) >= 2000:
+            self.img_front_deque.popleft()
+        self.img_front_deque.append(msg)
+
+    def puppet_arm_left_callback(self, msg):
+        if len(self.puppet_arm_left_deque) >= 2000:
+            self.puppet_arm_left_deque.popleft()
+        self.puppet_arm_left_deque.append(msg)
+
+    def puppet_arm_right_callback(self, msg):
+        if len(self.puppet_arm_right_deque) >= 2000:
+            self.puppet_arm_right_deque.popleft()
+        self.puppet_arm_right_deque.append(msg)
+
+    def robot_base_callback(self, msg):
+        if len(self.robot_base_deque) >= 2000:
+            self.robot_base_deque.popleft()
+        self.robot_base_deque.append(msg)
+
+    def init_ros(self):
+        """Initialize ROS node and subscribers/publishers."""
+        rospy.init_node('openvla_inference', anonymous=True)
+        
+        # Subscribers
+        rospy.Subscriber(self.cfg.img_left_topic, Image, self.img_left_callback, 
+                        queue_size=1000, tcp_nodelay=True)
+        rospy.Subscriber(self.cfg.img_right_topic, Image, self.img_right_callback,
+                        queue_size=1000, tcp_nodelay=True)
+        rospy.Subscriber(self.cfg.img_front_topic, Image, self.img_front_callback,
+                        queue_size=1000, tcp_nodelay=True)
+        rospy.Subscriber(self.cfg.puppet_arm_left_topic, JointState, self.puppet_arm_left_callback,
+                        queue_size=1000, tcp_nodelay=True)
+        rospy.Subscriber(self.cfg.puppet_arm_right_topic, JointState, self.puppet_arm_right_callback,
+                        queue_size=1000, tcp_nodelay=True)
+        
+        if self.cfg.use_robot_base:
+            rospy.Subscriber(self.cfg.robot_base_topic, Odometry, self.robot_base_callback,
+                            queue_size=1000, tcp_nodelay=True)
+        
+        # Publishers
+        self.puppet_arm_left_publisher = rospy.Publisher(self.cfg.puppet_arm_left_cmd_topic, 
+                                                        JointState, queue_size=10)
+        self.puppet_arm_right_publisher = rospy.Publisher(self.cfg.puppet_arm_right_cmd_topic,
+                                                         JointState, queue_size=10)
+        if self.cfg.use_robot_base:
+            self.robot_base_publisher = rospy.Publisher(self.cfg.robot_base_cmd_topic,
+                                                       Twist, queue_size=10)
+
+
+def validate_config(cfg: OpenVLAConfig) -> None:
+    """Validate configuration parameters."""
+    assert cfg.use_vla_server, (
+        "Must use VLA server for remote inference! Please set --use_vla_server=True"
+    )
+    assert cfg.vla_server_url, "A valid --vla_server_url must be provided for MsgPack remote inference."
+    assert cfg.unnorm_key, "A valid --unnorm_key matching the deployed policy's dataset stats is required."
+
+
+def setup_logging(cfg: OpenVLAConfig):
+    """Set up logging to file.""" 
+    # Create run ID
+    run_id = f"OPENVLA-INFERENCE-{cfg.model_family}-{DATE_TIME}"
+    if cfg.run_id_note is not None:
+        run_id += f"--{cfg.run_id_note}"
+
+    # Set up local logging
+    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")
+    logger.info(f"Logging to local log file: {local_log_filepath}")
+
+    return log_file, local_log_filepath, run_id
+
+
+def log_message(message: str, log_file=None):
+    """Log a message to console and optionally to a log file."""
+    print(message)
+    logger.info(message)
+    if log_file:
+        log_file.write(message + "\n")
+        log_file.flush()
+
+
+def get_server_endpoint(cfg: OpenVLAConfig):
+    """Get the server endpoint for remote inference."""
+    server_url = str(cfg.vla_server_url).strip()
+    if server_url.startswith("http"):
+        return server_url.rstrip("/")
+
+    # Support host[:port] inputs without protocol
+    host_and_path = server_url.split("/", 1)[0]
+    if ":" in host_and_path:
+        host, port = host_and_path.split(":", 1)
+    else:
+        host, port = host_and_path, "8777"
+
+    ip_address = socket.gethostbyname(host)
+    protocol = "https" if any(keyword in host for keyword in ("nat-notebook", "ngrok")) else "http"
+    return f"{protocol}://{ip_address}:{port}"
+
+
+def prepare_observation_for_server(obs_data, task_description, resize_size):
+    """Prepare observation for OpenVLA server input."""
+    # Support both dict observations (real ROS bridge) and dm_env.TimeStep (ALOHA sim)
+    if isinstance(obs_data, dict) and "images" in obs_data:
+        img = obs_data["images"]["cam_high"]
+        left_wrist_img = obs_data["images"]["cam_left_wrist"]
+        right_wrist_img = obs_data["images"]["cam_right_wrist"]
+    else:
+        img = get_aloha_image(obs_data)  # Main camera image
+        left_wrist_img, right_wrist_img = get_aloha_wrist_images(obs_data)
+
+    # Resize images to size expected by model
+    img_resized = resize_image_for_policy(img, resize_size)
+    left_wrist_img_resized = resize_image_for_policy(left_wrist_img, resize_size)
+    right_wrist_img_resized = resize_image_for_policy(right_wrist_img, resize_size)
+
+    # Prepare observations dict for server
+    observation = {
+        "full_image": img_resized,
+        "left_wrist_image": left_wrist_img_resized,
+        "right_wrist_image": right_wrist_img_resized,
+        "state": obs_data['qpos'],
+        "instruction": task_description,
+    }
+
+    return observation, img_resized, left_wrist_img_resized, right_wrist_img_resized
+
+
+def manual_stop_requested() -> bool:
+    """Check whether the operator requested to stop the current trial via stdin."""
+    if not sys.stdin.isatty():
+        return False
+
+    try:
+        ready, _, _ = select.select([sys.stdin], [], [], 0)
+    except (ValueError, OSError):
+        return False
+
+    if ready:
+        raw_input = sys.stdin.readline()
+        if raw_input == "":
+            return False
+        user_signal = raw_input.rstrip("\r\n")
+        if user_signal == " " or user_signal.lower() in {"space", "stop", "s"}:
+            return True
+
+    return False
+
+
+def run_inference_loop(cfg: OpenVLAConfig, ros_operator: RosOperator, log_file=None, run_id: Optional[str] = None):
+    """Main inference loop supporting multiple trials."""
+    resize_size = get_image_resize_size(cfg)
+    server_endpoint = get_server_endpoint(cfg)
+    client = MsgPackHttpClientPolicy(host=server_endpoint)
+    log_message(f"Connecting to OpenVLA server at: {client.infer_url}", log_file)
+
+    previous_task_description = cfg.task_label
+    STEP_DURATION_IN_SEC = 1.0 / cfg.publish_rate
+    rate = rospy.Rate(cfg.publish_rate)
+
+    # Nominal joint targets used to settle the robot before each attempt
+    left0 = [-0.00133514404296875, 0.00209808349609375, 0.01583099365234375,
+             -0.032616615295410156, -0.00286102294921875, 0.00095367431640625, 3.557830810546875]
+    right0 = [-0.00133514404296875, 0.00438690185546875, 0.034523963928222656,
+              -0.053597450256347656, -0.00476837158203125, -0.00209808349609375, 3.557830810546875]
+
+    trial_results = []
+    total_successes = 0
+
+    for trial_idx in range(cfg.num_trials):
+        log_message(f"\n========== Trial {trial_idx + 1}/{cfg.num_trials} ==========", log_file)
+        task_description = get_next_task_label(previous_task_description)
+        previous_task_description = task_description
+        log_message(f"Task: {task_description}", log_file)
+        log_message("Tip: press <Space> then Enter at any time to stop this trial early.", log_file)
+
+        action_queue = deque(maxlen=cfg.num_open_loop_steps)
+        t = 0
+        curr_state = None
+
+        ros_operator.puppet_arm_publish(left0, right0)
+        time.sleep(3)
+        log_message("Prepare the scene, and then press Enter to begin...", log_file)
+        input()
+
+        episode_start_time = time.time()
+        total_model_query_time = 0.0
+
+        try:
+            while t < cfg.max_publish_step and not rospy.is_shutdown():
+                if manual_stop_requested():
+                    log_message("Manual stop requested; ending trial early.", log_file)
+                    break
+                step_start_time = time.time()
+
+                obs_data = ros_operator.get_observation()
+                if obs_data is None:
+                    log_message("Waiting for synchronized sensor data...", log_file)
+                    rate.sleep()
+                    continue
+
+                if len(action_queue) == 0:
+                    log_message("Requerying OpenVLA server...", log_file)
+                    observation, _, _, _ = prepare_observation_for_server(obs_data, task_description, resize_size)
+                    observation["unnorm_key"] = cfg.unnorm_key
+
+                    model_query_start_time = time.time()
+                    try:
+                        response = client.infer(observation)
+                        actions = np.array(response["actions"])
+                        actions = actions[: cfg.num_open_loop_steps]
+                        total_model_query_time += time.time() - model_query_start_time
+                        action_queue.extend(actions)
+                        log_message(f"Received {len(actions)} actions from server", log_file)
+                    except Exception as e:
+                        log_message(f"Error querying server: {e}", log_file)
+                        rate.sleep()
+                        continue
+
+                action = action_queue.popleft()
+                log_message("-----------------------------------------------------", log_file)
+                log_message(f"t: {t}", log_file)
+                log_message(f"action: {action}", log_file)
+
+                if cfg.use_relative_actions:
+                    if curr_state is None:
+                        curr_state = obs_data['qpos']
+                    rel_action = action
+                    target_state = curr_state + rel_action
+                    left_action = target_state[:7]
+                    right_action = target_state[7:14]
+                    curr_state = target_state
+                else:
+                    left_action = action[:7]
+                    right_action = action[7:14]
+
+                ros_operator.puppet_arm_publish(left_action, right_action)
+
+                if cfg.use_robot_base and len(action) > 14:
+                    vel_action = action[14:16]
+                    ros_operator.robot_base_publish(vel_action)
+
+                t += 1
+
+                step_elapsed_time = time.time() - step_start_time
+                if step_elapsed_time < STEP_DURATION_IN_SEC:
+                    time.sleep(STEP_DURATION_IN_SEC - step_elapsed_time)
+
+        except (KeyboardInterrupt, Exception) as e:
+            if isinstance(e, KeyboardInterrupt):
+                log_message("\nCaught KeyboardInterrupt: Terminating episode early.", log_file)
+            else:
+                log_message(f"\nCaught exception: {e}", log_file)
+
+        episode_end_time = time.time()
+        num_queries = max(1, t // cfg.num_open_loop_steps)
+        avg_inference_time = total_model_query_time / num_queries
+
+        user_input = input("Success? Enter 'y' or 'n': ")
+        success = user_input.strip().lower() == "y"
+        if success:
+            total_successes += 1
+
+        current_trial_count = len(trial_results) + 1
+        success_rate = total_successes / current_trial_count
+        trial_stats = {
+            "trial_index": trial_idx + 1,
+            "task_description": task_description,
+            "success": success,
+            "total_steps": t,
+            "model_query_time": total_model_query_time,
+            "episode_duration": episode_end_time - episode_start_time,
+            "avg_inference_time": avg_inference_time,
+            "cumulative_success_rate": success_rate,
+        }
+        trial_results.append(trial_stats)
+
+        log_message("\nTrial summary:", log_file)
+        log_message(f"Total steps: {t}", log_file)
+        log_message(f"Total model query time: {total_model_query_time:.2f} sec", log_file)
+        log_message(f"Episode duration: {trial_stats['episode_duration']:.2f} sec", log_file)
+        log_message(f"Average inference time: {avg_inference_time:.3f} sec", log_file)
+        log_message(f"Success: {success}", log_file)
+        log_message(
+            f"Current success rate: {total_successes}/{len(trial_results)} ({success_rate * 100:.1f}%)",
+            log_file,
+        )
+
+        if rospy.is_shutdown():
+            break
+
+    if trial_results:
+        final_success_rate = total_successes / len(trial_results)
+        log_message("\nFinal multi-trial summary:", log_file)
+        log_message(f"Total trials run: {len(trial_results)}", log_file)
+        log_message(f"Total successes: {total_successes}", log_file)
+        log_message(f"Overall success rate: {final_success_rate * 100:.1f}%", log_file)
+
+        results_filename = f"{run_id or f'cobot_{DATE_TIME}'}_results.json"
+        results_subdir = os.path.join(cfg.local_log_dir, cfg.unnorm_key or "default")
+        os.makedirs(results_subdir, exist_ok=True)
+        results_path = os.path.join(results_subdir, results_filename)
+        with open(results_path, "w") as f:
+            json.dump(trial_results, f, indent=2)
+        log_message(f"Saved trial results to {results_path}", log_file)
+
+    return trial_results
+
+
+def main():
+    """Main function."""
+    parser = argparse.ArgumentParser(description="OpenVLA remote inference with local ROS control")
+    
+    # Model parameters
+    parser.add_argument('--model_family', type=str, default='openvla', help='Model family')
+    parser.add_argument('--center_crop', action='store_true', help='Center crop images')
+    parser.add_argument('--num_open_loop_steps', type=int, default=25, help='Open loop steps')
+    
+    # Server parameters  
+    parser.add_argument('--use_vla_server', action='store_true', default=True, help='Use VLA server')
+    parser.add_argument('--vla_server_url', type=str, default='0.0.0.0', help='VLA server URL')
+    parser.add_argument('--unnorm_key', type=str, default='', help='Dataset key for action un-normalization')
+    
+    # Robot control parameters
+    parser.add_argument('--max_publish_step', type=int, default=10000, help='Max steps per episode')
+    parser.add_argument('--publish_rate', type=int, default=40, help='Control frequency Hz')
+    parser.add_argument('--num_trials', type=int, default=10, help='Number of inference trials to record')
+    parser.add_argument('--use_relative_actions', action='store_true', help='Use relative actions')
+    parser.add_argument('--pos_lookahead_step', type=int, default=25, help='Lookahead steps')
+    
+    # ROS topics
+    parser.add_argument('--img_front_topic', type=str, default='/camera_f/color/image_raw')
+    parser.add_argument('--img_left_topic', type=str, default='/camera_l/color/image_raw')
+    parser.add_argument('--img_right_topic', type=str, default='/camera_r/color/image_raw')
+    parser.add_argument('--puppet_arm_left_topic', type=str, default='/puppet/joint_left')
+    parser.add_argument('--puppet_arm_right_topic', type=str, default='/puppet/joint_right')
+    parser.add_argument('--puppet_arm_left_cmd_topic', type=str, default='/master/joint_left')
+    parser.add_argument('--puppet_arm_right_cmd_topic', type=str, default='/master/joint_right')
+    parser.add_argument('--robot_base_topic', type=str, default='/odom_raw')
+    parser.add_argument('--robot_base_cmd_topic', type=str, default='/cmd_vel')
+    
+    # Robot base
+    parser.add_argument('--use_robot_base', action='store_true', help='Use robot base')
+    parser.add_argument('--use_actions_interpolation', action='store_true', help='Use action interpolation')
+    
+    # Utils
+    parser.add_argument('--run_id_note', type=str, help='Run ID note')
+    parser.add_argument('--local_log_dir', type=str, default='./experiments/logs', help='Log directory')
+    parser.add_argument('--seed', type=int, default=7, help='Random seed')
+    parser.add_argument('--task_label', type=str, default='', help='Default task label for get_next_task_label')
+    
+    args = parser.parse_args()
+    
+    # Create config from args
+    cfg = OpenVLAConfig(
+        model_family=args.model_family,
+        center_crop=args.center_crop,
+        num_open_loop_steps=args.num_open_loop_steps,
+        use_vla_server=args.use_vla_server,
+        vla_server_url=args.vla_server_url,
+        unnorm_key=args.unnorm_key,
+        max_publish_step=args.max_publish_step,
+        publish_rate=args.publish_rate,
+        num_trials=args.num_trials,
+        use_relative_actions=args.use_relative_actions,
+        pos_lookahead_step=args.pos_lookahead_step,
+        img_front_topic=args.img_front_topic,
+        img_left_topic=args.img_left_topic,
+        img_right_topic=args.img_right_topic,
+        puppet_arm_left_topic=args.puppet_arm_left_topic,
+        puppet_arm_right_topic=args.puppet_arm_right_topic,
+        puppet_arm_left_cmd_topic=args.puppet_arm_left_cmd_topic,
+        puppet_arm_right_cmd_topic=args.puppet_arm_right_cmd_topic,
+        robot_base_topic=args.robot_base_topic,
+        robot_base_cmd_topic=args.robot_base_cmd_topic,
+        use_robot_base=args.use_robot_base,
+        use_actions_interpolation=args.use_actions_interpolation,
+        run_id_note=args.run_id_note,
+        local_log_dir=args.local_log_dir,
+        seed=args.seed,
+        task_label=args.task_label,
+    )
+    
+    # Validate config
+    validate_config(cfg)
+    
+    # Set random seed
+    set_seed_everywhere(cfg.seed)
+    
+    # Setup logging
+    log_file, local_log_filepath, run_id = setup_logging(cfg)
+    
+    # Initialize ROS operator
+    ros_operator = RosOperator(cfg)
+    
+    log_message("OpenVLA remote inference initialized", log_file)
+    log_message(f"Config: {cfg}", log_file)
+    
+    try:
+        # Run inference loop
+        run_inference_loop(cfg, ros_operator, log_file, run_id=run_id)
+    finally:
+        if log_file:
+            log_file.close()
+
+
+if __name__ == "__main__":
+    main() 

VLA-Adapter-UAV/experiments/robot/aloha/run_fake_cobot_client.py

@@ -0,0 +1,310 @@
+#!/usr/bin/python3
+"""
+run_fake_cobot_client.py
+
+Lightweight client that mimics the cobot inference loop without requiring ROS.
+It fabricates proprioception and image observations with the same shapes as the
+real robot logs (e.g., qpos (14,), camera frames 480x640x3) and streams them to
+the remote OpenVLA server over MsgPack HTTP.
+"""
+
+import argparse
+import logging
+import os
+import socket
+import sys
+import time
+from collections import deque
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Union
+
+import numpy as np
+np.set_printoptions(precision=8, suppress=True)
+
+from experiments.robot.openvla_utils import resize_image_for_policy
+from experiments.robot.robot_utils import (
+    DATE_TIME,
+    MsgPackHttpClientPolicy,
+    get_image_resize_size,
+    set_seed_everywhere,
+)
+
+# Append current directory so that interpreter can find experiments.robot
+sys.path.append(".")
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    handlers=[logging.StreamHandler()],
+)
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class FakeOpenVLAConfig:
+    # fmt: off
+    #################################################################################################################
+    # Server parameters
+    #################################################################################################################
+    use_vla_server: bool = True                      # Whether to query remote VLA server for actions
+    vla_server_url: Union[str, Path] = "0.0.0.0"  # Remote VLA server URL
+    unnorm_key: str = ""                             # Dataset key for action un-normalization
+
+    #################################################################################################################
+    # Model parameters
+    #################################################################################################################
+    model_family: str = "openvla"
+    center_crop: bool = True
+    num_open_loop_steps: int = 25
+
+    #################################################################################################################
+    # Fake stream parameters
+    #################################################################################################################
+    sequence_length: int = 260                       # Matches collected episode length
+    num_joints: int = 14                             # qpos dimensionality per frame
+    image_height: int = 480
+    image_width: int = 640
+    max_publish_step: int = 1000                     # Safety upper bound for loop
+
+    #################################################################################################################
+    # Utils
+    #################################################################################################################
+    run_id_note: Optional[str] = None
+    local_log_dir: str = "./experiments/logs"
+    seed: int = 7
+    task_label: str = "open the box"
+    # fmt: on
+
+
+class FakeRobotStream:
+    """Generates deterministic fake proprio and image observations."""
+
+    def __init__(self, cfg: FakeOpenVLAConfig):
+        self.cfg = cfg
+        self.rng = np.random.default_rng(cfg.seed)
+        self.step = 0
+
+    def reset(self):
+        self.step = 0
+
+    def get_observation(self):
+        """
+        Returns a dictionary shaped like the real ROS observation:
+        - images: cam_high, cam_left_wrist, cam_right_wrist in 480x640x3 uint8
+        - qpos: 14D vector (matches dataset episode shape (260, 14))
+        """
+        if self.step >= self.cfg.sequence_length:
+            return None
+
+        t = self.step
+        base_angles = np.linspace(-np.pi, np.pi, self.cfg.num_joints)
+        qpos = np.sin(base_angles + 0.05 * t).astype(np.float32)
+        qpos += 0.01 * self.rng.standard_normal(self.cfg.num_joints).astype(np.float32)
+
+        observation = {
+            "images": {
+                "cam_high": self._generate_image(t, 0.0),
+                "cam_left_wrist": self._generate_image(t, 0.25),
+                "cam_right_wrist": self._generate_image(t, 0.5),
+            },
+            "qpos": qpos,
+        }
+        self.step += 1
+        return observation
+
+    def _generate_image(self, step: int, phase: float) -> np.ndarray:
+        """Create a simple gradient pattern with slight temporal variation."""
+        height, width = self.cfg.image_height, self.cfg.image_width
+        x = np.linspace(0, 1, width, dtype=np.float32)
+        y = np.linspace(0, 1, height, dtype=np.float32)[:, None]
+        base = (x + y + 0.02 * step + phase) % 1.0
+        img = np.stack(
+            [
+                base,
+                np.roll(base, 1, axis=1),
+                np.roll(base, 2, axis=1),
+            ],
+            axis=-1,
+        )
+        noise = self.rng.uniform(-0.02, 0.02, size=img.shape)
+        img = np.clip(img + noise, 0.0, 1.0)
+        return (img * 255).astype(np.uint8)
+
+
+def setup_logging(cfg: FakeOpenVLAConfig):
+    """Set up logging to file."""
+    run_id = f"OPENVLA-FAKE-INFERENCE-{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")
+    logger.info(f"Logging to local log file: {local_log_filepath}")
+    return log_file, local_log_filepath, run_id
+
+
+def log_message(message: str, log_file=None):
+    """Log a message to console and optionally to a log file."""
+    print(message)
+    logger.info(message)
+    if log_file:
+        log_file.write(message + "\n")
+        log_file.flush()
+
+
+def validate_config(cfg: FakeOpenVLAConfig):
+    assert cfg.use_vla_server, "Fake client still requires --use_vla_server for remote inference."
+    assert cfg.vla_server_url, "A valid --vla_server_url must be provided."
+    assert cfg.unnorm_key, "A valid --unnorm_key matching the remote policy is required."
+    assert cfg.sequence_length > 0, "--sequence_length must be positive."
+    assert cfg.num_joints > 0, "--num_joints must be positive."
+
+
+def get_server_endpoint(cfg: FakeOpenVLAConfig):
+    """Normalize different URL formats into a base URL for MsgPack client."""
+    server_url = str(cfg.vla_server_url).strip()
+    if server_url.startswith("http"):
+        return server_url.rstrip("/")
+
+    host_and_path = server_url.split("/", 1)[0]
+    if ":" in host_and_path:
+        host, port = host_and_path.split(":", 1)
+    else:
+        host, port = host_and_path, "8777"
+
+    ip_address = socket.gethostbyname(host)
+    protocol = "https" if any(keyword in host for keyword in ("nat-notebook", "ngrok")) else "http"
+    return f"{protocol}://{ip_address}:{port}"
+
+
+def prepare_observation_for_server(obs_data, task_description, resize_size, unnorm_key):
+    """Format fake observation into the payload required by the server."""
+    img_front = resize_image_for_policy(obs_data["images"]["cam_high"], resize_size)
+    left_wrist = resize_image_for_policy(obs_data["images"]["cam_left_wrist"], resize_size)
+    right_wrist = resize_image_for_policy(obs_data["images"]["cam_right_wrist"], resize_size)
+
+    observation = {
+        "full_image": img_front,
+        "left_wrist_image": left_wrist,
+        "right_wrist_image": right_wrist,
+        "state": obs_data["qpos"],
+        "instruction": task_description,
+        "unnorm_key": unnorm_key,
+    }
+    return observation
+
+
+def run_inference_loop(cfg: FakeOpenVLAConfig, log_file=None):
+    """Main fake inference loop."""
+    resize_size = get_image_resize_size(cfg)
+    server_endpoint = get_server_endpoint(cfg)
+    client = MsgPackHttpClientPolicy(host=server_endpoint)
+    log_message(f"Connecting to OpenVLA server at: {client.infer_url}", log_file)
+    log_message(f"Task: {cfg.task_label}", log_file)
+
+    stream = FakeRobotStream(cfg)
+    action_queue = deque(maxlen=cfg.num_open_loop_steps)
+
+    total_model_query_time = 0.0
+    t = 0
+
+    try:
+        while t < min(cfg.max_publish_step, cfg.sequence_length):
+            obs_data = stream.get_observation()
+            if obs_data is None:
+                log_message("Fake stream exhausted. Stopping episode.", log_file)
+                break
+
+            if len(action_queue) == 0:
+                observation = prepare_observation_for_server(
+                    obs_data,
+                    cfg.task_label,
+                    resize_size,
+                    cfg.unnorm_key,
+                )
+                log_message("Requerying OpenVLA server...", log_file)
+                model_query_start_time = time.time()
+                try:
+                    response = client.infer(observation)
+                except Exception as exc:
+                    log_message(f"Error querying server: {exc}", log_file)
+                    break
+                actions = np.array(response["actions"])
+                actions = actions[: cfg.num_open_loop_steps]
+                total_model_query_time += time.time() - model_query_start_time
+                action_queue.extend(actions)
+                log_message(f"Received {len(actions)} actions from server", log_file)
+
+            action = action_queue.popleft()
+            log_message(f"Step {t}: action={action}", log_file)
+            t += 1
+
+        log_message("\nEpisode completed:", log_file)
+        log_message(f"Total steps: {t}", log_file)
+        log_message(f"Total model query time: {total_model_query_time:.2f} sec", log_file)
+    except KeyboardInterrupt:
+        log_message("\nCaught KeyboardInterrupt: Terminating episode early.", log_file)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Fake OpenVLA remote inference client (no ROS).")
+
+    # Server parameters
+    parser.add_argument("--use_vla_server", action="store_true", default=True, help="Use VLA server")
+    parser.add_argument("--vla_server_url", type=str, default="0.0.0.0", help="VLA server URL")
+    parser.add_argument("--unnorm_key", type=str, default="", help="Dataset key for action un-normalization")
+
+    # Model parameters
+    parser.add_argument("--model_family", type=str, default="openvla", help="Model family")
+    parser.add_argument("--center_crop", action="store_true", help="Center crop images")
+    parser.add_argument("--num_open_loop_steps", type=int, default=25, help="Open loop steps")
+
+    # Fake stream parameters
+    parser.add_argument("--sequence_length", type=int, default=260, help="Length of fake episode")
+    parser.add_argument("--num_joints", type=int, default=14, help="Dimensionality of qpos vector")
+    parser.add_argument("--image_height", type=int, default=480, help="Source image height")
+    parser.add_argument("--image_width", type=int, default=640, help="Source image width")
+    parser.add_argument("--max_publish_step", type=int, default=1000, help="Maximum steps to execute")
+
+    # Utils
+    parser.add_argument("--run_id_note", type=str, help="Run ID note")
+    parser.add_argument("--local_log_dir", type=str, default="./experiments/logs", help="Log directory")
+    parser.add_argument("--seed", type=int, default=7, help="Random seed")
+    parser.add_argument("--task_label", type=str, default="open the box", help="Task description")
+
+    args = parser.parse_args()
+
+    cfg = FakeOpenVLAConfig(
+        use_vla_server=args.use_vla_server,
+        vla_server_url=args.vla_server_url,
+        unnorm_key=args.unnorm_key,
+        model_family=args.model_family,
+        center_crop=args.center_crop,
+        num_open_loop_steps=args.num_open_loop_steps,
+        sequence_length=args.sequence_length,
+        num_joints=args.num_joints,
+        image_height=args.image_height,
+        image_width=args.image_width,
+        max_publish_step=args.max_publish_step,
+        run_id_note=args.run_id_note,
+        local_log_dir=args.local_log_dir,
+        seed=args.seed,
+        task_label=args.task_label,
+    )
+
+    validate_config(cfg)
+    set_seed_everywhere(cfg.seed)
+
+    log_file, _, _ = setup_logging(cfg)
+    try:
+        run_inference_loop(cfg, log_file)
+    finally:
+        if log_file:
+            log_file.close()
+
+
+if __name__ == "__main__":
+    main()

VLA-Adapter-UAV/experiments/robot/aloha/train_files/dinosiglip_vit_local_vision.py

@@ -0,0 +1,215 @@
+"""
+dinosiglip_vit.py
+
+Vision backbone that returns concatenated features from both DINOv2 and SigLIP.
+"""
+
+from dataclasses import dataclass
+from functools import partial
+from typing import Callable, Dict, Tuple
+from pathlib import Path
+
+import timm
+import torch
+from PIL import Image
+from timm.models.vision_transformer import Block, VisionTransformer
+from torch.distributed.fsdp.wrap import _module_wrap_policy, _or_policy, transformer_auto_wrap_policy
+from torchvision.transforms import Compose, Resize
+
+from prismatic.models.backbones.vision.base_vision import (
+    ImageTransform,
+    LetterboxPad,
+    VisionBackbone,
+    compute_sequence_patches,
+    unpack_tuple,
+)
+
+# Registry =>> Supported DinoSigLIP Pairs (as TIMM identifiers)
+DINOSigLIP_VISION_BACKBONES = {
+    "dinosiglip-vit-so-224px": {
+        "dino": "vit_large_patch14_reg4_dinov2.lvd142m",
+        "siglip": "vit_so400m_patch14_siglip_224",
+    },
+    "dinosiglip-vit-so-384px": {
+        "dino": "vit_large_patch14_reg4_dinov2.lvd142m",
+        "siglip": "vit_so400m_patch14_siglip_384",
+    },
+}
+
+
+@dataclass
+class DinoSigLIPImageTransform:
+    dino_image_transform: ImageTransform
+    siglip_image_transform: ImageTransform
+    is_prismatic: bool = True
+
+    def __call__(self, img: Image, **kwargs: str) -> Dict[str, torch.Tensor]:
+        return {"dino": self.dino_image_transform(img, **kwargs), "siglip": self.siglip_image_transform(img, **kwargs)}
+
+
+def find_hf_checkpoint(model_dir: Path) -> Path:
+    """Find the model checkpoint file within a Hugging Face Hub cache directory."""
+    for pattern in ["*.bin"]:
+        if files := list(model_dir.glob(pattern)):
+            return files[0]
+
+    raise FileNotFoundError(f"No model checkpoint file found in {model_dir} or its snapshots.")
+
+
+class DinoSigLIPViTBackbone(VisionBackbone):
+    def __init__(
+        self,
+        vision_backbone_id: str,
+        image_resize_strategy: str,
+        default_image_size: int = 224,
+        image_sequence_len: int = 1,
+        vision_models_path: str = None,
+    ) -> None:
+        super().__init__(
+            vision_backbone_id,
+            image_resize_strategy,
+            default_image_size=default_image_size,
+            image_sequence_len=image_sequence_len,
+        )
+        dino_model_name = DINOSigLIP_VISION_BACKBONES[vision_backbone_id]["dino"]
+        siglip_model_name = DINOSigLIP_VISION_BACKBONES[vision_backbone_id]["siglip"]
+
+        # Create model keyword arguments
+        dino_kwargs = {"pretrained": False, "num_classes": 0, "img_size": self.default_image_size}
+        siglip_kwargs = {"pretrained": False, "num_classes": 0, "img_size": self.default_image_size}
+
+        # If a local path is provided, update kwargs to load from local checkpoints.
+        if vision_models_path:
+            if siglip_model_name == 'vit_so400m_patch14_siglip_224':
+                siglip_model_local_path = 'ViT-SO400M-14-SigLIP'
+            else:
+                siglip_model_local_path = siglip_model_name
+
+            dino_dir = Path(vision_models_path) / f"{dino_model_name}"
+            siglip_dir = Path(vision_models_path) / f"{siglip_model_local_path}"
+
+            dino_checkpoint = find_hf_checkpoint(dino_dir)
+            siglip_checkpoint = find_hf_checkpoint(siglip_dir)
+
+            dino_kwargs["checkpoint_path"] = str(dino_checkpoint)
+            siglip_kwargs["checkpoint_path"] = str(siglip_checkpoint)
+
+        # Initialize both Featurizers (ViTs) by downloading from HF / TIMM Hub or loading from local path
+        self.dino_featurizer: VisionTransformer = timm.create_model(dino_model_name, **dino_kwargs)
+        self.dino_featurizer.eval()
+
+        self.siglip_featurizer: VisionTransformer = timm.create_model(siglip_model_name, **siglip_kwargs)
+        self.siglip_featurizer.eval()
+
+        # Monkey-Patch the `forward()` function of the featurizers to ensure FSDP-compatibility
+        #   => Note: By default set `get_intermediate_layers` to return the *SECOND-TO-LAST* layer patches!
+        #   => TODO (siddk) Remove after resolution of https://github.com/pytorch/pytorch/issues/109385
+        self.dino_featurizer.forward = unpack_tuple(
+            partial(self.dino_featurizer.get_intermediate_layers, n={len(self.dino_featurizer.blocks) - 2})
+        )
+        self.siglip_featurizer.forward = unpack_tuple(
+            partial(self.siglip_featurizer.get_intermediate_layers, n={len(self.siglip_featurizer.blocks) - 2})
+        )
+
+        # Get Configs for _both_ Featurizers =>> Note :: Override default image size for larger resolution models
+        self.dino_data_cfg = timm.data.resolve_model_data_config(self.dino_featurizer)
+        self.dino_data_cfg["input_size"] = (3, self.default_image_size, self.default_image_size)
+
+        self.siglip_data_cfg = timm.data.resolve_model_data_config(self.siglip_featurizer)
+        self.siglip_data_cfg["input_size"] = (3, self.default_image_size, self.default_image_size)
+
+        # Initialize *both* Transforms
+        default_dino_transform = timm.data.create_transform(**self.dino_data_cfg, is_training=False)
+        default_siglip_transform = timm.data.create_transform(**self.siglip_data_cfg, is_training=False)
+
+        # Fix =>> SigLIP default transform resizes to *larger* than `self.default_image_size` (crops image)!!
+        assert isinstance(default_siglip_transform, Compose), "Unexpected `default_image_transform`!"
+        assert isinstance(default_siglip_transform.transforms[0], Resize)
+        default_siglip_transform = Compose(
+            [
+                Resize(self.default_image_size, interpolation=default_siglip_transform.transforms[0].interpolation),
+                *default_siglip_transform.transforms[1:],
+            ]
+        )
+
+        if self.image_resize_strategy == "resize-naive":
+            assert isinstance(default_dino_transform, Compose), "Unexpected `default_dino_image_transform`!"
+            assert isinstance(default_siglip_transform, Compose), "Unexpected `default_siglip_image_transform`!"
+            assert isinstance(default_dino_transform.transforms[0], Resize)
+            assert isinstance(default_siglip_transform.transforms[0], Resize)
+
+            target_size = (self.default_image_size, self.default_image_size)
+            dino_transform = Compose(
+                [
+                    Resize(target_size, interpolation=default_dino_transform.transforms[0].interpolation),
+                    *default_dino_transform.transforms[1:],
+                ]
+            )
+            siglip_transform = Compose(
+                [
+                    Resize(target_size, interpolation=default_siglip_transform.transforms[0].interpolation),
+                    *default_siglip_transform.transforms[1:],
+                ]
+            )
+
+            self.image_transform = DinoSigLIPImageTransform(dino_transform, siglip_transform)
+
+        elif self.image_resize_strategy == "resize-crop":
+            self.image_transform = DinoSigLIPImageTransform(default_dino_transform, default_siglip_transform)
+
+        elif self.image_resize_strategy == "letterbox":
+            assert isinstance(default_dino_transform, Compose), "Unexpected `default_dino_transform`!"
+            assert isinstance(default_siglip_transform, Compose), "Unexpected `default_siglip_transform`!"
+            assert (
+                "mean" in self.dino_data_cfg and "mean" in self.siglip_data_cfg
+            ), "DinoSigLIP `data_cfg` missing `mean`!"
+
+            # Compute Padding Fill Value(s) (rescaled normalization mean if applicable)
+            dino_fill = tuple([int(x * 255) for x in self.dino_data_cfg["mean"]])
+            siglip_fill = tuple([int(x * 255) for x in self.siglip_data_cfg["mean"]])
+
+            # Build New Transform
+            self.image_transform = DinoSigLIPImageTransform(
+                Compose([LetterboxPad(dino_fill), *default_dino_transform.transforms]),
+                Compose([LetterboxPad(siglip_fill), *default_siglip_transform.transforms]),
+            )
+
+        else:
+            raise ValueError(f"Image Resize Strategy `{self.image_resize_strategy}` is not supported!")
+
+    def get_fsdp_wrapping_policy(self) -> Callable:
+        """Return a simple FSDP policy that wraps each ViT block and then both of the _entire_ featurizers."""
+        vit_wrap_policy = partial(_module_wrap_policy, module_classes={VisionTransformer})
+        transformer_block_policy = partial(transformer_auto_wrap_policy, transformer_layer_cls={Block})
+        return partial(_or_policy, policies=[vit_wrap_policy, transformer_block_policy])
+
+    def forward(self, pixel_values: Dict[str, torch.Tensor]) -> torch.Tensor:
+        """Runs the transformed image/pixel tensors through each vision backbone, returning concatenated patches."""
+        if self.image_sequence_len == 1:
+            dino_patches = self.dino_featurizer(pixel_values["dino"])
+            siglip_patches = self.siglip_featurizer(pixel_values["siglip"])
+        else:
+            featurizers = {
+                "dino": self.dino_featurizer,
+                "siglip": self.siglip_featurizer,
+            }
+            patches = compute_sequence_patches(pixel_values, featurizers, self.image_sequence_len)
+            dino_patches, siglip_patches = patches["dino"], patches["siglip"]
+        return torch.cat([dino_patches, siglip_patches], dim=2)
+
+    @property
+    def default_image_resolution(self) -> Tuple[int, int, int]:
+        return self.dino_data_cfg["input_size"]
+
+    @property
+    def embed_dim(self) -> int:
+        return self.dino_featurizer.embed_dim + self.siglip_featurizer.embed_dim
+
+    @property
+    def num_patches(self) -> int:
+        assert self.dino_featurizer.patch_embed.num_patches == self.siglip_featurizer.patch_embed.num_patches
+        return self.dino_featurizer.patch_embed.num_patches * self.image_sequence_len
+
+    @property
+    def half_precision_dtype(self) -> torch.dtype:
+        return torch.bfloat16

VLA-Adapter-UAV/experiments/robot/aloha/train_files/download_models.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+#========== Download pretrained models from HuggingFace ==========#
+#
+# Usage:
+#   bash download_models.sh
+#   HF_TOKEN=your_huggingface_token bash download_models.sh
+#
+# HF_TOKEN is optional for public repos. If provided, it will be used.
+# ROOT_DIR can be edited below or overridden via environment variable.
+# Skips download if model directory already exists and is non-empty.
+#
+
+# User-configurable default root path.
+DEFAULT_ROOT_DIR="/path/to/root"
+ROOT_DIR="${ROOT_DIR:-${DEFAULT_ROOT_DIR}}"
+MODEL_DIR="${ROOT_DIR}/ai_models"
+HF_TOKEN="${HF_TOKEN:-}"
+
+download_model() {
+  local repo="$1"
+  local local_dir="$2"
+
+  if [ -d "${local_dir}" ] && [ "$(ls -A "${local_dir}" 2>/dev/null)" ]; then
+    echo "[SKIP] ${repo} already exists at ${local_dir}"
+    return
+  fi
+
+  echo "[DOWNLOAD] ${repo} -> ${local_dir}"
+  if [ -n "${HF_TOKEN}" ]; then
+    huggingface-cli download --resume-download \
+      "${repo}" \
+      --local-dir "${local_dir}" \
+      --token "${HF_TOKEN}"
+  else
+    huggingface-cli download --resume-download \
+      "${repo}" \
+      --local-dir "${local_dir}"
+  fi
+}
+
+download_model "timm/vit_large_patch14_reg4_dinov2.lvd142m" \
+  "${MODEL_DIR}/timm/vit_large_patch14_reg4_dinov2.lvd142m"
+
+download_model "timm/ViT-SO400M-14-SigLIP" \
+  "${MODEL_DIR}/timm/ViT-SO400M-14-SigLIP"
+
+download_model "Qwen/Qwen2.5-0.5B" \
+  "${MODEL_DIR}/Qwen/Qwen2.5-0.5B"
+
+download_model "Stanford-ILIAD/prism-qwen25-extra-dinosiglip-224px-0_5b" \
+  "${MODEL_DIR}/Stanford-ILIAD/prism-qwen25-extra-dinosiglip-224px-0_5b"
+
+echo "Done."

VLA-Adapter-UAV/experiments/robot/aloha/train_files/materialize_local_vision.py

@@ -0,0 +1,183 @@
+"""
+materialize.py
+
+Factory class for initializing Vision Backbones, LLM Backbones, and VLMs from a set registry; provides and exports
+individual functions for clear control flow.
+"""
+
+from typing import Optional, Tuple
+
+from transformers import PreTrainedTokenizerBase
+
+from prismatic.models.backbones.llm import LLaMa2LLMBackbone, LLMBackbone, MistralLLMBackbone, PhiLLMBackbone
+from prismatic.models.backbones.llm.qwen25 import Qwen25LLMBackbone
+from prismatic.models.backbones.vision import (
+    CLIPViTBackbone,
+    DinoCLIPViTBackbone,
+    DinoSigLIPViTBackbone,
+    DinoV2ViTBackbone,
+    ImageTransform,
+    IN1KViTBackbone,
+    SigLIPViTBackbone,
+    VisionBackbone,
+)
+from prismatic.models.vlms import PrismaticVLM
+
+# === Registries =>> Maps ID --> {cls(), kwargs} :: Different Registries for Vision Backbones, LLM Backbones, VLMs ===
+# fmt: off
+
+# === Vision Backbone Registry ===
+VISION_BACKBONES = {
+    # === 224px Backbones ===
+    "clip-vit-l": {"cls": CLIPViTBackbone, "kwargs": {"default_image_size": 224}},
+    "siglip-vit-so400m": {"cls": SigLIPViTBackbone, "kwargs": {"default_image_size": 224}},
+    "dinov2-vit-l": {"cls": DinoV2ViTBackbone, "kwargs": {"default_image_size": 224}},
+    "in1k-vit-l": {"cls": IN1KViTBackbone, "kwargs": {"default_image_size": 224}},
+    "dinosiglip-vit-so-224px": {"cls": DinoSigLIPViTBackbone, "kwargs": {"default_image_size": 224, "vision_models_path": "__LOCAL_TIMM_PATH__"}},
+
+    # === Assorted CLIP Backbones ===
+    "clip-vit-b": {"cls": CLIPViTBackbone, "kwargs": {"default_image_size": 224}},
+    "clip-vit-l-336px": {"cls": CLIPViTBackbone, "kwargs": {"default_image_size": 336}},
+
+    # === Assorted SigLIP Backbones ===
+    "siglip-vit-b16-224px": {"cls": SigLIPViTBackbone, "kwargs": {"default_image_size": 224}},
+    "siglip-vit-b16-256px": {"cls": SigLIPViTBackbone, "kwargs": {"default_image_size": 256}},
+    "siglip-vit-b16-384px": {"cls": SigLIPViTBackbone, "kwargs": {"default_image_size": 384}},
+    "siglip-vit-so400m-384px": {"cls": SigLIPViTBackbone, "kwargs": {"default_image_size": 384}},
+
+    # === Fused Backbones ===
+    "dinoclip-vit-l-336px": {"cls": DinoCLIPViTBackbone, "kwargs": {"default_image_size": 336}},
+    "dinosiglip-vit-so-384px": {"cls": DinoSigLIPViTBackbone, "kwargs": {"default_image_size": 384}},
+}
+
+
+# === Language Model Registry ===
+LLM_BACKBONES = {
+    # === LLaMa-2 Pure (Non-Chat) Backbones ===
+    "llama2-7b-pure": {"cls": LLaMa2LLMBackbone, "kwargs": {}},
+    "llama2-13b-pure": {"cls": LLaMa2LLMBackbone, "kwargs": {}},
+
+    # === LLaMa-2 Chat Backbones ===
+    "llama2-7b-chat": {"cls": LLaMa2LLMBackbone, "kwargs": {}},
+    "llama2-13b-chat": {"cls": LLaMa2LLMBackbone, "kwargs": {}},
+
+    # === Vicuna-v1.5 Backbones ===
+    "vicuna-v15-7b": {"cls": LLaMa2LLMBackbone, "kwargs": {}},
+    "vicuna-v15-13b": {"cls": LLaMa2LLMBackbone, "kwargs": {}},
+
+    # === Mistral v0.1 Backbones ===
+    "mistral-v0.1-7b-pure": {"cls": MistralLLMBackbone, "kwargs": {}},
+    "mistral-v0.1-7b-instruct": {"cls": MistralLLMBackbone, "kwargs": {}},
+
+    # === Phi-2 Backbone ===
+    "phi-2-3b": {"cls": PhiLLMBackbone, "kwargs": {}},
+
+    # === Qwen2.5 Backbone ===
+    "qwen25-0_5b-pure": {"cls": Qwen25LLMBackbone, "kwargs": {}},
+    "qwen25-0_5b-extra": {"cls": Qwen25LLMBackbone, "kwargs": {"num_extra_tokens": 256}},
+    "qwen25-1_5b-pure": {"cls": Qwen25LLMBackbone, "kwargs": {}},
+    "qwen25-3b-pure": {"cls": Qwen25LLMBackbone, "kwargs": {}},
+}
+
+# fmt: on
+
+
+def get_vision_backbone_and_transform(
+    vision_backbone_id: str,
+    image_resize_strategy: str,
+    image_sequence_len: int,
+) -> Tuple[VisionBackbone, ImageTransform]:
+    """Instantiate a Vision Backbone, returning both the nn.Module wrapper class and default Image Transform."""
+    if vision_backbone_id in VISION_BACKBONES:
+        vision_cfg = VISION_BACKBONES[vision_backbone_id]
+        vision_backbone: VisionBackbone = vision_cfg["cls"](
+            vision_backbone_id, image_resize_strategy, image_sequence_len=image_sequence_len, **vision_cfg["kwargs"]
+        )
+        image_transform = vision_backbone.get_image_transform()
+        return vision_backbone, image_transform
+
+    else:
+        raise ValueError(f"Vision Backbone `{vision_backbone_id}` is not supported!")
+
+
+# def _is_network_or_dns_error(e: Exception) -> bool:
+#     s = str(e)
+#     return (
+#         "Name or service not known" in s or
+#         "Failed to resolve" in s or
+#         "HTTPSConnectionPool" in s or
+#         isinstance(e, socket.gaierror)
+#     )
+
+
+# from typing import Tuple, Optional, Any, Dict
+# def get_vision_backbone_and_transform(
+#     vision_backbone_id: str,
+#     image_resize_strategy: str,
+#     image_sequence_len: int,
+#     *,
+#     checkpoint_path: Optional[str] = None,
+#     pretrained: Optional[bool] = None,
+#     **extra_kwargs: Any,  
+# ) -> Tuple[VisionBackbone, ImageTransform]:
+#     """Instantiate a Vision Backbone, returning both the nn.Module wrapper class and default Image Transform."""
+#     if vision_backbone_id not in VISION_BACKBONES:
+#         raise ValueError(f"Vision Backbone `{vision_backbone_id}` is not supported!")
+
+#     vision_cfg = VISION_BACKBONES[vision_backbone_id]
+
+
+#     merged_kwargs: Dict[str, Any] = dict(vision_cfg["kwargs"])
+#     if pretrained is not None:
+#         merged_kwargs["pretrained"] = pretrained
+#     if checkpoint_path is not None:
+#         merged_kwargs["checkpoint_path"] = checkpoint_path
+#     merged_kwargs.update(extra_kwargs)
+
+#     vision_backbone: VisionBackbone = vision_cfg["cls"](
+#         vision_backbone_id,
+#         image_resize_strategy,
+#         image_sequence_len=image_sequence_len,
+#         **merged_kwargs,
+#     )
+#     image_transform = vision_backbone.get_image_transform()
+#     return vision_backbone, image_transform
+
+
+def get_llm_backbone_and_tokenizer(
+    llm_backbone_id: str,
+    llm_max_length: int = 2048,
+    hf_token: Optional[str] = None,
+    inference_mode: bool = False,
+) -> Tuple[LLMBackbone, PreTrainedTokenizerBase]:
+    if llm_backbone_id in LLM_BACKBONES:
+        llm_cfg = LLM_BACKBONES[llm_backbone_id]
+        llm_backbone: LLMBackbone = llm_cfg["cls"](
+            llm_backbone_id,
+            llm_max_length=llm_max_length,
+            hf_token=hf_token,
+            inference_mode=inference_mode,
+            **llm_cfg["kwargs"],
+        )
+        tokenizer = llm_backbone.get_tokenizer()
+        return llm_backbone, tokenizer
+
+    else:
+        raise ValueError(f"LLM Backbone `{llm_backbone_id}` is not supported!")
+
+
+def get_vlm(
+    model_id: str,
+    arch_specifier: str,
+    vision_backbone: VisionBackbone,
+    llm_backbone: LLMBackbone,
+    enable_mixed_precision_training: bool = True,
+) -> PrismaticVLM:
+    """Lightweight wrapper around initializing a VLM, mostly for future-proofing (if one wants to add a new VLM)."""
+    return PrismaticVLM(
+        model_id,
+        vision_backbone,
+        llm_backbone,
+        enable_mixed_precision_training=enable_mixed_precision_training,
+        arch_specifier=arch_specifier,
+    )

VLA-Adapter-UAV/experiments/robot/aloha/train_files/qwen25.py

@@ -0,0 +1,86 @@
+"""
+qwen2_5.py
+
+Class definition for all LLMs derived from QwenForCausalLM.
+"""
+
+from typing import Optional, Sequence, Type
+
+import torch
+from transformers import AutoModelForCausalLM
+from transformers.models.qwen2.modeling_qwen2 import Qwen2DecoderLayer
+
+from prismatic.models.backbones.llm.base_llm import HFCausalLLMBackbone
+from prismatic.models.backbones.llm.prompting.base_prompter import PromptBuilder
+from prismatic.models.backbones.llm.prompting.qwen_prompter import QwenPromptBuilder
+
+# Registry =>> Support Qwen-2.5 Models (from HF Transformers)
+# fmt: off
+QWEN25_MODELS = {
+    # === Pure Qwen2.5 (non-instruct/chat-tuned) Models ===
+    "qwen25-0_5b-extra": {
+        "llm_family": "qwen2.5", "llm_cls": AutoModelForCausalLM, "hf_hub_path": "__LOCAL_QWEN_PATH__"
+    },
+    "qwen25-0_5b-pure": {
+        "llm_family": "qwen2.5", "llm_cls": AutoModelForCausalLM, "hf_hub_path": "Qwen/Qwen2.5-0.5B"
+    },
+    "qwen25-1_5b-pure": {
+        "llm_family": "qwen2.5", "llm_cls": AutoModelForCausalLM, "hf_hub_path": "Qwen/Qwen2.5-1.5B"
+    },
+    "qwen25-3b-pure": {
+        "llm_family": "qwen2.5", "llm_cls": AutoModelForCausalLM, "hf_hub_path": "Qwen/Qwen2.5-3B"
+    },
+    "qwen25-7b-pure": {
+        "llm_family": "qwen2.5", "llm_cls": AutoModelForCausalLM, "hf_hub_path": "Qwen/Qwen2.5-7B"
+    },
+
+}
+# fmt: on
+
+
+class Qwen25LLMBackbone(HFCausalLLMBackbone):
+    def __init__(
+        self,
+        llm_backbone_id: str,
+        llm_max_length: int = 2048,
+        hf_token: Optional[str] = None,
+        inference_mode: bool = False,
+        use_flash_attention_2: bool = True,
+        num_extra_tokens: int = 0,
+    ) -> None:
+        super().__init__(
+            llm_backbone_id,
+            llm_max_length=llm_max_length,
+            hf_token=hf_token,
+            inference_mode=inference_mode,
+            use_flash_attention_2=use_flash_attention_2,
+            **QWEN25_MODELS[llm_backbone_id],
+        )
+
+        # add some more special tokens
+        if num_extra_tokens > 0:
+            added = self.tokenizer.add_tokens([f"<|extra_{i}|>" for i in range(num_extra_tokens)])
+            assert added == num_extra_tokens, f"Added {added} of {num_extra_tokens} extra tokens to tokenizer!"
+            print(f"Added {num_extra_tokens} extra tokens.")
+
+        # there is already a special token for Qwen
+        # self.tokenizer.add_special_tokens({"pad_token": "<PAD>"})
+        self.llm.config.pad_token_id = self.tokenizer.pad_token_id
+        self.llm.resize_token_embeddings(len(self.tokenizer), pad_to_multiple_of=64)
+
+    @property
+    def prompt_builder_fn(self) -> Type[PromptBuilder]:
+        return QwenPromptBuilder
+
+    @property
+    def transformer_layer_cls(self) -> Type[torch.nn.Module]:
+        return Qwen2DecoderLayer
+
+    @property
+    def half_precision_dtype(self) -> torch.dtype:
+        return torch.bfloat16
+
+    @property
+    def last_layer_finetune_modules(self) -> Sequence[torch.nn.Module]:
+        # TODO not sure that this works
+        return (self.llm.model.embed_tokens, self.llm.model.layers[-1], self.llm.lm_head)

VLA-Adapter-UAV/experiments/robot/aloha/train_files/setup_training.sh

@@ -0,0 +1,159 @@
+#!/bin/bash
+#========== One-click training setup: register dataset + local Qwen + optional local model loading ==========#
+#
+# Usage:
+#   bash setup_training.sh <dataset_name> [--local-models]
+#
+# Examples:
+#   # Register dataset only (vision models loaded from HF Hub)
+#   bash setup_training.sh bowl_stack_and_shelf_aloha_realworld_50
+#
+#   # Register dataset + enable local model loading (no internet needed)
+#   bash setup_training.sh bowl_stack_and_shelf_aloha_realworld_50 --local-models
+#
+# What it does:
+#   1. Adds the dataset entry to configs.py, mixtures.py, transforms.py
+#   2. (--local-models) Replaces qwen25.py so qwen25-0_5b-extra loads from the local disk path
+#   3. (--local-models) Replaces materialize.py and dinosiglip_vit.py with
+#      local-loading versions that read vision weights from disk instead of HF Hub
+#
+# How to restore overwritten files with git:
+#   cd <project_root>
+#   git restore prismatic/models/backbones/llm/qwen25.py
+#   git restore prismatic/models/materialize.py
+#   git restore prismatic/models/backbones/vision/dinosiglip_vit.py
+#
+# How to re-enable network download instead of local files:
+#   1. Restore qwen25.py to re-enable HF loading for Qwen:
+#      git restore prismatic/models/backbones/llm/qwen25.py
+#   2. If you previously used --local-models, also restore the two vision files:
+#      git restore prismatic/models/materialize.py
+#      git restore prismatic/models/backbones/vision/dinosiglip_vit.py
+#
+# Local path settings:
+#   Edit ROOT_DIR / LOCAL_QWEN_PATH / LOCAL_TIMM_PATH below before running this script.
+#   These values will be written into the overwritten training files.
+#
+
+set -euo pipefail
+
+# User-configurable local model paths.
+ROOT_DIR="${ROOT_DIR:-/path/to/root}"
+LOCAL_QWEN_PATH="${LOCAL_QWEN_PATH:-${ROOT_DIR}/ai_models/Qwen/Qwen2.5-0.5B}"
+LOCAL_TIMM_PATH="${LOCAL_TIMM_PATH:-${ROOT_DIR}/ai_models/timm}"
+
+DATASET_NAME="${1:?Usage: bash setup_training.sh <dataset_name> [--local-models]}"
+LOCAL_MODELS_FLAG="${2:-}"
+
+# Auto-detect project root (script is at experiments/robot/aloha/train_files/)
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_ROOT="$(cd "${SCRIPT_DIR}/../../../.." && pwd)"
+
+CONFIGS="${PROJECT_ROOT}/prismatic/vla/datasets/rlds/oxe/configs.py"
+MIXTURES="${PROJECT_ROOT}/prismatic/vla/datasets/rlds/oxe/mixtures.py"
+TRANSFORMS="${PROJECT_ROOT}/prismatic/vla/datasets/rlds/oxe/transforms.py"
+
+########################################
+# Step 1: Register dataset
+########################################
+
+check_exists() {
+  if grep -q "\"${DATASET_NAME}\"" "$1" 2>/dev/null; then
+    echo "[SKIP] ${DATASET_NAME} already exists in $(basename $1)"
+    return 0
+  fi
+  return 1
+}
+
+render_template() {
+  local src="$1"
+  local dst="$2"
+  local qwen_escaped="${LOCAL_QWEN_PATH//&/\\&}"
+  local timm_escaped="${LOCAL_TIMM_PATH//&/\\&}"
+
+  sed \
+    -e "s|__LOCAL_QWEN_PATH__|${qwen_escaped}|g" \
+    -e "s|__LOCAL_TIMM_PATH__|${timm_escaped}|g" \
+    "${src}" > "${dst}"
+}
+
+# Add to configs.py
+if ! check_exists "${CONFIGS}"; then
+  sed -i '/^}$/i\
+    "'"${DATASET_NAME}"'": {\
+        "image_obs_keys": {"primary": "image", "secondary": None, "left_wrist": "left_wrist_image", "right_wrist": "right_wrist_image"},\
+        "depth_obs_keys": {"primary": None, "secondary": None, "wrist": None},\
+        "state_obs_keys": ["state"],\
+        "state_encoding": StateEncoding.JOINT_BIMANUAL,\
+        "action_encoding": ActionEncoding.JOINT_POS_BIMANUAL,\
+    },' "${CONFIGS}"
+  echo "[ADDED] ${DATASET_NAME} to configs.py"
+fi
+
+# Add to mixtures.py
+if ! check_exists "${MIXTURES}"; then
+  sed -i '/^# fmt: on$/i\
+    "'"${DATASET_NAME}"'": [\
+        ("'"${DATASET_NAME}"'", 1.0),\
+    ],' "${MIXTURES}"
+  echo "[ADDED] ${DATASET_NAME} to mixtures.py"
+fi
+
+# Add to transforms.py
+if ! check_exists "${TRANSFORMS}"; then
+  sed -i '/^}$/i\
+    "'"${DATASET_NAME}"'": aloha_dataset_transform,' "${TRANSFORMS}"
+  echo "[ADDED] ${DATASET_NAME} to transforms.py"
+fi
+
+echo "[OK] Dataset '${DATASET_NAME}' registered."
+
+########################################
+# Step 2: Enable local model loading
+########################################
+
+if [ "${LOCAL_MODELS_FLAG}" = "--local-models" ] || [ "${LOCAL_MODELS_FLAG}" = "--local-vision" ]; then
+  QWEN25_SRC="${SCRIPT_DIR}/qwen25.py"
+  QWEN25_DST="${PROJECT_ROOT}/prismatic/models/backbones/llm/qwen25.py"
+  MATERIALIZE_SRC="${SCRIPT_DIR}/materialize_local_vision.py"
+  DINOSIGLIP_SRC="${SCRIPT_DIR}/dinosiglip_vit_local_vision.py"
+  MATERIALIZE_DST="${PROJECT_ROOT}/prismatic/models/materialize.py"
+  DINOSIGLIP_DST="${PROJECT_ROOT}/prismatic/models/backbones/vision/dinosiglip_vit.py"
+
+  if [ ! -f "${QWEN25_SRC}" ] || [ ! -f "${MATERIALIZE_SRC}" ] || [ ! -f "${DINOSIGLIP_SRC}" ]; then
+    echo "[ERROR] Local model files not found in ${SCRIPT_DIR}"
+    exit 1
+  fi
+
+  if [[ "${ROOT_DIR}" == "/path/to/root" ]] || [[ "${LOCAL_QWEN_PATH}" == /path/to/root/* ]] || [[ "${LOCAL_TIMM_PATH}" == /path/to/root/* ]]; then
+    echo "[ERROR] Please set ROOT_DIR, or set LOCAL_QWEN_PATH and LOCAL_TIMM_PATH explicitly before using --local-models."
+    exit 1
+  fi
+
+  render_template "${QWEN25_SRC}" "${QWEN25_DST}"
+  render_template "${MATERIALIZE_SRC}" "${MATERIALIZE_DST}"
+  cp "${DINOSIGLIP_SRC}" "${DINOSIGLIP_DST}"
+  echo "[OK] Local model loading enabled (materialize.py + dinosiglip_vit.py replaced)."
+  echo "     Qwen will be loaded from local disk: ${LOCAL_QWEN_PATH}"
+  echo "     Vision models will be loaded from local disk: ${LOCAL_TIMM_PATH}"
+else
+  echo "[INFO] HF / default model loading remains enabled."
+  echo "       Use --local-models if you want local Qwen + local vision loading."
+fi
+
+echo
+echo "Configured local paths:"
+echo "  LOCAL_QWEN_PATH=${LOCAL_QWEN_PATH}"
+echo "  LOCAL_TIMM_PATH=${LOCAL_TIMM_PATH}"
+echo
+echo "Restore commands:"
+echo "  cd ${PROJECT_ROOT}"
+echo "  git restore prismatic/models/backbones/llm/qwen25.py"
+echo "  git restore prismatic/models/materialize.py"
+echo "  git restore prismatic/models/backbones/vision/dinosiglip_vit.py"
+echo
+echo "To re-enable network download:"
+echo "  - Restore qwen25.py to use HF for Qwen."
+echo "  - If you used --local-models, also restore materialize.py and dinosiglip_vit.py."
+
+echo "Done."

VLA-Adapter-UAV/experiments/robot/aloha/train_files/train_aloha.sh

@@ -0,0 +1,91 @@
+#!/bin/bash
+###
+ # @Description: raw finetuning script for bottle_cleanup task
+ # @FilePath: /github_projects/Inspire-cli/.claude/mnt/shared/vla_projects/realworld_vla_adapter/experiments/robot/aloha/train_files/train_aloha.sh
+###
+
+#========== Basic Settings ==========#
+PROJECT_PATH=realworld_vla_adapter
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_ROOT="$(cd "${SCRIPT_DIR}/../../../.." && pwd)"
+ROOT_DIR="${ROOT_DIR:-/path/to/root}"
+export WANDB_CONSOLE=off
+export WANDB_MODE=offline
+export PYTHONPATH="${PROJECT_ROOT}"
+#========== Training Configuration ==========#
+# Dataset and paths
+data_name="${DATASET_NAME:-bowl_stack_and_shelf_aloha_realworld_50}"
+data_root_dir="${DATA_ROOT_DIR:-${ROOT_DIR}/datasets/cobot_aloha/tfds}"
+vlm_path="${VLM_PATH:-${ROOT_DIR}/ai_models/Stanford-ILIAD/prism-qwen25-extra-dinosiglip-224px-0_5b}"
+config_file_path="${CONFIG_FILE_PATH:-pretrained_models/configs}"
+
+# Training parameters
+batch_size=12
+grad_accumulation_steps=1
+learning_rate=2e-4
+max_steps=10005
+num_steps_before_decay=5000
+save_freq=2000
+lr_warmup_steps=0
+
+# Model configuration
+num_images_in_input=3
+lora_rank=64
+use_film=False
+use_proprio=True
+use_lora=True
+use_fz=False
+use_minivlm=True
+image_aug=True
+save_latest_checkpoint_only=False
+merge_lora_during_training=True
+use_pro_version=True
+# Wandb settings
+wandb_entity="${WANDB_ENTITY:-your-wandb-entity}"
+wandb_project="${WANDB_PROJECT:-vla_adapter}"
+
+# Generate timestamp and run ID
+current_time=$(date +"%Y%m%d_%H%M%S")
+run_id_note="raw"
+
+# Build MODE string with important configuration variables (excluding those already in run_id)
+MODE="${run_id_note}_img${num_images_in_input}_mini${use_minivlm}_prop${use_proprio}_pro${use_pro_version}_film${use_film}"
+
+# Build run_root_dir using MODE
+run_root_dir="outputs/${data_name}/${MODE}-$current_time"
+
+mkdir -p logs
+
+#========== Training Execution ==========#
+torchrun --standalone --nnodes 1 --nproc-per-node 4 vla-scripts/finetune.py \
+  --vlm_path $vlm_path \
+  --config_file_path $config_file_path \
+  --data_root_dir $data_root_dir \
+  --dataset_name $data_name \
+  --run_root_dir $run_root_dir \
+  --use_film $use_film \
+  --num_images_in_input $num_images_in_input \
+  --use_proprio $use_proprio \
+  --use_lora $use_lora \
+  --use_fz $use_fz \
+  --use_minivlm $use_minivlm \
+  --image_aug $image_aug \
+  --num_steps_before_decay $num_steps_before_decay \
+  --max_steps $max_steps \
+  --save_freq $save_freq \
+  --save_latest_checkpoint_only $save_latest_checkpoint_only \
+  --merge_lora_during_training $merge_lora_during_training \
+  --batch_size $batch_size \
+  --grad_accumulation_steps $grad_accumulation_steps \
+  --learning_rate $learning_rate \
+  --lora_rank $lora_rank \
+  --use_pro_version $use_pro_version \
+  --wandb_entity "$wandb_entity" \
+  --wandb_project "$wandb_project" \
+  --run_id_note $run_id_note \
+  --lr_warmup_steps $lr_warmup_steps
+
+echo "Training started with run ID: $run_id_note"
+echo "Output directory: $run_root_dir"
+echo "Log file: logs/$run_id_note.log"
+echo "Process ID: $!" 

VLA-Adapter-UAV/experiments/robot/libero/libero_requirements.txt

@@ -0,0 +1,6 @@
+imageio[ffmpeg]
+robosuite==1.4.1
+bddl
+easydict
+cloudpickle
+gym

VLA-Adapter-UAV/experiments/robot/libero/libero_utils.py

@@ -0,0 +1,87 @@
+"""Utils for evaluating policies in LIBERO simulation environments."""
+
+import math
+import os
+
+import imageio
+import numpy as np
+import tensorflow as tf
+from libero.libero import get_libero_path
+from libero.libero.envs import OffScreenRenderEnv
+
+from experiments.robot.robot_utils import (
+    DATE,
+    DATE_TIME,
+)
+
+
+def get_libero_env(task, model_family, resolution=256):
+    """Initializes and returns the LIBERO environment, along with the task description."""
+    task_description = task.language
+    task_bddl_file = os.path.join(get_libero_path("bddl_files"), task.problem_folder, task.bddl_file)
+    env_args = {"bddl_file_name": task_bddl_file, "camera_heights": resolution, "camera_widths": resolution}
+    env = OffScreenRenderEnv(**env_args)
+    env.seed(0)  # IMPORTANT: seed seems to affect object positions even when using fixed initial state
+    return env, task_description
+
+
+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]
+
+
+def get_libero_image(obs):
+    """Extracts third-person image from observations and preprocesses it."""
+    img = obs["agentview_image"]
+    img = img[::-1, ::-1]  # IMPORTANT: rotate 180 degrees to match train preprocessing
+    return img
+
+
+def get_libero_wrist_image(obs):
+    """Extracts wrist camera image from observations and preprocesses it."""
+    img = obs["robot0_eye_in_hand_image"]
+    img = img[::-1, ::-1]  # IMPORTANT: rotate 180 degrees to match train preprocessing
+    return img
+
+
+def save_rollout_video(rollout_images, idx, success, task_description, log_file=None, save_version=None):
+    """Saves an MP4 replay of an episode."""
+    rollout_dir = f"./rollouts/{save_version}/{DATE}"
+    os.makedirs(rollout_dir, exist_ok=True)
+    processed_task_description = task_description.lower().replace(" ", "_").replace("\n", "_").replace(".", "_")[:50]
+    mp4_path = f"{rollout_dir}/{DATE_TIME}--episode={idx}--success={success}--task={processed_task_description}.mp4"
+    video_writer = imageio.get_writer(mp4_path, fps=30)
+    for img in rollout_images:
+        video_writer.append_data(img)
+    video_writer.close()
+    print(f"Saved rollout MP4 at path {mp4_path}")
+    if log_file is not None:
+        log_file.write(f"Saved rollout MP4 at path {mp4_path}\n")
+    return mp4_path
+
+
+def quat2axisangle(quat):
+    """
+    Copied from robosuite: https://github.com/ARISE-Initiative/robosuite/blob/eafb81f54ffc104f905ee48a16bb15f059176ad3/robosuite/utils/transform_utils.py#L490C1-L512C55
+
+    Converts quaternion to axis-angle format.
+    Returns a unit vector direction scaled by its angle in radians.
+
+    Args:
+        quat (np.array): (x,y,z,w) vec4 float angles
+
+    Returns:
+        np.array: (ax,ay,az) axis-angle exponential coordinates
+    """
+    # clip quaternion
+    if quat[3] > 1.0:
+        quat[3] = 1.0
+    elif quat[3] < -1.0:
+        quat[3] = -1.0
+
+    den = np.sqrt(1.0 - quat[3] * quat[3])
+    if math.isclose(den, 0.0):
+        # This is (close to) a zero degree rotation, immediately return
+        return np.zeros(3)
+
+    return (quat[:3] * 2.0 * math.acos(quat[3])) / den

VLA-Adapter-UAV/experiments/robot/libero/regenerate_libero_dataset.py

@@ -0,0 +1,249 @@
+"""
+Regenerates a LIBERO dataset (HDF5 files) by replaying demonstrations in the environments.
+
+Notes:
+    - We save image observations at 256x256px resolution (instead of 128x128).
+    - We filter out transitions with "no-op" (zero) actions that do not change the robot's state.
+    - We filter out unsuccessful demonstrations.
+    - In the LIBERO HDF5 data -> RLDS data conversion (not shown here), we rotate the images by
+    180 degrees because we observe that the environments return images that are upside down
+    on our platform.
+
+Usage:
+    python experiments/robot/libero/regenerate_libero_dataset.py \
+        --libero_task_suite [ libero_spatial | libero_object | libero_goal | libero_10 ] \
+        --libero_raw_data_dir <PATH TO RAW HDF5 DATASET DIR> \
+        --libero_target_dir <PATH TO TARGET DIR>
+
+    Example (LIBERO-Spatial):
+        python experiments/robot/libero/regenerate_libero_dataset.py \
+            --libero_task_suite libero_spatial \
+            --libero_raw_data_dir ./LIBERO/libero/datasets/libero_spatial \
+            --libero_target_dir ./LIBERO/libero/datasets/libero_spatial_no_noops
+
+"""
+
+import argparse
+import json
+import os
+import time
+
+import h5py
+import numpy as np
+import robosuite.utils.transform_utils as T
+import tqdm
+from libero.libero import benchmark
+
+from experiments.robot.libero.libero_utils import (
+    get_libero_dummy_action,
+    get_libero_env,
+)
+
+
+IMAGE_RESOLUTION = 256
+
+
+def is_noop(action, prev_action=None, threshold=1e-4):
+    """
+    Returns whether an action is a no-op action.
+
+    A no-op action satisfies two criteria:
+        (1) All action dimensions, except for the last one (gripper action), are near zero.
+        (2) The gripper action is equal to the previous timestep's gripper action.
+
+    Explanation of (2):
+        Naively filtering out actions with just criterion (1) is not good because you will
+        remove actions where the robot is staying still but opening/closing its gripper.
+        So you also need to consider the current state (by checking the previous timestep's
+        gripper action as a proxy) to determine whether the action really is a no-op.
+    """
+    # Special case: Previous action is None if this is the first action in the episode
+    # Then we only care about criterion (1)
+    if prev_action is None:
+        return np.linalg.norm(action[:-1]) < threshold
+
+    # Normal case: Check both criteria (1) and (2)
+    gripper_action = action[-1]
+    prev_gripper_action = prev_action[-1]
+    return np.linalg.norm(action[:-1]) < threshold and gripper_action == prev_gripper_action
+
+
+def main(args):
+    print(f"Regenerating {args.libero_task_suite} dataset!")
+
+    # Create target directory
+    if os.path.isdir(args.libero_target_dir):
+        user_input = input(f"Target directory already exists at path: {args.libero_target_dir}\nEnter 'y' to overwrite the directory, or anything else to exit: ")
+        if user_input != 'y':
+            exit()
+    os.makedirs(args.libero_target_dir, exist_ok=True)
+
+    # Prepare JSON file to record success/false and initial states per episode
+    metainfo_json_dict = {}
+    metainfo_json_out_path = f"./experiments/robot/libero/{args.libero_task_suite}_metainfo.json"
+    with open(metainfo_json_out_path, "w") as f:
+        # Just test that we can write to this file (we overwrite it later)
+        json.dump(metainfo_json_dict, f)
+
+    # Get task suite
+    benchmark_dict = benchmark.get_benchmark_dict()
+    task_suite = benchmark_dict[args.libero_task_suite]()
+    num_tasks_in_suite = task_suite.n_tasks
+
+    # Setup
+    num_replays = 0
+    num_success = 0
+    num_noops = 0
+
+    for task_id in tqdm.tqdm(range(num_tasks_in_suite)):
+        # Get task in suite
+        task = task_suite.get_task(task_id)
+        env, task_description = get_libero_env(task, "llava", resolution=IMAGE_RESOLUTION)
+
+        # Get dataset for task
+        orig_data_path = os.path.join(args.libero_raw_data_dir, f"{task.name}_demo.hdf5")
+        assert os.path.exists(orig_data_path), f"Cannot find raw data file {orig_data_path}."
+        orig_data_file = h5py.File(orig_data_path, "r")
+        orig_data = orig_data_file["data"]
+
+        # Create new HDF5 file for regenerated demos
+        new_data_path = os.path.join(args.libero_target_dir, f"{task.name}_demo.hdf5")
+        new_data_file = h5py.File(new_data_path, "w")
+        grp = new_data_file.create_group("data")
+
+        for i in range(len(orig_data.keys())):
+            # Get demo data
+            demo_data = orig_data[f"demo_{i}"]
+            orig_actions = demo_data["actions"][()]
+            orig_states = demo_data["states"][()]
+
+            # Reset environment, set initial state, and wait a few steps for environment to settle
+            env.reset()
+            env.set_init_state(orig_states[0])
+            for _ in range(10):
+                obs, reward, done, info = env.step(get_libero_dummy_action("llava"))
+
+            # Set up new data lists
+            states = []
+            actions = []
+            ee_states = []
+            gripper_states = []
+            joint_states = []
+            robot_states = []
+            agentview_images = []
+            eye_in_hand_images = []
+
+            # Replay original demo actions in environment and record observations
+            for _, action in enumerate(orig_actions):
+                # Skip transitions with no-op actions
+                prev_action = actions[-1] if len(actions) > 0 else None
+                if is_noop(action, prev_action):
+                    print(f"\tSkipping no-op action: {action}")
+                    num_noops += 1
+                    continue
+
+                if states == []:
+                    # In the first timestep, since we're using the original initial state to initialize the environment,
+                    # copy the initial state (first state in episode) over from the original HDF5 to the new one
+                    states.append(orig_states[0])
+                    robot_states.append(demo_data["robot_states"][0])
+                else:
+                    # For all other timesteps, get state from environment and record it
+                    states.append(env.sim.get_state().flatten())
+                    robot_states.append(
+                        np.concatenate([obs["robot0_gripper_qpos"], obs["robot0_eef_pos"], obs["robot0_eef_quat"]])
+                    )
+
+                # Record original action (from demo)
+                actions.append(action)
+
+                # Record data returned by environment
+                if "robot0_gripper_qpos" in obs:
+                    gripper_states.append(obs["robot0_gripper_qpos"])
+                joint_states.append(obs["robot0_joint_pos"])
+                ee_states.append(
+                    np.hstack(
+                        (
+                            obs["robot0_eef_pos"],
+                            T.quat2axisangle(obs["robot0_eef_quat"]),
+                        )
+                    )
+                )
+                agentview_images.append(obs["agentview_image"])
+                eye_in_hand_images.append(obs["robot0_eye_in_hand_image"])
+
+                # Execute demo action in environment
+                obs, reward, done, info = env.step(action.tolist())
+
+            # At end of episode, save replayed trajectories to new HDF5 files (only keep successes)
+            if done:
+                dones = np.zeros(len(actions)).astype(np.uint8)
+                dones[-1] = 1
+                rewards = np.zeros(len(actions)).astype(np.uint8)
+                rewards[-1] = 1
+                assert len(actions) == len(agentview_images)
+
+                ep_data_grp = grp.create_group(f"demo_{i}")
+                obs_grp = ep_data_grp.create_group("obs")
+                obs_grp.create_dataset("gripper_states", data=np.stack(gripper_states, axis=0))
+                obs_grp.create_dataset("joint_states", data=np.stack(joint_states, axis=0))
+                obs_grp.create_dataset("ee_states", data=np.stack(ee_states, axis=0))
+                obs_grp.create_dataset("ee_pos", data=np.stack(ee_states, axis=0)[:, :3])
+                obs_grp.create_dataset("ee_ori", data=np.stack(ee_states, axis=0)[:, 3:])
+                obs_grp.create_dataset("agentview_rgb", data=np.stack(agentview_images, axis=0))
+                obs_grp.create_dataset("eye_in_hand_rgb", data=np.stack(eye_in_hand_images, axis=0))
+                ep_data_grp.create_dataset("actions", data=actions)
+                ep_data_grp.create_dataset("states", data=np.stack(states))
+                ep_data_grp.create_dataset("robot_states", data=np.stack(robot_states, axis=0))
+                ep_data_grp.create_dataset("rewards", data=rewards)
+                ep_data_grp.create_dataset("dones", data=dones)
+
+                num_success += 1
+
+            num_replays += 1
+
+            # Record success/false and initial environment state in metainfo dict
+            task_key = task_description.replace(" ", "_")
+            episode_key = f"demo_{i}"
+            if task_key not in metainfo_json_dict:
+                metainfo_json_dict[task_key] = {}
+            if episode_key not in metainfo_json_dict[task_key]:
+                metainfo_json_dict[task_key][episode_key] = {}
+            metainfo_json_dict[task_key][episode_key]["success"] = bool(done)
+            metainfo_json_dict[task_key][episode_key]["initial_state"] = orig_states[0].tolist()
+
+            # Write metainfo dict to JSON file
+            # (We repeatedly overwrite, rather than doing this once at the end, just in case the script crashes midway)
+            with open(metainfo_json_out_path, "w") as f:
+                json.dump(metainfo_json_dict, f, indent=2)
+
+            # Count total number of successful replays so far
+            print(
+                f"Total # episodes replayed: {num_replays}, Total # successes: {num_success} ({num_success / num_replays * 100:.1f} %)"
+            )
+
+            # Report total number of no-op actions filtered out so far
+            print(f"  Total # no-op actions filtered out: {num_noops}")
+
+        # Close HDF5 files
+        orig_data_file.close()
+        new_data_file.close()
+        print(f"Saved regenerated demos for task '{task_description}' at: {new_data_path}")
+
+    print(f"Dataset regeneration complete! Saved new dataset at: {args.libero_target_dir}")
+    print(f"Saved metainfo JSON at: {metainfo_json_out_path}")
+
+
+if __name__ == "__main__":
+    # Parse command-line arguments
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--libero_task_suite", type=str, choices=["libero_spatial", "libero_object", "libero_goal", "libero_10", "libero_90"],
+                        help="LIBERO task suite. Example: libero_spatial", required=True)
+    parser.add_argument("--libero_raw_data_dir", type=str,
+                        help="Path to directory containing raw HDF5 dataset. Example: ./LIBERO/libero/datasets/libero_spatial", required=True)
+    parser.add_argument("--libero_target_dir", type=str,
+                        help="Path to regenerated dataset directory. Example: ./LIBERO/libero/datasets/libero_spatial_no_noops", required=True)
+    args = parser.parse_args()
+
+    # Start data regeneration
+    main(args)

VLA-Adapter-UAV/experiments/robot/libero/run_libero_eval.py

@@ -0,0 +1,555 @@
+"""
+run_libero_eval.py
+
+Evaluates a trained policy in a LIBERO simulation benchmark task suite.
+"""
+
+import json
+import logging
+import os
+import sys
+from collections import deque
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Optional, Union
+
+import draccus
+import numpy as np
+import tqdm
+from libero.libero import benchmark
+
+import wandb
+
+# Append current directory so that interpreter can find experiments.robot
+sys.path.append("../..")
+from experiments.robot.libero.libero_utils import (
+    get_libero_dummy_action,
+    get_libero_env,
+    get_libero_image,
+    get_libero_wrist_image,
+    quat2axisangle,
+    save_rollout_video,
+)
+from experiments.robot.openvla_utils import (
+    get_action_head,
+    get_noisy_action_projector,
+    get_processor,
+    get_proprio_projector,
+    resize_image_for_policy,
+)
+from experiments.robot.robot_utils import (
+    DATE_TIME,
+    get_action,
+    get_image_resize_size,
+    get_model,
+    invert_gripper_action,
+    normalize_gripper_action,
+    set_seed_everywhere,
+)
+from prismatic.vla.constants import NUM_ACTIONS_CHUNK
+
+
+# Define task suite constants
+class TaskSuite(str, Enum):
+    LIBERO_SPATIAL = "libero_spatial"
+    LIBERO_OBJECT = "libero_object"
+    LIBERO_GOAL = "libero_goal"
+    LIBERO_10 = "libero_10"
+    LIBERO_90 = "libero_90"
+
+
+# Define max steps for each task suite
+TASK_MAX_STEPS = {
+    TaskSuite.LIBERO_SPATIAL: 220,  # longest training demo has 193 steps
+    TaskSuite.LIBERO_OBJECT: 280,  # longest training demo has 254 steps
+    TaskSuite.LIBERO_GOAL: 300,  # longest training demo has 270 steps
+    TaskSuite.LIBERO_10: 520,  # longest training demo has 505 steps
+    TaskSuite.LIBERO_90: 400,  # longest training demo has 373 steps
+}
+
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    handlers=[logging.StreamHandler()],
+)
+logger = logging.getLogger(__name__)
+
+
+
+@dataclass
+class GenerateConfig:
+    # fmt: off
+
+    #################################################################################################################
+    # Model-specific parameters
+    #################################################################################################################
+    model_family: str = "openvla"                    # Model family
+    pretrained_checkpoint: Union[str, Path] = ""     # Pretrained checkpoint path
+    use_l1_regression: bool = True                   # If True, uses continuous action head with L1 regression objective
+    use_minivlm: bool = True                         # If True, uses minivlm
+    num_diffusion_steps: int = 50                    # (When `diffusion==True`) Number of diffusion steps for inference
+    use_film: bool = False                           # If True, uses FiLM to infuse language inputs into visual features
+    num_images_in_input: int = 2                     # Number of images in the VLA input (default: 1)
+    use_proprio: bool = True                         # Whether to include proprio state in input
+
+    center_crop: bool = True                         # Center crop? (if trained w/ random crop image aug)
+    num_open_loop_steps: int = 8                     # Number of actions to execute open-loop before requerying policy
+    unnorm_key: Union[str, Path] = ""                # Action un-normalization key
+
+    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
+
+    #################################################################################################################
+    # LIBERO environment-specific parameters
+    #################################################################################################################
+    task_suite_name: str = TaskSuite.LIBERO_SPATIAL  # Task suite
+    num_steps_wait: int = 10                         # Number of steps to wait for objects to stabilize in sim
+    num_trials_per_task: int = 50                    # Number of rollouts per task
+    initial_states_path: str = "DEFAULT"             # "DEFAULT", or path to initial states JSON file
+    env_img_res: int = 256                           # Resolution for environment images (not policy input resolution)
+
+    #################################################################################################################
+    # Utils
+    #################################################################################################################
+    run_id_note: Optional[str] = None                # Extra note to add to end of run ID for logging
+    local_log_dir: str = "./experiments/logs"        # Local directory for eval logs
+
+    use_wandb: bool = False                          # Whether to also log results in Weights & Biases
+    wandb_entity: str = "your-wandb-entity"          # Name of WandB entity
+    wandb_project: str = "your-wandb-project"        # Name of WandB project
+
+    seed: int = 7                                    # Random Seed (for reproducibility)
+
+    # fmt: on
+    save_version: str = "vla-adapter"                # version of 
+    use_pro_version: bool = True                     # encourage to use the pro models we released.
+    phase: str = "Inference"
+
+
+
+def validate_config(cfg: GenerateConfig) -> None:
+    """Validate configuration parameters."""
+    assert cfg.pretrained_checkpoint is not None, "pretrained_checkpoint must not be None!"
+
+    if "image_aug" in str(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!"
+
+    # Validate task suite
+    assert cfg.task_suite_name in [suite.value for suite in TaskSuite], f"Invalid task suite: {cfg.task_suite_name}"
+
+
+
+def initialize_model(cfg: GenerateConfig):
+    """Initialize model and associated components."""
+    # Load model
+    model = get_model(cfg)
+    model.set_version(cfg.save_version)
+    # Load proprio projector if needed
+    proprio_projector = None
+    if cfg.use_proprio:
+        proprio_projector = get_proprio_projector(
+            cfg,
+            model.llm_dim,
+            proprio_dim=8,  # 8-dimensional proprio for LIBERO
+        )
+
+    # Load action head if needed
+    action_head = None
+    if cfg.use_l1_regression:
+        action_head = get_action_head(cfg, model.llm_dim)
+
+    # Load noisy action projector if using diffusion
+    noisy_action_projector = None
+
+    # Get OpenVLA processor if needed
+    processor = None
+    if cfg.model_family == "openvla":
+        processor = get_processor(cfg)
+        check_unnorm_key(cfg, model)
+
+    return model, action_head, proprio_projector, noisy_action_projector, processor
+
+
+def check_unnorm_key(cfg: GenerateConfig, model) -> None:
+    """Check that the model contains the action un-normalization key."""
+    # Initialize unnorm_key
+    unnorm_key = cfg.task_suite_name
+
+    # 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 unnorm_key not in model.norm_stats and f"{unnorm_key}_no_noops" in model.norm_stats:
+        unnorm_key = f"{unnorm_key}_no_noops"
+
+    assert unnorm_key in model.norm_stats, f"Action un-norm key {unnorm_key} not found in VLA `norm_stats`!"
+
+    # Set the unnorm_key in cfg
+    cfg.unnorm_key = unnorm_key
+
+
+
+def setup_logging(cfg: GenerateConfig):
+    """Set up logging to file and optionally to wandb."""
+    # Create run ID
+    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}"
+
+    # Set up local logging
+    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")
+    logger.info(f"Logging to local log file: {local_log_filepath}")
+
+    # Initialize Weights & Biases logging if enabled
+    if cfg.use_wandb:
+        wandb.init(
+            entity=cfg.wandb_entity,
+            project=cfg.wandb_project,
+            name=run_id,
+        )
+
+    return log_file, local_log_filepath, run_id
+
+
+
+def log_message(message: str, log_file=None):
+    """Log a message to console and optionally to a log file."""
+    logger.info(message)
+    if log_file:
+        log_file.write(message + "\n")
+        log_file.flush()
+
+
+
+def load_initial_states(cfg: GenerateConfig, task_suite, task_id: int, log_file=None):
+    """Load initial states for the given task."""
+    # Get default initial states
+    initial_states = task_suite.get_task_init_states(task_id)
+
+    # If using custom initial states, load them from file
+    if cfg.initial_states_path != "DEFAULT":
+        with open(cfg.initial_states_path, "r") as f:
+            all_initial_states = json.load(f)
+        log_message(f"Using initial states from {cfg.initial_states_path}", log_file)
+        return initial_states, all_initial_states
+    else:
+        log_message("Using default initial states", log_file)
+        return initial_states, None
+
+
+
+def prepare_observation(obs, resize_size):
+    """Prepare observation for policy input."""
+    # Get preprocessed images
+    img = get_libero_image(obs)
+    wrist_img = get_libero_wrist_image(obs)
+
+    # Resize images to size expected by model
+    img_resized = resize_image_for_policy(img, resize_size)
+    wrist_img_resized = resize_image_for_policy(wrist_img, resize_size)
+
+    # Prepare observations dict
+    observation = {
+        "full_image": img_resized,
+        "wrist_image": wrist_img_resized,
+        "state": np.concatenate(
+            (obs["robot0_eef_pos"], quat2axisangle(obs["robot0_eef_quat"]), obs["robot0_gripper_qpos"])
+        ),
+    }
+
+    return observation, img  # Return both processed observation and original image for replay
+
+
+
+def process_action(action, model_family):
+    """Process action before sending to environment."""
+    # 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 model_family == "openvla":
+        action = invert_gripper_action(action)
+
+    return action
+
+
+
+def run_episode(
+    cfg: GenerateConfig,
+    env,
+    task_description: str,
+    model,
+    resize_size,
+    processor=None,
+    action_head=None,
+    proprio_projector=None,
+    noisy_action_projector=None,
+    initial_state=None,
+    log_file=None,
+):
+    """Run a single episode in the environment."""
+    # Reset environment
+    env.reset()
+
+    # Set initial state if provided
+    if initial_state is not None:
+        obs = env.set_init_state(initial_state)
+    else:
+        obs = env.get_observation()
+
+    # Initialize action queue
+    if cfg.num_open_loop_steps != NUM_ACTIONS_CHUNK:
+        print(f"WARNING: cfg.num_open_loop_steps ({cfg.num_open_loop_steps}) does not match the NUM_ACTIONS_CHUNK "
+               "{NUM_ACTIONS_CHUNK} constant defined in prismatic.vla.constants! For best performance (in terms of "
+               "both speed and success rate), we recommend executing the full action chunk.")
+    action_queue = deque(maxlen=cfg.num_open_loop_steps)
+
+    # Setup
+    t = 0
+    replay_images = []
+    max_steps = TASK_MAX_STEPS[cfg.task_suite_name]
+
+    # Run episode
+    success = False
+    try:
+        while t < max_steps + cfg.num_steps_wait:
+            # Do nothing for the first few timesteps to let objects stabilize
+            if t < cfg.num_steps_wait:
+                obs, reward, done, info = env.step(get_libero_dummy_action(cfg.model_family))
+                t += 1
+                continue
+
+            # Prepare observation
+            observation, img = prepare_observation(obs, resize_size)
+            replay_images.append(img)
+
+            # If action queue is empty, requery model
+            if len(action_queue) == 0:
+                # Query model to get action
+                actions = get_action(
+                    cfg,
+                    model,
+                    observation,
+                    task_description,
+                    processor=processor,
+                    action_head=action_head,
+                    proprio_projector=proprio_projector,
+                    noisy_action_projector=noisy_action_projector,
+                    use_film=cfg.use_film,
+                    use_minivlm=cfg.use_minivlm
+                )
+
+                action_queue.extend(actions) 
+
+            # Get action from queue
+            action = action_queue.popleft()
+            # action = actions[0]
+
+
+            # Process action
+            action = process_action(action, cfg.model_family)
+
+            # Execute action in environment
+            obs, reward, done, info = env.step(action.tolist())
+            if done:
+                success = True
+                break
+            t += 1
+
+    except Exception as e:
+        log_message(f"Episode error: {e}", log_file)
+
+    return success, replay_images
+
+
+
+
+def run_task(
+    cfg: GenerateConfig,
+    task_suite,
+    task_id: int,
+    model,
+    resize_size,
+    processor=None,
+    action_head=None,
+    proprio_projector=None,
+    noisy_action_projector=None,
+    total_episodes=0,
+    total_successes=0,
+    log_file=None,
+    save_version=None
+):
+    """Run evaluation for a single task."""
+    # Get task
+    # task_id = 8
+    task = task_suite.get_task(task_id)
+
+    # Get initial states
+    initial_states, all_initial_states = load_initial_states(cfg, task_suite, task_id, log_file)
+
+    # Initialize environment and get task description
+    env, task_description = get_libero_env(task, cfg.model_family, resolution=cfg.env_img_res)
+
+    # Start episodes
+    task_episodes, task_successes = 0, 0
+    for episode_idx in tqdm.tqdm(range(cfg.num_trials_per_task)):
+        log_message(f"\nTask: {task_description}", log_file)
+
+        # Handle initial state
+        if cfg.initial_states_path == "DEFAULT":
+            # Use default initial state
+            initial_state = initial_states[episode_idx]
+        else:
+            # Get keys for fetching initial episode state from JSON
+            initial_states_task_key = task_description.replace(" ", "_")
+            episode_key = f"demo_{episode_idx}"
+
+            # Skip episode if expert demonstration failed to complete the task
+            if not all_initial_states[initial_states_task_key][episode_key]["success"]:
+                log_message(f"Skipping task {task_id} episode {episode_idx} due to failed expert demo!", log_file)
+                continue
+
+            # Get initial state
+            initial_state = np.array(all_initial_states[initial_states_task_key][episode_key]["initial_state"])
+
+        log_message(f"Starting episode {task_episodes + 1}...", log_file)
+
+        # Run episode
+        success, replay_images = run_episode(
+            cfg,
+            env,
+            task_description,
+            model,
+            resize_size,
+            processor,
+            action_head,
+            proprio_projector,
+            noisy_action_projector,
+            initial_state,
+            log_file,
+        )
+
+        # Update counters
+        task_episodes += 1
+        total_episodes += 1
+        if success:
+            task_successes += 1
+            total_successes += 1
+
+        # Save replay video
+        save_rollout_video(
+            replay_images, total_episodes, success=success, task_description=task_description, log_file=log_file, save_version=save_version
+        )
+
+        # Log results
+        log_message(f"Success: {success}", log_file)
+        log_message(f"# episodes completed so far: {total_episodes}", log_file)
+        log_message(f"# successes: {total_successes} ({total_successes / total_episodes * 100:.1f}%)", log_file)
+
+    # Log task results
+    task_success_rate = float(task_successes) / float(task_episodes) if task_episodes > 0 else 0
+    total_success_rate = float(total_successes) / float(total_episodes) if total_episodes > 0 else 0
+
+    log_message(f"Current task success rate: {task_success_rate}", log_file)
+    log_message(f"Current total success rate: {total_success_rate}", log_file)
+    
+    # close env
+    env.close()
+    del env
+
+    # Log to wandb if enabled
+    if cfg.use_wandb:
+        wandb.log(
+            {
+                f"success_rate/{task_description}": task_success_rate,
+                f"num_episodes/{task_description}": task_episodes,
+            }
+        )
+
+    return total_episodes, total_successes
+
+
+
+@draccus.wrap()
+def eval_libero(cfg: GenerateConfig) -> float:
+    """Main function to evaluate a trained policy on LIBERO benchmark tasks."""
+    # Validate configuration
+    validate_config(cfg)
+
+    # Set random seed
+    set_seed_everywhere(cfg.seed)
+
+    # Initialize model and components
+    model, action_head, proprio_projector, noisy_action_projector, processor = initialize_model(cfg)
+
+    # for name, param in model.named_parameters():
+    #     if 'action_queries' in name: 
+    #         print(f"{name}: {param}")
+
+    # Get expected image dimensions
+    resize_size = get_image_resize_size(cfg)
+
+    # Setup logging
+    log_file, local_log_filepath, run_id = setup_logging(cfg)
+
+    # Initialize LIBERO task suite
+    benchmark_dict = benchmark.get_benchmark_dict()
+    task_suite = benchmark_dict[cfg.task_suite_name]()
+    num_tasks = task_suite.n_tasks
+
+    log_message(f"Task suite: {cfg.task_suite_name}", log_file)
+
+    # Start evaluation
+    total_episodes, total_successes = 0, 0
+    for task_id in tqdm.tqdm(range(num_tasks)):
+        total_episodes, total_successes = run_task(
+            cfg,
+            task_suite,
+            task_id,
+            model,
+            resize_size,
+            processor,
+            action_head,
+            proprio_projector,
+            noisy_action_projector,
+            total_episodes,
+            total_successes,
+            log_file,
+            cfg.save_version
+        )
+
+    # Calculate final success rate
+    final_success_rate = float(total_successes) / float(total_episodes) if total_episodes > 0 else 0
+
+    # Log final results
+    log_message("Final results:", log_file)
+    log_message(f"Total episodes: {total_episodes}", log_file)
+    log_message(f"Total successes: {total_successes}", log_file)
+    log_message(f"Overall success rate: {final_success_rate:.4f} ({final_success_rate * 100:.1f}%)", log_file)
+
+    # Log to wandb if enabled
+    if cfg.use_wandb:
+        wandb.log(
+            {
+                "success_rate/total": final_success_rate,
+                "num_episodes/total": total_episodes,
+            }
+        )
+        wandb.save(local_log_filepath)
+
+    # Close log file
+    if log_file:
+        log_file.close()
+
+    return final_success_rate
+
+
+
+if __name__ == "__main__":
+    eval_libero()

VLA-Adapter-UAV/experiments/robot/libero/sample_libero_spatial_observation.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:326db6c78dd0a9d91c11f05af03b93fa3095338ee3cb5a5eb15adf3d87eb0109
+size 301501

VLA-Adapter-UAV/experiments/robot/openvla_utils.py

@@ -0,0 +1,850 @@
+"""Utils for evaluating VLA-Adapter or fine-tuned VLA-Adapter policies."""
+
+import filecmp
+import json
+import os
+import shutil
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import json_numpy
+import numpy as np
+import requests
+import tensorflow as tf
+import torch
+from huggingface_hub import HfApi, hf_hub_download
+from PIL import Image
+from transformers import AutoConfig, AutoImageProcessor, AutoModelForVision2Seq, AutoProcessor
+
+# Apply JSON numpy patch for serialization
+json_numpy.patch()
+
+from prismatic.extern.hf.configuration_prismatic import OpenVLAConfig
+from prismatic.extern.hf.modeling_prismatic import OpenVLAForActionPrediction
+from prismatic.extern.hf.processing_prismatic import PrismaticImageProcessor, PrismaticProcessor
+from prismatic.models.action_heads import L1RegressionActionHead
+from prismatic.models.film_vit_wrapper import FiLMedPrismaticVisionBackbone
+from prismatic.models.projectors import NoisyActionProjector, ProprioProjector
+from prismatic.vla.constants import (
+    ACTION_DIM,
+    ACTION_PROPRIO_NORMALIZATION_TYPE,
+)
+from prismatic.vla.datasets.rlds.utils.data_utils import NormalizationType
+
+# Initialize important constants
+DATE = time.strftime("%Y_%m_%d")
+DATE_TIME = time.strftime("%Y_%m_%d-%H_%M_%S")
+DEVICE = torch.device("cuda:0") if torch.cuda.is_available() else torch.device("cpu")
+OPENVLA_IMAGE_SIZE = 224  # Standard image size expected by OpenVLA
+
+# Configure NumPy print settings
+np.set_printoptions(formatter={"float": lambda x: "{0:0.8f}".format(x)})
+
+
+def model_is_on_hf_hub(model_path: str) -> bool:
+    """Checks whether a model path points to a model on Hugging Face Hub."""
+    # Local paths should never trigger a Hub lookup; otherwise each rank can block
+    # on a pointless network probe before training starts.
+    if os.path.exists(os.path.expanduser(model_path)):
+        return False
+
+    # If the API call below runs without error, the model is on the hub
+    try:
+        HfApi().model_info(model_path)
+        return True
+    except Exception:
+        return False
+
+
+def update_auto_map(pretrained_checkpoint: str) -> None:
+    """
+    Update the AutoMap configuration in the checkpoint config.json file.
+
+    This loads the config.json file inside the checkpoint directory and overwrites
+    the AutoConfig and AutoModelForVision2Seq fields to use OpenVLA-specific classes.
+
+    Args:
+        pretrained_checkpoint: Path to the checkpoint directory
+    """
+    if not os.path.isdir(pretrained_checkpoint):
+        return
+
+    config_path = os.path.join(pretrained_checkpoint, "config.json")
+    if not os.path.exists(config_path):
+        print(f"Warning: No config.json found at {config_path}")
+        return
+
+    # Create timestamped backup
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    backup_path = os.path.join(pretrained_checkpoint, f"config.json.back.{timestamp}")
+    shutil.copy2(config_path, backup_path)
+    print(f"Created backup of original config at: {os.path.abspath(backup_path)}")
+
+    # Read and update the config
+    with open(config_path, "r") as f:
+        config = json.load(f)
+
+    config["auto_map"] = {
+        "AutoConfig": "configuration_prismatic.OpenVLAConfig",
+        "AutoModelForVision2Seq": "modeling_prismatic.OpenVLAForActionPrediction",
+    }
+
+    # Write back the updated config
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=2)
+
+    print(f"Updated config.json at: {os.path.abspath(config_path)}")
+    print("Changes made:")
+    print('  - Set AutoConfig to "configuration_prismatic.OpenVLAConfig"')
+    print('  - Set AutoModelForVision2Seq to "modeling_prismatic.OpenVLAForActionPrediction"')
+
+
+def check_identical_files(path1: Union[str, Path], path2: Union[str, Path]) -> bool:
+    """
+    Check if two files are identical in content.
+
+    Args:
+        path1: Path to the first file
+        path2: Path to the second file
+
+    Returns:
+        bool: True if files are identical, False otherwise
+    """
+    path1, path2 = Path(path1), Path(path2)
+
+    # First check if file sizes match
+    if path1.stat().st_size != path2.stat().st_size:
+        return False
+
+    # Check if contents match
+    return filecmp.cmp(path1, path2, shallow=False)
+
+
+def _handle_file_sync(curr_filepath: str, checkpoint_filepath: str, file_type: str) -> None:
+    """
+    Handle syncing of files between current directory and checkpoint.
+
+    Creates backups if files exist but differ, and copies current versions to checkpoint.
+
+    Args:
+        curr_filepath: Path to the current file version
+        checkpoint_filepath: Path where the file should be in the checkpoint
+        file_type: Description of the file type for logging
+    """
+    if os.path.exists(checkpoint_filepath):
+        # Check if existing files are identical
+        match = check_identical_files(curr_filepath, checkpoint_filepath)
+
+        if not match:
+            print(
+                "\n------------------------------------------------------------------------------------------------\n"
+                f"Found mismatch between:\n"
+                f"Current:   {curr_filepath}\n"
+                f"Checkpoint: {checkpoint_filepath}\n"
+            )
+
+            # Create timestamped backup
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            backup_path = f"{checkpoint_filepath}.back.{timestamp}"
+            shutil.copy2(checkpoint_filepath, backup_path)
+            print(f"Created backup of original checkpoint file at: {os.path.abspath(backup_path)}")
+
+            # Copy current version to checkpoint directory
+            shutil.copy2(curr_filepath, checkpoint_filepath)
+            print(f"Copied current version to checkpoint at: {os.path.abspath(checkpoint_filepath)}")
+            print(
+                f"Changes complete. The checkpoint will now use the current version of {file_type}"
+                "\n------------------------------------------------------------------------------------------------\n"
+            )
+    else:
+        # If file doesn't exist in checkpoint directory, copy it
+        shutil.copy2(curr_filepath, checkpoint_filepath)
+        print(
+            "\n------------------------------------------------------------------------------------------------\n"
+            f"No {file_type} found in checkpoint directory.\n"
+            f"Copied current version from: {curr_filepath}\n"
+            f"To checkpoint location: {os.path.abspath(checkpoint_filepath)}"
+            "\n------------------------------------------------------------------------------------------------\n"
+        )
+
+
+def check_model_logic_mismatch(pretrained_checkpoint: str) -> None:
+    """
+    Check and sync model logic files between current code and checkpoint.
+
+    Handles the relationship between current and checkpoint versions of both
+    modeling_prismatic.py and configuration_prismatic.py:
+    - If checkpoint file exists and differs: creates backup and copies current version
+    - If checkpoint file doesn't exist: copies current version
+
+    Args:
+        pretrained_checkpoint: Path to the checkpoint directory
+    """
+    if not os.path.isdir(pretrained_checkpoint):
+        return
+
+    # Find current files
+    curr_files = {"modeling_prismatic.py": None, "configuration_prismatic.py": None}
+
+    for root, _, files in os.walk("./prismatic/"):
+        for filename in curr_files.keys():
+            if filename in files and curr_files[filename] is None:
+                curr_files[filename] = os.path.join(root, filename)
+
+    # Check and handle each file
+    for filename, curr_filepath in curr_files.items():
+        if curr_filepath is None:
+            print(f"WARNING: `{filename}` is not found anywhere in the current directory.")
+            continue
+
+        checkpoint_filepath = os.path.join(pretrained_checkpoint, filename)
+        _handle_file_sync(curr_filepath, checkpoint_filepath, filename)
+
+
+def find_checkpoint_file(pretrained_checkpoint: str, file_pattern: str) -> str:
+    """
+    Find a specific checkpoint file matching a pattern.
+
+    Args:
+        pretrained_checkpoint: Path to the checkpoint directory
+        file_pattern: String pattern to match in filenames
+
+    Returns:
+        str: Path to the matching checkpoint file
+
+    Raises:
+        AssertionError: If no files or multiple files match the pattern
+    """
+    assert os.path.isdir(pretrained_checkpoint), f"Checkpoint path must be a directory: {pretrained_checkpoint}"
+
+    checkpoint_files = []
+    for filename in os.listdir(pretrained_checkpoint):
+        if file_pattern in filename and "checkpoint" in filename:
+            full_path = os.path.join(pretrained_checkpoint, filename)
+            checkpoint_files.append(full_path)
+
+    assert len(checkpoint_files) == 1, (
+        f"Expected exactly 1 {file_pattern} checkpoint but found {len(checkpoint_files)} in directory: {pretrained_checkpoint}"
+    )
+
+    return checkpoint_files[0]
+
+
+def load_component_state_dict(checkpoint_path: str) -> Dict[str, torch.Tensor]:
+    """
+    Load a component's state dict from checkpoint and handle DDP prefix if present.
+
+    Args:
+        checkpoint_path: Path to the checkpoint file
+
+    Returns:
+        Dict: The processed state dictionary for loading
+    """
+    state_dict = torch.load(checkpoint_path, weights_only=True)
+
+    # If the component was trained with DDP, elements in the state dict have prefix "module." which we must remove
+    new_state_dict = {}
+    for k, v in state_dict.items():
+        if k.startswith("module."):
+            new_state_dict[k[7:]] = v
+        else:
+            new_state_dict[k] = v
+
+    return new_state_dict
+
+def load_component_state_dict_v1(checkpoint_path: str) -> Dict[str, torch.Tensor]:
+    """
+    Load a component's state dict from checkpoint and handle DDP prefix if present.
+
+    Args:
+        checkpoint_path: Path to the checkpoint file
+
+    Returns:
+        Dict: The processed state dictionary for loading
+    """
+    state_dict = torch.load(checkpoint_path, weights_only=True)
+
+    # If the component was trained with DDP, elements in the state dict have prefix "module." which we must remove
+    new_state_dict = {}
+    for k, v in state_dict.items():
+        new_state_dict[k] = v
+
+    return new_state_dict
+
+
+def get_vla(cfg: Any) -> torch.nn.Module:
+    """
+    Load and initialize the VLA model from checkpoint.
+
+    Args:
+        cfg: Configuration object
+
+    Returns:
+        torch.nn.Module: The initialized VLA model
+    """
+    print("Instantiating pretrained VLA policy...")
+
+    # If loading a locally stored pretrained checkpoint, check whether config or model files
+    # need to be synced so that any changes the user makes to the VLA modeling code will
+    # actually go into effect
+    # If loading a pretrained checkpoint from Hugging Face Hub, we just assume that the policy
+    # will be used as is, with its original modeling logic
+    if not model_is_on_hf_hub(cfg.pretrained_checkpoint):
+        # Register OpenVLA model to HF Auto Classes (not needed if the model is on HF Hub)
+        AutoConfig.register("openvla", OpenVLAConfig)
+        AutoImageProcessor.register(OpenVLAConfig, PrismaticImageProcessor)
+        AutoProcessor.register(OpenVLAConfig, PrismaticProcessor)
+        AutoModelForVision2Seq.register(OpenVLAConfig, OpenVLAForActionPrediction)
+
+        # Update config.json and sync model files
+        update_auto_map(cfg.pretrained_checkpoint)
+        check_model_logic_mismatch(cfg.pretrained_checkpoint)
+
+    # Load the model
+    vla = AutoModelForVision2Seq.from_pretrained(
+        cfg.pretrained_checkpoint,
+        # attn_implementation="flash_attention_2",
+        torch_dtype=torch.bfloat16,
+        load_in_8bit=cfg.load_in_8bit,
+        load_in_4bit=cfg.load_in_4bit,
+        low_cpu_mem_usage=False,
+        trust_remote_code=False,
+    )
+
+    # If using FiLM, wrap the vision backbone to allow for infusion of language inputs
+    if cfg.use_film:
+        vla = _apply_film_to_vla(vla, cfg)
+
+    # Set number of images in model input
+    vla.vision_backbone.set_num_images_in_input(cfg.num_images_in_input)
+
+    vla.eval()
+
+    # Move model to device if not using quantization
+    if not cfg.load_in_8bit and not cfg.load_in_4bit:
+        vla = vla.to(DEVICE)
+
+    # Load dataset stats for action normalization
+    _load_dataset_stats(vla, cfg.pretrained_checkpoint)
+
+    return vla
+
+
+def _apply_film_to_vla(vla: torch.nn.Module, cfg: Any) -> torch.nn.Module:
+    """
+    Apply FiLM (Feature-wise Linear Modulation) to the VLA vision backbone.
+
+    Args:
+        vla: The VLA model
+        cfg: Configuration object with model parameters
+
+    Returns:
+        torch.nn.Module: VLA model with FiLM applied
+    """
+    from peft import LoraConfig, get_peft_model
+
+    # Apply LoRA configuration
+    lora_config = LoraConfig(
+        r=32,
+        lora_alpha=16,
+        lora_dropout=0.0,
+        target_modules="all-linear",
+        init_lora_weights="gaussian",
+    )
+    vla = get_peft_model(vla, lora_config)
+
+    # Create and apply FiLMed vision backbone
+    new_vision_backbone = FiLMedPrismaticVisionBackbone(
+        vision_backbone=vla.vision_backbone, llm_dim=vla.llm_dim,
+    )
+    vla.model.vision_backbone = new_vision_backbone
+
+    # Load vision backbone checkpoint
+    checkpoint_path = find_checkpoint_file(cfg.pretrained_checkpoint, "vision_backbone")
+    state_dict = torch.load(checkpoint_path, weights_only=True)
+    vla.model.vision_backbone.load_state_dict(state_dict)
+
+    # Use the model component instead of wrapper and convert to bfloat16
+    vla = vla.model
+    vla.vision_backbone = vla.vision_backbone.to(torch.bfloat16)
+
+    return vla
+
+
+def _load_dataset_stats(vla: torch.nn.Module, checkpoint_path: str) -> None:
+    """
+    Load dataset statistics used during training for action normalization.
+
+    Args:
+        vla: The VLA model
+        checkpoint_path: Path to the checkpoint directory
+    """
+    if model_is_on_hf_hub(checkpoint_path):
+        # Download dataset stats directly from HF Hub
+        dataset_statistics_path = hf_hub_download(
+            repo_id=checkpoint_path,
+            filename="dataset_statistics.json",
+        )
+    else:
+        dataset_statistics_path = os.path.join(checkpoint_path, "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`."
+        )
+
+
+def get_processor(cfg: Any) -> AutoProcessor:
+    """
+    Get the VLA model's Hugging Face processor.
+
+    Args:
+        cfg: Configuration object with model parameters
+
+    Returns:
+        AutoProcessor: The model's processor
+    """
+    return AutoProcessor.from_pretrained(cfg.pretrained_checkpoint, trust_remote_code=False)
+
+
+def get_proprio_projector(cfg: Any, llm_dim: int, proprio_dim: int) -> ProprioProjector:
+    """
+    Get proprioception projector for the VLA model.
+
+    Args:
+        cfg: Configuration object with model parameters
+        llm_dim: Dimension of the language model
+        proprio_dim: Dimension of proprioception data
+
+    Returns:
+        ProprioProjector: The initialized proprio projector
+    """
+    # Initialize projector and move to device
+    proprio_projector = ProprioProjector(
+        llm_dim=llm_dim,
+        proprio_dim=proprio_dim,
+    ).to(DEVICE)
+    proprio_projector = proprio_projector.to(torch.bfloat16).to(DEVICE)
+    proprio_projector.eval()
+
+    # Find and load checkpoint (may be on Hugging Face Hub or stored locally)
+    if model_is_on_hf_hub(cfg.pretrained_checkpoint):
+        model_path_to_proprio_projector_name = {
+            "VLA-Adapter/LIBERO-Spatial-Pro": "proprio_projector--checkpoint.pt",
+            "VLA-Adapter/LIBERO-Object-Pro": "proprio_projector--checkpoint.pt",
+            "VLA-Adapter/LIBERO-Goal-Pro": "proprio_projector--checkpoint.pt",
+            "VLA-Adapter/LIBERO-Long-Pro": "proprio_projector--checkpoint.pt",
+        }
+        if cfg.pretrained_checkpoint not in model_path_to_proprio_projector_name.keys():
+            raise ValueError("Unsupported HF Hub pretrained checkpoint found!")
+        # Download proprio projector directly from HF Hub
+        proprio_projector_path = hf_hub_download(
+            repo_id=cfg.pretrained_checkpoint, filename=model_path_to_proprio_projector_name[cfg.pretrained_checkpoint]
+        )
+        state_dict = load_component_state_dict(proprio_projector_path)
+        proprio_projector.load_state_dict(state_dict)
+    else:
+        checkpoint_path = find_checkpoint_file(cfg.pretrained_checkpoint, "proprio_projector")
+        state_dict = load_component_state_dict(checkpoint_path)
+        proprio_projector.load_state_dict(state_dict)
+
+    return proprio_projector
+
+
+def get_noisy_action_projector(cfg: Any, llm_dim: int) -> NoisyActionProjector:
+    """
+    Get noisy action projector for diffusion-based action prediction.
+
+    Args:
+        cfg: Configuration object with model parameters
+        llm_dim: Dimension of the language model
+
+    Returns:
+        NoisyActionProjector: The initialized noisy action projector
+    """
+    # Initialize projector and move to device
+    noisy_action_projector = NoisyActionProjector(
+        llm_dim=llm_dim,
+    ).to(DEVICE)
+    noisy_action_projector = noisy_action_projector.to(torch.bfloat16).to(DEVICE)
+    noisy_action_projector.eval()
+
+    # Find and load checkpoint
+    checkpoint_path = find_checkpoint_file(cfg.pretrained_checkpoint, "noisy_action_projector")
+    state_dict = load_component_state_dict(checkpoint_path)
+    noisy_action_projector.load_state_dict(state_dict)
+
+    return noisy_action_projector
+
+
+def get_action_head(cfg: Any, llm_dim: int) -> Union[L1RegressionActionHead]:
+    """
+    Get action head for continuous value prediction.
+
+    Args:
+        cfg: Configuration object with model parameters
+        llm_dim: Dimension of the language model
+
+    Returns:
+        Union[L1RegressionActionHead, DiffusionActionHead]: The initialized action head
+
+    Raises:
+        AssertionError: If both L1 regression and diffusion are specified
+    """
+    # assert not cfg.use_l1_regression, "Cannot use both L1 regression and diffusion action head!"
+    if not hasattr(cfg, "use_pro_version"):
+        if "Pro" in cfg.pretrained_checkpoint or "Pro" in cfg.save_version:
+            cfg.use_pro_version = True
+        else:
+            cfg.use_pro_version = False
+
+    # Initialize appropriate action head based on configuration
+    if cfg.use_l1_regression:
+        action_head = L1RegressionActionHead(
+            input_dim=llm_dim, 
+            hidden_dim=llm_dim, 
+            action_dim=ACTION_DIM,
+            use_pro_version=cfg.use_pro_version,
+        )
+
+    else:
+        raise ValueError("Either use_l1_regression or use_diffusion must be True")
+
+    action_head = action_head.to(torch.bfloat16).to(DEVICE)
+    action_head.eval()
+
+    # Find and load checkpoint (may be on Hugging Face Hub or stored locally)
+    if model_is_on_hf_hub(cfg.pretrained_checkpoint):
+        model_path_to_action_head_name = {
+            "VLA-Adapter/LIBERO-Spatial-Pro": "action_head--checkpoint.pt",
+            "VLA-Adapter/LIBERO-Object-Pro": "action_head--checkpoint.pt",
+            "VLA-Adapter/LIBERO-Goal-Pro": "action_head--checkpoint.pt",
+            "VLA-Adapter/LIBERO-Long-Pro": "action_head--checkpoint.pt",
+        }
+        if cfg.pretrained_checkpoint not in model_path_to_action_head_name.keys():
+            raise ValueError("Unsupported HF Hub pretrained checkpoint found!")
+        # Download proprio projector directly from HF Hub
+        action_head_path = hf_hub_download(
+            repo_id=cfg.pretrained_checkpoint, filename=model_path_to_action_head_name[cfg.pretrained_checkpoint]
+        )
+        state_dict = load_component_state_dict(action_head_path)
+        action_head.load_state_dict(state_dict)
+    else:
+        checkpoint_path = find_checkpoint_file(cfg.pretrained_checkpoint, "action_head")
+        state_dict = load_component_state_dict(checkpoint_path)
+        action_head.load_state_dict(state_dict)
+
+    return action_head
+
+
+def resize_image_for_policy(img: np.ndarray, resize_size: Union[int, Tuple[int, int]]) -> np.ndarray:
+    """
+    Resize an image to match the policy's expected input size.
+
+    Uses the same resizing scheme as in the training data pipeline for distribution matching.
+
+    Args:
+        img: Numpy array containing the image
+        resize_size: Target size as int (square) or (height, width) tuple
+
+    Returns:
+        np.ndarray: The resized image
+    """
+    assert isinstance(resize_size, int) or isinstance(resize_size, tuple)
+    if isinstance(resize_size, int):
+        resize_size = (resize_size, resize_size)
+
+    # Resize using the same pipeline as in RLDS dataset builder
+    img = tf.image.encode_jpeg(img)  # Encode as JPEG
+    img = tf.io.decode_image(img, expand_animations=False, dtype=tf.uint8)  # Decode back
+    img = tf.image.resize(img, resize_size, method="lanczos3", antialias=True)
+    img = tf.cast(tf.clip_by_value(tf.round(img), 0, 255), tf.uint8)
+
+    return img.numpy()
+
+
+def crop_and_resize(image: tf.Tensor, crop_scale: float, batch_size: int) -> tf.Tensor:
+    """
+    Center-crop an image and resize it back to original dimensions.
+
+    Uses the same logic as in the training data pipeline for distribution matching.
+
+    Args:
+        image: TF Tensor of shape (batch_size, H, W, C) or (H, W, C) with values in [0,1]
+        crop_scale: Area of center crop relative to original image
+        batch_size: Batch size
+
+    Returns:
+        tf.Tensor: The cropped and resized image
+    """
+    # Handle 3D inputs by adding batch dimension if needed
+    assert image.shape.ndims in (3, 4), "Image must be 3D or 4D tensor"
+    expanded_dims = False
+    if image.shape.ndims == 3:
+        image = tf.expand_dims(image, axis=0)
+        expanded_dims = True
+
+    # Calculate crop dimensions (note: we use sqrt(crop_scale) for h/w)
+    new_heights = tf.reshape(tf.clip_by_value(tf.sqrt(crop_scale), 0, 1), shape=(batch_size,))
+    new_widths = tf.reshape(tf.clip_by_value(tf.sqrt(crop_scale), 0, 1), shape=(batch_size,))
+
+    # Create bounding box for the crop
+    height_offsets = (1 - new_heights) / 2
+    width_offsets = (1 - new_widths) / 2
+    bounding_boxes = tf.stack(
+        [
+            height_offsets,
+            width_offsets,
+            height_offsets + new_heights,
+            width_offsets + new_widths,
+        ],
+        axis=1,
+    )
+
+    # Apply crop and resize
+    image = tf.image.crop_and_resize(
+        image, bounding_boxes, tf.range(batch_size), (OPENVLA_IMAGE_SIZE, OPENVLA_IMAGE_SIZE)
+    )
+
+    # Remove batch dimension if it was added
+    if expanded_dims:
+        image = image[0]
+
+    return image
+
+
+def center_crop_image(image: Union[np.ndarray, Image.Image]) -> Image.Image:
+    """
+    Center crop an image to match training data distribution.
+
+    Args:
+        image: Input image (PIL or numpy array)
+
+    Returns:
+        Image.Image: Cropped PIL Image
+    """
+    batch_size = 1
+    crop_scale = 0.9
+
+    # Convert to TF Tensor if needed
+    if not isinstance(image, tf.Tensor):
+        image = tf.convert_to_tensor(np.array(image))
+
+    orig_dtype = image.dtype
+
+    # Convert to float32 in range [0,1]
+    image = tf.image.convert_image_dtype(image, tf.float32)
+
+    # Apply center crop and resize
+    image = crop_and_resize(image, crop_scale, batch_size)
+
+    # Convert back to original data type
+    image = tf.clip_by_value(image, 0, 1)
+    image = tf.image.convert_image_dtype(image, orig_dtype, saturate=True)
+
+    # Convert to PIL Image
+    return Image.fromarray(image.numpy()).convert("RGB")
+
+
+def check_image_format(image: Any) -> None:
+    """
+    Validate input image format.
+
+    Args:
+        image: Image to check
+
+    Raises:
+        AssertionError: If image format is invalid
+    """
+    is_numpy_array = isinstance(image, np.ndarray)
+    has_correct_shape = len(image.shape) == 3 and image.shape[-1] == 3
+    has_correct_dtype = image.dtype == np.uint8
+
+    assert is_numpy_array and has_correct_shape and has_correct_dtype, (
+        "Incorrect image format detected! Make sure that the input image is a "
+        "numpy array with shape (H, W, 3) and dtype np.uint8!"
+    )
+
+
+def normalize_proprio(proprio: np.ndarray, norm_stats: Dict[str, Any]) -> np.ndarray:
+    """
+    Normalize proprioception data to match training distribution.
+
+    Args:
+        proprio: Raw proprioception data
+        norm_stats: Normalization statistics
+
+    Returns:
+        np.ndarray: Normalized proprioception data
+    """
+    if ACTION_PROPRIO_NORMALIZATION_TYPE == NormalizationType.BOUNDS:
+        mask = norm_stats.get("mask", np.ones_like(norm_stats["min"], dtype=bool))
+        proprio_high, proprio_low = np.array(norm_stats["max"]), np.array(norm_stats["min"])
+    elif ACTION_PROPRIO_NORMALIZATION_TYPE == NormalizationType.BOUNDS_Q99:
+        mask = norm_stats.get("mask", np.ones_like(norm_stats["q01"], dtype=bool))
+        proprio_high, proprio_low = np.array(norm_stats["q99"]), np.array(norm_stats["q01"])
+    else:
+        raise ValueError("Unsupported action/proprio normalization type detected!")
+
+    normalized_proprio = np.clip(
+        np.where(
+            mask,
+            2 * (proprio - proprio_low) / (proprio_high - proprio_low + 1e-8) - 1,
+            proprio,
+        ),
+        a_min=-1.0,
+        a_max=1.0,
+    )
+
+    return normalized_proprio
+
+
+def prepare_images_for_vla(images: List[np.ndarray], cfg: Any) -> List[Image.Image]:
+    """
+    Prepare images for VLA input by resizing and cropping as needed.
+
+    Args:
+        images: List of input images as numpy arrays
+        cfg: Configuration object with parameters
+
+    Returns:
+        List[Image.Image]: Processed images ready for the model
+    """
+    processed_images = []
+
+    for image in images:
+        # Validate format
+        check_image_format(image)
+
+        # Resize if needed
+        if image.shape != (OPENVLA_IMAGE_SIZE, OPENVLA_IMAGE_SIZE, 3):
+            image = resize_image_for_policy(image, OPENVLA_IMAGE_SIZE)
+
+        # Convert to PIL image
+        pil_image = Image.fromarray(image).convert("RGB")
+
+        # Apply center crop if configured
+        if cfg.center_crop:
+            pil_image = center_crop_image(pil_image)
+
+        processed_images.append(pil_image)
+
+    return processed_images
+
+
+def get_vla_action(
+    cfg: Any,
+    vla: torch.nn.Module,
+    processor: Any,
+    obs: Dict[str, Any],
+    task_label: str,
+    action_head: Optional[torch.nn.Module] = None,
+    proprio_projector: Optional[torch.nn.Module] = None,
+    noisy_action_projector: Optional[torch.nn.Module] = None,
+    use_film: bool = False,
+    use_minivlm: bool = False,
+) -> List[np.ndarray]:
+    """
+    Generate action predictions with the VLA policy.
+
+    Args:
+        cfg: Configuration object with parameters
+        vla: The VLA model
+        processor: Model processor for inputs
+        obs: Observation dictionary
+        task_label: Text description of the task
+        action_head: Optional action head for continuous actions
+        proprio_projector: Optional proprioception projector
+        noisy_action_projector: Optional noisy action projector for diffusion
+        use_film: Whether to use FiLM
+
+    Returns:
+        List[np.ndarray]: Predicted actions
+    """
+    with torch.inference_mode():
+
+        # Collect all input images
+        all_images = [obs["full_image"]]
+        if cfg.num_images_in_input > 1:
+            all_images.extend([obs[k] for k in obs.keys() if "wrist" in k])
+
+        # Process images
+        all_images = prepare_images_for_vla(all_images, cfg)
+
+        # Extract primary image and additional images
+        primary_image = all_images.pop(0)
+
+        # Build VLA prompt
+        if not use_minivlm:
+            prompt = f"In: What action should the robot take to {task_label.lower()}?\nOut:"
+        else:
+            prompt = f'<|im_start|>system\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\n<|im_start|>user\nWhat action should the robot take to {task_label.lower()}?<|im_end|>\n<|im_start|>assistant\n'
+
+        # Process primary image
+        inputs = processor(prompt, primary_image).to(DEVICE, dtype=torch.bfloat16)
+
+        # Process additional wrist images if any
+        if all_images:
+            all_wrist_inputs = [
+                processor(prompt, image_wrist).to(DEVICE, dtype=torch.bfloat16) for image_wrist in all_images
+            ]
+            # Concatenate all images
+            primary_pixel_values = inputs["pixel_values"]
+            all_wrist_pixel_values = [wrist_inputs["pixel_values"] for wrist_inputs in all_wrist_inputs]
+            inputs["pixel_values"] = torch.cat([primary_pixel_values] + all_wrist_pixel_values, dim=1)
+
+        # Process proprioception data if used
+        proprio = None
+        if cfg.use_proprio:
+            proprio = obs["state"]
+            proprio_norm_stats = vla.norm_stats[cfg.unnorm_key]["proprio"]
+            obs["state"] = normalize_proprio(proprio, proprio_norm_stats)
+            proprio = obs["state"]
+
+        
+        # Generate action
+        if action_head is None:
+            # Standard VLA output (single-image inputs, discrete actions)
+            action, _ = vla.predict_action(**inputs, unnorm_key=cfg.unnorm_key, do_sample=False)
+        else:
+            # Custom action head for continuous actions
+            action, _ = vla.predict_action(
+                **inputs,
+                unnorm_key=cfg.unnorm_key,
+                do_sample=False,
+                proprio=proprio,
+                proprio_projector=proprio_projector,
+                noisy_action_projector=noisy_action_projector,
+                action_head=action_head,
+                use_film=use_film,
+            )
+
+    # Extract subset of actions for open loop steps
+    return [action[i] for i in range(min(len(action), cfg.num_open_loop_steps))]
+
+
+def get_action_from_server(
+    observation: Dict[str, Any], server_endpoint: str = "http://0.0.0.0:8777/act"
+) -> Dict[str, Any]:
+    """
+    Get VLA action from remote inference server.
+
+    Args:
+        observation: Observation data to send to server
+        server_endpoint: URL of the inference server
+
+    Returns:
+        Dict[str, Any]: Action response from server
+    """
+    response = requests.post(
+        server_endpoint,
+        json=observation,
+    )
+    return response.json()

VLA-Adapter-UAV/experiments/robot/robot_utils.py

@@ -0,0 +1,279 @@
+"""Utils for evaluating robot policies in various environments."""
+
+import os
+import random
+import time
+from typing import Any, Dict, List, Optional, Union
+
+import numpy as np
+import torch
+
+from experiments.robot.openvla_utils import (
+    get_vla,
+    get_vla_action,
+)
+
+# Initialize important constants
+ACTION_DIM = 7
+DATE = time.strftime("%Y_%m_%d")
+DATE_TIME = time.strftime("%Y_%m_%d-%H_%M_%S")
+DEVICE = torch.device("cuda:0") if torch.cuda.is_available() else torch.device("cpu")
+
+# Configure NumPy print settings
+np.set_printoptions(formatter={"float": lambda x: "{0:0.8f}".format(x)})
+
+# Initialize system prompt for OpenVLA v0.1
+OPENVLA_V01_SYSTEM_PROMPT = (
+    "A chat between a curious user and an artificial intelligence assistant. "
+    "The assistant gives helpful, detailed, and polite answers to the user's questions."
+)
+
+# Model image size configuration
+MODEL_IMAGE_SIZES = {
+    "openvla": 224,
+    # Add other models as needed
+}
+
+
+def set_seed_everywhere(seed: int) -> None:
+    """
+    Set random seed for all random number generators for reproducibility.
+
+    Args:
+        seed: The random seed to use
+    """
+    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_model(cfg: Any, wrap_diffusion_policy_for_droid: bool = False) -> torch.nn.Module:
+    """
+    Load and initialize model for evaluation based on configuration.
+
+    Args:
+        cfg: Configuration object with model parameters
+        wrap_diffusion_policy_for_droid: Whether to wrap diffusion policy for DROID
+
+    Returns:
+        torch.nn.Module: The loaded model
+
+    Raises:
+        ValueError: If model family is not supported
+    """
+    if cfg.model_family == "openvla":
+        model = get_vla(cfg)
+    else:
+        raise ValueError(f"Unsupported model family: {cfg.model_family}")
+
+    print(f"Loaded model: {type(model)}")
+    return model
+
+
+def get_image_resize_size(cfg: Any) -> Union[int, tuple]:
+    """
+    Get image resize dimensions for a specific model.
+
+    If returned value is an int, the resized image will be a square.
+    If returned value is a tuple, the resized image will be a rectangle.
+
+    Args:
+        cfg: Configuration object with model parameters
+
+    Returns:
+        Union[int, tuple]: Image resize dimensions
+
+    Raises:
+        ValueError: If model family is not supported
+    """
+    if cfg.model_family not in MODEL_IMAGE_SIZES:
+        raise ValueError(f"Unsupported model family: {cfg.model_family}")
+
+    return MODEL_IMAGE_SIZES[cfg.model_family]
+
+
+def get_action(
+    cfg: Any,
+    model: torch.nn.Module,
+    obs: Dict[str, Any],
+    task_label: str,
+    processor: Optional[Any] = None,
+    action_head: Optional[torch.nn.Module] = None,
+    proprio_projector: Optional[torch.nn.Module] = None,
+    noisy_action_projector: Optional[torch.nn.Module] = None,
+    use_film: bool = False,
+    use_minivlm: bool = False,
+) -> Union[List[np.ndarray], np.ndarray]:
+    """
+    Query the model to get action predictions.
+
+    Args:
+        cfg: Configuration object with model parameters
+        model: The loaded model
+        obs: Observation dictionary
+        task_label: Text description of the task
+        processor: Model processor for inputs
+        action_head: Optional action head for continuous actions
+        proprio_projector: Optional proprioception projector
+        noisy_action_projector: Optional noisy action projector for diffusion
+        use_film: Whether to use FiLM
+
+    Returns:
+        Union[List[np.ndarray], np.ndarray]: Predicted actions
+
+    Raises:
+        ValueError: If model family is not supported
+    """
+    with torch.no_grad():
+        if cfg.model_family == "openvla":
+            action = get_vla_action(
+                cfg=cfg,
+                vla=model,
+                processor=processor,
+                obs=obs,
+                task_label=task_label,
+                action_head=action_head,
+                proprio_projector=proprio_projector,
+                noisy_action_projector=noisy_action_projector,
+                use_film=use_film,
+                use_minivlm=use_minivlm
+            )
+        else:
+            raise ValueError(f"Unsupported model family: {cfg.model_family}")
+
+    return action
+
+
+def normalize_gripper_action(action: np.ndarray, binarize: bool = True) -> np.ndarray:
+    """
+    Normalize gripper action from [0,1] to [-1,+1] range.
+
+    This is necessary for some environments 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.
+
+    Normalization formula: y = 2 * (x - orig_low) / (orig_high - orig_low) - 1
+
+    Args:
+        action: Action array with gripper action in the last dimension
+        binarize: Whether to binarize gripper action to -1 or +1
+
+    Returns:
+        np.ndarray: Action array with normalized gripper action
+    """
+    # Create a copy to avoid modifying the original
+    normalized_action = action.copy()
+
+    # Normalize the last action dimension to [-1,+1]
+    orig_low, orig_high = 0.0, 1.0
+    normalized_action[..., -1] = 2 * (normalized_action[..., -1] - orig_low) / (orig_high - orig_low) - 1
+
+    if binarize:
+        # Binarize to -1 or +1
+        normalized_action[..., -1] = np.sign(normalized_action[..., -1])
+
+    return normalized_action
+
+
+def invert_gripper_action(action: np.ndarray) -> np.ndarray:
+    """
+    Flip the sign of the gripper action (last dimension of action vector).
+
+    This is necessary for environments where -1 = open, +1 = close, since
+    the RLDS dataloader aligns gripper actions such that 0 = close, 1 = open.
+
+    Args:
+        action: Action array with gripper action in the last dimension
+
+    Returns:
+        np.ndarray: Action array with inverted gripper action
+    """
+    # Create a copy to avoid modifying the original
+    inverted_action = action.copy()
+
+    # Invert the gripper action
+    inverted_action[..., -1] *= -1.0
+
+    return inverted_action
+
+
+# -------- Msgpack for VLA: Start ----------
+
+import msgpack
+import msgpack_numpy
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+import requests
+import logging
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    handlers=[logging.StreamHandler()],
+)
+logger = logging.getLogger(__name__)
+
+class MsgPackHttpClientPolicy:
+    """A client policy for communicating with a VLA server using MessagePack."""
+
+    def __init__(self, host: str, port: int=None):
+        """
+        Initializes the client.
+
+        Args:
+            host (str): The server host address.
+            port (int): The server port.
+        """
+        protocol = "https" if "nat-notebook-inspire" in host or "ngrok" in host else "http"
+        if host.startswith("http"):
+            base_url = host
+        else:
+            base_url = f"{protocol}://{host}:{port}"
+        
+        self.infer_url = f"{base_url.rstrip('/')}/act"
+        self.session = requests.Session()
+        # Robust retries for occasional connection resets from server
+        retries = Retry(
+            total=3,
+            connect=3,
+            read=3,
+            backoff_factor=0.2,
+            status_forcelist=(502, 503, 504),
+            raise_on_status=False,
+            allowed_methods=frozenset(["POST", "GET"]),
+        )
+        adapter = HTTPAdapter(max_retries=retries)
+        self.session.mount("http://", adapter)
+        self.session.mount("https://", adapter)
+        self.session.headers.update({"Content-Type": "application/msgpack"})
+        print(f"Standalone MsgPack HTTP Client configured for: {self.infer_url}")
+
+    def infer(self, observation: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+        """
+        Sends an observation to the server and returns the predicted action.
+
+        Args:
+            observation (Dict[str, Any]): The observation dictionary.
+
+        Returns:
+            Dict[str, Any]: The action dictionary from the server.
+        """
+        packed_observation = msgpack.packb(observation, default=msgpack_numpy.encode, use_bin_type=True)
+        try:
+            response = self.session.post(self.infer_url, data=packed_observation, timeout=30)
+            response.raise_for_status()
+            return msgpack.unpackb(response.content, object_hook=msgpack_numpy.decode, raw=False)
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Inference request failed: {e}")
+            # Propagate exception to let the main loop handle it
+            raise e
+        except msgpack.UnpackException as e:
+            logger.error(f"Failed to unpack server response: {e}")
+            raise e
+        
+        
+# -------- Msgpack for VLA: End ----------

VLA-Adapter-UAV/experiments/robot/server_deploy/deploy.py

@@ -0,0 +1,226 @@
+"""
+deploy.py
+
+Starts VLA server which the client can query to get robot actions.
+"""
+import logging
+import traceback
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, Union
+import time
+import sys
+
+import draccus
+import msgpack
+import torch
+import uvicorn
+import numpy as np
+from fastapi import FastAPI, HTTPException, Request, Response
+from PIL import Image
+import msgpack_numpy
+
+
+# Append project root to sys.path
+sys.path.append("../..")
+
+from experiments.robot.openvla_utils import (
+    get_action_head,
+    get_processor,
+    get_proprio_projector,
+)
+from experiments.robot.robot_utils import (
+    get_action,
+    get_image_resize_size,
+    get_model,
+    set_seed_everywhere,
+)
+
+
+# Set up logging to display timestamp, level, and message
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s.%(msecs)03d [%(levelname)s] %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+    handlers=[logging.StreamHandler()],
+)
+
+
+@dataclass
+class DeployConfig:
+    # fmt: off
+
+    # Server Configuration
+    host: str = "0.0.0.0"                                               # Host IP Address
+    port: int = 8000                                                    # Host Port
+    device: str = "cuda:0"                                              # Device to run model on
+
+    #################################################################################################################
+    # Model-specific parameters
+    #################################################################################################################
+    model_family: str = "openvla"                    # Model family
+    pretrained_checkpoint: Union[str, Path] = ""     # Pretrained checkpoint path
+    use_l1_regression: bool = True                   # If True, uses continuous action head with L1 regression objective
+    use_minivlm: bool = True                         # If True, uses minivlm
+    num_diffusion_steps: int = 50                    # (When `diffusion==True`) Number of diffusion steps for inference
+    use_film: bool = False                           # If True, uses FiLM to infuse language inputs into visual features
+    num_images_in_input: int = 3                     # Number of images in the VLA input (default: 1)
+    use_proprio: bool = True                         # Whether to include proprio state in input
+
+    center_crop: bool = True                         # Center crop? (if trained w/ random crop image aug)
+    num_open_loop_steps: int = 25                    # Number of actions to execute open-loop before requerying policy
+    unnorm_key: Union[str, Path] = ""                # Action un-normalization key
+
+    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
+
+    #################################################################################################################
+    # LIBERO environment-specific parameters
+    #################################################################################################################
+    num_steps_wait: int = 10                         # Number of steps to wait for objects to stabilize in sim
+    num_trials_per_task: int = 50                    # Number of rollouts per task
+    initial_states_path: str = "DEFAULT"             # "DEFAULT", or path to initial states JSON file
+    env_img_res: int = 256                           # Resolution for environment images (not policy input resolution)
+
+    #################################################################################################################
+    # Utils
+    #################################################################################################################
+
+    use_wandb: bool = False                          # Whether to also log results in Weights & Biases
+    wandb_entity: str = "your-wandb-entity"          # Name of WandB entity
+    wandb_project: str = "your-wandb-project"        # Name of WandB project
+
+    seed: int = 42                                   # Random Seed (for reproducibility)
+
+    # fmt: on
+    save_version: str = "vla-adapter"                # version of 
+    phase: str = "Inference"
+    use_pro_version: bool = True
+
+
+
+def initialize_model(cfg: DeployConfig):
+    """Initialize model and associated components."""
+    # Load model
+    model = get_model(cfg)
+    model.set_version(cfg.save_version)
+    
+    # Get number of vision patches
+    NUM_PATCHES = model.vision_backbone.get_num_patches() * model.vision_backbone.get_num_images_in_input()
+    # If we have proprio inputs, a single proprio embedding is appended to the end of the vision patch embeddings
+    if cfg.use_proprio:
+        NUM_PATCHES += 1
+    cfg.num_task_tokens=NUM_PATCHES
+
+    # Load proprio projector if needed
+    proprio_projector = None
+    if cfg.use_proprio:
+        proprio_projector = get_proprio_projector(
+            cfg,
+            model.llm_dim,
+            proprio_dim=14,  # 14-dimensional proprio for aloha
+        )
+
+    # Load action head if needed
+    action_head = None
+    if cfg.use_l1_regression:
+        action_head = get_action_head(cfg, model.llm_dim)
+
+    # Get OpenVLA processor
+    processor = get_processor(cfg)
+
+
+    return model, processor, action_head, proprio_projector
+
+
+class MsgPackResponse(Response):
+    """Custom FastAPI Response class to automatically encode response data into MessagePack."""
+
+    media_type = "application/msgpack"
+
+    def render(self, content: Any) -> bytes:
+        return msgpack.packb(content, default=msgpack_numpy.encode, use_bin_type=True)
+
+
+# === Server Interface ===
+class VLAServer:
+    def __init__(self, cfg: DeployConfig):
+        """
+        A simple server for VLA models, exposing `/act` endpoint.
+        This server receives observations and instructions via MessagePack,
+        and returns predicted actions in MessagePack format.
+        """
+        self.cfg = cfg
+        (
+            self.model,
+            self.processor,
+            self.action_head,
+            self.proprio_projector,
+        ) = initialize_model(cfg)
+        self.resize_size = get_image_resize_size(cfg)
+        set_seed_everywhere(self.cfg.seed)
+        self.app = FastAPI()
+
+        @self.app.middleware("http")
+        async def log_requests(request: Request, call_next):
+            """
+            Middleware to log request details including processing time.
+            """
+            start_time = time.time()
+            response = await call_next(request)
+            process_time = (time.time() - start_time) * 1000  # in milliseconds
+            logging.info(f'"{request.method} {request.url.path}" {response.status_code} - {process_time:.2f}ms')
+            return response
+
+        self.app.post("/act", response_class=MsgPackResponse)(self.get_server_action)
+
+    async def get_server_action(self, request: Request) -> Dict[str, Any]:
+        """Handles a single action prediction request using MessagePack."""
+        if request.headers.get("content-type") != "application/msgpack":
+            raise HTTPException(
+                status_code=415, detail="Unsupported Media Type. 'application/msgpack' is required."
+            )
+        try:
+            body = await request.body()
+            batch = msgpack.unpackb(body, object_hook=msgpack_numpy.decode, raw=False)
+            
+            # Extract unnorm_key and instruction from the batch
+            unnorm_key = batch.pop("unnorm_key")
+            instruction = batch.pop("instruction")
+
+            # Update cfg with the unnorm_key from the client
+            self.cfg.unnorm_key = unnorm_key
+
+            # Use get_action to get model's prediction
+            actions = get_action(
+                self.cfg,
+                self.model,
+                batch,
+                instruction,
+                processor=self.processor,
+                action_head=self.action_head,
+                proprio_projector=self.proprio_projector,
+            )
+            
+            return {"actions": np.array(actions).tolist()}
+
+        except msgpack.UnpackException:
+            raise HTTPException(status_code=400, detail="Invalid MessagePack data provided.")
+        except Exception:
+            logging.error(traceback.format_exc())
+            # Re-raise as a generic 500 error to avoid leaking implementation details.
+            raise HTTPException(status_code=500, detail="An internal server error occurred.")
+
+    def run(self) -> None:
+        """Starts the Uvicorn server."""
+        uvicorn.run(self.app, host=self.cfg.host, port=self.cfg.port, access_log=False, timeout_keep_alive=120)
+
+
+@draccus.wrap()
+def deploy(cfg: DeployConfig) -> None:
+    server = VLAServer(cfg)
+    server.run()
+
+
+if __name__ == "__main__":
+    deploy()

VLA-Adapter-UAV/prismatic/__init__.py

@@ -0,0 +1 @@
+from .models import available_model_names, available_models, get_model_description, load

VLA-Adapter-UAV/prismatic/conf/__init__.py

@@ -0,0 +1,3 @@
+from .datasets import DatasetConfig, DatasetRegistry
+from .models import ModelConfig, ModelRegistry
+from .vla import VLAConfig, VLARegistry

VLA-Adapter-UAV/prismatic/conf/datasets.py

@@ -0,0 +1,133 @@
+"""
+datasets.py
+
+Draccus Dataclass Definition for a DatasetConfig object, with various registered subclasses for each dataset variant
+and processing scheme. A given dataset variant (e.g., `llava-lightning`) configures the following attributes:
+    - Dataset Variant (Identifier) --> e.g., "llava-v15"
+    - Align Stage Dataset Components (annotations, images)
+    - Finetune Stage Dataset Components (annotations, images)
+    - Dataset Root Directory (Path)
+"""
+
+from dataclasses import dataclass
+from enum import Enum, unique
+from pathlib import Path
+from typing import Tuple
+
+from draccus import ChoiceRegistry
+
+
+@dataclass
+class DatasetConfig(ChoiceRegistry):
+    # fmt: off
+    dataset_id: str                                 # Unique ID that fully specifies a dataset variant
+
+    # Dataset Components for each Stage in < align | finetune >
+    align_stage_components: Tuple[Path, Path]       # Path to annotation file and images directory for `align` stage
+    finetune_stage_components: Tuple[Path, Path]    # Path to annotation file and images directory for `finetune` stage
+
+    dataset_root_dir: Path                          # Path to dataset root directory; others paths are relative to root
+    # fmt: on
+
+
+# [Reproduction] LLaVa-v15 (exact dataset used in all public LLaVa-v15 models)
+@dataclass
+class LLaVa_V15_Config(DatasetConfig):
+    dataset_id: str = "llava-v15"
+
+    align_stage_components: Tuple[Path, Path] = (
+        Path("download/llava-laion-cc-sbu-558k/chat.json"),
+        Path("download/llava-laion-cc-sbu-558k/"),
+    )
+    finetune_stage_components: Tuple[Path, Path] = (
+        Path("download/llava-v1.5-instruct/llava_v1_5_mix665k.json"),
+        Path("download/llava-v1.5-instruct/"),
+    )
+    dataset_root_dir: Path = Path("/mnt/fsx/skaramcheti/datasets/prismatic-vlms")
+
+
+# [Multimodal-Only] LLava-v15 WITHOUT the Language-Only ShareGPT Data (No Co-Training)
+@dataclass
+class LLaVa_Multimodal_Only_Config(DatasetConfig):
+    dataset_id: str = "llava-multimodal"
+
+    align_stage_components: Tuple[Path, Path] = (
+        Path("download/llava-laion-cc-sbu-558k/chat.json"),
+        Path("download/llava-laion-cc-sbu-558k/"),
+    )
+    finetune_stage_components: Tuple[Path, Path] = (
+        Path("download/llava-v1.5-instruct/llava_v1_5_stripped625k.json"),
+        Path("download/llava-v1.5-instruct/"),
+    )
+    dataset_root_dir: Path = Path("/mnt/fsx/skaramcheti/datasets/prismatic-vlms")
+
+
+# LLaVa-v15 + LVIS-Instruct-4V
+@dataclass
+class LLaVa_LVIS4V_Config(DatasetConfig):
+    dataset_id: str = "llava-lvis4v"
+
+    align_stage_components: Tuple[Path, Path] = (
+        Path("download/llava-laion-cc-sbu-558k/chat.json"),
+        Path("download/llava-laion-cc-sbu-558k/"),
+    )
+    finetune_stage_components: Tuple[Path, Path] = (
+        Path("download/llava-v1.5-instruct/llava_v1_5_lvis4v_mix888k.json"),
+        Path("download/llava-v1.5-instruct/"),
+    )
+    dataset_root_dir: Path = Path("/mnt/fsx/skaramcheti/datasets/prismatic-vlms")
+
+
+# LLaVa-v15 + LRV-Instruct
+@dataclass
+class LLaVa_LRV_Config(DatasetConfig):
+    dataset_id: str = "llava-lrv"
+
+    align_stage_components: Tuple[Path, Path] = (
+        Path("download/llava-laion-cc-sbu-558k/chat.json"),
+        Path("download/llava-laion-cc-sbu-558k/"),
+    )
+    finetune_stage_components: Tuple[Path, Path] = (
+        Path("download/llava-v1.5-instruct/llava_v1_5_lrv_mix1008k.json"),
+        Path("download/llava-v1.5-instruct/"),
+    )
+    dataset_root_dir: Path = Path("/mnt/fsx/skaramcheti/datasets/prismatic-vlms")
+
+
+# LLaVa-v15 + LVIS-Instruct-4V + LRV-Instruct
+@dataclass
+class LLaVa_LVIS4V_LRV_Config(DatasetConfig):
+    dataset_id: str = "llava-lvis4v-lrv"
+
+    align_stage_components: Tuple[Path, Path] = (
+        Path("download/llava-laion-cc-sbu-558k/chat.json"),
+        Path("download/llava-laion-cc-sbu-558k/"),
+    )
+    finetune_stage_components: Tuple[Path, Path] = (
+        Path("download/llava-v1.5-instruct/llava_v1_5_lvis4v_lrv_mix1231k.json"),
+        Path("download/llava-v1.5-instruct/"),
+    )
+    dataset_root_dir: Path = Path("/mnt/fsx/skaramcheti/datasets/prismatic-vlms")
+
+
+# === Define a Dataset Registry Enum for Reference & Validation =>> all *new* datasets must be added here! ===
+@unique
+class DatasetRegistry(Enum):
+    # === LLaVa v1.5 ===
+    LLAVA_V15 = LLaVa_V15_Config
+
+    LLAVA_MULTIMODAL_ONLY = LLaVa_Multimodal_Only_Config
+
+    LLAVA_LVIS4V = LLaVa_LVIS4V_Config
+    LLAVA_LRV = LLaVa_LRV_Config
+
+    LLAVA_LVIS4V_LRV = LLaVa_LVIS4V_LRV_Config
+
+    @property
+    def dataset_id(self) -> str:
+        return self.value.dataset_id
+
+
+# Register Datasets in Choice Registry
+for dataset_variant in DatasetRegistry:
+    DatasetConfig.register_subclass(dataset_variant.dataset_id, dataset_variant.value)

VLA-Adapter-UAV/prismatic/conf/models.py

@@ -0,0 +1,614 @@
+"""
+models.py
+
+Draccus Dataclass Definition for a ModelConfig object, with various registered subclasses for each model family and
+variant thereof. A given model variant configures the following attributes:
+    - Pretrained Visual Representation (e.g., OpenAI CLIP ViT-L/14) + Pretrained LLM Backbone (e.g., LLaMa-2 7B)
+    - VLM Configuration + Parameters (e.g., MLP Projector, Image Preprocessing, etc.)
+    - [Optional] Stage 1 (`align`) Optimization Hyperparameters
+    - Stage 2 (`finetune`) Optimization Hyperparameters
+"""
+
+from dataclasses import dataclass
+from enum import Enum, unique
+from typing import Optional
+
+from draccus import ChoiceRegistry
+
+
+@dataclass
+class ModelConfig(ChoiceRegistry):
+    # fmt: off
+    model_id: str                                           # Unique Model ID that fully specifies a given variant
+    arch_specifier: str                                     # Architecture specifier string (e.g., "gelu-mlp")
+
+    # Pretrained Backbones
+    vision_backbone_id: str                                 # Pretrained Visual Featurizer (from TIMM) to load
+    llm_backbone_id: str                                    # Pretrained LLM (from HF Transformers) to load
+
+    # Backbone Parameters
+    image_resize_strategy: str                              # Resizing strategy in < crop | letterbox | corner-pad >
+    llm_max_length: int                                     # Maximum context length for LLM (can be < than max!)
+    image_sequence_len: int                                 # Sequence length to use for the vision backbone
+
+    # === Multi-Stage Optimization Hyperparameters ===
+    # By default, we assume an AdamW optimizer with FSDP (Gradient Sharding or Full Sharding depending on stage)
+
+    # Align Stage Optimization Parameters
+    align_epochs: int                                       # Epochs to Run (in case `max_steps` is not specified)
+    align_max_steps: Optional[int]                          # [Optional] Max Gradient Steps (overrides epochs)
+    align_save_every_n_steps: Optional[int]
+    align_global_batch_size: int                            # Global Batch Size (divided across processes)
+    align_per_device_batch_size: int                        # Per-Device Batch Size (per-process)
+                                                            #   => # of accumulation steps is auto-computed
+
+    align_learning_rate: float                              # Peak Learning Rate (lr_scheduler sets warmup/decay)
+    align_weight_decay: float                               # Weight Decay for AdamW Optimizer
+    align_max_grad_norm: float                              # Max Grad Norm (for global gradient clipping)
+    align_lr_scheduler_type: str                            # LR Scheduler (default: "linear-warmup+cosine-decay")
+    align_warmup_ratio: float                               # Fraction of total steps to warmup
+
+    align_train_strategy: str                               # Align Train Strategy (default: "fsdp-shard-grad-op")
+
+    # Finetune Stage Optimization Parameters
+    finetune_epochs: int                                    # Epochs to Run (in case `max_steps` is not specified)
+    finetune_max_steps: Optional[int]                       # [Optional] Max Gradient Steps (overrides epochs)
+    finetune_save_every_n_steps: Optional[int]
+    finetune_global_batch_size: int                         # Global Batch Size (divided across processes)
+    finetune_per_device_batch_size: int                     # Per-Device Batch Size (per-process)
+                                                            #   => # of accumulation steps is auto-computed
+
+    finetune_learning_rate: float                           # Peak Learning Rate (lr_scheduler sets warmup/decay)
+    finetune_weight_decay: float                            # Weight Decay for AdamW Optimizer
+    finetune_max_grad_norm: float                           # Max Grad Norm (for global gradient clipping)
+    finetune_lr_scheduler_type: str                         # LR Scheduler (default: "linear-warmup+cosine-decay")
+    finetune_warmup_ratio: float                            # Fraction of total steps to warmup
+
+    finetune_train_strategy: str                            # Finetune Train Strategy (default: "fsdp-full-shard")
+
+    # Enable Gradient/Activation Checkpointing (for the LLM Backbone)
+    enable_gradient_checkpointing: bool = True
+
+    # Enable Traditional Mixed Precision Training via Torch Native AMP (`autocast`)
+    enable_mixed_precision_training: bool = True            # Whether to enable mixed precision training
+    reduce_in_full_precision: bool = False                  # Whether to run gradient reduction in FP32
+
+    # fmt: on
+
+
+# === LLaVa v1.5 Reproduction - Fully Specified Configurations ===
+@dataclass
+class LLaVa_v15_Reproduction_7B(ModelConfig):
+    model_id: str = "reproduction-llava-v15+7b"
+    arch_specifier: str = "gelu-mlp"
+
+    vision_backbone_id: str = "clip-vit-l-336px"
+    llm_backbone_id: str = "vicuna-v15-7b"
+
+    image_resize_strategy: str = "letterbox"
+    llm_max_length: int = 2048
+    image_sequence_len: int = 1
+
+    # Align Stage Optimization Parameters
+    align_epochs: int = 1
+    align_max_steps: Optional[int] = None
+    align_save_every_n_steps: int = 10000
+    align_global_batch_size: int = 96
+    align_per_device_batch_size: int = 16
+
+    align_learning_rate: float = 1e-3
+    align_weight_decay: float = 0.0
+    align_max_grad_norm: float = 1.0
+    align_lr_scheduler_type: str = "linear-warmup+cosine-decay"
+    align_warmup_ratio: float = 0.03
+
+    align_train_strategy: str = "fsdp-shard-grad-op"
+
+    # Finetune Stage Optimization Parameters
+    finetune_epochs: int = 1
+    finetune_max_steps: Optional[int] = None
+    finetune_save_every_n_steps: int = 10000
+    finetune_global_batch_size: int = 128
+    finetune_per_device_batch_size: int = 16
+
+    finetune_learning_rate: float = 2e-5
+    finetune_weight_decay: float = 0.1
+    finetune_max_grad_norm: float = 1.0
+    finetune_lr_scheduler_type: str = "linear-warmup+cosine-decay"
+    finetune_warmup_ratio: float = 0.03
+
+    finetune_train_strategy: str = "fsdp-full-shard"
+
+
+@dataclass
+class LLaVa_v15_Reproduction_13B(LLaVa_v15_Reproduction_7B):
+    model_id: str = "reproduction-llava-v15+13b"
+    llm_backbone_id: str = "vicuna-v15-13b"
+
+
+# === Section 4.1 :: Optimization Procedure ===
+
+
+# Section 4.1A :: 🚀 --> Necessity of Multi-Stage Training
+@dataclass
+class Exp_7B_One_Stage(LLaVa_v15_Reproduction_7B):
+    model_id: str = "one-stage+7b"
+    arch_specifier: str = "no-align+gelu-mlp"
+
+
+@dataclass
+class Exp_13B_One_Stage(LLaVa_v15_Reproduction_13B):
+    model_id: str = "one-stage+13b"
+    arch_specifier: str = "no-align+gelu-mlp"
+
+
+# Section 4.1B :: 🛠️ --> Full Finetuning through Visual Backbones
+#   =>> Note :: Run with `--stage full-finetune`
+@dataclass
+class Exp_7B_Full_Finetune_Multi_Stage(LLaVa_v15_Reproduction_7B):
+    model_id: str = "full-ft-multi-stage+7b"
+
+
+@dataclass
+class Exp_7B_Full_Finetune_One_Stage(Exp_7B_One_Stage):
+    model_id: str = "full-ft-one-stage+7b"
+
+
+# === Section 4.2 :: Image Processing and Visual Representations ===
+
+
+# Section 4.2A :: 📸 --> Choosing a Pretrained Representation
+@dataclass
+class Exp_7B_IN1K_ViT_L_p16_224px(Exp_7B_One_Stage):
+    model_id: str = "in1k-224px+7b"
+    vision_backbone_id: str = "in1k-vit-l"
+
+
+@dataclass
+class Exp_7B_DINOv2_ViT_L_p14_224px(Exp_7B_One_Stage):
+    model_id: str = "dinov2-224px+7b"
+    vision_backbone_id: str = "dinov2-vit-l"
+
+
+@dataclass
+class Exp_7B_CLIP_ViT_L_p14_224px(Exp_7B_One_Stage):
+    model_id: str = "clip-224px+7b"
+    vision_backbone_id: str = "clip-vit-l"
+
+
+@dataclass
+class Exp_7B_SigLIP_ViT_SO_p14_224px(Exp_7B_One_Stage):
+    model_id: str = "siglip-224px+7b"
+    vision_backbone_id: str = "siglip-vit-so400m"
+
+
+# Section 4.2B :: 📐 --> Choosing an Image Preprocessing Strategy
+@dataclass
+class Exp_7B_CLIP_ViT_L_p14_336px_Resize_Crop(Exp_7B_One_Stage):
+    model_id: str = "clip-336px-resize-crop+7b"
+    image_resize_strategy: str = "resize-crop"
+
+
+@dataclass
+class Exp_7B_CLIP_ViT_L_p14_336px_Resize_Naive(Exp_7B_One_Stage):
+    model_id: str = "clip-336px-resize-naive+7b"
+    image_resize_strategy: str = "resize-naive"
+
+
+@dataclass
+class Exp_7B_SigLIP_ViT_SO_p14_384px_Letterbox(Exp_7B_One_Stage):
+    model_id: str = "siglip-384px-letterbox+7b"
+    vision_backbone_id: str = "siglip-vit-so400m-384px"
+    image_resize_strategy: str = "letterbox"
+
+
+@dataclass
+class Exp_7B_SigLIP_ViT_SO_p14_384px_Resize_Crop(Exp_7B_One_Stage):
+    model_id: str = "siglip-384px-resize-crop+7b"
+    vision_backbone_id: str = "siglip-vit-so400m-384px"
+    image_resize_strategy: str = "resize-crop"
+
+
+@dataclass
+class Exp_7B_SigLIP_ViT_SO_p14_384px_Resize_Naive(Exp_7B_One_Stage):
+    model_id: str = "siglip-384px-resize-naive+7b"
+    vision_backbone_id: str = "siglip-vit-so400m-384px"
+    image_resize_strategy: str = "resize-naive"
+
+
+# Section 4.2D :: 🥞 --> Stacking/Ensembling Visual Representations
+@dataclass
+class Exp_7B_DINOCLIP_ViT_L_p14_336px_Letterbox(Exp_7B_One_Stage):
+    model_id: str = "dinoclip-336px-letterbox+7b"
+    vision_backbone_id: str = "dinoclip-vit-l-336px"
+    image_resize_strategy: str = "letterbox"
+    arch_specifier: str = "no-align+fused-gelu-mlp"
+
+
+@dataclass
+class Exp_7B_DINOCLIP_ViT_L_p14_336px_Resize_Naive(Exp_7B_One_Stage):
+    model_id: str = "dinoclip-336px-resize-naive+7b"
+    vision_backbone_id: str = "dinoclip-vit-l-336px"
+    image_resize_strategy: str = "resize-naive"
+    arch_specifier: str = "no-align+fused-gelu-mlp"
+
+
+@dataclass
+class Exp_7B_DINOSigLIP_ViT_L_p14_384px_Letterbox(Exp_7B_One_Stage):
+    model_id: str = "dinosiglip-384px-letterbox+7b"
+    vision_backbone_id: str = "dinosiglip-vit-so-384px"
+    image_resize_strategy: str = "letterbox"
+    arch_specifier: str = "no-align+fused-gelu-mlp"
+
+
+@dataclass
+class Exp_7B_DINOSigLIP_ViT_L_p14_384px_Resize_Naive(Exp_7B_One_Stage):
+    model_id: str = "dinosiglip-384px-resize-naive+7b"
+    vision_backbone_id: str = "dinosiglip-vit-so-384px"
+    image_resize_strategy: str = "resize-naive"
+    arch_specifier: str = "no-align+fused-gelu-mlp"
+
+
+# === Section 4.3 :: Language Models ===
+
+
+# Section 4.3A :: 📝 --> Base vs. Instruct-Tuned (Chat) LLMs
+@dataclass
+class Exp_7B_Llama2(Exp_7B_One_Stage):
+    model_id: str = "llama2+7b"
+    llm_backbone_id: str = "llama2-7b-pure"
+
+
+@dataclass
+class Exp_13B_Llama2(Exp_13B_One_Stage):
+    model_id: str = "llama2+13b"
+    llm_backbone_id: str = "llama2-13b-pure"
+
+
+# ~ Additional LLM Backbones :: LLaMa-2 Chat, Mistral v0.1, Mistral v0.1 Instruct, Phi-2 ~
+@dataclass
+class Ext_Exp_7B_Llama2_Chat(Exp_7B_One_Stage):
+    model_id: str = "llama2-chat+7b"
+    llm_backbone_id: str = "llama2-7b-chat"
+
+
+@dataclass
+class Ext_Exp_13B_Llama2_Chat(Exp_13B_One_Stage):
+    model_id: str = "llama2-chat+13b"
+    llm_backbone_id: str = "llama2-13b-chat"
+
+
+@dataclass
+class Ext_Exp_7B_Mistral_V1(Exp_7B_One_Stage):
+    model_id: str = "mistral-v0.1+7b"
+    llm_backbone_id: str = "mistral-v0.1-7b-pure"
+
+
+@dataclass
+class Ext_Exp_7B_Mistral_Instruct_V1(Exp_7B_One_Stage):
+    model_id: str = "mistral-instruct-v0.1+7b"
+    llm_backbone_id: str = "mistral-v0.1-7b-instruct"
+
+
+@dataclass
+class Ext_Exp_3B_Phi_2(Exp_7B_One_Stage):
+    model_id: str = "phi-2+3b"
+    llm_backbone_id: str = "phi-2-3b"
+
+
+# Section 4.3B :: ✌️ --> Co-training on Language-only Data
+#   =>> Note :: Run with `--dataset.type "llava-multimodal" (multimodal data only / no co-training)
+@dataclass
+class Exp_7B_Vicuna_No_Cotraining(Exp_7B_One_Stage):
+    model_id: str = "vicuna-no-cotraining+7b"
+
+
+@dataclass
+class Exp_7B_Llama2_No_Cotraining(Exp_7B_One_Stage):
+    model_id: str = "llama2-no-cotraining+7b"
+    llm_backbone_id: str = "llama2-7b-pure"
+
+
+# === Section 4.4 :: Scaling Properties - Train Time & Data ===
+
+
+# Section 4.4A :: ⏰ --> Scaling Train Time
+@dataclass
+class Exp_7B_1p25_Epochs(Exp_7B_One_Stage):
+    model_id: str = "train-1.25-epochs+7b"
+    finetune_max_steps: int = 6500
+
+
+@dataclass
+class Exp_7B_1p5_Epochs(Exp_7B_One_Stage):
+    model_id: str = "train-1.5-epochs+7b"
+    finetune_max_steps: int = 7800
+
+
+@dataclass
+class Exp_7B_2_Epochs(Exp_7B_One_Stage):
+    model_id: str = "train-2-epochs+7b"
+    finetune_epochs: int = 2
+
+
+@dataclass
+class Exp_7B_3_Epochs(Exp_7B_One_Stage):
+    model_id: str = "train-3-epochs+7b"
+    finetune_epochs: int = 3
+
+
+# Section 4.4B :: 📚 --> Scaling Data
+#   =>> Note :: Run with `--dataset.type "llava-lvis4v"`
+@dataclass
+class Exp_7B_LLaVa_LVIS4V(Exp_7B_One_Stage):
+    model_id: str = "llava-lvis4v+7b"
+
+
+#   =>> Note :: Run with `--dataset.type "llava-lrv"`
+@dataclass
+class Exp_7B_LLaVa_LRV(Exp_7B_One_Stage):
+    model_id: str = "llava-lrv+7b"
+
+
+#   =>> Note :: Run with `--dataset.type "llava-lvis4v-lrv"`
+@dataclass
+class Exp_7B_LLaVa_LVIS4V_LRV(Exp_7B_One_Stage):
+    model_id: str = "llava-lvis4v-lrv+7b"
+
+
+# === Section 5 :: Prisms ===
+
+
+# Prism-CLIP
+@dataclass
+class Prism_7B_CLIP_Controlled(Exp_7B_One_Stage):
+    model_id: str = "prism-clip-controlled+7b"
+    vision_backbone_id: str = "clip-vit-l-336px"
+    image_resize_strategy: str = "resize-naive"
+    llm_backbone_id: str = "llama2-7b-pure"
+
+
+@dataclass
+class Prism_13B_CLIP_Controlled(Exp_13B_One_Stage):
+    model_id: str = "prism-clip-controlled+13b"
+    vision_backbone_id: str = "clip-vit-l-336px"
+    image_resize_strategy: str = "resize-naive"
+    llm_backbone_id: str = "llama2-13b-pure"
+
+
+#   =>> Note :: Run with `--dataset.type "llava-lvis4v-lrv"`
+@dataclass
+class Prism_7B_CLIP(Exp_7B_One_Stage):
+    model_id: str = "prism-clip+7b"
+    vision_backbone_id: str = "clip-vit-l-336px"
+    image_resize_strategy: str = "resize-naive"
+    llm_backbone_id: str = "llama2-7b-pure"
+    finetune_epochs: int = 2
+
+
+#   =>> Note :: Run with `--dataset.type "llava-lvis4v-lrv"`
+@dataclass
+class Prism_13B_CLIP(Exp_13B_One_Stage):
+    model_id: str = "prism-clip+13b"
+    vision_backbone_id: str = "clip-vit-l-336px"
+    image_resize_strategy: str = "resize-naive"
+    llm_backbone_id: str = "llama2-13b-pure"
+    finetune_epochs: int = 2
+
+
+# Prism-SigLIP
+@dataclass
+class Prism_7B_SigLIP_Controlled(Exp_7B_One_Stage):
+    model_id: str = "prism-siglip-controlled+7b"
+    vision_backbone_id: str = "siglip-vit-so400m-384px"
+    image_resize_strategy: str = "resize-naive"
+    llm_backbone_id: str = "llama2-7b-pure"
+
+
+@dataclass
+class Prism_13B_SigLIP_Controlled(Exp_13B_One_Stage):
+    model_id: str = "prism-siglip-controlled+13b"
+    vision_backbone_id: str = "siglip-vit-so400m-384px"
+    image_resize_strategy: str = "resize-naive"
+    llm_backbone_id: str = "llama2-13b-pure"
+
+
+#   =>> Note :: Run with `--dataset.type "llava-lvis4v-lrv"`
+@dataclass
+class Prism_7B_SigLIP(Exp_7B_One_Stage):
+    model_id: str = "prism-siglip+7b"
+    vision_backbone_id: str = "siglip-vit-so400m-384px"
+    image_resize_strategy: str = "resize-naive"
+    llm_backbone_id: str = "llama2-7b-pure"
+    finetune_epochs: int = 2
+
+
+#   =>> Note :: Run with `--dataset.type "llava-lvis4v-lrv"`
+@dataclass
+class Prism_13B_SigLIP(Exp_13B_One_Stage):
+    model_id: str = "prism-siglip+13b"
+    vision_backbone_id: str = "clip-vit-l-336px"
+    image_resize_strategy: str = "resize-naive"
+    llm_backbone_id: str = "llama2-13b-pure"
+    finetune_epochs: int = 2
+
+
+# Prism-DINOSigLIP
+@dataclass
+class Prism_7B_DINOSigLIP_Controlled(Exp_7B_One_Stage):
+    model_id: str = "prism-dinosiglip-controlled+7b"
+    vision_backbone_id: str = "dinosiglip-vit-so-384px"
+    image_resize_strategy: str = "resize-naive"
+    llm_backbone_id: str = "llama2-7b-pure"
+    arch_specifier: str = "no-align+fused-gelu-mlp"
+
+
+@dataclass
+class Prism_13B_DINOSigLIP_Controlled(Exp_13B_One_Stage):
+    model_id: str = "prism-dinosiglip-controlled+13b"
+    vision_backbone_id: str = "dinosiglip-vit-so-384px"
+    image_resize_strategy: str = "resize-naive"
+    llm_backbone_id: str = "llama2-13b-pure"
+    arch_specifier: str = "no-align+fused-gelu-mlp"
+
+
+#   =>> Note :: Run with `--dataset.type "llava-lvis4v-lrv"`
+@dataclass
+class Prism_7B_DINOSigLIP(Exp_7B_One_Stage):
+    model_id: str = "prism-dinosiglip+7b"
+    vision_backbone_id: str = "dinosiglip-vit-so-384px"
+    image_resize_strategy: str = "resize-naive"
+    llm_backbone_id: str = "llama2-7b-pure"
+    arch_specifier: str = "no-align+fused-gelu-mlp"
+    finetune_epochs: int = 2
+
+
+#   =>> Note :: Run with `--dataset.type "llava-lvis4v-lrv"`
+@dataclass
+class Prism_13B_DINOSigLIP(Exp_13B_One_Stage):
+    model_id: str = "prism-dinosiglip+13b"
+    vision_backbone_id: str = "dinosiglip-vit-so-384px"
+    image_resize_strategy: str = "resize-naive"
+    llm_backbone_id: str = "llama2-13b-pure"
+    arch_specifier: str = "no-align+fused-gelu-mlp"
+    finetune_epochs: int = 2
+
+
+# [Inference-Optimized] 224px Prisms
+@dataclass
+class Opt_7B_DINOSigLIP_ViT_SO_p14_224px_Resize_Naive(Exp_7B_One_Stage):
+    model_id: str = "dinosiglip-224px-resize-naive+7b"
+    vision_backbone_id: str = "dinosiglip-vit-so-224px"
+    image_resize_strategy: str = "resize-naive"
+    arch_specifier: str = "no-align+fused-gelu-mlp"
+
+
+@dataclass
+class Prism_7B_DINOSigLIP_224px_Controlled(Exp_7B_One_Stage):
+    model_id: str = "prism-dinosiglip-224px-controlled+7b"
+    vision_backbone_id: str = "dinosiglip-vit-so-224px"
+    image_resize_strategy: str = "resize-naive"
+    llm_backbone_id: str = "llama2-7b-pure"
+    arch_specifier: str = "no-align+fused-gelu-mlp"
+
+
+#   =>> Note :: Run with `--dataset.type "llava-lvis4v-lrv"`
+@dataclass
+class Prism_7B_DINOSigLIP_224px(Exp_7B_One_Stage):
+    model_id: str = "prism-dinosiglip-224px+7b"
+    vision_backbone_id: str = "dinosiglip-vit-so-224px"
+    image_resize_strategy: str = "resize-naive"
+    llm_backbone_id: str = "llama2-7b-pure"
+    arch_specifier: str = "no-align+fused-gelu-mlp"
+    finetune_epochs: int = 2
+
+
+#   =>> Note :: Run with `--dataset.type "llava-lvis4v-lrv"`
+@dataclass
+class Prism_Qwen25_0_5B_DINOSigLIP_224px(Exp_7B_One_Stage):
+    model_id: str = "prism-qwen25-dinosiglip-224px+0_5b"
+    vision_backbone_id: str = "dinosiglip-vit-so-224px"
+    image_resize_strategy: str = "resize-naive"
+    llm_backbone_id: str = "qwen25-0_5b-pure"
+    arch_specifier: str = "no-align+fused-gelu-mlp"
+    finetune_epochs: int = 2
+
+    llm_max_length: int = 32768
+
+
+#   =>> Note :: Run with `--dataset.type "llava-lvis4v-lrv"`
+@dataclass
+class Prism_Qwen25_0_5B_Extra_DINOSigLIP_224px(Prism_Qwen25_0_5B_DINOSigLIP_224px):
+    model_id: str = "prism-qwen25-extra-dinosiglip-224px+0_5b"
+    llm_backbone_id: str = "qwen25-0_5b-extra"
+
+
+# === Define a Model Registry Enum for Reference & Validation ===
+@unique
+class ModelRegistry(Enum):
+    # === LLaVa v1.5 Base Reproductions ===
+    REPRODUCTION_7B = LLaVa_v15_Reproduction_7B
+    REPRODUCTION_13B = LLaVa_v15_Reproduction_13B
+
+    # === Section 4.1 :: Optimization Procedure ===
+    EXP_ONE_STAGE_7B = Exp_7B_One_Stage
+    EXP_ONE_STAGE_13B = Exp_13B_One_Stage
+
+    EXP_FULL_FT_MULTI_STAGE = Exp_7B_Full_Finetune_Multi_Stage
+    EXP_FULL_FT_ONE_STAGE = Exp_7B_Full_Finetune_One_Stage
+
+    # === Section 4.2 :: Image Processing and Visual Representations ===
+    EXP_IN1K_224PX = Exp_7B_IN1K_ViT_L_p16_224px
+    EXP_DINOV2_224PX = Exp_7B_DINOv2_ViT_L_p14_224px
+    EXP_CLIP_224PX = Exp_7B_CLIP_ViT_L_p14_224px
+    EXP_SIGLIP_224PX = Exp_7B_SigLIP_ViT_SO_p14_224px
+
+    EXP_CLIP_336PX_RESIZE_CROP = Exp_7B_CLIP_ViT_L_p14_336px_Resize_Crop
+    EXP_CLIP_336PX_RESIZE_NAIVE = Exp_7B_CLIP_ViT_L_p14_336px_Resize_Naive
+    EXP_SIGLIP_384PX_LETTERBOX = Exp_7B_SigLIP_ViT_SO_p14_384px_Letterbox
+    EXP_SIGLIP_384PX_RESIZE_CROP = Exp_7B_SigLIP_ViT_SO_p14_384px_Resize_Crop
+    EXP_SIGLIP_384PX_RESIZE_NAIVE = Exp_7B_SigLIP_ViT_SO_p14_384px_Resize_Naive
+
+    EXP_DINOCLIP_336PX_LETTERBOX = Exp_7B_DINOCLIP_ViT_L_p14_336px_Letterbox
+    EXP_DINOCLIP_336PX_RESIZE_NAIVE = Exp_7B_DINOCLIP_ViT_L_p14_336px_Resize_Naive
+    EXP_DINOSIGLIP_384PX_LETTERBOX = Exp_7B_DINOSigLIP_ViT_L_p14_384px_Letterbox
+    EXP_DINOSIGLIP_384PX_RESIZE_NAIVE = Exp_7B_DINOSigLIP_ViT_L_p14_384px_Resize_Naive
+
+    # === Section 4.3 :: Language Models ===
+    EXP_LLAMA2_7B = Exp_7B_Llama2
+    EXP_LLAMA2_13B = Exp_13B_Llama2
+
+    # ~ Additional LLM Backbone Experiments :: LLaMa-2 Chat, Mistral v0.1, Mistral v0.1 Instruct ~
+    EXT_EXP_LLAMA2_CHAT_7B = Ext_Exp_7B_Llama2_Chat
+    EXT_EXP_LLAMA2_CHAT_13B = Ext_Exp_13B_Llama2_Chat
+    EXT_EXP_MISTRAL_V1_7B = Ext_Exp_7B_Mistral_V1
+    EXT_EXP_MISTRAL_INSTRUCT_V1_7B = Ext_Exp_7B_Mistral_Instruct_V1
+    EXT_EXP_PHI_2_3B = Ext_Exp_3B_Phi_2
+
+    # Cotraining w/ Unimodal Data
+    EXP_VICUNA_NO_COTRAINING_7B = Exp_7B_Vicuna_No_Cotraining
+    EXP_LLAMA2_NO_COTRAINING_7B = Exp_7B_Llama2_No_Cotraining
+
+    # === Section 4.4 :: Scaling Properties - Train Time & Data ===
+    EXP_1P25_EPOCHS = Exp_7B_1p25_Epochs
+    EXP_1P5_EPOCHS = Exp_7B_1p5_Epochs
+    EXP_2_EPOCHS = Exp_7B_2_Epochs
+    EXP_3_EPOCHS = Exp_7B_3_Epochs
+
+    EXP_LLAVA_LVIS4V = Exp_7B_LLaVa_LVIS4V
+    EXP_LLAVA_LRV = Exp_7B_LLaVa_LRV
+    EXP_LLAVA_LVIS4V_LRV = Exp_7B_LLaVa_LVIS4V_LRV
+
+    # === Section 5 :: Prisms ===
+    PRISM_CLIP_CONTROLLED_7B = Prism_7B_CLIP_Controlled
+    PRISM_CLIP_CONTROLLED_13B = Prism_13B_CLIP_Controlled
+    PRISM_CLIP_7B = Prism_7B_CLIP
+    PRISM_CLIP_13B = Prism_13B_CLIP
+
+    PRISM_SIGLIP_CONTROLLED_7B = Prism_7B_SigLIP_Controlled
+    PRISM_SIGLIP_CONTROLLED_13B = Prism_13B_SigLIP_Controlled
+    PRISM_SIGLIP_7B = Prism_7B_SigLIP
+    PRISM_SIGLIP_13B = Prism_13B_SigLIP
+
+    PRISM_DINOSIGLIP_CONTROLLED_7B = Prism_7B_DINOSigLIP_Controlled
+    PRISM_DINOSIGLIP_CONTROLLED_13B = Prism_13B_DINOSigLIP_Controlled
+    PRISM_DINOSIGLIP_7B = Prism_7B_DINOSigLIP
+    PRISM_DINOSIGLIP_13B = Prism_13B_DINOSigLIP
+
+    # === Inference Optimized :: 224px Prisms ===
+    OPT_DINOSIGLIP_224PX_RESIZE_NAIVE = Opt_7B_DINOSigLIP_ViT_SO_p14_224px_Resize_Naive
+    PRISM_DINOSIGLIP_224PX_CONTROLLED_7B = Prism_7B_DINOSigLIP_224px_Controlled
+    PRISM_DINOSIGLIP_224PX_7B = Prism_7B_DINOSigLIP_224px
+
+    # Qwen
+    PRISM_QWEN25_DINOSIGLIP_224PX_0_5B = Prism_Qwen25_0_5B_DINOSigLIP_224px
+    PRISM_QWEN25_EXTRA_DINOSIGLIP_224PX_0_5B = Prism_Qwen25_0_5B_Extra_DINOSigLIP_224px
+
+    @property
+    def model_id(self) -> str:
+        return self.value.model_id
+
+
+# Register Models in Choice Registry
+for model_variant in ModelRegistry:
+    ModelConfig.register_subclass(model_variant.model_id, model_variant.value)

VLA-Adapter-UAV/prismatic/conf/vla.py

@@ -0,0 +1,319 @@
+"""
+vla.py
+
+Draccus Dataclass Definition for a VLAConfig object, with various registered subclasses for each VLA experiment and
+model configuration thereof. A given VLA model (`policy`) configures the following attributes:
+    - Data Mixture (e.g., Bridge, OXE_MAGIC_SOUP, etc.)
+    - Base VLM from Prismatic Registry (e.g., `prism-dinosiglip+7b`)
+    - VLA Model Architecture / Parameters (e.g., freeze vision encoder, last layer finetuning)
+    - Training / Optimization Hyperparameters
+"""
+
+from dataclasses import dataclass
+from enum import Enum, unique
+from pathlib import Path
+from typing import Optional, Union
+
+from draccus import ChoiceRegistry
+
+
+@dataclass
+class VLAConfig(ChoiceRegistry):
+    # fmt: off
+    vla_id: str                                     # Unique VLA Policy ID that fully specifies a configuration variant
+    base_vlm: Union[str, Path]                      # Base VLM as ID/Path to Run Directory (e.g., `prism-dinosiglip+7b`)
+    freeze_vision_backbone: bool                    # Freeze Vision Backbone Parameters (akin to pretraining)
+    freeze_llm_backbone: bool                       # Freeze LLM Backbone parameters
+    unfreeze_last_llm_layer: bool                   # Unfreeze final layer of LLM (only takes effect if LLM is frozen)
+
+    # Data Mixture Parameters
+    data_mix: str                                   # Open-X Embodiment Dataset =>> Unique Mixture ID (e.g., `bridge`)
+    shuffle_buffer_size: int                        # Size of Shuffle Buffer (100K for Bridge, 1M for OXE)
+
+    # Optimization Parameters
+    epochs: int                                     # Epochs to Run (in case `max_steps` is not specified)
+    max_steps: Optional[int]                        # [Optional] Max Gradient Steps to Run (overrides `epochs`)
+    save_every_n_steps: Optional[int]
+
+    expected_world_size: int                        # Expected # of GPUs =>> allows us to gate training on hardware
+    global_batch_size: int                          # Global Batch Size (divided across processes / world size)
+    per_device_batch_size: int                      # Per-Device Batch Size (per-process / individual GPU)
+                                                    #   =>> # of accumulation steps is auto-computed
+
+    learning_rate: float                            # Peak Learning Rate (`lr_scheduler_type` sets warmup/decay)
+    weight_decay: float                             # Weight Decay for AdamW Optimizer
+    max_grad_norm: float                            # Max Grad Norm (for global gradient clipping)
+    lr_scheduler_type: str                          # LR Scheduler (usually: "constant" | "linear-warmup+cosine-decay")
+    warmup_ratio: float                             # Fraction of Steps to Warmup (for warmup LR schedulers)
+
+    train_strategy: str                             # Train Strategy (default "fsdp-full-shard")
+    action_tokenizer: str
+
+    image_sequence_len: int
+    use_wrist_image: bool
+
+    # Enable Gradient/Activation Checkpointing (for the LLM Backbone)
+    enable_gradient_checkpointing: bool = True      # Enable Gradient/Activation Checkpointing during Training
+
+    # Mixed Precision Training via Torch Native AMP (`autocast`)
+    enable_mixed_precision_training: bool = True    # Enable Traditional BF16 Mixed Precision
+    reduce_in_full_precision: bool = True           # Accumulate/Reduce All-Gather Gradients in FP32 Full Precision
+
+    # fmt: on
+
+
+# === OpenVLA Training Configurations ===
+
+
+# = [8 GPU] Fast Iteration =>> SigLIP 224px + Bridge =
+@dataclass
+class Exp_SigLIP_224px_Bridge(VLAConfig):
+    vla_id: str = "siglip-224px+mx-bridge"
+    base_vlm: Union[str, Path] = "siglip-224px+7b"
+
+    image_sequence_len: int = 1
+    use_wrist_image: bool = False
+
+    freeze_vision_backbone: bool = False
+    freeze_llm_backbone: bool = False
+    unfreeze_last_llm_layer: bool = False
+
+    # Data Mixture Parameters
+    data_mix: str = "bridge"
+    shuffle_buffer_size: int = 256_000
+
+    # Optimization Parameters
+    epochs: int = 1000
+    max_steps: Optional[int] = None
+    save_every_n_steps: Optional[int] = 25000
+
+    expected_world_size: int = 8
+    global_batch_size: int = 256
+    per_device_batch_size: int = 32
+
+    learning_rate: float = 2e-5
+    weight_decay: float = 0.0
+    max_grad_norm: float = 1.0
+    lr_scheduler_type: str = "constant"
+    warmup_ratio: float = 0.0
+
+    train_strategy: str = "fsdp-full-shard"
+    action_tokenizer: str = "action_tokenizer"
+
+
+# = [8 GPU] SigLIP 224px Frozen Vision Backbone + Bridge =
+@dataclass
+class Exp_FreezeVIT_SigLIP_224px_Bridge(Exp_SigLIP_224px_Bridge):
+    vla_id: str = "siglip-224px-icy+mx-bridge"
+    base_vlm: Union[str, Path] = "siglip-224px+7b"
+    freeze_vision_backbone: bool = True
+
+
+# = [8 GPU] Fast Iteration =>> DINO-SigLIP 224px + Bridge =
+@dataclass
+class Exp_DinoSigLIP_224px_Bridge(Exp_SigLIP_224px_Bridge):
+    vla_id: str = "prism-dinosiglip-224px+mx-bridge"
+    base_vlm: Union[str, Path] = "prism-dinosiglip-224px+7b"
+
+    data_mix: str = "bridge"
+
+
+# = [64 GPU] SigLIP 224px + OXE Magic Soup =
+@dataclass
+class Exp_SigLIP_224px_OXE_Magic_Soup(Exp_SigLIP_224px_Bridge):
+    vla_id: str = "siglip-224px+mx-oxe-magic-soup"
+    base_vlm: Union[str, Path] = "siglip-224px+7b"
+
+    data_mix: str = "oxe_magic_soup"
+
+    expected_world_size: int = 64
+    global_batch_size: int = 2048
+    per_device_batch_size: int = 32
+
+
+# = [8 GPU] Qwen2.5 0.5B SigLIP 224px + OXE Magic Soup =
+@dataclass
+class Exp_Qwen25_DinoSigLIP_224px_0_5B_OXE_Magic_Soup(Exp_SigLIP_224px_Bridge):
+    vla_id: str = "prism-qwen25-dinosiglip-224px+0_5b+mx-oxe-magic-soup"
+    base_vlm: Union[str, Path] = "prism-qwen25-extra-dinosiglip-224px+0_5b"
+
+    data_mix: str = "oxe_magic_soup"
+    action_tokenizer: str = "extra_action_tokenizer"
+
+    expected_world_size: int = 8
+    global_batch_size: int = 256
+    per_device_batch_size: int = 32
+
+
+@dataclass
+class Exp_Qwen25_DinoSigLIP_224px_0_5B_LIBERO_90(Exp_Qwen25_DinoSigLIP_224px_0_5B_OXE_Magic_Soup):
+    vla_id: str = "prism-qwen25-dinosiglip-224px+0_5b+mx-libero-90"
+
+    data_mix: str = "libero_90"
+
+    expected_world_size: int = 8
+    global_batch_size: int = 256
+    per_device_batch_size: int = 32
+
+
+@dataclass
+class Exp_Qwen25_DinoSigLIP_224px_T2_0_5B_LIBERO_90(Exp_Qwen25_DinoSigLIP_224px_0_5B_LIBERO_90):
+    vla_id: str = "prism-qwen25-dinosiglip-224px-t2+0_5b+mx-libero-90"
+    image_sequence_len: int = 2
+
+
+@dataclass
+class Exp_Qwen25_DinoSigLIP_224px_wrist_0_5B_LIBERO_90(Exp_Qwen25_DinoSigLIP_224px_0_5B_LIBERO_90):
+    vla_id: str = "prism-qwen25-dinosiglip-224px-wrist+0_5b+mx-libero-90"
+    image_sequence_len: int = 2
+    use_wrist_image: bool = True
+
+
+## bridge Qwen
+
+
+@dataclass
+class Exp_Qwen25_DinoSigLIP_224px_0_5B_Bridge(Exp_SigLIP_224px_Bridge):
+    vla_id: str = "prism-qwen25-dinosiglip-224px+0_5b+mx-bridge"
+    base_vlm: Union[str, Path] = "prism-qwen25-extra-dinosiglip-224px+0_5b"
+
+    data_mix: str = "bridge_dataset"  # direct dataset
+    action_tokenizer: str = "extra_action_tokenizer"
+
+    expected_world_size: int = 8
+    global_batch_size: int = 256
+    per_device_batch_size: int = 32
+
+
+@dataclass
+class Exp_DinoSigLIP_224px_LIBERO_90(Exp_DinoSigLIP_224px_Bridge):
+    vla_id: str = "prism-dinosiglip-224px+mx-libero-90"
+
+    data_mix: str = "libero_90"
+
+    expected_world_size: int = 8
+    global_batch_size: int = 256
+    per_device_batch_size: int = 32
+
+
+# = [64 GPU] DINO-SigLIP 224px + OXE Magic Soup++ =
+@dataclass
+class Exp_DinoSigLIP_224px_OXE_Magic_Soup_Plus(Exp_SigLIP_224px_Bridge):
+    vla_id: str = "prism-dinosiglip-224px+mx-oxe-magic-soup-plus"
+    base_vlm: Union[str, Path] = "prism-dinosiglip-224px+7b"
+
+    # Note =>> We adopt two stages, training on a mixture including DROID for 70% of training, before resampling!
+    # data_mix: str = "oxe_magic_soup_plus"
+    data_mix: str = "oxe_magic_soup_plus_minus"
+
+    expected_world_size: int = 64
+    global_batch_size: int = 2048
+    per_device_batch_size: int = 32
+
+
+# === OpenVLA Fine-tuning Configurations ===
+
+
+# = [8 GPU] SigLIP 224px + T-DROID =
+@dataclass
+class Exp_SigLIP_224px_TDROID_CarrotInBowl(Exp_SigLIP_224px_Bridge):
+    vla_id: str = "siglip-224px+mx-tdroid_carrot_in_bowl"
+    base_vlm: Union[str, Path] = "siglip-224px+7b"
+
+    data_mix: str = "tdroid_carrot_in_bowl"
+
+
+@dataclass
+class Exp_SigLIP_224px_TDROID_PourCornInPot(Exp_SigLIP_224px_Bridge):
+    vla_id: str = "siglip-224px+mx-tdroid_pour_corn_in_pot"
+    base_vlm: Union[str, Path] = "siglip-224px+7b"
+
+    data_mix: str = "tdroid_pour_corn_in_pot"
+
+
+# = [8 GPU] SigLIP 224px + T-DROID -- Partial Finetuning =
+@dataclass
+class Exp_SigLIP_224px_Icy_TDROID_CarrotInBowl(Exp_SigLIP_224px_Bridge):
+    vla_id: str = "siglip-224px-icy+mx-tdroid_carrot_in_bowl"
+    base_vlm: Union[str, Path] = "siglip-224px+7b"
+    freeze_vision_backbone: bool = True
+    freeze_llm_backbone: bool = False
+
+    data_mix: str = "tdroid_carrot_in_bowl"
+
+
+@dataclass
+class Exp_SigLIP_224px_LastLayer_TDROID_CarrotInBowl(Exp_SigLIP_224px_Bridge):
+    vla_id: str = "siglip-224px-last_layer+mx-tdroid_carrot_in_bowl"
+    base_vlm: Union[str, Path] = "siglip-224px+7b"
+    freeze_vision_backbone: bool = True
+    freeze_llm_backbone: bool = True
+    unfreeze_last_llm_layer: bool = True
+
+    data_mix: str = "tdroid_carrot_in_bowl"
+
+
+@dataclass
+class Exp_SigLIP_224px_Sandwich_TDROID_CarrotInBowl(Exp_SigLIP_224px_Bridge):
+    vla_id: str = "siglip-224px-sandwich+mx-tdroid_carrot_in_bowl"
+    base_vlm: Union[str, Path] = "siglip-224px+7b"
+    freeze_vision_backbone: bool = False
+    freeze_llm_backbone: bool = True
+    unfreeze_last_llm_layer: bool = True
+
+    data_mix: str = "tdroid_carrot_in_bowl"
+
+
+# === [8 GPU] SigLIP 224px + FrankaWipe ===
+@dataclass
+class Exp_SigLIP_224px_Droid_Wipe(Exp_SigLIP_224px_Bridge):
+    vla_id: str = "siglip-224px+mx-droid_wipe"
+    base_vlm: Union[str, Path] = "siglip-224px+7b"
+
+    data_mix: str = "droid_wipe"
+
+
+# === Define a VLA Registry Enum for Reference & Validation ===
+@unique
+class VLARegistry(Enum):
+    # Sanity Check Configurations =>> BridgeV2
+    SIGLIP_224PX_MX_BRIDGE = Exp_SigLIP_224px_Bridge
+    DINOSIGLIP_224PX_MX_BRIDGE = Exp_DinoSigLIP_224px_Bridge
+    DINOSIGLIP_224PX_MX_LIBERO_90 = Exp_DinoSigLIP_224px_LIBERO_90
+
+    # SigLIP Frozen Backbone Experiment
+    FREEZE_SIGLIP_224PX_MX_BRIDGE = Exp_FreezeVIT_SigLIP_224px_Bridge
+
+    # [OpenVLA v0.1 7B] SigLIP 224px + OXE Magic Soup
+    SIGLIP_224PX_MX_OXE_MAGIC_SOUP = Exp_SigLIP_224px_OXE_Magic_Soup
+
+    # [OpenVLA 7B] DINO + SigLIP 224px + OXE Magic Soup++
+    DINOSIGLIP_224PX_MX_OXE_MAGIC_SOUP_PLUS = Exp_DinoSigLIP_224px_OXE_Magic_Soup_Plus
+
+    # [OpenVLA 0.5B] Qwen backbones
+    QWEN25_DINOSIGLIP_224PX_0_5B_MX_OXE_MAGIC_SOUP = Exp_Qwen25_DinoSigLIP_224px_0_5B_OXE_Magic_Soup
+    QWEN25_DINOSIGLIP_224PX_0_5B_LIBERO_90 = Exp_Qwen25_DinoSigLIP_224px_0_5B_LIBERO_90
+    QWEN25_DINOSIGLIP_224PX_T2_0_5B_LIBERO_90 = Exp_Qwen25_DinoSigLIP_224px_T2_0_5B_LIBERO_90
+    QWEN25_DINOSIGLIP_224PX_WRIST_0_5B_LIBERO_90 = Exp_Qwen25_DinoSigLIP_224px_wrist_0_5B_LIBERO_90
+
+    QWEN25_DINOSIGLIP_224PX_0_5B_BRIDGE = Exp_Qwen25_DinoSigLIP_224px_0_5B_Bridge
+
+    # === TDROID Fine-tuning Configs ===
+    SIGLIP_224PX_MX_TDROID_CARROT_IN_BOWL = Exp_SigLIP_224px_TDROID_CarrotInBowl
+    SIGLIP_224PX_MX_TDROID_POUR_CORN_IN_POT = Exp_SigLIP_224px_TDROID_PourCornInPot
+
+    SIGLIP_224PX_ICY_MX_TDROID_CARROT_IN_BOWL = Exp_SigLIP_224px_Icy_TDROID_CarrotInBowl
+    SIGLIP_224PX_LASTLAYER_MX_TDROID_CARROT_IN_BOWL = Exp_SigLIP_224px_LastLayer_TDROID_CarrotInBowl
+    SIGLIP_224PX_SANDWICH_MX_TDROID_CARROT_IN_BOWL = Exp_SigLIP_224px_Sandwich_TDROID_CarrotInBowl
+
+    # === DROID Fine-tuning Configs ===
+    SIGLIP_224PX_MX_DROID_WIPE = Exp_SigLIP_224px_Droid_Wipe
+
+    @property
+    def vla_id(self) -> str:
+        return self.value.vla_id
+
+
+# Register VLAs in Choice Registry
+for vla_variant in VLARegistry:
+    VLAConfig.register_subclass(vla_variant.vla_id, vla_variant.value)