get_llm_calib_data.py

"""
get_llm_calib_data.py

Script to extract LLM input embeddings from OpenVLA-OFT forward pass for use as calibration data in quantization.
This script captures the multimodal embeddings (vision + text + proprio) that are fed to the LLM.

The script randomly samples episodes from the dataset and captures ALL frames within each selected episode.

Run with:
    python vla-scripts/get_llm_calib_data.py \
        --vla_path <PATH/TO/CHECKPOINT> \
        --dataset_name libero_spatial_no_noops \
        --output_path ./calib_data/libero_spatial.bin \
        --num_episodes 10
"""

import json
import os
import random
import struct
from dataclasses import dataclass
from pathlib import Path
from typing import Dict, List

import draccus
import numpy as np
import torch
import tqdm
from transformers import AutoConfig, AutoImageProcessor, AutoModelForVision2Seq, AutoProcessor

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.backbones.llm.prompting import PurePromptBuilder
from prismatic.util.data_utils import PaddedCollatorForActionPrediction
from prismatic.vla.action_tokenizer import ActionTokenizer
from prismatic.vla.datasets import EpisodicRLDSDataset, RLDSBatchTransform

os.environ["TOKENIZERS_PARALLELISM"] = "false"

# Binary format constants
CALIB_MAGIC = b"OPENVLA_CALIB\0\0\0"  # 16 bytes
CALIB_VERSION = 2


@dataclass
class CalibrationConfig:
    # fmt: off
    vla_path: str = "openvla/openvla-7b"                   # HuggingFace Hub ID or local path
    data_root_dir: Path = Path("modified_libero_rlds_data") # Path to RLDS dataset directory
    dataset_name: str = "libero_spatial_no_noops"          # Name of dataset (task suite)
    output_path: Path = Path("calibration_data.bin")       # Output binary file path
    num_episodes: int = -1                                 # Number of episodes to sample (-1 = all)
    num_images_in_input: int = 2                           # Number of images (1 or 2)
    use_proprio: bool = True                               # Use proprioception
    batch_size: int = 1                                    # Batch size for processing
    seed: int = 42                                         # Random seed
    targets_only: bool = False                             # Only extract action targets (no model needed)
    # fmt: on


class EpisodeTaskTransform:
    """Minimal transform to extract task language per episode."""

    def __call__(self, rlds_batch: Dict) -> Dict[str, str]:
        lang = rlds_batch["task"]["language_instruction"].decode().lower()
        return {"language_instruction": lang}


def select_episode_indices_stratified(
    cfg: CalibrationConfig,
    image_sizes,
) -> set:
    """Select episode indices with equal per-task sampling."""
    # Build a lightweight episodic dataset to map episode index -> task description.
    # We keep the same dataset construction so episode indexing matches the main pass.
    index_dataset = EpisodicRLDSDataset(
        cfg.data_root_dir,
        cfg.dataset_name,
        EpisodeTaskTransform(),
        resize_resolution=image_sizes,
        shuffle_buffer_size=1,
        image_aug=False,
    )

    task_to_indices: Dict[str, List[int]] = {}
    num_total = len(index_dataset)
    for ep_idx, episode_frames in enumerate(tqdm.tqdm(index_dataset, total=num_total, desc="Indexing episodes by task")):
        if len(episode_frames) == 0:
            continue
        task = episode_frames[0]["language_instruction"]
        task_to_indices.setdefault(task, []).append(ep_idx)

    if cfg.num_episodes == -1 or cfg.num_episodes >= num_total:
        selected = set(range(num_total))
        print(f"[*] Collecting all episodes: {len(selected)}")
        return selected

    num_tasks = len(task_to_indices)
    if num_tasks == 0:
        raise ValueError("No tasks found while indexing episodes.")
    if cfg.num_episodes % num_tasks != 0:
        raise ValueError(
            f"num_episodes={cfg.num_episodes} must be divisible by number of tasks={num_tasks} "
            f"for balanced per-task sampling."
        )

    per_task = cfg.num_episodes // num_tasks
    selected = set()
    print(f"[*] Stratified sampling: {per_task} episode(s) per task across {num_tasks} tasks")

    for task in sorted(task_to_indices.keys()):
        indices = task_to_indices[task]
        if per_task > len(indices):
            raise ValueError(
                f"Requested {per_task} episodes for task '{task}', but only {len(indices)} available."
            )
        chosen = random.sample(indices, per_task)
        selected.update(chosen)
        print(f"    - {task}: selected {len(chosen)} / {len(indices)}")

    print(f"[*] Selected {len(selected)} episodes total (balanced)")
    return selected


