FineART-VLA

FineART-VLA s’appuie sur π0.5 de Physical Intelligence et son implémentation openpi, via la politique Pi05 de LeRobot. Il étend cette base avec une tête de langage PaliGemma entraînable et un runtime qui alterne la génération de langage et la génération d’actions. Un seul point de contrôle peut prédire une sous-tâche de bas niveau, mettre à jour la mémoire ou répondre à des questions visuelles, et conditionner son expert d’actions flow-matching sur ce texte.

Utilisez Pi05 lorsque vous avez uniquement besoin d’actions conditionnées par la tâche. Utilisez FineART-VLA lorsque la politique doit générer ou consommer un langage intermédiaire au cours d’un déroulement.

En quoi FineART-VLA diffère de Pi05

FineART-VLA peut être initialisé à partir d'un checkpoint Pi05. L'architecture de la politique reste compatible, tandis que FineART-VLA construit ses propres processeurs afin que les étiquettes de recette et les étiquettes FAST ne soient pas remplacées silencieusement par la pile de processeurs Pi05.

Installer

Installer LeRobot avec les dépendances FineART-VLA :

git clone https://github.com/huggingface/lerobot.git
cd lerobot
python -m venv .venv
source .venv/bin/activate
pip install -e ".[fineart_vla]"

L’extension fineart_vla inclut les dépendances PaliGemma/FAST. Pour les noyaux de formation fusionnés optionnels sur Linux avec un GPU CUDA, installez plutôt ".[fineart_vla_kernels]". Cela ajoute liger-kernel et le package kernels de Hugging Face utilisé par les backends FlashRT. Les noyaux FlashRT ne sont publiés que pour certaines versions de PyTorch ; en l’absence d’une compilation correspondante, les backends FlashRT affichent un avertissement et basculent sur PyTorch. Liger est activé via --policy.use_liger_kernels=true : il modifie le RoPE/GeGLU de PaliGemma dans transformers pour l’ensemble du processus, de sorte que les autres politiques basées sur PaliGemma chargées dans le même processus s’exécutent également avec les noyaux fusionnés.

Préparer des données annotées par langue

FineART-VLA ne déduit pas les sous-tâches supervisées à partir d'un jeu de données LeRobot standard pendant l'entraînement. Le jeu de données doit contenir les cibles linguistiques utilisées par la recette sélectionnée dans les colonnes facultatives language_persistent et language_events.

À minima, annoter une chronologie de subtask continue afin que chaque image d’entraînement dispose d’une instruction de bas niveau active. Ajouter les annotations memory, VQA, interjections et parole uniquement si la recette entraîne ces capacités.

FineART-VLA intègre sa recette par défaut dans FineARTVLAConfig, tout comme EO-1. Il échantillonne 30 % de prédictions de tâches de haut niveau → sous-tâches et 70 % d’entraînement d’actions conditionnées par sous-tâche de bas niveau. Chaque configuration possède son propre dictionnaire de recette, et les points de contrôle enregistrés transmettent ce dictionnaire à l’inférence.

Utilisez --policy.recipe_path=/path/to/custom.yaml pour remplacer la valeur par défaut. Les recettes partagées dans src/lerobot/configs/recipes/ conservent la sémantique de main ; FineART-VLA ne les remplace pas. Pour une formation uniquement par objectif, utilisez une recette en ligne avec un seul message utilisateur de bas niveau contenant ${task}, ou définissez recipe=None et désactivez les pertes text/FAST pour le pipeline PI05 standard.

Par défaut, l’inférence est factorisée en π(a|o, subtask)·π(subtask|o, task). Une recette de séquence conjointe personnalisée nécessite un processeur d’exécution correspondant qui rend la tâche et l’assistant généré avec les mêmes marques causales que lors de l’entraînement. L’ancien constructeur de prompt conjoint côté politique n’est plus utilisé par le déroulement.

Rollout gère le rythme de planification (--autosteer_interval_s=3), les commandes interactives et l’ordonnancement synchrone/RTC. FineART-VLA ne génère du texte que lorsqu’il est interrogé ; les appels d’action ordinaires ne génèrent jamais un autre sous-tâche à l’insu du runtime.

Les brouillons mémoire/sous-tâche combinés ne sont pas la valeur par défaut et nécessitent une recette personnalisée ainsi qu’un contrôleur d’exécution conscient de la mémoire. Conservez memory_scratchpad=false pour la génération ordinaire de sous-tâches ; les points de contrôle de brouillon plus anciens conservent leur garde-fou explicite contre le passage direct des réponses combinées au contrôle des actions.

Utilisez lerobot-annotate pour générer ces colonnes. Le dépôt inclut un lanceur Hugging Face Jobs que vous pouvez modifier pour vos jeux de données source et de destination. Pour une exécution d’annotation locale, installez d’abord pip install -e ".[annotations]" :

