Política MolmoAct2

MolmoAct2 é a implementação da política do LeRobot de MolmoAct2, adaptada para as interfaces de treinamento, avaliação, checkpointing e conjuntos de dados do LeRobot, facilitando o uso com conjuntos de dados do LeRobot.

Esta implementação atualmente suporta o treinamento e a avaliação para o modelo regular MolmoAct2. O MolmoAct2-Think, que suporta raciocínio de profundidade adaptativa, ainda não está incluído nesta política do LeRobot.

Para o código de treinamento original do MolmoAct2 usado nos experimentos relatados no artigo, consulte allenai/molmoact2.

Requisitos de instalação

Instale o LeRobot com as dependências opcionais do MolmoAct2:

uv sync --locked --extra molmoact2

Para executar os modelos neste repositório, é necessário uma GPU NVIDIA. O caminho atual de precisão mista armazena o especialista de ação completo em fp32 e as grandes matrizes do VLM em bf16. policy.compile_model=true compila opcionalmente os blocos do especialista de ação, mantendo o VLM, a torre de visão, o conector e o wrapper de política em modo eager. Essa fronteira passou nos testes de paridade de saída com início idêntico, gradiente e atualização do otimizador; compilar o caminho do VLM em bf16 não passou.

O treinamento multi-GPU por meio do accelerate aumenta o throughput e o tamanho do lote global. Este caminho foi testado em execuções de dois nós com oito GPUs GB200, mas este port do LeRobot não expõe o caminho de treinamento paralelo de modelo fsdp_devices original do MolmoAct2. Uma reprodução em uma GPU GB200 com duas larguras reais de prompt gerou um único grafo de ação compilado, sem quebras de grafo, a mesma memória de pico de 55,15 GiB da execução eager e uma aceleração modesta no estado estacionário. Considere esses resultados como verificações de implementação, e não como afirmações portáveis de throughput ou ETA.

O repositório foi testado com Ubuntu 22.04.

Uso

Para usar o MolmoAct2 em uma configuração de treinamento do LeRobot, defina:

--policy.type=molmoact2

Treinamento

O MolmoAct2 pode ser ajustado a partir do formato de checkpoint do MolmoAct2 publicado no Hugging Face ou de um checkpoint já salvo pelo LeRobot. Ambos os caminhos usam o mesmo loop de treinamento do LeRobot, transformações de dataset, salvamento de checkpoints e registro de logs. A única diferença é como os pesos iniciais da política e o estado do processador são carregados.

LeRobot desativa o aumento de imagens do dataset por padrão. Mantenha --dataset.image_transforms.enable=true nos comandos de treinamento do MolmoAct2. A receita de transformações original do MolmoAct2 não é o padrão genérico de transformações do LeRobot, portanto o primeiro comando também fixa explicitamente o recorte de 95%, a rotação de 5 graus e o jitter de cor. A receita original aplica adicionalmente um desfoque gaussiano com probabilidade 0,2; a configuração genérica de subconjunto de transformações do LeRobot não consegue expressar essa quarta transformação opcional sem às vezes descartar uma das três transformações obrigatórias.

Treinamento com o Peso Original do MolmoAct2

Use policy.checkpoint_path ao iniciar a partir de um checkpoint liberado do MolmoAct2, por exemplo allenai/MolmoAct2 ou allenai/MolmoAct2-LIBERO. O LeRobot carregará os arquivos de modelo originais do HF e, em seguida, construirá seu próprio policy processor a partir dos metadados do dataset e das opções de policy abaixo.

O comando abaixo mostra o fine-tuning completo no conjunto de dados LIBERO mesclado a partir do checkpoint base liberado. Ele usa carregamento do modelo em bf16, 8 timesteps de fluxo, as estatísticas de quantis oficiais do LIBERO, aumento de imagem e o caminho de checkpointing/registro do LeRobot. Não substitua os quantis de metadados aproximados do lerobot/libero pelos norm_stats.json liberados; seus valores de q01/q99 não são idênticos.

