X-VLA : Le premier modèle de fondation robotique à invite douce pour tout robot, toute tâche

Aperçu

Pendant des années, la robotique a aspiré à construire des agents capables de suivre des instructions humaines naturelles et d’opérer avec dextérité dans de nombreux environnements et sur différents corps robotiques. Les récentes percées dans les LLM et les VLM suggèrent une voie à suivre : étendre ces architectures de modèles de fondation au contrôle incarné en les ancrant dans des actions. Cela a conduit à l’essor des modèles Vision-Language-Action (VLA), avec l’espoir qu’un modèle généraliste unique puisse combiner une compréhension sémantique large avec des compétences de manipulation robustes.

Mais entraîner de tels modèles est difficile. Les données robotiques sont fragmentées entre les plateformes, les capteurs, les incarnations et les protocoles de collecte. L’hétérogénéité se manifeste partout : différentes configurations de bras, différents espaces d’actions, différents montages de caméras, différents domaines visuels et différentes distributions de tâches. Ces incohérences créent des décalages de distribution majeurs qui rendent le pré-entraînement instable et l’adaptation peu fiable.

Inspiré par le méta-apprentissage et l'apprentissage par invite, nous nous demandons : « Et si un modèle VLA pouvait apprendre la structure de chaque robot et de chaque jeu de données de la même manière que les LLM apprennent des tâches, à travers des invites ? »

X-VLA est un cadre VLA à correspondance de flux et à prompts doux qui considère chaque configuration matérielle comme une « tâche » et l’encode à l’aide d’un petit ensemble d’embeddings apprenables. Ces Soft Prompts capturent les variations liées à l’incarnation et au domaine, guidant le Transformer dès les premières étapes de la fusion multimodale. Grâce à ce mécanisme, X-VLA peut concilier des morphologies de robots, des types de données et des configurations de capteurs variés au sein d’une architecture unifiée unique.

Construit à partir de codeurs Transformer purs, X-VLA s’adapte naturellement à la taille du modèle et à la diversité des jeux de données. Sur six benchmarks de simulation et trois robots réels, les Soft Prompts surpassent systématiquement les méthodes existantes dans la gestion des différences matérielles et de domaine. X-VLA-0.9B, entraîné sur 290K épisodes couvrant sept plateformes robotiques, apprend une politique généraliste indépendante de l’incarnation en Phase I, et s’adapte efficacement à de nouveaux robots en Phase II simplement en apprenant un nouvel ensemble de prompts, tout en gardant le backbone figé.

Avec seulement 1 % des paramètres ajustés (9M), X-VLA-0.9B atteint des performances proches de celles de π₀ sur LIBERO et Simpler-WidowX, malgré l'utilisation de 300 fois moins de paramètres entraînables. Il démontre également une grande dextérité en conditions réelles avec un minimum de démonstrations, notamment en pliant des tissus en moins de deux minutes.

X-VLA démontre que l’intelligence robotique généraliste ne requiert pas des architectures de plus en plus complexes, mais simplement la bonne manière d’absorber l’hétérogénéité. Les Soft Prompts offrent un mécanisme simple et évolutif pour unifier des données robotiques diverses, ouvrant la voie vers des modèles de fondation robotiques adaptables et inter-embodiment.

Installation

Après avoir installé LeRobot, installez les dépendances de X-VLA :

pip install -e ".[xvla]"

Si vous avez installé LeRobot depuis PyPI à la place :

pip install 'lerobot[xvla]'

Démarrage rapide

Utilisation de base

Pour utiliser X-VLA dans votre configuration LeRobot, spécifiez le type de politique comme suit :

policy.type=xvla

Évaluation des points de contrôle pré-entraînés

Exemple d'évaluation avec LIBERO :

lerobot-eval \
  --policy.path="lerobot/xvla-libero" \
  --env.type=libero \
  --env.task=libero_spatial,libero_goal,libero_10 \
  --env.control_mode=absolute \
  --eval.batch_size=1 \
  --eval.n_episodes=1 \
  --env.episode_length=800 \
  --seed=142

Points de contrôle disponibles

🎯 Modèle de base

