Vertrieb kontaktieren
Zurück zu Learn

Wie man OpenVLA auf dem eigenen Roboterdataset abgestimmt

LoRA-Feinabstimmung von OpenVLA-7B auf Ihrem eigenen RLDS-Roboter-Datensatz. GPU-Größe, PEFT-Konfiguration, Datenaufladung, Trainingsschleife und Bewertung in weniger als 3 Stunden.

OpenVLA-7B ist das beliebteste Open Vision-Language-Action-Modell. Dieses Tutorial führt durch LoRA-basierte Fein-Tuning auf Ihrem eigenen RLDS-Datensatz: Hardware-Größe, PEFT-Konfiguration, Dateloader-Setup, Training und Bewertung auf einer ausgehaltenen Episode oder dem echten Roboter.

VLA / Fein-Tuning Gesamtzeit: ca. 3 Stunden (plus Schulzeit) Schwierigkeiten: Fortgeschritten aktualisiert April 2026

Was Sie erreichen werden

Am Ende dieses Tutorials haben Sie einen LoRA-fein-tuned OpenVLA-7B Checkpoint, der auf Ihre Aufgabe und Ihre Ausführungsform spezialisiert ist. LoRA (Low-Rank Adaptation) ist die richtige Wahl für die meisten Teams: Es reduziert die VRAM-Anforderungen von ~ 100 GB für die vollständige Feintuning auf etwa 24 GB, konvergiert schnell auf bescheidene Datensätze (ein paar hundert Episoden) und produziert einen kleinen Adapter, der einfach zu verteilen ist.

OpenVLA wird vom Stanford IRIS Lab und seinen Mitarbeitern gepflegt. Das Basismodell 7B wurde vorab auf Open X-Embodiment, einem Datensatz von fast einer Million Bahnen in 22 Ausführungsformen, ausgebildet.

Voraussetzungen

  • **A 24 GB+ VRAM GPU.**A100 40/80 GB, H100, RTX 4090 oder L40S funktionieren alle. RTX 3090 mit 24 GB funktioniert, ist aber eng.
  • Ein RLDS-Datensatz mit mindestens 50 Episoden (200+ empfohlen) mit Bildbeobachtungen, proprioception und Natursprachen-Task-Anweisungen.
  • Familiarkeit mit PyTorch, HuggingFace-Transformatoren und Imitationslerngrundlagen.
  • Ubuntu 22.04 oder 20.04 mit CUDA 12.1+-Treiber.
  • 200 GB kostenlose Festplatte für Modellgewichte, Checkpoints und Ihre Datensätze.

Wenn Sie noch keinen Datensatz haben, können Sie einen erstmals sammeln sehen Sie unser [LeRobot-Aufnahme-Tutorial]T18) oder durchsuchen [Offene Datensätze]T19) im RCSV-Datensatz-Hub. Sie können auch öffentliche Datensätze mit einem kleineren Satz Ihrer eigenen Episoden mischen, um dem Modell eine gezielte Vorbereitung zu geben.

Die Schritte

  1. Überprüfen Sie Hardware und Umgebung

Überprüfen Sie Ihre GPU und CUDA:

```
nvidia-smi
python -c "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0), torch.version.cuda)"
```

Sie wollen T8, Ihren GPU-Namen und eine CUDA-Version, die mit Ihrem PyTorch-Build übereinstimmt.

```
conda create -n openvla python=3.10 -y
conda activate openvla
```
  1. Installieren Sie OpenVLA und Abhängigkeiten

Installieren Sie die OpenVLA-Codebase und den PEFT-Stack.

```
git clone https://github.com/openvla/openvla.git
cd openvla
pip install -e .
pip install peft bitsandbytes accelerate wandb
```

