Wie man ein VLA-Modell für den Roboter anpasst
Schritt-für-Schritt-Leitfaden zur Fein-Tuning von OpenVLA oder pi0 auf Ihrem Teleoperationsdatensatz <unk> Datenvorbereitung, Ausbildungskonfiguration, Bewertung und Bereitstellung.
Schritt-für-Schritt-Leitfaden zum Fein-Tuning von OpenVLA oder pi0 auf Ihrem Teleoperationsdatensatz
Weiterentwicklung
1. Voraussetzungen 2. Installieren 3. Datensatz 4. Konfiguration 5. Zug 6. Monitor 7. Beurteilung 8. Quantifizieren 9. Bereitstellung 10. Iteration
Voraussetzungen
- Ein Teleoperationsdatensatz mit mehr als 300 hochwertigen Episoden im RLDS-Format ([siehe Datenerhebungslehrbuch](
T10 )) - NVIDIA-GPU mit 24 GB+ VRAM (RTX 4090 für LoRA, A100/H100 für vollständige Feintuning)
- Python 3.10+ mit CUDA 12.1+
- Bekanntschaft mit PyTorch und HuggingFace Transformers
- Gewichte & Vorurteile (für Holzbau, kostenlose Arbeiten)
- ROS2 installiert auf Ihrer Robotermaschine ([siehe Einrichtungsanleitung](
T11 ))
Was du bauen wirst
Sie nehmen ein vorgeübtes VLA-Modell (OpenVLA-7B), passen es auf die Demonstrationsdaten Ihres Robots ein, bewerten es mit Ausführungsexperimenten, quantifizieren es für Echtzeit-Förderung und setzen es als ROS2-Aktionsserver auf Ihrem Roboter ein. Erwarten Sie eine Erfolgsrate von 60
VLA-Feinabstimmung-Pipeline
RLDS Datensatz Mehr als 300 Episoden
Die
OpenVLA / pi0 Vorgebildeter 7B
Die
- Schöne Ton LoRA oder Voll
Die
Beurteilung Ausführungstests
Die
Einsatz ROS2 + INT4
1
Überprüfen Sie die Vorbedingungen und die GPU-Einstellung
Überprüfen Sie Ihre GPU, CUDA-Version und verfügbare VRAM vor dem Start.
| Method | Min VRAM | GPU | Cost Estimate |
|---|---|---|---|
| LoRA fine-tune | 24 GB | RTX 4090, A5000 | $50–150 |
| Full fine-tune | 40 GB | A100 40GB | $150–300 |
| Full fine-tune (multi-GPU) | 2x 40 GB | 2x A100 | $250–400 |
Kopieren# Verifizieren CUDA und GPU nvidia-smi python3 -c "Import Torch; print(f'CUDA: {torch.cuda.is_available()}, Gerät: {torch.cuda.get_device_name(0)}, VRAM: {torch.cuda.get_device_properties(0).total_mem / 1e9:.1f}GB')" # Verifizieren CUDA-Version (Bedarf 12.1+ nvcc) --Version
** Budget Tipp:** Verwenden Sie Vast.ai oder Lambda Labs für die Cloud-GPU-Vermietung. Ein A100 80GB kostet 1,50
2 .
Installieren von OpenVLA-Abhängigkeiten
Klonen Sie OpenVLA und installieren Sie alle erforderlichen Pakete.
Kopieren# Erstellen Sie virtuelle Umgebung python3 -m venv ~/vla_env Quelle ~/vla_env/bin/aktivieren # Clone OpenVLA git clone
3
Bereiten Sie Ihren Datensatz vor
OpenVLA erwartet Daten in einem bestimmten Format. Konvertieren Sie Ihren RLDS-Datensatz oder Ihren LeRobot-Datensatz in das OpenVLA-Trainingsformat.
Copy# Umwandeln Sie Ihren RLDS-Datensatz in OpenVLA-Format python3 scripts/convert_rlds_to_openvla.py \ --input-dir=/datensets/openarm_pick_place_rlds \ --output-dir=/datensets/openarm_openvla \ --image-key="observation/image" \ --state-key="observation/state" \ --action-key="action" \ --language-key="language\instruction" \ \"meta\"#\" Überprüfen Sie den konvertierten Datensatz " json, osson = json.openos.odes.exp.opener's_dim/action/arm\open_task((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
Datenformatprüfung: OpenVLA erwartet Bilder als 224x224 RGB (es vergrößert intern), Aktionen als 7D-kontinuelle Vektoren (6 DOF + Griff) und eine Textspracheanweisung pro Episode. Überprüfen Sie diese Dimensionen vor dem Training
4
Einrichten der Ausbildung
Erstellen Sie eine Trainingskonfiguration YAML. Diese Hyperparameter sind für einen typischen Ein-Task-Feinabstimmung-Run abgestimmt.
Kopieren# Speichern als Konfigurationen/finetune_openarm.yaml cat > configs/finetune_openarm.yaml << 'EOF' # OpenVLA Feinabstimmung Config
Hypperparameter-Anleitung: Lernrate 2e-5 ist eine sichere Standardregelung für LoRA. Für eine vollständige Fein-Tuning-Verwendung 1e-5. Wenn der Trainingsabzug nach 500 Schritten nicht abnimmt, versuchen Sie 5e-5. Batchgröße 8 mit Gradient-Akkumulation 4 gibt eine effektive Batchgröße von 32, die gut für 300
5
Ein Schritt zur Fein-Tuning
Beginnen Sie den Trainingslauf. Für eine einzige GPU verwenden Sie
Copy# Single GPU (RTX 4090 / A100) python3 Skripts/finetune.py \ --config=configs/finetune_openarm.yaml \ --output-dir=runs/openarm-pick-place-v1 \ # Multi-GPU (2x A100) Torchrunnproc-per-Node=2 Skripts/finetune.py \ config=configs/finetune_openarm.yaml \ --output-dir=runs/openarm-pick-place-v1 \ # Erwartete Ausgabe: # 10/5000 \ Loss: 2.34\ LR: 2.0e-6\ TM Time: 1.2s/step # 100/5000 \ Loss: 0.87 \ LR: 1.1e-5e Time: - Step / s / Step: # 0.42 / Loss: # 500/5000 \ ...
Schätzungen der Ausbildungszäle:
| Setup | Steps/sec | Time for 5K steps | GPU Cost |
|---|---|---|---|
| RTX 4090 (LoRA) | ~0.8 | ~1.7 hours | $5–10 |
| A100 40GB (LoRA) | ~1.5 | ~55 min | $2–4 |
| A100 80GB (Full) | ~0.6 | ~2.3 hours | $5–8 |
| 2x A100 (Full) | ~1.0 | ~1.4 hours | $6–10 |
6
Überwachen Sie die Ausbildung
Beobachten Sie die Verlustkurve und die Gradientnormen in Gewichten und Biasen.
- Verluste sollten für die ersten 1.000
2.000 Schritte stetig sinken , dann Plateau - Die Gradiale Norm sollte zwischen 0,1 und 10,0 liegen
Spitzen über 50 zeigen Instabilität - Checkpoints werden alle 500 Schritte gespeichert
Sie können von jedem Checkpoint aus aufnehmen, wenn das Training abstürzt
Kopieren Sie# Öffnen Sie das Dashboard in Browser wandb öffnen Sie # oder überprüfen Sie die Trainingslogs direkt Schwanz -f-Run/openarm-pick-place-v1/training.log # Liste der gespeicherten Checkpoints ls -la runs/openarm-pick-place-v1/checkpoints/
Wenn die Verlustplateaus über 1.0 liegen: Ihr Datensatz kann Qualitätsprobleme haben. Überprüfen Sie, ob fehlerhafte Episoden, inkonsistente Aktionsskalien oder beschädigte Bilder auftreten. Versuchen Sie, die Lernrate auf 5e-5 zu erhöhen oder die Batchgröße auf 4 zu reduzieren.
7
Beurteilung des Kontrollpunkts
Führen Sie eine Ausführungserhöhung auf Ihrem Roboter (oder in Simulationen) durch, um die Erfolgsrate des fein abgestimmten Modells zu messen.
Kopie# Beurteilen Sie den besten Checkpoint (niedrigsten Valverlust) Python3 Skripts/evaluate.py \ --checkpoint=runs/openarm-pick-place-v1/checkpoints/step-4500 \ --robot-type=openarm \ --robot-port=/dev/ttyUSB0 \ --num-rollouts=20 \ --task="Pick up the red block and place it on the green target zone" # Erwartete Ausgabe: # Rollout 1/20: SUCCESS (14.2s) # Rollout 2/20: SUCCESS (12.8s) # Rollout 3/20: FAILURE
** Erfolgsquote-Benchmarks:** 60
8
Quantiz für den Einsatz
Die VLA-Modelle mit voller Präzision laufen bei 2
Kopieren# Quantizieren Sie auf INT4 mit Bit-und-Bytes python3 Skripts/quantize.py \ --checkpoint=runs/openarm-pick-place-v1/checkpoints/step-4500 \ --quantization=int4 \ --output-dir=runs/openarm-pick-place-v1/quantiziert \ # Benchmark-Inferenzgeschwindigkeit python3 Skripts/benchmark_inference.py \ --checkpoint=runs/openarm-pick-place-v1/quantiziert \ --num-steps=100 \ # Erwartete Ausgabe: # Modellgröße: 4.2 GB (unter 14,8 GB) # Inferenzgeschwindigkeit: 18,3 Hz (± 1,2 Hz) # Latenz: 54,6 ms pro Schritt
| Präzision | Model Size | Inference Hz | Min GPU |
|---|---|---|---|
| FP16 (baseline) | 14.8 GB | 3–5 Hz | 24 GB VRAM |
| INT8 | 7.4 GB | 8–15 Hz | 12 GB VRAM |
| INT4 | 4.2 GB | 15–25 Hz | 8 GB VRAM |
9
Auf Robot über ROS2 eingesetzt
Erstellen Sie einen ROS2-Aktionsserver, der das quantifizierte VLA-Modell ausführt und Kommandos zum Roboter bei 10
Kopieren Sie das ROS2-Paket für den VLA-Inferenzknoten cd ~/ros2_ws/src ros2 pkg erstellen Sie --build-type ament_python vla_inference \ --dependencies rclpy sensor_msgs std_msgs # Kopieren Sie das Inferenzschrift (einfachere Version unten) cat > ~/ros2_ws/srcvla_inference/vla_inference/inference\self_node.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py.py
Kopieren Sie# Erstellen und ausführen Sie den Ableitungsknoten cd ~/ros2_ws Colcon Build --Packs-Select vla_Inferenzquelle Installation/Setup.bash # Start Roboter + Kameras + VLA Ableitungs-Ros2 Start Openarm_bringup Openarm.launch.py & ros2 Run vla_Inferenz-Inferenz_Node
10
Iterate: Sammeln Sie mehr Daten, Retrain
Ihr erstes Modell wird Fehlermodus haben. Der effektivste Weg, um zu verbessern, ist gezielte Demonstrationen über die Fehlerfälle zu sammeln und neu zu trainieren.
Kopie # 1. Identifizieren Sie Fehlermodi aus den Auswertungsrollen # Häufige Fehler: Objekte in Randpositionen, ungewöhnliche Orientierungen, # Lichtänderungen, Objekte, die das Modell nicht gesehen hat # 2. Sammeln Sie 50-100 gezielte Demonstrationen für Fehlerfälle lerobot-Record \ --robot-type=openarm \ --task="pick_red_block_edge_positions" \ --num-episodes=50 \ --output-dir=~/datasets/openarm_pick_place_v2 # 3. Fusion mit dem ursprünglichen Datensatz python3 scripts/merge_datasets.py \ --datasets ~/datasets/openarm_pick_place ~/datasets/openarm_pick_place_v2 \ --output /datasets/openarm_pick_place_merged # 4. -Fine-Tune wieder (von dem besten vorherigen Checkpoint) python3 scripts/finetune.py \ --config=configs/finetune_openarm.yaml \ --resume-from=runs/openarm-pick-place-v1/checkpoints/step-4500 \ --output-dir=runs/openarm-pick-place-v2 \ --data.dataset_path=/datasets/openarm_pick_place_merged
Iterationsschleife
Die DAgger-Schleife (Dataset Aggregation) hat nachweislich die politische Leistung bei jedem Zyklus verbessert: Bereitstellen → Fehler erkennen → Zieldemos sammeln → Retrain → Beurteilen. Die meisten Teams sehen eine Erfolgsrate von 5
Fehlerbehebung
CUDA Out of Memory (OOM) während des Trainings
Reduzieren Sie
Training Verlust ist NaN
Dies bedeutet in der Regel eine zu hohe Lernrate oder beschädigte Daten. Verringern Sie die Lernrate auf 1e-5. Überprüfen Sie mit
Modell erzeugt konstante/identielle Aktionen
Das Modell ist möglicherweise nicht in der Lage, die mittlere Aktion vorherzusagen. Überprüfen Sie, ob Ihr Aktionsraum normalisiert ist (Null-Mittel, Einheitsvarianz). Überprüfen Sie, ob die Aufgabenbeschreibung mit der während der Datenerhebung verwendeten Übereinstimmung übereinstimmt. Versuchen Sie, die Trainingsschritte oder die Lernrate zu erhöhen.
Die Inferenz ist zu langsam für die Echtzeitkontrolle
Verwenden Sie die INT4-Quantifizierung (Schritt 8). Verwenden Sie
Das Quantifizierte Modell hat eine viel niedrigere Erfolgsrate
Einiger Qualitätsverlust wird erwartet (1
Verwandte Tutorials
- Ich weiß .
Sammeln Sie Roboter-Training-Daten
Das Vorkursum
](
LeRobot Quickstart
Einfachere Richtlinien (ACT, Diffusionspolitik) vor der Bekämpfung von VLA-Modellen zu entwickeln.
](
ROS2-Setup-Leitfaden
Einrichten Sie ROS2 für die Roboterteilung und die Entwicklung von Ableitknoten.
](
Häufig gestellte Fragen
Wie viel kostet es, ein VLA-Modell zu optimieren?
Ein typischer Feintuning-Run kostet 150
Was ist der Unterschied zwischen OpenVLA und pi0?
OpenVLA ist ein Open-Source-Vision-Language-Action-Modell mit 7B-Parameter von Stanford, das Kamerabilder und Sprachanweisungen als Eingabe und Ausgabe von Roboteraktionen nimmt. pi0 (aus der physischen Intelligenz) ist ein Flow-Matching-basiertes VLA, das bei geschickter Manipulation hervorragend ist. OpenVLA ist leichter zu feinen Ton; pi0 erreicht oft höhere Erfolgsraten bei komplexen Aufgaben.
Wie viele Demonstrationen-Episoden brauche ich für VLA-Feinabstimmung?
Für eine einzelne Aufgabe sind 300
Kann ich ein VLA-Modell auf eine GPU des Konsumenten feinen Ton anpassen?
Ja, mit LoRA (Low-Rank Adaptation) können Sie OpenVLA auf einem RTX 4090 (24 GB VRAM) oder sogar einem RTX 3090 feinen Ton machen.
Welche Erfolgsrate kann ich von einem feinem VLA-Modell erwarten?
Bei Aufgaben in der Verteilung (gleiche Objekte, ähnliche Positionen wie Trainingsdaten) erwarten Sie bei Ihrem ersten Feinschaltungslauf eine Erfolgsrate von 60
War dieses Tutorial hilfreich?
👍 Ja
Bleiben Sie bei der Robotik vorne
Erhalten Sie die neuesten Informationen zu Robotern, Datenerhebung und physischer KI