accelerate launch \
  --num_processes=8 \
  --mixed_precision=bf16 \
  -m lerobot.scripts.lerobot_train \
  --dataset.repo_id=lerobot/libero \
  --dataset.root=/path/to/lerobot/libero \
  --dataset.video_backend=pyav \
  --dataset.image_transforms.enable=true \
  --dataset.image_transforms.max_num_transforms=3 \
  --dataset.image_transforms.random_order=false \
  --dataset.image_transforms.tfs='{"crop":{"weight":1.0,"type":"RandomResizedCrop","kwargs":{"size":[256,256],"scale":[0.9025,0.9025],"ratio":[1.0,1.0]}},"rotation":{"weight":1.0,"type":"RandomRotation","kwargs":{"degrees":[-5.0,5.0],"interpolation":2}},"color":{"weight":1.0,"type":"ColorJitter","kwargs":{"brightness":0.2,"contrast":[0.8,1.2],"saturation":[0.8,1.2],"hue":0.05}}}' \
  --policy.type=molmoact2 \
  --policy.checkpoint_path=allenai/MolmoAct2 \
  --policy.device=cuda \
  --policy.action_mode=continuous \
  --policy.norm_tag=libero \
  --policy.norm_stats_path=/path/to/MolmoAct2-LIBERO/norm_stats.json \
  --policy.train_mode_vlm=fft \
  --policy.chunk_size=10 \
  --policy.n_action_steps=10 \
  --policy.setup_type="single franka robotic arm in libero" \
  --policy.control_mode="delta end-effector pose" \
  --policy.image_keys='["observation.images.image","observation.images.image2"]' \
  --policy.dtype=bfloat16 \
  --policy.num_flow_timesteps=8 \
  --policy.gradient_checkpointing=true \
  --policy.compile_model=true \
  --policy.freeze_embedding=true \
  --policy.normalize_gripper=false \
  --policy.enable_knowledge_insulation=false \
  --policy.push_to_hub=false \
  --trackio.enable=true \
  --trackio.project=<trackio_project> \
  --job_name=<job_name> \
  --output_dir=outputs/<job_name> \
  --steps=10000 \
  --batch_size=32 \
  --num_workers=4 \
  --log_freq=20 \
  --env_eval_freq=-1 \
  --save_checkpoint=true \
  --save_freq=2000

Treinamento com o peso LeRobot MolmoAct2

Use policy.path ao iniciar a partir de um checkpoint do MolmoAct2 que foi salvo pelo LeRobot, seja de um diretório local pretrained_model ou do Hub. Isso restaura a configuração de política do LeRobot salva, os pesos do modelo, o processador e as estatísticas de normalização. Você ainda pode sobrescrever opções de tempo de treinamento, como batch_size, steps ou policy.action_mode. O carregamento de checkpoints é estrito e preserva a topologia FFT ou LoRA salva, portanto, não sobrescreva policy.train_mode_vlm ao usar policy.path. Para iniciar uma nova execução LoRA, inicialize a partir dos pesos do HF com policy.checkpoint_path em vez disso, por exemplo, com --policy.type=molmoact2, --policy.checkpoint_path=allenai/MolmoAct2 e --policy.train_mode_vlm=lora.

accelerate launch \
  --num_processes=8 \
  --mixed_precision=bf16 \
  -m lerobot.scripts.lerobot_train \
  --dataset.repo_id=allenai/MolmoAct2-LIBERO-Dataset \
  --dataset.root=/path/to/lerobot/data/allenai/MolmoAct2-LIBERO-Dataset \
  --dataset.video_backend=pyav \
  --dataset.image_transforms.enable=true \
  --policy.path=/path/to/pretrained_model \
  --policy.device=cuda \
  --policy.action_mode=continuous \
  --policy.chunk_size=10 \
  --policy.n_action_steps=10 \
  --policy.dtype=bfloat16 \
  --policy.num_flow_timesteps=8 \
  --policy.gradient_checkpointing=true \
  --policy.compile_model=true \
  --trackio.enable=true \
  --trackio.project=<trackio_project> \
  --job_name=<job_name> \
  --output_dir=outputs/<job_name> \
  --steps=10000 \
  --batch_size=32 \
  --num_workers=4 \
  --log_freq=20 \
  --env_eval_freq=-1 \
  --save_checkpoint=true \
  --save_freq=2000

Práticas Comuns