PEFT bietet die Implementierung von LoRA. Bitandbytes bietet Ihnen 8-Bit-Quantifizierung für das Basismodell, so dass es in 24 GB passt. Beschleunigen Hands verteilte Ausbildung. Wandb ist optional, aber für die Verfolgung von Laufen empfohlen.

  1. Bereiten Sie Ihren Datensatz im RLDS-Format vor

OpenVLA verbraucht RLDS (Reinforcement Learning Datasets) ein von Google Research unterstütztes TFDS-Format. Jede Episode enthält eine Schrittenfolge, in der jeder Schritt T9 (Bild, Zustand), T10, T11 und T12 hat.

Wenn Ihre Daten bereits in LeRobot oder HDF5 sind, müssen Sie konvertieren. Das Open X-Embodiment Repository enthält Referenzkonverter, die Sie anpassen können. Ein minimaler RLDS-Builder sieht aus wie:

```
import tensorflow_datasets as tfds

class MyRobotDataset(tfds.core.GeneratorBasedBuilder):
    VERSION = tfds.core.Version('1.0.0')

    def _info(self):
        return tfds.core.DatasetInfo(
            builder=self,
            features=tfds.features.FeaturesDict({
                'steps': tfds.features.Dataset({
                    'observation': tfds.features.FeaturesDict({
                        'image': tfds.features.Image(shape=(224, 224, 3)),
                        'state': tfds.features.Tensor(shape=(7,), dtype=tf.float32),
                    }),
                    'action': tfds.features.Tensor(shape=(7,), dtype=tf.float32),
                    'language_instruction': tfds.features.Text(),
                    'is_terminal': tfds.features.Scalar(dtype=tf.bool),
                }),
            })
        )
```

Zeigen Sie diesen Builder an Ihre Episode-Dateien und registrieren Sie den Datensatznamen in der OpenVLA Datensatzkonfiguration.

  1. Download OpenVLA-7B Basiswächten

Ziehen Sie das Basismodell von HuggingFace Hub:

```
huggingface-cli download openvla/openvla-7b --local-dir ./openvla-7b
```

Das ist etwa 15 GB. Optional können Sie es unter T13 cachen, um es für Projekte wiederverwendet zu können.

  1. Konfiguration von LoRA

Der Standard-Startpunkt für OpenVLA ist LoRA Rang 32, der auf die Aufmerksamkeitsmodule abzielt.

```
from peft import LoraConfig, get_peft_model

lora_config = LoraConfig(
    r=32,
    lora_alpha=16,
    target_modules="all-linear",
    lora_dropout=0.0,
    bias="none",
    task_type="CAUSAL_LM",
)
```

Rang 32 ist eine sinnvolle Standard für 50 bis 500 Episoden. Fall auf 16 wenn VRAM eng ist; Steigen auf 64 für größere Datensätze. Ziel T14 entspricht dem OpenVLA Referenzrezept; Sie können auf nur Aufmerksamkeitsprojektionen beschränken, wenn das Speicher eine Einschränkung ist.

  1. Start die Fein-Tuning

Verwenden Sie das Referenz-Finetune-Skript aus dem OpenVLA-Repo. Der genaue Eingangspunkt bewegt sich über Veröffentlichungen hinweg Überprüfen Sie das README des Repo das allgemeine Invokationsmuster ist:

```
torchrun --standalone --nnodes 1 --nproc-per-node 1 \
  vla-scripts/finetune.py \
  --vla_path ./openvla-7b \
  --data_root_dir /path/to/rlds \
  --dataset_name my_robot_dataset \
  --run_root_dir ./runs \
  --adapter_tmp_dir ./adapter-tmp \
  --lora_rank 32 \
  --batch_size 16 \
  --grad_accumulation_steps 1 \
  --learning_rate 5e-4 \
  --image_aug True \
  --wandb_project openvla-finetune
```

Auf einem A100 mit 80 GB erwartet man etwa 1 Stunde pro 10k Schritte. Ein typischer 200-Episoden-Datensatz konvergiert in 20 bis 40k Schritten.

