MolmoAct2 Policy

MolmoAct2 est l'implémentation de la politique MolmoAct2 dans LeRobot, adaptée aux interfaces d'entraînement, d'évaluation, de point de contrôle et de jeu de données de LeRobot pour un usage plus simple avec les jeux de données LeRobot.

Cette implémentation prend actuellement en charge l’entraînement et l’évaluation du modèle MolmoAct2 standard. MolmoAct2-Think, qui prend en charge le raisonnement à profondeur adaptative, n’est pas encore inclus dans cette politique LeRobot.

Pour le code d’entraînement original de MolmoAct2 utilisé pour les expériences rapportées dans l’article, consultez allenai/molmoact2.

Prérequis d'installation

Installer LeRobot avec les dépendances optionnelles MolmoAct2 :

uv sync --locked --extra molmoact2

Pour exécuter les modèles de ce dépôt, vous avez besoin d'un GPU NVIDIA. Le chemin de précision mixte actuel stocke l'expert d'action complet en fp32 et les grandes matrices du VLM en bf16. policy.compile_model=true compile optionnellement les blocs de l'expert d'action tout en laissant le VLM, la tour de vision, le connecteur et l'enveloppe de politique en mode eager. Cette limite a passé les vérifications de parité des sorties de départ identiques, des gradients et des mises à jour de l'optimiseur ; la compilation du chemin VLM en bf16 n'a pas réussi.

L’entraînement multi-GPU via accelerate augmente le débit et la taille du lot global. Ce chemin a été testé sur des exécutions GB200 à deux nœuds et huit GPU, mais ce portage LeRobot n’expose pas le chemin d’entraînement parallèle de modèle fsdp_devices original de MolmoAct2. Un replay GB200 sur un seul GPU avec deux largeurs de prompt réelles a produit un graphe d’action compilé sans rupture de graphe, la même mémoire de pointe de 55,15 Go qu’en exécution eager, et une accélération modérée en régime permanent. Considérez ces résultats comme des vérifications d’implémentation plutôt que comme des affirmations portables sur le débit ou les délais estimés.

Le dépôt a été testé avec Ubuntu 22.04.

Utilisation

Pour utiliser MolmoAct2 dans une configuration d'entraînement LeRobot, définissez :

--policy.type=molmoact2

Entraînement

MolmoAct2 peut être affiné à partir du format de checkpoint Hugging Face de MolmoAct2 publié ou à partir d'un checkpoint déjà enregistré par LeRobot. Les deux approches utilisent la même boucle d'entraînement LeRobot, les mêmes transformations de jeu de données, la même sauvegarde de checkpoints et la même journalisation. La seule différence réside dans la manière dont les poids initiaux de la politique et l'état du processeur sont chargés.

LeRobot désactive par défaut l’augmentation des images des jeux de données. Conservez --dataset.image_transforms.enable=true dans les commandes d’entraînement de MolmoAct2. La recette de transformation originale de MolmoAct2 n’est pas le réglage par défaut générique de transformation de LeRobot, la première commande fixe donc explicitement son recadrage à 95 %, sa rotation de 5 degrés et son ajustement des couleurs. La recette originale applique en outre un flou gaussien avec une probabilité de 0,2 ; la configuration générique de sous-ensemble de transformations de LeRobot ne peut pas exprimer cette quatrième transformation optionnelle sans parfois supprimer l’une des trois transformations requises.

Entraînement avec les poids d'origine de MolmoAct2

Utilisez policy.checkpoint_path lorsque vous démarrez à partir d'un checkpoint MolmoAct2 publié, par exemple allenai/MolmoAct2 ou allenai/MolmoAct2-LIBERO. LeRobot chargera les fichiers de modèle HF d'origine, puis construira son propre processeur de politique à partir des métadonnées du jeu de données et des options de politique ci-dessous.