Para o ajuste fino em um conjunto de dados comparativamente pequeno, como uma única suíte LIBERO ou um conjunto de dados do mundo real com menos de 200 demonstrações, um tamanho de lote global de 16 a 32 é um bom ponto de partida. Nesses cenários, recomendamos o uso de policy.train_mode_vlm=lora (o padrão), que geralmente oferece desempenho semelhante ou até melhor do que fft. Além disso, policy.train_mode_vlm=freeze também é uma escolha prática. Em todos os modos, mantemos intencionalmente o especialista de ação totalmente treinável, o que consideramos crucial para o desempenho do modelo. Para conjuntos de dados maiores de ajuste fino, tamanhos de lote global maiores e ajuste fino completo do VLM (policy.train_mode_vlm=fft) são geralmente preferidos.

Opções de Política Comuns

• policy.checkpoint_path: checkpoint original do MolmoAct2 HF para inicialização. Use isso para os pesos do MolmoAct2 liberados.
• policy.path: checkpoint do LeRobot para inicialização. Use isso para checkpoints criados pelo treinamento do LeRobot.
• policy.action_mode: alvo de treinamento, um de continuous, discrete ou both. O ajuste fino oficial do robô MolmoAct2 usa continuous. Os checkpoints liberados mantêm pesos de ação discreta; both está disponível como uma ablação explícita de fluxo combinado mais token de ação.
• policy.train_mode_vlm: controla o modo de fine-tuning do VLM, sendo um de fft, lora ou freeze. fft realiza o fine-tuning completo do VLM, lora treina adaptadores LoRA nas camadas lineares do VLM e freeze congela o VLM. O especialista de ação é totalmente ajustado nos três modos. O padrão é lora. freeze requer policy.action_mode=continuous.
• policy.enable_knowledge_insulation: quando true, desanexa os estados de contexto K/V do especialista de ação antes da perda de ação. O padrão é false.
• policy.chunk_size: horizonte de ação usado pela política. Para o LIBERO, usamos 10. Esta portação do LeRobot substitui o max_action_horizon do checkpoint carregado por este valor.
• policy.n_action_steps: número de ações consumidas de cada bloco previsto antes de consultar a política novamente. Para LIBERO, defina-o como chunk_size.
• policy.setup_type: texto inserido no prompt para descrever o robô e a cena, por exemplo, single franka robotic arm in libero. Mais exemplos estão listados nas entradas de metadata_by_tag em norm_stats.json.
• policy.control_mode: texto inserido no prompt para descrever o espaço de ações, por exemplo, delta end-effector pose ou absolute joint pose.
• policy.image_keys: chaves de observação de imagem do LeRobot, em ordem, passadas ao processador.
• policy.dtype: alternância de precisão no estilo Pi0.5. bfloat16 usa autocast/armazenamento bf16 para as grandes matrizes do VLM, mantendo o especialista de ações completo e os módulos numericamente sensíveis em fp32. float32 desativa o autocast e mantém o modelo completo em fp32. O perfil de baixa memória bfloat16 difere intencionalmente da execução original MolmoAct2 AMP com mestre FP32: os momentos do AdamW seguem o dtype de armazenamento de cada parâmetro, de modo que os grandes parâmetros bf16 do VLM também possuem momentos bf16. O fine-tuning completo aloca preguiçosamente um tensor de compensação bf16 para cada parâmetro bf16 que carrega gradiente, para que atualizações menores que um ULP do parâmetro sejam levadas para etapas posteriores. Isso não é uma cópia mestre em fp32. Os adaptadores LoRA, o especialista de ações e os módulos explicitamente sensíveis mantêm parâmetros e estado do otimizador em fp32; parâmetros congelados do VLM no modo LoRA não alocam tensor de compensação.
• policy.compile_model: habilita o caminho de torch.compile por bloco do MolmoAct2. O fine-tuning completo e o LoRA compilam apenas os blocos do transformer do especialista de ação. A execução eager do VLM/ViT/conector evita a deriva de ativação e gradiente em BF16 induzida pelo compilador, mantendo a aceleração para o caminho de ação avaliado em cada timestep de fluxo. O Inductor também é instruído a preservar as fronteiras de downcast/upcast eager em BF16 entre operações fundidas. Esta é uma fronteira fixa e segura em termos de precisão e não adiciona outra opção de compilação. A compilação é desabilitada por padrão; habilite-a para longas execuções de treinamento em GPU. Os blocos de ação usam a estratégia de forma automática do PyTorch. Com checkpointing de gradiente, apenas a dimensão de sequência do contexto do codificador variável é marcada como dinâmica; o tamanho do lote, o horizonte de ação e a contagem de timesteps de fluxo permanecem estáticos. A reordenação do cache de grafo do Dynamo e seu splitter de grafo DDP extra são desabilitados nesse modo, para que a recomputação do backward selecione o mesmo grafo de bloco que o forward. As sequências de texto/ação locais ao lote são preenchidas à esquerda (left-padded) até um múltiplo interno de 8 antes da inserção do BOS. Isso adiciona no máximo sete tokens mascarados, reduzindo drasticamente o aquecimento de compilação específico de forma; não é uma opção voltada ao usuário.
• policy.num_flow_timesteps: número de timesteps de flow-matching amostrados por exemplo durante o treinamento. Usamos 8 para fine-tuning.
• policy.num_inference_steps: substituição opcional para as etapas de geração de ação contínua no momento da inferência.
• policy.gradient_checkpointing: habilita o checkpointing no caminho VLM/ação para reduzir a memória de ativação.
• policy.freeze_embedding: congela os embeddings de entrada. O padrão é true.
• policy.normalize_gripper: controla se as dimensões do garra são incluídas na normalização de quantis do estado/ação. O padrão é false.
• policy.normalize_language: normaliza as strings de tarefa antes da construção do prompt. O padrão é true.
• policy.mask_action_dim_padding: mascara as dimensões preenchidas na perda de fluxo. Os checkpoints liberados usam policy.expected_max_action_dim=32.
• policy.max_sequence_length: limite manual opcional de sequência. Deixe não definido para inferi-lo a partir das imagens, dimensão do estado, dimensão da ação, horizonte de ação e modo de ação discreta.

