ROBOMETER

ROBOMETER é um modelo de recompensa robótica de vídeo-linguagem de uso geral. Ele prevê o progresso da tarefa em nível de quadro e o sucesso em nível de quadro a partir de um vídeo de trajetória e uma descrição da tarefa.

Artigo: ROBOMETER: Scaling General-Purpose Robotic Reward Models via Trajectory Comparisons Projeto: robometer.github.io Código original: github.com/robometer/robometer Checkpoint: lerobot/Robometer-4B

Visão geral

O ROBOMETER é construído sobre o Qwen/Qwen3-VL-4B-Instruct e adiciona três cabeças de previsão leves:

• Cabeçalho de progresso: prevê o progresso da tarefa por quadro em [0, 1].
• Cabeça de sucesso: prevê a probabilidade de sucesso da tarefa por quadro.
• Cabeça de preferência: prevê qual das duas trajetórias completa melhor a tarefa durante o treinamento.

O artigo treina o ROBOMETER com um objetivo composto:

L = L_pref + L_prog + L_succ

A integração do LeRobot é atualmente apenas para inferência. Ela preserva a cabeça de preferência para que o checkpoint publicado Robometer-4B seja carregado sem remapeamento, mas compute_reward() consulta apenas a cabeça de progresso ou sucesso.

O que a Integração do LeRobot Abrange

• Configuração padrão reward_model.type=robometer por meio do LeRobot.
• Pré-processamento de imagem e texto do Qwen3-VL por meio de RobometerEncoderProcessorStep.
• APIs de salvar/carregar modelos de recompensa do LeRobot por meio de PreTrainedRewardModel.
• Previsões internas de progresso e sucesso em nível de quadro, densas.
• Uma recompensa escalar por meio de compute_reward() para uso em modelos de recompensa do LeRobot.

Esta página foca no uso do checkpoint publicado do ROBOMETER como um modelo de recompensa zero-shot. O treinamento do ROBOMETER do zero está fora da integração atual do LeRobot.

Requisitos de instalação

1. Instale o LeRobot seguindo o Guia de Instalação.
2. Instale as dependências do ROBOMETER:

pip install -e ".[robometer]"

Se você usa uv diretamente de um checkout de fonte:

uv sync --extra robometer

O ROBOMETER usa um backbone Qwen3-VL-4B, portanto, a inferência em GPU é fortemente recomendada.

Entradas e Saídas do Modelo

O ROBOMETER espera:

• Um vídeo de trajetória ou uma sequência de quadros.
• Uma descrição da tarefa em linguagem natural.

Nos conjuntos de dados do LeRobot, o pré-processador lê:

O modelo prevê internamente o progresso e o sucesso por quadro. A API de recompensa do LeRobot retorna um escalar por amostra:

• reward_output="progress" (padrão): retorna o progresso do último quadro, limitado a [0, 1].
• reward_output="success": retorna 1.0 se a probabilidade de sucesso do último quadro for maior que success_threshold, caso contrário, 0.0.

Uso

Carregue o Modelo de Recompensa Diretamente

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 Quadros e Calcular uma Recompensa

Para uma chamada direta em Python, forneça os quadros como arrays uint8 com a forma (T, H, W, C) e uma string de tarefa:

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 é um tensor de forma (batch_size,).

Use a Reward Factory

Você também pode instanciar o ROBOMETER por meio da 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)

O pré-processador grava os tensores do Qwen-VL no namespace observation.robometer.*, e compute_reward() lê esses tensores codificados.

Notas de configuração

Backbone e Vocabulário

O checkpoint publicado usa um backbone Qwen3-VL-4B. O ROBOMETER adiciona cinco tokens especiais ao tokenizer em uma ordem fixa:

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

<|prog_token|> é inserido após cada quadro e é a posição do estado oculto usada para a previsão de progresso e sucesso por quadro. <|split_token|> e <|pref_token|> são usados pelo objetivo de preferência de trajetória em pares do artigo. <|reward_token|> e <|sim_token|> são mantidos para compatibilidade de checkpoint.

A configuração do LeRobot armazena um vlm_config serializado com o vocabulário pós-redimensionamento para que o modelo possa ser recarregado a partir do config.json sem precisar baixar primeiro os pesos base do Qwen. Para o Qwen/Qwen3-VL-4B-Instruct, o comprimento do tokenizer é 151669, e os cinco tokens ROBOMETER resultam no tamanho do vocabulário do checkpoint 151674.

Previsão de Progresso

No checkpoint publicado, o progresso é discreto. A cabeça de progresso produz logits sobre progress_discrete_bins=10 centros de bin uniformemente espaçados em [0, 1]. O LeRobot converte essas logits em um valor contínuo aplicando um softmax e calculando a expectativa sobre os centros de bin, em conformidade com a implementação upstream do ROBOMETER.

Previsão de Sucesso

A cabeça de sucesso produz logits brutos por quadro. O LeRobot os converte em probabilidades com sigmoid. Quando reward_output="success", compute_reward() aplica um limiar à probabilidade de sucesso do último quadro usando success_threshold.

Limitações

• A integração atual do LeRobot é apenas para inferência; ela não implementa o treinamento do ROBOMETER nem o treinamento de pares de preferências.
• compute_reward() retorna um escalar por amostra para a API do modelo de recompensa do LeRobot, mesmo que o ROBOMETER preveja internamente o progresso e o sucesso por quadro.
• ROBOMETER é baseado em vídeo e linguagem; ele não utiliza estados privilegiados do robô, como forças de contato ou poses de objetos.

Referências

• projeto ROBOMETER
• artigo ROBOMETER
• Código original do ROBOMETER
• Checkpoint ROBOMETER-4B publicado
• Qwen3-VL-4B-Instruct

Citação

@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},
}

Licença

Esta integração do LeRobot segue a Apache 2.0 License utilizada pelo LeRobot. Consulte o código ROBOMETER e as páginas de modelos originais para verificar as licenças da implementação original e dos checkpoints liberados.