lerobot/xvla-base

Une instantiation de X-VLA de 0,9 milliard de paramètres, entraînée avec une recette de traitement des données et d'apprentissage soigneusement conçue. Le pipeline d'entraînement se compose de deux phases :

• Phase I : Pré-entraînement - Pré-entraîné sur 290K épisodes issus de Droid, Robomind et Agibot, couvrant sept plateformes réparties sur cinq types de bras robotiques (configurations mono-bras à bi-manuelles). En exploitant des soft prompts pour absorber les variations spécifiques à chaque embodiment, le modèle apprend une politique généraliste indépendante de l'embodiment.

• Phase II : Adaptation au domaine - Adaptée aux politiques déployables pour les domaines cibles. Un nouvel ensemble de prompts doux est introduit et optimisé pour encoder la configuration matérielle du nouveau domaine, tandis que le tronc préentraîné reste figé.

Points de contrôle de simulation

lerobot/xvla-libero

Atteint un taux de réussite de 93 % sur les benchmarks LIBERO. Ajusté à partir du modèle de base pour les tâches de simulation.

lerobot/xvla-widowx

Ajusté finement sur BridgeData pour des expériences de préhension et de placement sur des plateformes compactes WidowX. Démonstre des capacités de manipulation robustes.

🤖 Points de contrôle réels

lerobot/xvla-folding

Un modèle de manipulation dextère fine-tuné, entraîné sur le jeu de données de pliage de tissus Soft-FOLD de haute qualité. Atteint un taux de réussite de 100 % sur 2 heures de pliage de tissus continu.

lerobot/xvla-agibot-world

Optimisé pour les tâches de manipulation habile du robot AgileX.

lerobot/xvla-google-robot

Adapté aux plateformes de robots Google.

Entraînement de X-VLA

Configuration d'entraînement recommandée

Lors de l’ajustement fin de X-VLA pour une nouvelle configuration ou tâche, nous recommandons de ne pas figer le VLM et de définir policy.dtype=bfloat16 afin d’éviter les erreurs OOM.

lerobot-train \
  --dataset.repo_id=YOUR_DATASET \
  --output_dir=./outputs/xvla_training \
  --job_name=xvla_training \
  --policy.path="lerobot/xvla-base" \
  --policy.repo_id="HF_USER/xvla-your-robot" \
  --policy.dtype=bfloat16 \
  --policy.action_mode=auto \
  --steps=20000 \
  --policy.device=cuda \
  --policy.freeze_vision_encoder=false \
  --policy.freeze_language_encoder=false \
  --policy.train_policy_transformer=true \
  --policy.train_soft_prompts=true

Explication des paramètres d'entraînement

💡 Bonne pratique : Pour l'adaptation de la phase II à de nouvelles incarnations, ne figez pas les encodeurs VLM et entraînez également le transformateur de politique et les prompts doux.

Exemple : Entraînement sur un robot bimanuel

lerobot-train \
  --dataset.repo_id=<USER>/bimanual-so100-handover-cube \
  --output_dir=./outputs/xvla_bimanual \
  --job_name=xvla_so101_training \
  --policy.path="lerobot/xvla-base" \
  --policy.dtype=bfloat16 \
  --policy.repo_id="YOUR_USERNAME/xvla-biso101" \
  --steps=3000 \
  --policy.device=cuda \
  --policy.action_mode=so101_bimanual \
  --policy.freeze_vision_encoder=false \
  --policy.freeze_language_encoder=false \
  --policy.train_policy_transformer=true \
  --policy.train_soft_prompts=true

💡 Meilleure performance : si vous disposez de ressources de calcul suffisantes et souhaitez obtenir la meilleure performance de fine-tuning de X-VLA, vous devez suivre la stratégie de fine-tuning officielle :

🔥 Ajustement fin complet de tous les composants avec un schéma de taux d'apprentissage personnalisé

Pour garantir une optimisation stable, le modèle Vision-Language (VLM) doit être entraîné avec un taux d'apprentissage de base divisé par 10, tandis que tous les autres composants utilisent le taux d'apprentissage complet. Ce ratio de taux d'apprentissage est crucial pour obtenir des performances de fine-tuning robustes et stables. Cela est déjà fait par défaut. ❕Note