Tipp: aktivieren T15 für kleine Datensätze.

  1. Überwachen Sie das Training

Beobachten Sie drei Signale in WandB oder Tensorboard: action MSE (Ihr primärer Verlust), gradient norm (Steuernorm, nicht Spiking) und per-dimension Action Accuracy (Token-Genauigkeit für den tokenized Action Head). Wenn die Action MSE Plateaus nach 5k Schritten über 0,1 liegen, ist Ihr Datensatz zu klein oder Ihre Sprachanweisungen entsprechen nicht der Trainingsverteilung des Policy Head.

  1. Fusion von LoRA und Bewertung

Am Ende des Trainings verschmelzen Sie den LoRA-Adapter in das Basismodell, um eine schnellere Abschlussfolgerung zu erzielen:

```
from peft import PeftModel
from transformers import AutoModelForVision2Seq

base = AutoModelForVision2Seq.from_pretrained('./openvla-7b', torch_dtype=torch.bfloat16)
model = PeftModel.from_pretrained(base, './runs/my_robot_dataset/adapter')
merged = model.merge_and_unload()
merged.save_pretrained('./openvla-7b-my-robot')
```

Bewertet nun: Führen Sie das zusammengeschmelzte Modell in einer ausgehaltenen Episode aus und vergleichen Sie vorhergesagte Aktionen mit der Grundwahrheit oder setzen Sie es auf den echten Roboter und messen Sie die Erfolgsrate der Aufgaben über 20 Versuche.

Was soll ich jetzt tun?

Sobald ein LoRA-Adapter funktioniert, werden drei natürliche Folgeaufnahmen durchgeführt: (1) Skalieren Sie mehr Daten Fügen Sie Episoden von [Open X-Embodiment] T21) oder anderen öffentlichen Datensätzen hinzu, um dem Modell eine breitere Vorstellung zu geben, (2) versuchen Sie eine vollständige Feinstimmung auf einer 80 GB-GPU, wenn Sie eine haben, die im Allgemeinen 2 bis 5 Prozentpunkte zum Erfolg der Aufgabe hinzufügt, und (3) vergleichen Sie mit anderen [VLA-Modelle] T22) Pi-Zero, Octo und RT-2-Varianten haben alle unterschiedliche Stärken.

Wenn Ihr Datensatz mit LeRobot gesammelt wurde, deckt unser LeRobot-Aufnahme-Tutorial die Abfangseite ab. Für zweibrochige Aufgaben siehe das ALOHA-Teleop-Reig-Tutorial.

Häufige Ausfallmodi

OOM beim Starten: ermöglichen 8-Bit-Quantifizierung mit T16 oder Drop-Batch-Größe.

** Aktions-MSE wird nicht abgenommen:** Überprüfen Sie, ob Ihre Aktionsnormalitätsstatistiken korrekt sind. Ein häufiger Fehler ist die Berechnungsstatistik auf der falschen Spaltung.

Politik treibt den Roboter zu gemeinsamen Grenzen: Die Sprachenanweisung in Ihrem Datensatz ist zu eng verteilt; das Modell wird statt gelernt auswendig gelernt.

Inferenz ist langsam: Laufen Sie immer mit T17 und bfloat16 nach der Verschmelzung von LoRA.

Tiefen Tauchgang: LoRA vs. Voll-Fine-Tune vs. von Grund auf

Drei Optionen sind auf dem Spektrum. ** Full-fine-tune** aktualisiert jeden Parameter des 7B-Modells. Es erzeugt typischerweise die beste Aufgabenerfolgrate, wenn Sie genügend Daten (500+ Episoden) und eine 80 GB GPU haben, da das Modell jede Darstellung an Ihre Ausführungsform anpassen kann. ** LoRA** fügt niedrigrangige Adapter zu einer Untermenge von Schichten hinzu, eiskalt die Basis und konvergiert schnell auf kleineren Datensätzen. In unseren Experimenten mit mittleren Manipulationsdaten-Sets erreicht LoRA 90 bis 95 Prozent der vollständigen Feintuning-Leistung bei einem Viertel der Berechnung. Von Grund macht es für VLA-Modelle fast nie Sinn Sie verlieren das Open X-Embodiment vorher und benötigen mehr Daten.