def save_embeddings_to_binary(embeddings_list: List[np.ndarray], output_path: Path, config: dict) -> None:
    """Save embeddings to binary format for llama.cpp imatrix calibration."""
    num_samples = len(embeddings_list)
    if num_samples == 0:
        raise ValueError("No embeddings to save!")

    hidden_dim = embeddings_list[0].shape[1]
    print(f"\nSaving {num_samples} samples to {output_path}")
    print(f"  Hidden dim: {hidden_dim}")

    # Compute sequence lengths and offsets
    sequence_lengths = [emb.shape[0] for emb in embeddings_list]
    offsets = []
    current_offset = 0
    for emb in embeddings_list:
        offsets.append(current_offset)
        current_offset += emb.shape[0] * hidden_dim * 4  # float32

    seq_lens_array = np.array(sequence_lengths)
    print(f"  Seq lengths: min={seq_lens_array.min()}, max={seq_lens_array.max()}, mean={seq_lens_array.mean():.1f}")
    print(f"  Total size: {current_offset / (1024**2):.2f} MB")

    # Create output directory
    output_path.parent.mkdir(parents=True, exist_ok=True)

    # Write binary file
    with open(output_path, 'wb') as f:
        f.write(CALIB_MAGIC)
        f.write(struct.pack('<I', CALIB_VERSION))
        f.write(struct.pack('<I', num_samples))
        f.write(struct.pack('<I', hidden_dim))
        f.write(struct.pack('<IIII', 0, 0, 0, 0))  # reserved
        f.write(struct.pack('<I', 0))  # padding to 48 bytes

        for seq_len in sequence_lengths:
            f.write(struct.pack('<I', seq_len))
        for offset in offsets:
            f.write(struct.pack('<Q', offset))
        for emb in embeddings_list:
            f.write(emb.astype(np.float32).tobytes())

    # Write metadata JSON
    metadata = {
        "format": "openvla_oft_calibration",
        "version": CALIB_VERSION,
        "num_frames": num_samples,
        "hidden_dim": hidden_dim,
        "dataset": config['dataset_name'],
        "model": config['vla_path'],
        "num_episodes": config['num_episodes'],
        "sequence_length_stats": {
            "min": int(seq_lens_array.min()),
            "max": int(seq_lens_array.max()),
            "mean": float(seq_lens_array.mean()),
        },
    }
    with open(output_path.with_suffix('.json'), 'w') as f:
        json.dump(metadata, f, indent=2)

    print(f"Saved to {output_path}")


