ROBOMETER

ROBOMETER es un modelo de recompensa robótica de video-lenguaje de uso general. Predice el progreso de la tarea a nivel de fotogramas y el éxito a nivel de fotogramas a partir de un video de trayectoria y una descripción de la tarea.

Artículo: ROBOMETER: Scaling General-Purpose Robotic Reward Models via Trajectory Comparisons Proyecto: robometer.github.io Código original: github.com/robometer/robometer Punto de control: lerobot/Robometer-4B

Resumen

ROBOMETER se basa en Qwen/Qwen3-VL-4B-Instruct y añade tres cabezas de predicción ligeras:

• Cabeza de progreso: predice el progreso de la tarea por fotograma en [0, 1].
• Cabeza de éxito: predice la probabilidad de éxito de la tarea por fotograma.
• Cabeza de preferencia: predice cuál de dos trayectorias completa mejor la tarea durante el entrenamiento.

El artículo entrena ROBOMETER con un objetivo compuesto:

L = L_pref + L_prog + L_succ

La integración de LeRobot es actualmente solo de inferencia. Conserva la cabeza de preferencia para que el punto de control publicado Robometer-4B se cargue sin remapeo, pero compute_reward() solo consulta la cabeza de progreso o éxito.

Lo que abarca la integración de LeRobot

• Configuración estándar reward_model.type=robometer a través de LeRobot.
• Preprocesamiento de imágenes y texto de Qwen3-VL a través de RobometerEncoderProcessorStep.
• APIs de guardado/carga de modelos de recompensa de LeRobot a través de PreTrainedRewardModel.
• Predicciones internas de progreso y éxito a nivel de fotograma, densas.
• Una recompensa escalar a través de compute_reward() para el uso de modelos de recompensa de LeRobot en etapas posteriores.

Esta página se centra en el uso del punto de control publicado de ROBOMETER como modelo de recompensa en modo zero-shot. Entrenar ROBOMETER desde cero está fuera de la integración actual de LeRobot.

Requisitos de instalación

1. Instala LeRobot siguiendo la Guía de instalación.
2. Instale las dependencias de ROBOMETER:

pip install -e ".[robometer]"

Si usas uv directamente desde un checkout de código fuente:

uv sync --extra robometer

ROBOMETER utiliza un backbone de Qwen3-VL-4B, por lo que se recomienda encarecidamente la inferencia en GPU.

Entradas y salidas del modelo

ROBOMETER espera:

• Un video de trayectoria o una secuencia de fotogramas.
• Una descripción de la tarea en lenguaje natural.

En los conjuntos de datos de LeRobot, el preprocesador lee:

El modelo predice internamente el progreso y el éxito por fotograma. La API de recompensa de LeRobot devuelve un escalar por muestra:

• reward_output="progress" (predeterminado): devuelve el progreso del último fotograma, limitado a [0, 1].
• reward_output="success": devuelve 1.0 si la probabilidad de éxito del último fotograma supera success_threshold, en caso contrario 0.0.

Uso

Cargar el modelo de recompensa directamente

from lerobot.rewards.robometer import RobometerConfig, RobometerRewardModel

cfg = RobometerConfig(
    pretrained_path="lerobot/Robometer-4B",
    device="cuda",
    reward_output="progress",
)
reward_model = RobometerRewardModel.from_pretrained(cfg.pretrained_path, config=cfg)

Codificar fotogramas y calcular una recompensa

Para una llamada directa en Python, proporcione los fotogramas como matrices uint8 con forma (T, H, W, C) y una cadena de tarea:

from lerobot.rewards.robometer.modeling_robometer import ROBOMETER_FEATURE_PREFIX
from lerobot.rewards.robometer.processor_robometer import RobometerEncoderProcessorStep

# frames: np.ndarray, shape (T, H, W, C), dtype uint8
# task: str
encoder = RobometerEncoderProcessorStep(
    base_model_id=cfg.base_model_id,
    use_multi_image=cfg.use_multi_image,
    use_per_frame_progress_token=cfg.use_per_frame_progress_token,
    max_frames=cfg.max_frames,
)