Obtenir une correspondance exacte avec les performances officielles peut nécessiter un calendrier de LR de réchauffage supplémentaire pour les soft-prompts, ce qui peut apporter de légères améliorations. Nous vous encourageons à l’implémenter dans votre pipeline d’entraînement personnalisé pour des résultats optimaux.

Concepts fondamentaux

1. Modes d'action

X-VLA utilise un système Action Registry pour gérer différents espaces d’actions et incarnations. Le paramètre action_mode définit la manière dont les actions sont traitées, les fonctions de perte utilisées et le post-traitement des prédictions.

Modes d'action disponibles

Pourquoi les modes d'action sont importants

Lorsque vous disposez d'un point de contrôle préentraîné comme lerobot/xvla-base, entraîné avec action_dim=20, et que vous souhaitez entraîner sur un jeu de données avec une dimension d'action différente (par exemple, 14 pour des bras bimanuels), vous ne pouvez pas simplement réduire la dimension d'action. Le mode d'action orchestre :

1. Calcul de la perte : différentes fonctions de perte pour les différents composants d'action (MSE pour les articulations, BCE pour les pinces, etc.)
2. Prétraitement : mise à zéro des canaux de la pince, bourrage des dimensions
3. Post-traitement : application de la fonction sigmoïde aux logits de la pince, suppression du bourrage

Exemple : Espace d’actions BimanualSO101

Le mode d’action so101_bimanual gère l’incompatibilité entre la sortie du modèle (20D) et le contrôle du robot réel (12D) :

# Model outputs 20 dimensions for compatibility
dim_action = 20

# Real robot only needs 12 dimensions
# [left_arm (6), right_arm (6)] = [joints (5) + gripper (1)] × 2
REAL_DIM = 12

# Preprocessing: Pad 12D actions to 20D for training
# Postprocessing: Trim 20D predictions to 12D for deployment

Consultez l'implémentation de action_hub.py pour plus de détails.

Mode d'action automatique (recommandé)

Le mode d’action auto est la méthode la plus simple pour utiliser X-VLA avec n’importe quel robot. Il détecte automatiquement la dimension des actions de votre jeu de données et gère le bourrage/la suppression :

lerobot-train \
  --policy.path="lerobot/xvla-base" \
  --policy.action_mode=auto \
  --policy.max_action_dim=20 \
  ...

Fonctionnement :

• Lit action_feature.shape[-1] de votre jeu de données (par exemple, 7 pour Franka)
• Les sorties du modèle max_action_dim (20 par défaut) pour la compatibilité avec les modèles pré-entraînés
• La perte est calculée uniquement sur les dimensions réelles : MSE(pred[:,:,:real_dim], target[:,:,:real_dim])
• Postprocess réduit la sortie à real_dim pour le contrôle du robot

Cela élimine le besoin de créer des modes d'action personnalisés pour la plupart des robots.

2. Identifiants de domaine

Les identifiants de domaine sont des identifiants apprenables pour différentes configurations de robots et de caméras. Ils permettent à X-VLA de distinguer :

• Différents robots (Robot 1 vs Robot 2)
• Différentes configurations de caméras (cam1 vs cam2)
• Différentes combinaisons (Robot1-cam1-cam2 vs Robot1-cam1 vs Robot2-cam1)

Définir les identifiants de domaine

Pendant l’entraînement : par défaut, domain_id est défini à 0 pour l’entraînement général.

Pendant l'évaluation : spécifiez le domain_id qui correspond à la configuration d'entraînement de votre checkpoint.

# Example: LIBERO checkpoint uses domain_id=3
domain_id = 3

Le `domain_id` est automatiquement ajouté aux observations par le XVLAAddDomainIdProcessorStep dans le pipeline de prétraitement.

Le modèle lerobot/xvla-base a été entraîné sur les identifiants de domaine suivants. Il est recommandé d’en choisir un qui ressemble le plus à votre robot/configuration :

Jeux de données pour l'ajustement fin