@draccus.wrap()
def collect_calibration_data(cfg: CalibrationConfig) -> None:
    print(f"Collecting calibration data from `{cfg.vla_path}` using `{cfg.dataset_name}`")
    if cfg.targets_only:
        print("[*] targets_only mode: skipping model loading, only extracting action labels")

    random.seed(cfg.seed)

    # Register model classes
    AutoConfig.register("openvla", OpenVLAConfig)
    AutoImageProcessor.register(OpenVLAConfig, PrismaticImageProcessor)
    AutoProcessor.register(OpenVLAConfig, PrismaticProcessor)
    AutoModelForVision2Seq.register(OpenVLAConfig, OpenVLAForActionPrediction)

    # Load processor (always needed for tokenizer/dataset)
    print("[*] Loading processor...")
    processor = AutoProcessor.from_pretrained(cfg.vla_path, trust_remote_code=True)

    # Load model only if we need embeddings
    vla = None
    image_sizes = None
    if not cfg.targets_only:
        device_id = 0
        torch.cuda.set_device(device_id)
        print("[*] Loading model...")
        vla = AutoModelForVision2Seq.from_pretrained(
            cfg.vla_path,
            torch_dtype=torch.bfloat16,
            low_cpu_mem_usage=True,
            trust_remote_code=True,
        ).to(device_id)
        vla.vision_backbone.set_num_images_in_input(cfg.num_images_in_input)
        vla.eval()

        # Monkey-patch forward method to use our local version with calibration_mode support
        from prismatic.extern.hf.modeling_prismatic import PrismaticForConditionalGeneration
        vla.forward = PrismaticForConditionalGeneration.forward.__get__(vla, type(vla))

        print(f"  Hidden dim: {vla.llm_dim}")
        print(f"  Num patches: {vla.vision_backbone.get_num_patches()}")
        image_sizes = tuple(vla.config.image_sizes)
    else:
        # Load config to get image_sizes without loading the full model
        model_config = AutoConfig.from_pretrained(cfg.vla_path, trust_remote_code=True)
        image_sizes = tuple(model_config.image_sizes)

    # Create dataset
    print(f"[*] Loading dataset: {cfg.dataset_name}")
    action_tokenizer = ActionTokenizer(processor.tokenizer)
    batch_transform = RLDSBatchTransform(
        action_tokenizer,
        processor.tokenizer,
        image_transform=processor.image_processor.apply_transform,
        prompt_builder_fn=PurePromptBuilder,
        use_wrist_image=(cfg.num_images_in_input > 1),
        use_proprio=cfg.use_proprio,
    )

    dataset = EpisodicRLDSDataset(
        cfg.data_root_dir,
        cfg.dataset_name,
        batch_transform,
        resize_resolution=image_sizes,
        shuffle_buffer_size=1,
        image_aug=False,
    )
    print(f"  Total episodes: {len(dataset)}")

    collator = PaddedCollatorForActionPrediction(
        processor.tokenizer.model_max_length,
        processor.tokenizer.pad_token_id,
        padding_side="right"
    )

    # Stratified episode sampling: equal number from each task description.
    selected = select_episode_indices_stratified(cfg, image_sizes)
    num_total = len(dataset)
    print(f"[*] Collecting {len(selected)} episodes (all frames per episode)")

    # Collect embeddings, token-ID labels, and continuous OFT actions
    embeddings_list: List[np.ndarray] = []
    labels_list: List[np.ndarray] = []
    oft_actions_list: List[np.ndarray] = []  # continuous (8, 7) actions for AMF
    episodes_done = 0
    IGNORE_INDEX = -100

    with torch.no_grad():
        for ep_idx, episode_frames in enumerate(tqdm.tqdm(dataset, total=num_total)):
            if ep_idx not in selected:
                continue

            # Process ALL frames in this episode
            for i in range(0, len(episode_frames), cfg.batch_size):
                batch_frames = episode_frames[i:i + cfg.batch_size]
                batch = collator(batch_frames)

                if not cfg.targets_only:
                    # Forward pass with calibration_mode=True to get multimodal embeddings
                    with torch.autocast("cuda", dtype=torch.bfloat16):
                        output = vla(
                            input_ids=batch["input_ids"].to(device_id),
                            attention_mask=batch["attention_mask"].to(device_id),
                            pixel_values=batch["pixel_values"].to(torch.bfloat16).to(device_id),
                            labels=batch["labels"].to(device_id),
                            calibration_mode=True,
                        )

                    # Extract multimodal embeddings
                    mm_embeds = output["multimodal_embeddings"]  # [B, seq_len, hidden_dim]
                    for j in range(mm_embeds.shape[0]):
                        embeddings_list.append(mm_embeds[j].float().cpu().numpy())

                # Extract action token ID labels (for NLL Fisher)
                frame_labels = batch["labels"]  # [B, seq_len]
                for j in range(frame_labels.shape[0]):
                    lbl = frame_labels[j].cpu().numpy()
                    labels_list.append(lbl[lbl != IGNORE_INDEX])

                # Extract continuous OFT actions (for Action-Mahalanobis Fisher / AMF)
                # shape: (B, 8, 7) — normalized actions in approximately [-1, 1]
                if "actions" in batch:
                    actions = batch["actions"].float().numpy()  # (B, 8, 7)
                    for j in range(actions.shape[0]):
                        oft_actions_list.append(actions[j])  # (8, 7)

            episodes_done += 1
            if episodes_done >= len(selected):
                break

    print(f"\n[*] Collected {len(labels_list)} frames from {episodes_done} episodes")

    # Save embeddings (skip in targets_only mode)
    if not cfg.targets_only:
        if embeddings_list:
            print(f"  Sample shape: {embeddings_list[0].shape}")
        config_dict = {
            "dataset_name": cfg.dataset_name,
            "vla_path": cfg.vla_path,
            "num_episodes": episodes_done,
        }
        save_embeddings_to_binary(embeddings_list, cfg.output_path, config_dict)

    # Save action token ID targets (for NLL Fisher / imatrix)
    targets_array = np.stack(labels_list, axis=0)
    targets_path = cfg.output_path.with_name(cfg.output_path.stem + "_targets.npy")
    np.save(targets_path, targets_array)
    print(f"Saved token-ID targets: shape={targets_array.shape} to {targets_path}")

    # Save continuous OFT action targets (for AMF — Action-Mahalanobis Fisher)
    if oft_actions_list:
        oft_targets_array = np.stack(oft_actions_list, axis=0)  # (N, 8, 7)
        oft_targets_path = cfg.output_path.with_name(cfg.output_path.stem + "_oft_targets.npy")
        np.save(oft_targets_path, oft_targets_array)
        print(f"Saved OFT action targets: shape={oft_targets_array.shape} to {oft_targets_path}")

    print("\nDone!")


if __name__ == "__main__":
    collect_calibration_data()