Taxas de Aprendizado

O MolmoAct2 usa taxas de aprendizado por grupo de parâmetros para corresponder aos experimentos originais de fine-tuning do MolmoAct2.

• O fine-tuning completo usa policy.optimizer_lr=1e-5 para o VLM, policy.optimizer_vit_lr=5e-6 para a torre de visão, policy.optimizer_connector_lr=5e-6 para as camadas do conector de imagem e policy.optimizer_action_expert_lr=5e-5 para o especialista de ação.
• O fine-tuning de VLM com LoRA define os grupos de parâmetros LoRA do VLM, da visão e do conector para 5e-5 quando policy.train_mode_vlm=lora; o especialista de ação ainda é totalmente ajustado com policy.optimizer_action_expert_lr.
• O fine-tuning do Frozen-VLM usa policy.train_mode_vlm=freeze, treina apenas o action expert e usa policy.optimizer_action_expert_lr=5e-5.
• policy.optimizer_grad_clip_norm é aplicado independentemente aos grupos de parâmetros do LLM, da torre de visão, do conector de imagem e do especialista de ação, correspondendo ao otimizador original do MolmoAct2. Não se trata de uma única norma de gradiente do modelo global.

Você pode sobrescrever as taxas de aprendizado do fine-tuning completo e do especialista de ações com policy.optimizer_lr, policy.optimizer_vit_lr, policy.optimizer_connector_lr e policy.optimizer_action_expert_lr. As configurações do agendador podem ser alteradas com policy.scheduler_warmup_steps, policy.scheduler_decay_steps e policy.scheduler_decay_lr. O horizonte de decaimento padrão de 24.000 etapas corresponde à receita oficial do train_lerobot.py.

Estatísticas de Quantis do Conjunto de Dados

MolmoAct2 usa normalização por quantil por padrão para os recursos de estado e ação. Se o seu conjunto de dados não tiver sido convertido com estatísticas de quantil, você pode adicioná-las com:

python src/lerobot/scripts/augment_dataset_quantile_stats.py \
  --repo-id=your_dataset