3. Étapes du processeur

X-VLA nécessite des étapes spécifiques de prétraitement et de post-traitement pour un fonctionnement correct.

Étapes de prétraitement requises

1. XVLAImageToFloatProcessorStep : convertit les images de l'intervalle [0, 255] à l'intervalle [0, 1]
2. XVLAImageNetNormalizeProcessorStep : applique la normalisation ImageNet (nécessaire pour le backbone VLM)
3. XVLAAddDomainIdProcessorStep : ajoute domain_id aux observations

Exemple de processeur personnalisé

Pour les environnements LIBERO, un processeur personnalisé transforme l’observation canonique en l’entrée sur laquelle X-VLA a été entraîné :

from lerobot.policies.xvla.processor_xvla import LiberoProcessorStep

processor = LiberoProcessorStep()
# Builds the 9D state from the canonical 8D state, with the end-effector rotation in 6D
# Rotates the wrist camera back, since the LIBERO integration rotates every camera by 180°

4. Paramètres de configuration

Paramètres de configuration clés pour X-VLA :

# Observation and action
n_obs_steps: int = 1          # Number of observation timesteps
chunk_size: int = 32           # Action sequence length
n_action_steps: int = 32       # Number of action steps to execute

# Model architecture
hidden_size: int = 1024        # Transformer hidden dimension
depth: int = 24                # Number of transformer layers
num_heads: int = 16            # Number of attention heads
num_domains: int = 30          # Maximum number of domain IDs
len_soft_prompts: int = 32     # Length of soft prompt embeddings

# Action space
action_mode: str = "ee6d"      # Action space type (use "auto" for auto-detection)
use_proprio: bool = True       # Use proprioceptive state
max_state_dim: int = 32        # Maximum state dimension
max_action_dim: int = 20       # Max action dim for padding (used by "auto" mode)

# Vision
num_image_views: int | None    # Number of camera views
resize_imgs_with_padding: tuple[int, int] | None  # Target image size with padding

# Training
num_denoising_steps: int = 10  # Flow matching denoising steps

Création de modes d'action personnalisés

Si votre robot possède un espace d’actions unique, vous pouvez créer un mode d’action personnalisé :

Étape 1 : Définir votre espace d’actions

from lerobot.policies.xvla.action_hub import BaseActionSpace, register_action
import torch
import torch.nn as nn

@register_action("my_custom_robot")
class MyCustomActionSpace(BaseActionSpace):
    """Custom action space for my robot."""

    dim_action = 15  # Your robot's action dimension
    gripper_idx = (7, 14)  # Gripper channel indices

    def __init__(self):
        super().__init__()
        self.mse = nn.MSELoss()
        self.bce = nn.BCEWithLogitsLoss()

    def compute_loss(self, pred, target):
        """Define your loss computation."""
        # Example: MSE for joints, BCE for grippers
        joints_loss = self.mse(pred[:, :, :7], target[:, :, :7])
        gripper_loss = self.bce(pred[:, :, self.gripper_idx],
                                target[:, :, self.gripper_idx])

        return {
            "joints_loss": joints_loss,
            "gripper_loss": gripper_loss,
        }

    def preprocess(self, proprio, action, mode="train"):
        """Preprocess actions before training."""
        # Example: Zero out grippers in proprioception
        proprio_m = proprio.clone()
        action_m = action.clone() if action is not None else None
        proprio_m[..., self.gripper_idx] = 0.0
        if action_m is not None:
            action_m[..., self.gripper_idx] = 0.0
        return proprio_m, action_m

    def postprocess(self, action):
        """Post-process predictions for deployment."""
        # Example: Apply sigmoid to gripper logits
        action[..., self.gripper_idx] = torch.sigmoid(action[..., self.gripper_idx])
        return action

Étape 2 : Utiliser votre mode d’action personnalisé

lerobot-train \
  --policy.action_mode=my_custom_robot \
  --dataset.repo_id=YOUR_DATASET \
  --policy.path="lerobot/xvla-base" \
  ...

Sujets avancés

Prise en charge de plusieurs caméras