La commande ci-dessous montre un fine-tuning complet sur le jeu de données LIBERO fusionné à partir du point de contrôle de base publié. Elle utilise le chargement du modèle en bf16, 8 pas de temps de flux, les statistiques de quantiles officielles de LIBERO, l’augmentation d’images et le chemin de point de contrôle/journalisation de LeRobot. Ne remplacez pas les quantiles de métadonnées approximatifs de lerobot/libero par les norm_stats.json publiés ; leurs valeurs q01/q99 ne sont pas identiques.

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

Entraînement avec le poids LeRobot MolmoAct2

Utilisez policy.path lorsque vous démarrez à partir d'un checkpoint MolmoAct2 enregistré par LeRobot, soit depuis un répertoire local pretrained_model, soit depuis le Hub. Cela restaure la configuration de la politique LeRobot enregistrée, les poids du modèle, le processeur et les statistiques de normalisation. Vous pouvez toujours remplacer les options de formation telles que batch_size, steps ou policy.action_mode. Le chargement du checkpoint est strict et préserve la topologie FFT ou LoRA enregistrée ; ne remplacez donc pas policy.train_mode_vlm lors de l'utilisation de policy.path. Pour démarrer une nouvelle exécution LoRA, initialisez à partir des poids HF avec policy.checkpoint_path à la place, par exemple avec --policy.type=molmoact2, --policy.checkpoint_path=allenai/MolmoAct2 et --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

Pratiques courantes

Pour l’ajustement fin sur un jeu de données relativement petit, tel qu’une seule suite LIBERO ou un jeu de données du monde réel comportant moins de 200 démonstrations, une taille de lot globale de 16 à 32 constitue un bon point de départ. Dans ces configurations, nous recommandons d’utiliser policy.train_mode_vlm=lora (par défaut), qui offre généralement des performances similaires, voire supérieures, à celles de fft. De plus, policy.train_mode_vlm=freeze est également un choix pratique. Dans tous les modes, nous conservons intentionnellement l’expert d’action entièrement entraînable, ce que nous avons jugé crucial pour les performances du modèle. Pour des jeux de données d’ajustement fin plus volumineux, des tailles de lot globales plus importantes et un ajustement fin complet du VLM (policy.train_mode_vlm=fft) sont généralement préférés.

Options de politique courantes