Gravar, retomar e mesclar quantis agregados a partir de resumos por episódio, para que meta/stats.json acabe contendo um envelope conservador (min para q <= 50, max para q > 50) em vez de quantis do conjunto de dados inteiro. Para estimar estes últimos, percorra todos os episódios com um histograma incremental:

python src/lerobot/scripts/augment_dataset_quantile_stats.py \
  --repo-id=your_dataset \
  --overwrite \
  --skip-images

--skip-images mantém as estatísticas de imagem existentes e evita o download ou a decodificação de dados de vídeo quando apenas STATE/ACTION precisam ser recalculados, e --root lê um dataset local em vez do Hub. Esses valores são estimativas de histograma, sujeitas a erros de discretização e rebinning, portanto podem diferir dos conservadores — o que altera os alvos normalizados do MolmoAct2 e, consequentemente, a escala de sua perda. Estatísticas já salvas dentro de um checkpoint existente não são afetadas.

Alternativamente, treine o MolmoAct2 com normalização de média/desvio padrão:

--policy.normalization_mapping='{"ACTION": "MEAN_STD", "STATE": "MEAN_STD", "VISUAL": "IDENTITY"}'

Avaliação

A avaliação também suporta checkpoints salvos pelo LeRobot e checkpoints originais do MolmoAct2 HF. Para a replicação do LIBERO, mantenha o ambiente de renderização EGL fixo e use policy.per_episode_seed=true.

Importante: Verificamos que num_steps_wait=10 não permite de forma confiável que a cena LIBERO se estabilize e pode degradar o sucesso medido. Todos os resultados de avaliação do LIBERO relatados aqui usam num_steps_wait=50.

Avaliação com o peso LeRobot MolmoAct2

Use policy.path para um checkpoint salvo pelo LeRobot. O processador salvo e as estatísticas de normalização são restaurados junto com o modelo.

export MUJOCO_GL=egl
export PYOPENGL_PLATFORM=egl
export OMP_NUM_THREADS=1
export MKL_NUM_THREADS=1

lerobot-eval \
  --policy.path=allenai/MolmoAct2-LIBERO-LeRobot \
  --policy.inference_action_mode=continuous \
  --policy.dtype=bfloat16 \
  --policy.enable_inference_cuda_graph=true \
  --policy.device=cuda \
  --policy.per_episode_seed=true \
  --policy.eval_seed=1000 \
  --env.type=libero \
  --env.task=libero_10,libero_goal,libero_object,libero_spatial \
  --env.camera_name_mapping='{"agentview_image":"image","robot0_eye_in_hand_image":"wrist_image"}' \
  --eval.batch_size=1 \
  --eval.n_episodes=50 \
  --seed=1000

Avaliação com o Peso Original do MolmoAct2

Você pode avaliar um checkpoint publicado no Hugging Face diretamente, sem primeiro convertê-lo para um checkpoint do LeRobot. Nesse caso, defina policy.checkpoint_path para o repositório do modelo no HF e forneça policy.norm_tag. Para o LIBERO, policy.norm_tag=libero carrega as estatísticas de normalização de ação/estado do LIBERO, o horizonte de ação, os metadados do prompt e a ordem das chaves de imagem do norm_stats.json do checkpoint.

Para replicar totalmente os resultados do paper MolmoAct2 com os checkpoints liberados no Hugging Face, recomendamos usar a branch allenai/lerobot molmoact2-hf-inference fixada na v0.5.1. Essa branch corresponde às configurações de avaliação originais usadas para os números reportados.

export MUJOCO_GL=egl
export PYOPENGL_PLATFORM=egl
export OMP_NUM_THREADS=1
export MKL_NUM_THREADS=1

lerobot-eval \
  --policy.type=molmoact2 \
  --policy.checkpoint_path=allenai/MolmoAct2-LIBERO \
  --policy.norm_tag=libero \
  --policy.inference_action_mode=continuous \
  --policy.dtype=float32 \
  --policy.enable_inference_cuda_graph=true \
  --policy.device=cuda \
  --policy.per_episode_seed=true \
  --policy.eval_seed=1000 \
  --env.type=libero \
  --env.task=libero_goal \
  --env.camera_name_mapping='{"agentview_image":"image","robot0_eye_in_hand_image":"wrist_image"}' \
  --eval.batch_size=1 \
  --eval.n_episodes=50 \
  --seed=1000