X-VLA prend en charge plusieurs vues de caméra via le paramètre num_image_views :

# Configure for 3 camera views
policy.num_image_views=3

# Add empty cameras if you have fewer physical cameras
policy.empty_cameras=1  # Adds 1 zero-padded camera view

Pipeline de prétraitement personnalisé

Créez un pipeline de prétraitement personnalisé pour votre environnement :

from lerobot.processor import PolicyProcessorPipeline
from lerobot.policies.xvla import (
    XVLAImageToFloatProcessorStep,
    XVLAImageNetNormalizeProcessorStep,
    XVLAAddDomainIdProcessorStep,
)

# Build custom pipeline
preprocessor = PolicyProcessorPipeline(
    steps=[
        YourCustomProcessorStep(),  # Your custom processing
        XVLAImageToFloatProcessorStep(),  # Required: convert to float
        XVLAImageNetNormalizeProcessorStep(),  # Required: ImageNet norm
        XVLAAddDomainIdProcessorStep(domain_id=5),  # Your domain ID
    ]
)

Gestion de différentes dimensions d'action

Lorsque votre jeu de données comporte moins de dimensions d’action que le modèle pré-entraîné :

Option 1 (Recommandée) : utiliser le mode d’action auto

# Automatically detects your dataset's action dimension
# Works with any robot without custom code
policy.action_mode=auto
policy.max_action_dim=20  # Match pretrained model

Option 2 : utiliser un mode d’action prédéfini avec un padding intégré

# Model expects 20D, dataset has 12D
# Action mode handles padding internally
action_mode = "so101_bimanual"  # Pads 12 → 20

Option 2 : Créer un mode d’action personnalisé qui mappe explicitement les dimensions

@register_action("my_mapped_action")
class MappedActionSpace(BaseActionSpace):
    dim_action = 20
    REAL_DIM = 12

    def _pad_to_model_dim(self, x):
        # Custom padding logic
        ...

Dépannage

Problèmes courants

Problème : « Incohérence de la dimension de l'action »

• Solution : Vérifiez que votre action_mode correspond à l'espace d'actions de votre robot. Créez un mode d'action personnalisé si nécessaire.

Problème : « Valeurs d'image hors de l'intervalle [0, 1] »

• Solution : Assurez-vous que les images sont prétraitées avec XVLAImageToFloatProcessorStep avant la normalisation.

Problème : « Domain ID not found »

• Solution : Assurez-vous que XVLAAddDomainIdProcessorStep est présent dans votre pipeline de prétraitement avec le bon domain_id.

Problème : « Taux de réussite faible sur la nouvelle incarnation »

• Solution:
  1. Vérifiez que votre action_mode est correct
  2. Vérifiez que les prompts doux sont entraînés (train_soft_prompts=True)
  3. Assurez-vous d'un prétraitement approprié (normalisation ImageNet, domain_id)
  4. Envisagez d'augmenter le nombre d'étapes d'entraînement

Problème : « Out of memory during training »

• Solution:
  1. Réduire chunk_size (par exemple, de 32 à 16)
  2. Activer le point de contrôle des gradients
  3. Réduire la taille du lot
  4. Geler davantage de composants

Citation

Si vous utilisez X-VLA dans vos recherches, veuillez citer :

@article{zheng2025x,
  title   = {X-VLA: Soft-Prompted Transformer as Scalable Cross-Embodiment Vision-Language-Action Model},
  author  = {Zheng, Jinliang and Li, Jianxiong and Wang, Zhihao and Liu, Dongxiu and Kang, Xirui
             and Feng, Yuchun and Zheng, Yinan and Zou, Jiayin and Chen, Yilun and Zeng, Jia and others},
  journal = {arXiv preprint arXiv:2510.10274},
  year    = {2025}
}

Ressources supplémentaires

• Article X-VLA
• Documentation LeRobot
• Implémentation du registre d'actions
• Implémentation du processeur
• Configuration du modèle

Contribuer

Nous accueillons avec enthousiasme les contributions ! Si vous avez implémenté un nouveau mode d'action ou un processeur pour votre robot, pensez à soumettre une PR pour aider la communauté.