• policy.checkpoint_path : point de contrôle MolmoAct2 HF d'origine à utiliser pour l'initialisation. Utilisez ce paramètre pour les poids MolmoAct2 publiés.
• policy.path : point de contrôle LeRobot à utiliser pour l'initialisation. Utilisez ce paramètre pour les points de contrôle créés par l'entraînement LeRobot.
• policy.action_mode : cible d’entraînement, l’une des valeurs continuous, discrete ou both. L’affinage officiel du robot MolmoAct2 utilise continuous. Les points de contrôle publiés conservent les poids d’actions discrètes ; both est disponible comme ablation explicite combinant flow-matching et jetons d’action.
• policy.train_mode_vlm : contrôle le mode de fine-tuning du VLM, l’un des fft, lora ou freeze. fft effectue un fine-tuning complet du VLM, lora entraîne des adaptateurs LoRA sur les couches linéaires du VLM, et freeze fige le VLM. L’expert d’action est entièrement fine-tuné dans les trois modes. La valeur par défaut est lora. freeze nécessite policy.action_mode=continuous.
• policy.enable_knowledge_insulation : lorsque la valeur est true, les états K/V du contexte de l’expert d’action sont détachés avant la perte d’action. La valeur par défaut est false.
• policy.chunk_size : horizon d’action utilisé par la politique. Pour LIBERO, nous utilisons 10. Cette portage LeRobot remplace le max_action_horizon du point de contrôle chargé par cette valeur.
• policy.n_action_steps : nombre d’actions consommées depuis chaque chunk prédit avant de requêter la politique. Pour LIBERO, définissez-le sur chunk_size.
• policy.setup_type : texte inséré dans le prompt pour décrire le robot et la scène, par exemple single franka robotic arm in libero. D'autres exemples sont répertoriés dans les entrées metadata_by_tag de norm_stats.json.
• policy.control_mode : texte inséré dans le prompt pour décrire l'espace d'action, par exemple delta end-effector pose ou absolute joint pose.
• policy.image_keys : clés d'observation d'image LeRobot ordonnées transmises au processeur.
• policy.dtype : commutateur de précision de type Pi0.5. bfloat16 utilise l'autocast et le stockage bf16 pour les grandes matrices VLM, tout en conservant l'expert d'action complet et les modules numériquement sensibles en fp32. float32 désactive l'autocast et maintient le modèle complet en fp32. Le profil à faible mémoire bfloat16 diffère intentionnellement de l'exécution AMP originale MolmoAct2 avec maître FP32 : les moments AdamW suivent le dtype de stockage de chaque paramètre, si bien que les grands paramètres VLM en bf16 ont également des moments en bf16. L'ajustement complet alloue paresseusement un tenseur de compensation bf16 pour chaque paramètre bf16 porteur de gradient, afin que les mises à jour inférieures à un ULP de paramètre soient prises en compte aux étapes suivantes. Il ne s'agit pas d'une copie maître en fp32. Les adaptateurs LoRA, l'expert d'action et les modules explicitement sensibles conservent des paramètres et un état d'optimiseur en fp32 ; les paramètres VLM gelés en mode LoRA n'allouent aucun tenseur de compensation.
• policy.compile_model : active le chemin de compilation par blocs torch.compile de MolmoAct2. Le fine-tuning complet et LoRA ne compilent que les blocs transformer de l'expert d'action. L'exécution en mode eager des composants VLM/ViT/connecteur évite les dérives d'activation et de gradient en BF16 induites par le compilateur, tout en conservant l'accélération pour le chemin d'action évalué à chaque pas de temps du flux. Inductor est également instruit de préserver les limites de conversion BF16 (downcast/upcast) en mode eager à travers les opérations fusionnées. Il s'agit d'une limite de précision fixe et sûre, qui n'ajoute pas d'option de compilation supplémentaire. La compilation est désactivée par défaut ; activez-la pour les longues exécutions d'entraînement sur GPU. Les blocs d'action utilisent la stratégie de forme automatique de PyTorch. Avec le checkpointing de gradient, seule la dimension de séquence variable du contexte encodeur est marquée comme dynamique ; la taille du lot, l'horizon d'action et le nombre de pas de temps du flux restent statiques. Le réordonnancement du cache de graphes de Dynamo et son séparateur de graphes DDP supplémentaire sont désactivés dans ce mode, afin que la recomputation en arrière-plan sélectionne le même graphe de blocs que l'avant. Les séquences texte/action locales au lot sont remplies à gauche (left-padding) jusqu'à un multiple interne de 8 avant l'insertion du BOS. Cela ajoute au maximum sept jetons masqués tout en réduisant fortement le temps de chauffe de compilation spécifique aux formes ; ce n'est pas une option destinée à l'utilisateur.
• policy.num_flow_timesteps : nombre d'étapes de flow-matching échantillonnées par exemple pendant l'entraînement. Nous utilisons 8 pour le fine-tuning.
• policy.num_inference_steps : paramètre facultatif pour remplacer le nombre d'étapes de génération d'actions continues lors de l'inférence.
• policy.gradient_checkpointing : active le checkpointing dans le chemin VLM/action pour réduire la mémoire des activations.
• policy.freeze_embedding : fige les embeddings d'entrée. La valeur par défaut est true.
• policy.normalize_gripper : contrôle si les dimensions de la pince sont incluses dans la normalisation par quantiles de l'état/action. La valeur par défaut est false.
• policy.normalize_language : normalise les chaînes de tâches avant la construction du prompt. La valeur par défaut est true.
• policy.mask_action_dim_padding : masque les dimensions rembourrées dans la perte de flux. Les points de contrôle publiés utilisent policy.expected_max_action_dim=32.
• policy.max_sequence_length : limite manuelle facultative de la longueur de séquence. Laissez-la non définie pour la déduire des images, de la dimension de l'état, de la dimension de l'action, de l'horizon d'action et du mode d'action discret.