HF_TOKEN=hf_... uv run python examples/annotations/run_hf_job.py

Avant une longue session d’entraînement, inspectez plusieurs épisodes et vérifiez que les sous-tâches sont temporellement correctes et couvrent la démonstration complète. Consultez Annotation Pipeline pour la génération et la validation, et Language Columns and Recipes pour le schéma et le résolveur de recettes.

If a dataset has no language columns, recipe rendering becomes a no-op and FineART-VLA falls back to the plain Pi05 prompt path. This is useful for compatibility but does not train the language planner.

Entraîner FineART-VLA

Cet exemple initialise FineART-VLA à partir de lerobot/fineart_vla_base, le point de contrôle entraîné à mi-parcours sur FineART pour prédire sa propre sous-tâche suivante, et entraîne la recette de sous-tâches 70/30 intégrée. --policy.path charge la configuration propre au point de contrôle de base, de sorte que l’ajustement fin conserve la disposition des jetons FAST (fast_skip_tokens) et la recette avec laquelle la base a été entraînée ; les autres drapeaux --policy.* la remplacent.

lerobot-train \
    --dataset.repo_id=${HF_USER}/my_language_annotated_dataset \
    --policy.path=lerobot/fineart_vla_base \
    --policy.tokenizer_max_length=256 \
    --policy.dtype=bfloat16 \
    --policy.device=cuda \
    --policy.freeze_vision_encoder=false \
    --policy.gradient_checkpointing=true \
    --batch_size=8 \
    --steps=30000 \
    --output_dir=outputs/fineart_vla \
    --job_name=fineart_vla \
    --trackio.enable=true

Commencez par une petite exécution et vérifiez dans le tableau de bord Trackio que les pertes se comportent comme prévu avant de passer à l'échelle supérieure.

Pour démarrer à partir du point de contrôle PI0.5 brut plutôt que de celui de FineART-VLA, conservez la configuration par défaut de FineART-VLA et pointez --policy.pretrained_path vers ce dernier : --policy.type=fineart_vla --policy.pretrained_path=lerobot/pi05_base. Les poids au format OpenPI sont convertis au chargement, et les pertes de texte et FAST démarrent de la tête de langage de PaliGemma plutôt que du pré-entraînement intermédiaire de FineART.

Contrôles principaux de l'entraînement

fast_skip_tokens=1152 place les codes FAST sous la plage <loc> de PaliGemma. La convention pi0-FAST d’openpi est 128 (FAST occupe les ids <loc>) ; utilisez cette valeur uniquement pour rester compatible en poids avec les points de contrôle entraînés de cette manière, et évitez de la combiner avec la recette VQA, dont les cibles <loc> partageraient des lignes d’embeddings avec les codes FAST.

Les poids de perte sont des points de départ, et non des constantes indépendantes du jeu de données. Suivez la perte de flux et les pertes texte/FAST séparément, et inspectez les sous-tâches générées plutôt que de sélectionner un point de contrôle uniquement à partir de la perte totale.

Tokeniseur FAST spécifique au jeu de données

Par défaut (--policy.auto_fit_fast_tokenizer=true), l’entraînement ajuste un tokenizer FAST sur le jeu de données d’entraînement, en partant de --policy.action_tokenizer_name, et le met en cache dans --policy.fast_tokenizer_cache_dir. Cela s’applique également lors d’un fine-tuning à partir d’un checkpoint tel que lerobot/fineart_vla_base, afin que les cibles FAST correspondent à la distribution des actions du nouveau robot. Le tokenizer ajusté est enregistré dans les artefacts du processeur du checkpoint, ce qui permet de le réutiliser lors de l’inférence. Définissez --policy.auto_fit_fast_tokenizer=false pour utiliser action_tokenizer_name sans modification.

Performance d'entraînement

FineART-VLA utilise des chemins d’entraînement optimisés par défaut :

• les lots répètent les cibles de flux et les projections de suffixe au lieu de rejouer de petites opérations en Python ;
• met en cache les masques d'action constants et calcule les positions RoPE une seule fois par passe avant ;
• sélectionne l'implémentation de l'entropie croisée text/FAST à partir de la forme cible et de la sparsité ;
• ignore le rétropropagation mathématiquement nulle du VLM/vision sur les lots isolés par le savoir, à flux uniquement ;
• utilise le checkpointing natif non-réentrant des couches SigLIP lorsque le checkpointing de gradient est activé ; et
• conserve les noyaux Liger RoPE/GeGLU tout en évitant le patch LayerNorm plus lent aux formes SigLIP.

Les backends d'entraînement optionnels sont désactivés par défaut :