Use --env.task=libero_10,libero_goal,libero_object,libero_spatial para executar a suíte completa do LIBERO. O mesmo comando funciona para outros checkpoints do MolmoAct2 já lançados, desde que o policy.norm_tag solicitado exista no norm_stats.json desse checkpoint.

Opções comuns de avaliação

• policy.inference_action_mode: obrigatório para o rollout. Use continuous para inferência de flow-matching ou discrete para inferência de tokens de ação. Ele deve ser compatível com o policy.action_mode de treinamento salvo no checkpoint.
• policy.path: Caminho do checkpoint do LeRobot ou repositório do Hub. Use isso para checkpoints salvos pelo LeRobot.
• policy.checkpoint_path: caminho original do checkpoint MolmoAct2 HF ou repositório do Hub. Use isso com policy.type=molmoact2 e policy.norm_tag.
• policy.norm_tag: seleciona as estatísticas de normalização, os metadados do prompt, a ordem das chaves de imagem e o horizonte de ação do checkpoint original em norm_stats.json. É obrigatório para a avaliação direta de checkpoints originais do HF.
• policy.dtype: perfil de armazenamento/autocast do modelo. Use bfloat16 para avaliação normal em GPU. Use float32 apenas quando você quiser explicitamente inferência em fp32 completo.
• policy.enable_inference_cuda_graph: habilita o caminho de grafo CUDA de inferência do MolmoAct2 para um rollout contínuo de ações repetidas mais rápido.
• policy.per_episode_seed e policy.eval_seed: tornam a geração estocástica de ações contínuas determinística por episódio para replicação.
• env.task: suítes do LIBERO separadas por vírgulas ou uma única suíte. Use libero_10,libero_goal,libero_object,libero_spatial para o benchmark completo.
• env.camera_name_mapping: mapeia os nomes das câmeras do LIBERO para as chaves de imagem esperadas pelo processador de política.

Resultados de Desempenho

Resultados do Benchmark LIBERO

O MolmoAct2 demonstrou um desempenho robusto na suíte de benchmarks LIBERO. Para comparar e testar sua implementação no LeRobot, ajustamos finamente o allenai/MolmoAct2-LIBERO por mais 10k passos no conjunto de dados LIBERO, com tamanho de lote por GPU de 32 em 8 GPUs H100, e em seguida comparamos os resultados com os resultados de referência originais do MolmoAct2.

O checkpoint fine-tuned do LeRobot relatado aqui está disponível em allenai/MolmoAct2-LIBERO-LeRobot e foi treinado em allenai/MolmoAct2-LIBERO-Dataset.

Esses resultados demonstram o forte desempenho do MolmoAct2 em diversas tarefas de manipulação robótica. Para reproduzi-los, siga as instruções na seção de avaliação do LIBERO.

Implantação de Hardware (lerobot-rollout)

Os checkpoints no formato LeRobot estão disponíveis no Hub para uso direto com lerobot-rollout. Cada checkpoint usa nomes de câmera específicos que devem corresponder à configuração de câmeras do seu robô.

Convenção de nomenclatura de câmeras

Cada checkpoint espera chaves específicas de observation.images.*. Se as câmeras do seu robô tiverem nomes diferentes, use --rename_map para mapeá-las:

Exemplo com um robô SO-100 usando câmeras superior e lateral:

lerobot-rollout \
  --policy.path=lerobot/MolmoAct2-SO100_101-LeRobot \
  --rename_map='{"observation.images.top": "observation.images.cam0", "observation.images.side": "observation.images.cam1"}' \
  --robot.type=so100_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.cameras='{
      top: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30},
      side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30}
  }' \
  --task="pick up the red cube" --duration=30

Para usar uma câmera de pulso em vez disso, basta alterar o mapeamento de renomeação:

--rename_map='{"observation.images.top": "observation.images.cam0", "observation.images.wrist": "observation.images.cam1"}'

Transformação de quadro conjunto (SO-100/101 zero-shot)