Taux d'apprentissage

MolmoAct2 utilise des taux d'apprentissage par groupe de paramètres pour correspondre aux expériences de fine-tuning originales de MolmoAct2.

• Le fine-tuning complet utilise policy.optimizer_lr=1e-5 pour le VLM, policy.optimizer_vit_lr=5e-6 pour la tour de vision, policy.optimizer_connector_lr=5e-6 pour les couches du connecteur d’images et policy.optimizer_action_expert_lr=5e-5 pour l’expert d’action.
• L’ajustement fin LoRA du VLM définit les groupes de paramètres LoRA du VLM, de la vision et du connecteur sur 5e-5 lorsque policy.train_mode_vlm=lora ; l’expert d’action est toujours entièrement ajusté avec policy.optimizer_action_expert_lr.
• Le fine-tuning de Frozen-VLM utilise policy.train_mode_vlm=freeze, entraîne uniquement l’expert d’action et utilise policy.optimizer_action_expert_lr=5e-5.
• policy.optimizer_grad_clip_norm est appliqué indépendamment aux groupes de paramètres du LLM, de la tour visuelle, du connecteur d’images et de l’expert d’action, conformément à l’optimiseur original de MolmoAct2. Il ne s’agit pas d’une norme de gradient unique pour le modèle global.

Vous pouvez remplacer les taux d’apprentissage du fine-tuning complet et de l’expert d’action avec policy.optimizer_lr, policy.optimizer_vit_lr, policy.optimizer_connector_lr et policy.optimizer_action_expert_lr. Les paramètres du planificateur peuvent être modifiés avec policy.scheduler_warmup_steps, policy.scheduler_decay_steps et policy.scheduler_decay_lr. L’horizon de décroissance par défaut de 24 000 étapes correspond à la recette officielle train_lerobot.py.

Statistiques de quantiles du jeu de données

MolmoAct2 utilise par défaut la normalisation par quantiles pour les caractéristiques d'état et d'action. Si votre jeu de données n'a pas été converti avec des statistiques de quantiles, vous pouvez les ajouter avec :

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

Enregistrement, reprise et fusion des quantiles agrégés à partir des résumés par épisode, afin que meta/stats.json contienne une enveloppe conservatrice (min pour q <= 50, max pour q > 50) plutôt que des quantiles sur l'ensemble du jeu de données. Pour estimer ces derniers, parcourez chaque épisode avec un histogramme incrémental :

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

--skip-images conserve les statistiques d’images existantes et évite le téléchargement ou le décodage des données vidéo lorsque seuls STATE/ACTION doivent être recalculés, et --root lit un jeu de données local au lieu du Hub. Ces valeurs sont des estimations par histogramme, sujettes à des erreurs de discrétisation et de rebinning, elles peuvent donc différer des valeurs conservatrices — ce qui modifie les cibles normalisées de MolmoAct2 et, par conséquent, l’échelle de sa perte. Les statistiques déjà enregistrées dans un point de contrôle existant ne sont pas affectées.

Sinon, entraînez MolmoAct2 avec une normalisation moyenne/écart-type :

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

Évaluation

L'évaluation prend en charge à la fois les points de contrôle enregistrés par LeRobot et les points de contrôle HF originaux de MolmoAct2. Pour la réplication de LIBERO, gardez l'environnement de rendu EGL fixe et utilisez policy.per_episode_seed=true.

Important : Nous avons constaté que num_steps_wait=10 ne permet pas de manière fiable à la scène LIBERO de se stabiliser et peut dégrader le taux de réussite mesuré. Tous les résultats d'évaluation LIBERO rapportés ici utilisent num_steps_wait=50.

Évaluation avec le poids LeRobot MolmoAct2

Utilisez policy.path pour un point de contrôle enregistré par LeRobot. Le processeur enregistré et les statistiques de normalisation sont restaurés avec le modèle.

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