N’activez pas tous les backends à l’aveugle. Flex et l’attention manuelle sont mutuellement exclusifs, et les alternatives attention/AdaRMS nécessitent une isolation des connaissances. La configuration la plus performante aux benchmarks utilisait le CE de texte compilé et FlashRT AdaRMS, avec l’attention Flex/manuelle et la vision compilée désactivées.

Performance d'inférence

FineART-VLA comporte deux boucles d'inférence, et les deux évitent d'encoder à répétition le préfixe multimodal coûteux :

1. Action denoising encode le préfixe image/langage une seule fois, réutilise son cache KV entre les étapes du flux, construit les masques de suffixe d’action sur l’appareil et recoupe les K/V de suffixe temporaires au lieu de cloner le cache du préfixe. Il crée le calendrier des pas de temps sur l’appareil une fois par bloc, en conservant l’arithmétique historique des pas de temps. Ce détail d’implémentation ne garantit pas une accélération de bout en bout sans benchmark.
2. Décodage de la langue utilise la mise en cache KV autorégressive, de sorte que chaque nouveau jeton ne traite que le jeton échantillonné par rapport aux clés image/langue mises en cache, au lieu de réexécuter le préfixe complet.

Le runtime partagé exécute le langage et les actions à des cadences différentes. Augmentez --autosteer_interval_s si une sous-tâche reste valide plus longtemps, ou utilisez /subtask pour fournir directement une instruction sans génération de langage. Un intervalle plus long réduit le coût de génération, mais ralentit également la replanification.

Exécuter un point de contrôle

Utilisez lerobot-rollout avec la configuration robot/caméra correspondant au checkpoint, --interactive=true et --autosteer_interval_s=3. Choisissez --inference.type=sync ou --inference.type=rtc. Dans le terminal interactif, /autosteer <goal> active les sous-tâches générées, /subtask <instruction> en fournit une manuellement et /start lance le contrôle du robot. Consultez Contrôle interactif par langage pour la configuration matérielle complète, le comportement de sécurité et les contrôles d’enregistrement. Les options CLI d’adaptateur précédentes --sim, --mode et --high_level_hz ne font pas partie de cette interface.

Dépannage

• Gradients de perte de flux élevés : FineART-VLA exécute l’attention conjointe préfixe/action KI-off sur le backend math de PyTorch SDPA avec une arithmétique d’attention en FP32, en recastant sa sortie vers le dtype du modèle (la version standard de PI0.5 conserve son attention eager). Cela évite l’attention en précision réduite, qui peut déstabiliser les gradients aux pas de temps de flux faibles avec de grandes activations de requêtes/clés. Les points de contrôle existants et les couches de normalisation restent inchangés ; KI-off s’entraîne toujours à travers les clés et les valeurs du VLM. Surveillez la norme de gradient avant rognage des flow_loss, text_loss et séparément, plutôt que de vous fier uniquement à la perte totale finie.
• Aucune perte de texte ni sous-tâches générées : vérifiez que la recette sélectionnée peut associer les annotations des échantillons de frames et que policy.text_loss_weight > 0.
• Les sous-tâches semblent plausibles mais les actions échouent : vérifiez les limites des sous-tâches, les statistiques normalisées des états/actions et la présence d'échantillons de recettes de bas niveau.
• Le texte se réduit à des jetons répétés ou de localisation : inspectez la couverture des cibles texte, le taux d’apprentissage de la tête de langue et l’équilibre entre les pertes de flux, FAST et texte.
• Mémoire insuffisante : réduisez d'abord la taille du lot, puis activez le point de contrôle des gradients. N'activez pas les backends d'attention compilés ou alternatifs sans avoir d'abord profilé leur consommation mémoire en fonction du nombre de caméras.
• Déploiement lent : séparez la latence d’action de la latence du langage, puis réglez --autosteer_interval_s (fréquence de génération d’une nouvelle sous-tâche) et --policy.num_inference_steps (étapes de débruitage du flux).

Citation

Si vous utilisez FineART-VLA ou le jeu de données FineART, veuillez citer :

@misc{choghari2026fineart,
  title  = {FineART: Fine-Grained Annotated Robotic Trajectory Dataset and Vision-Language-Action Model for Bimanual Manipulation},
  author = {Choghari, Jade and Kooijmans, Pepijn and Agarwal, Mansi and Ciftci, Yusuf Umut and Doriwala, Aseem and Weaver, Catherine and Sivapurapu, Mouli and Yang, Kai and Lee, Jackson and Wolf, Thomas and Mannam, Pragna},
  year   = {2026},
}

FineART-VLA s’appuie sur π₀.₅ et l’isolation des connaissances de Physical Intelligence.

Licence

Ce modèle est soumis à la licence Apache 2.0, conformément au dépôt OpenPI d'origine, dont le backbone PI0.5 est adapté.