Ein viertes Weg, der anziehungskraft gewinnt, ist ** DoRA** (Gewicht-zerfallene Niedrigrang-Adaptation), das Gewichte in Größe- und Richtungskomponenten zerlegt. DoRA fügt eine kleine Menge an Parameter über LoRA hinzu und schließt oft die Lücke bis zur vollen Feinrichtung weiter. PEFT unterstützt DoRA aus dem Feld wenn Sie LoRA ausprobiert haben und eine Decke getroffen haben, tauschen Sie es mit einer ein-Linie-Konfigurationsänderung ein.

Tiefschwimmen: Datenbestandsqualität übertrifft Datenbestandsgröße

Die Teams investieren stets übermäßig in die Episodezahl und unterinvestitionen in die Episodevielfalt. 200 Episoden über 20 Licht- und Objektposition-Variationen schlagen 1000 Episoden derselben Szene. Der Grund ist modeltheoretisch: VLA-Feinabstimmung lernt nicht in erster Linie was zu tun ist das Basismodell kennt bereits grobe Manipulationsvorurteile es lernt, die Politik auf ihre Kamera-Einheit, ihr Arbeitsplatz und ihre Sprachanweisungen zu verankern.

Ein konkretes Rezept, das funktioniert: innerhalb der 200 Episoden variieren Sie die ursprüngliche Position des Objekts über ein 20 cm x 20 cm Gitter (10 Positionen mindestens), registrieren Sie unter 3 Lichtbedingungen und drehen Sie sich durch 5 Natursprache-Phrasen der gleichen Anweisung.

Tiefschwimmen: bei der Bewertung machen Teams Fehler

Der häufigste Fehler ist die Bewertung nur auf ausgehaltenen Episoden aus derselben Aufnahme. Die reale Bewertung hat drei Ebenen: (1) Held-out von der gleichen Sitzung niedrigere Grenze auf die Fähigkeit, (2) Held-out von einem anderen Tag / Beleuchtung reale Welt Robustheit Check, und (3) Zero-Schuss auf eine neue Aufgabe Phrase oder leicht neues Objekt was eine verwendbare VLA von einem Demo-nur eine Trennung. Budget mindestens 30 Minuten reale Roboterzeit pro Kandidaten Checkpoint für eine richtige Bewertung.

Häufig gestellte Fragen

Wie viele Episoden brauche ich? 50 ist ein Minimum für nicht trivial Ergebnisse. 200 ist ein gutes Ziel. 500+ sättigt die LoRA-Kapazität für die meisten einzelnen Aufgaben.

** Kann ich auf mehrtägige Daten einstellen? ** Ja, und es hilft normalerweise. Der 7B OpenVLA-Spielraum hat Kopfraum, um mehrere Aufgaben pro Adapter zu absorbieren.

** Was ist mit Pi-Zero oder Octo?** Pi-Zero ist das Flow-matching VLA von Physical Intelligence unterschiedliches Trainingsrezept, oft höhere Erfolgsrate pro Episode, erfordert aber proprietäre Gewichte. Octo ist ein kleineres offenes Modell, das für die Forschung nützlich ist. Siehe unseren VLA-Modellvergleich.

Inferenz-Latenz ist für meine Anwendung wichtig. OpenVLA-7B-Inferenz beträgt etwa 200 ms auf einem einzigen A100. Wenn das zu langsam ist, schauen Sie sich kleinere VLAs, Quantifizierung oder Action-Chunking-Strategien an.

Verwandte Tutorials und Ressourcen