Évaluation avec les poids d'origine de MolmoAct2

Vous pouvez évaluer un point de contrôle Hugging Face publié directement, sans d’abord le convertir en point de contrôle LeRobot. Dans ce cas, définissez policy.checkpoint_path sur le dépôt de modèle HF et fournissez policy.norm_tag. Pour LIBERO, policy.norm_tag=libero charge les statistiques de normalisation des actions/états de LIBERO, l’horizon des actions, les métadonnées de l’invite et l’ordre des clés d’image depuis le norm_stats.json du point de contrôle.

Pour reproduire intégralement les résultats de l’article MolmoAct2 avec les points de contrôle Hugging Face publiés, nous recommandons d’utiliser la branche allenai/lerobot molmoact2-hf-inference verrouillée à la v0.5.1. Cette branche correspond aux paramètres d’évaluation d’origine utilisés pour les chiffres rapportés.

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

Utilisez --env.task=libero_10,libero_goal,libero_object,libero_spatial pour exécuter la suite complète LIBERO. La même commande fonctionne pour les autres points de contrôle MolmoAct2 publiés, à condition que le policy.norm_tag demandé existe dans le norm_stats.json de ce point de contrôle.

Options d'évaluation courantes

• policy.inference_action_mode : requis pour le rollout. Utilisez continuous pour l’inférence par flow-matching ou discrete pour l’inférence par jetons d’action. Il doit être compatible avec le policy.action_mode de l’entraînement enregistré dans le checkpoint.
• policy.path : chemin du checkpoint LeRobot ou dépôt Hub. À utiliser pour les checkpoints enregistrés par LeRobot.
• policy.checkpoint_path : chemin du checkpoint MolmoAct2 HF original ou dépôt Hub. Utilisez ceci avec policy.type=molmoact2 et policy.norm_tag.
• policy.norm_tag : sélectionne les statistiques de normalisation, les métadonnées du prompt, l’ordre des clés d’image et l’horizon d’action à partir du fichier norm_stats.json du checkpoint d’origine. Il est requis pour l’évaluation directe d’un checkpoint HF d’origine.
• policy.dtype : profil de stockage/autocast du modèle. Utilisez bfloat16 pour une évaluation GPU standard. Utilisez float32 uniquement si vous souhaitez explicitement une inférence en fp32 complet.
• policy.enable_inference_cuda_graph : active le chemin d’inférence CUDA graph de MolmoAct2 pour des rollouts d’actions continues répétés plus rapides.
• policy.per_episode_seed et policy.eval_seed : rendent la génération d’actions continues stochastiques déterministe par épisode pour la réplication.
• env.task : suites LIBERO séparées par des virgules ou une seule suite. Utilisez libero_10,libero_goal,libero_object,libero_spatial pour le benchmark complet.
• env.camera_name_mapping : associe les noms de caméras LIBERO aux clés d’images attendues par le processeur de politique.

Résultats de performance

Résultats du benchmark LIBERO

MolmoAct2 a démontré de solides performances sur la suite de benchmarks LIBERO. Pour comparer et tester son implémentation LeRobot, nous avons effectué un fine-tuning de allenai/MolmoAct2-LIBERO pendant 10k étapes supplémentaires sur le jeu de données LIBERO, avec une taille de lot par GPU de 32 sur 8 GPU H100, puis nous avons comparé les résultats aux résultats de référence originaux de MolmoAct2.

Le point de contrôle fine-tuné de LeRobot présenté ici est disponible sur allenai/MolmoAct2-LIBERO-LeRobot et a été entraîné sur allenai/MolmoAct2-LIBERO-Dataset.

Ces résultats démontrent les excellentes performances de MolmoAct2 sur des tâches de manipulation robotique variées. Pour les reproduire, suivez les instructions de la section d’évaluation LIBERO.

Déploiement matériel (lerobot-rollout)

Les points de contrôle au format LeRobot sont disponibles sur le Hub pour une utilisation directe avec lerobot-rollout. Chaque point de contrôle utilise des noms de caméras spécifiques qui doivent correspondre à la configuration des caméras de votre robot.