encoded = encoder.encode_samples([(frames, task)])
batch = {f"{ROBOMETER_FEATURE_PREFIX}{key}": value for key, value in encoded.items()}

reward = reward_model.compute_reward(batch)

reward es un tensor de forma (batch_size,).

Usar la Reward Factory

También puedes instanciar ROBOMETER a través de la fábrica de recompensas:

from lerobot.rewards import make_reward_model, make_reward_model_config, make_reward_pre_post_processors

cfg = make_reward_model_config(
    "robometer",
    pretrained_path="lerobot/Robometer-4B",
    device="cuda",
    image_key="observation.images.top",
)
reward_model = make_reward_model(cfg)
preprocessor, postprocessor = make_reward_pre_post_processors(cfg)

El preprocesador escribe los tensores de Qwen-VL bajo el espacio de nombres observation.robometer.*, y compute_reward() lee esos tensores codificados.

Notas de configuración

Backbone y Vocabulario

El checkpoint publicado utiliza un backbone de Qwen3-VL-4B. ROBOMETER añade cinco tokens especiales al tokenizer en un orden fijo:

<|split_token|>
<|reward_token|>
<|pref_token|>
<|sim_token|>
<|prog_token|>

<|prog_token|> se inserta después de cada fotograma y es la posición del estado oculto utilizada para la predicción de progreso y éxito por fotograma. <|split_token|> y <|pref_token|> se utilizan en el objetivo de preferencia de trayectorias por pares del artículo. <|reward_token|> y <|sim_token|> se conservan por compatibilidad con los puntos de control.

La configuración de LeRobot almacena un vlm_config serializado con el vocabulario posterior al redimensionado, de modo que el modelo pueda recargar desde config.json sin necesidad de descargar primero los pesos base de Qwen. Para Qwen/Qwen3-VL-4B-Instruct, la longitud del tokenizador es 151669, y los cinco tokens de ROBOMETER producen el tamaño de vocabulario del checkpoint 151674.

Predicción de progreso

En el punto de control publicado, el progreso es discreto. La cabeza de progreso emite logits sobre progress_discrete_bins=10 centros de intervalos uniformemente espaciados en [0, 1]. LeRobot convierte estos logits en un valor continuo aplicando un softmax y tomando la esperanza sobre los centros de los intervalos, lo que coincide con la implementación de ROBOMETER de origen.

Predicción de éxito

La cabeza de éxito genera logits crudos por fotograma. LeRobot los convierte en probabilidades con sigmoid. Cuando reward_output="success", compute_reward() aplica un umbral a la probabilidad de éxito del último fotograma usando success_threshold.

Limitaciones

• La integración actual de LeRobot es solo para inferencia; no implementa el entrenamiento de ROBOMETER ni el entrenamiento de pares de preferencia.
• compute_reward() devuelve un escalar por muestra para la API de modelos de recompensa de LeRobot, aunque ROBOMETER predice internamente el progreso y el éxito por fotograma.
• ROBOMETER se basa en video y lenguaje; no utiliza el estado privilegiado del robot, como las fuerzas de contacto o las poses de los objetos.

Referencias

• proyecto ROBOMETER
• paper de ROBOMETER
• Código original de ROBOMETER
• Punto de control ROBOMETER-4B publicado
• Qwen3-VL-4B-Instruct

Cita

@inproceedings{liang2026robometer,
title = {Robometer: Scaling General-Purpose Robotic Reward Models via Trajectory Comparisons},
author={Anthony Liang and Yigit Korkmaz and Jiahui Zhang and Minyoung Hwang and Abrar Anwar and Sidhant Kaushik and Aditya Shah and Alex S. Huang and Luke Zettlemoyer and Dieter Fox and Yu Xiang and Anqi Li and Andreea Bobu and Abhishek Gupta and Stephen Tu and Erdem Biyik and Jesse Zhang},
year={2026},
booktitle={Robotics: Science and Systems 2026},
}

Licencia

Esta integración de LeRobot sigue la Apache 2.0 License utilizada por LeRobot. Consulte el código y las páginas de modelos de ROBOMETER de origen para conocer las licencias de la implementación original y de los puntos de control publicados.