The MolmoAct2-SO100_101 checkpoint was trained on data that uses a different joint calibration convention than LeRobot >= 0.5.0. Without a frame correction, the arm may move in the wrong direction.

Isso afeta tanto o zero-shot deployment quanto o fine-tuning a partir do checkpoint original. Os pesos pré-treinados esperam a convenção antiga, portanto, todos os dados conjuntos (observações e ações) devem ser transformados para corresponder a ela.

O checkpoint LeRobot convertido (lerobot/MolmoAct2-SO100_101-LeRobot) já inclui essa correção em seu pipeline de processador. Se você converter ou ajustar o checkpoint por conta própria, defina o seguinte na configuração da política (configuration_molmoact2.py):

• joint_signs: [1, -1, 1, 1, 1, 1] (inverte a direção de shoulder_lift)
• joint_offsets: [0, 90, 90, 0, 0, 0] (desloca shoulder_lift e elbow_flex em 90°)

Veja o guia de compatibilidade reversa para detalhes sobre a alteração de calibração.

Diferenças em relação à implementação original

Esta portação para LeRobot tem como objetivo corresponder ao comportamento do MolmoAct2, utilizando a infraestrutura de dataset, treinamento, avaliação, checkpoint e logging do LeRobot. As principais diferenças em relação ao repositório de treinamento original são:

• A pilha de treinamento do artigo original mantém parâmetros mestres em fp32 e treina sob AMP bf16. Esta portação para LeRobot usa policy.dtype=bfloat16 para reduzir a memória: grandes matrizes de VLM são armazenadas em bf16, enquanto o especialista de ação e os módulos numericamente sensíveis permanecem em fp32 e os operadores elegíveis são executados sob autocast bf16. Um tensor de compensação de atualização em bf16 reduz a perda de arredondamento de parâmetros durante o fine-tuning completo, mas seus momentos Adam em bf16 ainda não reproduzem exatamente o estado do otimizador original em fp32.
• O repositório original usa seu próprio caminho de treinamento FSDP/paralelismo de modelo. A portação para LeRobot usa o caminho padrão de treinamento LeRobot/Accelerate e não foi testada para treinamento multi-nó.
• O repositório original suporta empacotamento de sequências. A portação para LeRobot treina com uma amostra LeRobot por item e usa preenchimento local por lote com uma guarda de comprimento máximo de sequência inferido.
• A port do LeRobot segue as convenções do LeRobot para otimizador, agendador, salvamento de checkpoints, transformações de dataset, aumento de imagem e log do Trackio.
• O caminho de treinamento original suporta horizontes de ação mistos, preenchendo até max_action_horizon e mascarando os slots de horizonte preenchidos na autoatenção do especialista de ação. Isso é útil ao treinar em conjuntos de dados com diferentes frequências de controle. A portabilidade para o LeRobot atualmente visa o ajuste fino em um único conjunto de dados, portanto policy.chunk_size substitui o max_action_horizon do checkpoint e o mascaramento de horizonte ainda não foi implementado. O suporte para esse caminho de horizonte misto está planejado.

Citação

@misc{fang2026molmoact2actionreasoningmodels,
      title={MolmoAct2: Action Reasoning Models for Real-world Deployment},
      author={Haoquan Fang and Jiafei Duan and Donovan Clay and Sam Wang and Shuo Liu and Weikai Huang and Xiang Fan and Wei-Chuan Tsai and Shirui Chen and Yi Ru Wang and Shanli Xing and Jaemin Cho and Jae Sung Park and Ainaz Eftekhar and Peter Sushko and Karen Farley and Angad Wadhwa and Cole Harrison and Winson Han and Ying-Chun Lee and Eli VanderBilt and Rose Hendrix and Suveen Ellawela and Lucas Ngoo and Joyce Chai and Zhongzheng Ren and Ali Farhadi and Dieter Fox and Ranjay Krishna},
      year={2026},
      eprint={2605.02881},
      archivePrefix={arXiv},
      primaryClass={cs.RO},
      url={https://arxiv.org/abs/2605.02881},
}

Licença

Este modelo é licenciado sob Apache 2.0. Ele é destinado para uso em pesquisa e educação, em conformidade com as Diretrizes de Uso Responsável da Ai2, consistente com allenai/molmoact2.