Convention de nommage des caméras

Chaque point de contrôle s'attend à des clés spécifiques observation.images.*. Si les caméras de votre robot ont des noms différents, utilisez --rename_map pour les associer :

Exemple avec un robot SO-100 utilisant des caméras en haut et sur le côté :

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

Pour utiliser une caméra de poignet à la place, il suffit de modifier la correspondance de renommage :

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

Transformation conjointe des articulations (SO-100/101 zéro-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.

Cela concerne à la fois le déploiement en zéro tir et le fine-tuning à partir du point de contrôle original. Les poids pré-entraînés s’attendent à la convention ancienne, il faut donc transformer toutes les données conjointes (observations et actions) pour qu’elles correspondent.

Le point de contrôle LeRobot converti (lerobot/MolmoAct2-SO100_101-LeRobot) inclut déjà cette correction dans son pipeline de processeur. Si vous convertissez ou affinez vous-même le point de contrôle, définissez les éléments suivants dans la configuration de la politique (configuration_molmoact2.py) :

• joint_signs : [1, -1, 1, 1, 1, 1] (inverse la direction de shoulder_lift)
• joint_offsets : [0, 90, 90, 0, 0, 0] (décale shoulder_lift et elbow_flex de 90°)

Consultez le guide de compatibilité ascendante pour plus de détails sur le changement de calibration.

Différences par rapport à l'implémentation originale

Ce portage LeRobot est conçu pour reproduire le comportement de MolmoAct2 tout en utilisant l’infrastructure de jeu de données, d’entraînement, d’évaluation, de points de contrôle et de journalisation de LeRobot. Les principales différences par rapport au dépôt d’entraînement original sont les suivantes :

• La pile d’entraînement du papier original conserve les paramètres maîtres en fp32 et entraîne sous AMP bf16. Cette portage LeRobot utilise policy.dtype=bfloat16 pour réduire la mémoire : les grandes matrices du VLM sont stockées en bf16, tandis que l’expert d’action et les modules numériquement sensibles restent en fp32 et les opérateurs éligibles s’exécutent sous autocast bf16. Un tenseur de compensation de mise à jour en bf16 réduit la perte d’arrondi des paramètres lors d’un fine-tuning complet, mais ses moments Adam en bf16 ne reproduisent toujours pas exactement l’état de l’optimiseur fp32 d’origine.
• Le dépôt d'origine utilise son propre chemin d'entraînement FSDP/parallélisme de modèle. La portage LeRobot utilise le chemin d'entraînement standard LeRobot/Accelerate et n'a pas été testé pour l'entraînement multi-nœuds.
• Le dépôt d'origine prend en charge le regroupement de séquences. La version LeRobot entraîne le modèle sur un échantillon LeRobot par élément et utilise un rembourrage local au lot avec une garde de longueur de séquence maximale déduite.
• Le port LeRobot suit les conventions de l’optimiseur, du planificateur, de la sauvegarde des points de contrôle, des transformations de jeu de données, de l’augmentation d’images et de la journalisation Trackio de LeRobot.
• Le chemin d’entraînement d’origine prend en charge des horizons d’action mixtes en effectuant un bourrage jusqu’à max_action_horizon et en masquant les emplacements d’horizon bourrés dans l’auto-attention de l’expert d’action. Cela est utile lors de l’entraînement sur des jeux de données ayant des fréquences de contrôle différentes. La portage LeRobot cible actuellement l’ajustement fin sur un seul jeu de données, de sorte que policy.chunk_size remplace le max_action_horizon du point de contrôle et que le masquage d’horizon n’est pas encore implémenté. La prise en charge de ce chemin à horizon mixte est prévue.

Citation

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

Licence

Ce modèle est sous licence Apache 2.0. Il est destiné à un usage de recherche et éducatif, conformément aux Directives d'utilisation responsable d'Ai2, en cohérence avec allenai/molmoact2.