LeRobot-Roboterarm-Tutorial

Im Shop kaufen

Dieses Tutorial wurde bis 15. Dezember aktualisiert. Sie können der neuesten offiziellen Dokumentation folgen. Das konkrete Tutorial siehe diesen Link. Für URDF-Dateien siehe diesen Link. Für die alte Version vom 15. September siehe diesen Link. SO-ARM101 und SO-ARM100 sind im ausgeführten Code kompatibel.

A. Hinweise zum Tutorial

Pro-Version: schwarzer Führungsarm mit 5V/6A-Netzteil, weißer Folgearm mit 12V/5A-Netzteil!

Servomontage und Winkeleichung müssen vorab erledigt sein – siehe offizielles Montage-Tutorial; darauf geht dieses Tutorial nicht ein!

Montage-Tutorial: Lerobot-Roboterarm-Montage

Falls Servos nicht konfiguriert oder der Arm nicht montiert ist, folgen Sie bitte zunächst dieser README. Sie enthält die Stückliste, Links zu Teilen, 3D-Druck-Anleitung und Ratschläge für Erstdrucker.

Beginnen wir mit der Installation der LeRobot-Umgebung.

B. Umgebungsvorbereitung

Für Ubuntu X86:

• Ubuntu 22.04
• CUDA 12+
• Python 3.10
• Torch 2.6+

Für Jetson Orin:

• Jetson Jetpack 6.0+
• Python 3.10
• Torch 2.5.0a0+872d972e41

LeRobot-Umgebung installieren

1. Miniconda installieren:

Je nach CUDA-Version müssen pytorch und torchvision installiert werden.

1. Für Jetson:

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh
chmod +x Miniconda3-latest-Linux-aarch64.sh
bash ~/Miniconda3-latest-Linux-aarch64.sh
source ~/.bashrc

Oder für X86 Ubuntu 22.04:

mkdir -p ~/miniconda3
cd miniconda3
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda3/miniconda.sh
bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3
rm ~/miniconda3/miniconda.sh
source ~/miniconda3/bin/activate
conda init --all

2. Im gewünschten Verzeichnis (z. B. lerobot anlegen) eine neue conda-Umgebung für lerobot erstellen und aktivieren:

Bitte kein lerobot-Projekt unter ~/miniconda3 anlegen oder importieren

conda create -y -n lerobot python=3.10

3. Danach die conda-Umgebung aktivieren (bei jedem Öffnen des Terminals mit lerobot nötig!):

conda activate lerobot

4. LeRobot klonen:

git clone https://github.com/Juxi-Technology/lerobot.git

Alternativ der neuesten Version folgen: https://github.com/huggingface/lerobot.git Hinweis: Die Befehle der neuesten Version können abweichen!

5. ffmpeg in der Umgebung installieren:

Bei miniconda in der Umgebung ffmpeg installieren:

conda install ffmpeg -c conda-forge

Dies installiert i. d. R. ffmpeg 7.X mit libsvtav1-Encoder. Falls nicht unterstützt (prüfbar mit ffmpeg -encoders):

【Alle Plattformen】ffmpeg 7.X explizit installieren: conda install ffmpeg=7.1.1 -c conda-forge

Ohne Grafikabhängigkeiten (gdk-pixbuf, librsvg) diesen Befehl nutzen: conda install ffmpeg=7.1.1 -c conda-forge --no-deps

【Nur Linux】Build-Abhängigkeiten installieren und ffmpeg mit libsvtav1 aus dem Quellcode kompilieren; mit which ffmpeg den richtigen ausführbaren Pfad prüfen.

Bei folgendem Fehler hilft der obige Befehl ebenfalls.

6. Ins lerobot-Verzeichnis wechseln und LeRobot mit feetech-Motor-Abhängigkeiten installieren:

cd ~/lerobot && pip install -e ".[feetech]"

Für Jetson Jetpack 6.0+ Geräte (vorher gemäß diesem Tutorial Pytorch-gpu und Torchvision installieren):

conda install -y -c conda-forge "opencv>=4.10.0.84"  # 通过 conda 安装 OpenCV 和其他依赖，仅适用于 Jetson Jetpack 6.0+
conda remove opencv   # 卸载 OpenCV
pip3 install opencv-python==4.10.0.84  # 使用 pip3 安装指定版本 OpenCV
conda install -y -c conda-forge ffmpeg
conda uninstall numpy
pip3 install numpy==1.26.0  # 该版本需与 torchvision 兼容

7. Pytorch und Torchvision prüfen

Da pip beim Installieren der lerobot-Umgebung das vorhandene Pytorch/Torchvision entfernt und CPU-Versionen installiert, muss in Python geprüft werden:

import torch
print(torch.cuda.is_available())

Bei False: Pytorch und Torchvision gemäß offiziellem Tutorial neu installieren.

Jetson-Orin-Pytorch-Inkompatibilität

8. Intel-RealSense-Tiefenkamera-SDK installieren (falls vorhanden)

Für die RealSense-Kamera unter lerobot/src/lerobot/ pyrealsense2 installieren:

pip install pyrealsense2

C. Roboterarm-Steuerung

Port-Berechtigung

Stromkabel anschließen: schwarzer Führungsarm mit 5V/6A-Netzteil, weißer Folgearm mit 12V/5A; Servo-Treiberplatine per Datenkabel mit dem Host verbinden.

Zuerst in das Verzeichnis lerobot/src/lerobot/ wechseln:

cd ~/lerobot/src/lerobot/

Dann die conda-Umgebung aktivieren (bei jedem Terminar nötig!):

conda activate lerobot

1. Skript zum Finden des Ports ausführen

Um den richtigen USB-Port jedes Armes zu finden, das Utility-Skript zweimal ausführen:

lerobot-find-port

2. Beispielausgabe

Beim Erkennen des Leader-Arms (z. B. /dev/tty.usbmodem575E0031751 auf dem Mac bzw. /dev/ttyACM0 unter Linux):

Finding all available ports for the MotorBus.
['/dev/ttyACM0', '/dev/ttyACM1']
Remove the usb cable from your MotorsBus and press Enter when done.
[...Disconnect corresponding leader or follower arm and press Enter...]
The port of this MotorsBus is /dev/ttyACM1
Reconnect the USB cable.

Beim Erkennen des Follower-Arms (z. B. /dev/tty.usbmodem575E0032081 bzw. /dev/ttyACM1 unter Linux):

Finding all available ports for the MotorBus.
['/dev/ttyACM0', '/dev/ttyACM1']
Remove the usb cable from your MotorsBus and press Enter when done.
[...Disconnect corresponding leader or follower arm and press Enter...]
The port of this MotorsBus is /dev/ttyACM0
Reconnect the USB cable.

Denken Sie daran, den USB-Stecker zu ziehen, sonst wird der Anschluss nicht erkannt.

3. Fehlerbehebung

Unter Linux Zugriff auf den USB-Port gewähren:

sudo chmod 666 /dev/ttyACM0

sudo chmod 666 /dev/ttyACM1

Roboterarm kalibrieren

Schließen Sie nun Strom und Datenkabel an und kalibrieren Sie, damit Leader- und Follower-Arm bei gleicher physischer Position übereinstimmen. Diese Kalibrierung ist entscheidend, damit ein auf einem SO-10x trainiertes neuronales Netz auch auf einem anderen funktioniert. Bei erneuter Kalibrierung die Dateien unter ~/.cache/huggingface/lerobot/calibration/robots bzw. ~/.cache/huggingface/lerobot/calibration/teleoperators vollständig löschen, sonst kommt es zu Fehlern. Die kalibrierten Daten liegen als json in diesem Verzeichnis.

1. Manuelle Kalibrierung des Follower-Arms

Die 6 Roboterservos über 3-Pin-Anschlüsse verbinden, Chassis-Servos an die Treiberplatine anschließen und zur Kalibrierung folgenden Befehl bzw. das API-Beispiel ausführen:

Bei PC (Linux) und Jetson: das erste USB-Gerät wird zu ttyACM0, das zweite zu ttyACM1.

Vor der Ausführung auf die Leader-/Follower-Zuordnung achten.

2. Schnittstellen-Berechtigung

Zuerst die Schnittstelle freigeben:

sudo chmod 666 /dev/ttyACM*

3. Dann den Follower-Arm kalibrieren

Folgenden Python-Befehl ausführen:

lerobot-calibrate \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_awesome_follower_arm

Zuerst den Roboter so positionieren, dass alle Gelenke in der Mitte des Bewegungsbereichs stehen, und stillhalten. Nach dem Drücken von Enter jeden Gelenkwinkel über den gesamten Bereich bewegen. Die Kalibrierdatei speichert Mittel-, Max- und Min-Werte im json unter ~/.cache/huggingface/lerobot/calibration/robots oder ~/.cache/huggingface/lerobot/calibration/teleoperators.

4. Leader-Arm kalibrieren

Wie oben – folgenden Befehl ausführen:

lerobot-calibrate \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM1 \
    --teleop.id=my_awesome_leader_arm

[Roboterarm-Mittenkalibrierung.mp4]

Teleoperation

**1. Einfache Teleoperation

Jetzt können Sie fernsteuern! Dieses einfache Skript ausführen (ohne Kamerabild):

Die mit dem Roboter verknüpfte **ID dient zum Speichern der Kalibrierdatei. Bei Teleoperation, Aufnahme und Evaluation mit derselben Konfiguration unbedingt dieselbe ** verwenden.

Zuerst Serienport freigeben:

sudo chmod 666 /dev/ttyACM*

Teleoperation starten:

lerobot-teleoperate \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_awesome_follower_arm \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM1 \
    --teleop.id=my_awesome_leader_arm

Der Befehl führt automatisch aus:

1. Fehlende Kalibrierdateien erkennen und Kalibrierung starten.
2. Roboter und Fernbedienung verbinden und Teleoperation starten.

2. Teleoperation mit Kamerabild

Für die Kamera wird ein Kamera-Identifier benötigt; dieser kann je nach OS bei Neustart oder Neuanschluss wechseln.

Den Kamera-Index der angeschlossenen Kamera finden:

lerobot-find-cameras realsense # or realsense for Intel Realsense cameras

Das Terminal zeigt die Kamerainformationen.

Unter ~/lerobot/outputs/captured_images liegen die Bilder jeder Kamera.

Auf macOS mit Intel-RealSense kann "Error finding RealSense cameras: failed to set power state" auftreten – durch sudo beheben. RealSense auf macOS ist instabil.

So zeigen Sie das Kamerabild während der Teleoperation an – nützlich zur Vorbereitung vor der ersten Aufnahme:

lerobot-teleoperate \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_awesome_follower_arm \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM1 \
    --teleop.id=my_awesome_leader_arm \
    --display_data=true

fourcc: "MJPG" liefert komprimierte Bilder; höhere Auflösung ist möglich. YUYV ist auch möglich, senkt aber Auflösung/FPS und lässt den Arm ruckeln. Aktuell unterstützt MJPG 3 Kameras mit 1920*1080 bei 30FPS; trotzdem: 2 Kameras desselben USB-HUBs nicht empfohlen.

Weitere Kameras über --robot.cameras hinzufügen. index_or_path richtet sich nach der letzten Ziffer der ID aus python -m lerobot.find_cameras opencv.

Beispiel für eine zusätzliche Kamera:

lerobot-teleoperate \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_awesome_follower_arm \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"}, side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM1 \
    --teleop.id=my_awesome_leader_arm \
    --display_data=true

Für die RealSense-Tiefenkamera zuerst python -m lerobot.find_cameras realsense ausführen, serial_number_or_name: "323622271780" durch die eigene ID ersetzen und use_depth: true setzen:

lerobot-teleoperate \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_awesome_follower_arm \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"}, side: {type: intelrealsense, serial_number_or_name: "323622271780", width: 1280, height: 720, fps: 30, use_depth: true}}" \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM1 \
    --teleop.id=my_awesome_leader_arm \
    --display_data=true

D. Datenerfassung

Datensatz aufnehmen

• Für lokale Speicherung direkt ausführen:

lerobot-record \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_awesome_follower_arm \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"}, side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM1 \
    --teleop.id=my_awesome_leader_arm \
    --display_data=true \
    --dataset.repo_id=juxi/test \
    --dataset.num_episodes=5 \
    --dataset.single_task="Put the blue cube on the black box" \
    --dataset.push_to_hub=false \
    --dataset.episode_time_s=30 \
    --dataset.reset_time_s=30

dateset.repo_id und dataset.single_task sind frei wählbar. Bei push_to_hub=false wird unter ~/.cache/huggingface/lerobot der Ordner juxi/test angelegt. Bei RealSense-Tiefenkamera den Befehl anpassen

• Für den Upload über den Hugging-Face-Hub ggf. mit Schreibrechte-Token anmelden (Erstellung unter Hugging Face Settings):

hf auth login

Repositoriennamen in einer Variable speichern:

hf auth whoami

5 Episoden aufzeichnen und zum Hub hochladen:

lerobot-record \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_awesome_follower_arm \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"}, side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM1 \
    --teleop.id=my_awesome_leader_arm \
    --display_data=true \
    --dataset.repo_id=${HF_USER}/record-test \
    --dataset.num_episodes=5 \
    --dataset.single_task="Put the blue cube on the black box" \
    --dataset.push_to_hub=true \
    --dataset.episode_time_s=30 \
    --dataset.reset_time_s=30

Ausgabe sieht etwa so aus:

INFO 2024-08-10 15:02:58 ol_robot.py:219 dt:33.34 (30.0hz) dtRlead: 5.06 (197.5hz) dtWfoll: 0.25 (3963.7hz) dtRfoll: 6.22 (160.7hz) dtRlaptop: 32.57 (30.7hz) dtRphone: 33.84 (29.5hz)

Parameter-Erklärung

• episode_time_s: Aufnahmedauer pro Episode.
• reset_time_s: Vorbereitungszeit zwischen den Episoden.
• num_episodes: Anzahl der Datensätze.
• push_to_hub: ob zum HuggingFace-Hub hochgeladen wird.

Taste	Aktion
Pfeil rechts →	aktuelle Episode beenden/zurücksetzen; zur nächsten.
Pfeil links ←	aktuelle Episode abbrechen; neu aufnehmen.
ESC	Session sofort beenden, Video kodieren und Datensatz hochladen.

Techniken der Datenerfassung

• Aufgabenvorschlag: Objekte an verschiedenen Positionen greifen und in die Box legen.
• Umfang: Mindestens 50 Episoden aufnehmen (10 Episoden pro Position).
• Konsistenz:
  • Die Kamera fest positioniert lassen.
  • Immer dasselbe Greifverhalten beibehalten.
  • Sicherstellen, dass das manipulierte Objekt im Kamerabild sichtbar ist.
• Schrittweise steigern:
  • Mit zuverlässigen Griffen beginnen, dann Variationen ergänzen (neue Positionen, Greiftechniken, Kameraanpassungen).
  • Komplexität nicht abrupt erhöhen, um Fehlschläge zu vermeiden.

💡 Faustregel: Nur das Kamerabild als Orientierung nutzen und den Roboterarm ausschließlich anhand der auf dem Bildschirm zurückgemeldeten Videobilder steuern, um die Aufgaben zu erledigen.

Wenn Sie tiefer in dieses wichtige Thema eintauchen möchten, lesen Sie unseren Blogbeitrag darüber, was einen guten Datensatz ausmacht.

• In den folgenden Kapiteln trainieren Sie Ihr neuronales Netz. Nachdem Sie zuverlässige Greifleistungen erreicht haben, können Sie während der Datenerfassung weitere Variationen einführen, z. B. zusätzliche Greifpositionen, andere Greiftechniken und veränderte Kamerapositionen.
• Vermeiden Sie zu viele Änderungen zu schnell, da dies Ihre Ergebnisse beeinträchtigen kann.
• Während der Aufzeichnung einer Episode kann jederzeit mit der rechten Pfeiltaste → vorzeitig gestoppt und in den Reset-Zustand gewechselt werden. Ebenso kann der Reset-Prozess vorzeitig beendet und mit der nächsten Aufzeichnung begonnen werden.
• Beim Aufnehmen oder Zurücksetzen kann jederzeit die linke Pfeiltaste ← gedrückt werden, um die aktuelle Episode vorzeitig zu beenden und neu aufzunehmen.
• Während der Aufzeichnung kann jederzeit ESCAPE (ESC) gedrückt werden, um die Session vorzeitig zu beenden und direkt zur Videokodierung und zum Hochladen des Datensatzes überzugehen.
• Die Aufzeichnung kann fortgesetzt werden, indem derselbe Befehl erneut ausgeführt und --resume=true hinzugefügt wird. ⚠️ Wichtiger Hinweis: Beim Fortsetzen --dataset.num_episodes auf die Anzahl der zusätzlich aufzuzeichnenden Episoden setzen (nicht auf die Gesamtzahl der Ziel-Episoden im Datensatz). Wenn die Aufzeichnung von Grund auf neu gestartet werden soll, das Datensatzverzeichnis manuell löschen.
• Falls die Pfeiltasten und die Esc-Taste unter Linux während der Datenaufzeichnung keine Wirkung zeigen, stellen Sie sicher, dass die Umgebungsvariable $DISPLAY gesetzt ist. Siehe pynput-Einschränkungen.

Falls Ihre Tastatur nach einem Tastendruck nicht reagiert, müssen Sie möglicherweise die pynput-Version herunterstufen, z. B. Version 1.6.8 installieren.

pip install pynput==1.6.8

Datensatz visualisieren

Hochgeladene Datensätze online visualisieren – die mit folgendem Befehl erzeugte Repo-ID kopieren und einfügen:

python lerobot/scripts/visualize_dataset_html.py \
  --repo-id ${HF_USER}/so101_test \
  --local-files-only 1

Ohne Upload auch lokal:

lerobot-dataset-viz \
  --repo-id ${HF_USER}/so101_test

juxi ist der bei der Erfassung verwendete eigene repo_id.

Episode abspielen (überspringbar, optional)

Eine Episode aus dem Datensatz abspielen:

lerobot-record \
  --robot.type=so101_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.id=my_awesome_follower_arm \
  --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"}, side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
  --dataset.repo_id=${HF_USER}/so101_test \
  --dataset.single_task="Put the blue cube on the black box" \
  --dataset.num_episodes=1 \
  --dataset.episode_time_s=30 \
  --dataset.reset_time_s=30 \
  --dataset.push_to_hub=true \
  --replay=true

E. Training und Evaluation des Datensatzes

ACT

Offizielles Tutorial ACT

Training

lerobot-train \
  --dataset.repo_id=${HF_USER}/so101_test \
  --policy.type=act \
  --output_dir=outputs/train/act_so101_test \
  --job_name=act_so101_test \
  --policy.device=cuda \
  --wandb.enable=false \
  --steps=300000

Für lokale Datensätze: repo_id muss mit der Aufnahme übereinstimmen; zusätzlich --policy.push_to_hub=false setzen.

lerobot-train \
  --dataset.repo_id=juxi/test \
  --policy.type=act \
  --output_dir=outputs/train/act_so101_test \
  --job_name=act_so101_test \
  --policy.device=cuda \
  --wandb.enable=false \
  --policy.push_to_hub=false\
  --steps=300000

Erklärung

• Datensatz: über --dataset.repo_id=${HF_USER}/so101_test.
• Schritte: --steps=300000; Standard 800000 – je nach Aufgabe über die Loss-Kurve anpassen.
• Politik: policy.type=act; auch [act,diffusion,pi0,pi0fast,pi0.5,sac,smolvla] möglich (lädt aus configuration_act.py). Wichtig: passt sich automatisch an Motoren, Aktionen und Kameraanzahl Ihres Roboters an – alles im Datensatz gespeichert.
• Gerät: policy.device=cuda für Nvidia; policy.device=mps für Apple Silicon.
• Visualisierung: wandb.enable=true nutzt Weights and Biases; optional, aber dann wandb login nicht vergessen.

Bei folgendem Fehler:

Diesen Befehl ausführen:

pip install datasets==2.19

Das Training kann Stunden dauern. Die Gewichte liegen unter outputs/train/act_so101_test/checkpoints.

Training fortsetzen – Beispiel mit dem letzten Checkpoint:

lerobot-train \
  --config_path=outputs/train/act_so101_test/checkpoints/last/pretrained_model/train_config.json \
  --resume=true

Evaluation

Die record-Funktion aus lerobot/record.py mit der Policy als Eingabe nutzen – z. B. 10 Evaluations-Episoden:

lerobot-record \
  --robot.type=so101_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"},   side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30,fourcc: "MJPG"}}" \
  --robot.id=my_awesome_follower_arm \
  --teleop.type=so101_leader \
  --teleop.port=/dev/ttyACM1 \
  --teleop.id=my_awesome_leader_arm \
  --display_data=false \
  --dataset.repo_id=juxi/eval_test123 \
  --dataset.single_task="Put the blue cube on the black box" \
  --dataset.episode_time_s=30 \
  --dataset.reset_time_s=30 \
  --dataset.num_episodes=5 \
  --policy.path=outputs/train/act_so101_test/checkpoints/last/pretrained_model
  --dataset.push_to_hub=false

1. --policy.path zeigt auf die Gewichtedatei (z. B. outputs/train/act_so101_test/checkpoints/last/pretrained_model); auch Modell-Repo möglich (z. B. $\{HF_USER\}/act_so101_test).
2. Beginnt dataset.repo_id mit eval_, werden Video und Daten separat unter dem eval_-Ordner aufgenommen (z. B. juxi/eval_test123).
3. Bei File exists: 'home/xxxx/.cache/huggingface/lerobot/xxxxx/juxi/eval_xxxx' zuerst den eval_-Ordner löschen.
4. Bei mean is infinity. ... müssen die Schlüssel in --robot.cameras (front, side ...) exakt mit der Aufnahme übereinstimmen.

Smolvla

Offizielles Tutorial SmolVLA

pip install -e ".[smolvla]"

Training

lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --dataset.repo_id=${HF_USER}/mydataset \
  --batch_size=64 \
  --steps=20000 \
  --output_dir=outputs/train/my_smolvla \
  --job_name=my_smolvla_training \
  --policy.device=cuda \
  --wandb.enable=true

Evaluation

lerobot-record \
  --robot.type=so101_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.id=my_awesome_follower_arm \ # <- Use your robot id
  --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"},   side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30,fourcc: "MJPG"}}" \
  --dataset.single_task="Put the blue cube on the black box" \
  --dataset.repo_id=juxi/eval_test123 \
  --dataset.episode_time_s=30 \
  --dataset.reset_time_s=30 \
  --dataset.num_episodes=5 \
  # <- Teleop optional if you want to teleoperate in between episodes \
  # --teleop.type=so101_leader \
  # --teleop.port=/dev/ttyACM0 \
  # --teleop.id=my_awesome_leader_arm \
  --policy.path=HF_USER/FINETUNE_MODEL_NAME # <- Use your fine-tuned model

Pi0

Offizielles Tutorial Pi0

pip install -e ".[pi]"

Training

lerobot-train \
  --policy.type=pi0 \
  --dataset.repo_id=juxi/eval_test123 \
  --job_name=pi0_training \
  --output_dir=outputs/pi0_training \
  --policy.pretrained_path=lerobot/pi0_base \
  --policy.compile_model=true \
  --policy.gradient_checkpointing=true \
  --policy.dtype=bfloat16 \
  --steps=20000 \
  --policy.device=cuda \
  --batch_size=32 \
  --wandb.enable=false

Evaluation

lerobot-record \
  --robot.type=so101_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"},   side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30,fourcc: "MJPG"}}" \
  --robot.id=my_awesome_follower_arm \
  --display_data=false \
  --dataset.repo_id=juxi/eval_test123 \
  --dataset.single_task="Put the blue cube on the black box" \
  --policy.path=outputs/pi0_training/checkpoints/last/pretrained_model

Pi0.5

Offizielles Tutorial Pi0.5

pip install -e ".[pi]"

Training

lerobot-train \
    --dataset.repo_id=juxi/eval_test123 \
    --policy.type=pi05 \
    --output_dir=outputs/pi05_training \
    --job_name=pi05_training \
    --policy.pretrained_path=lerobot/pi05_base \
    --policy.compile_model=true \
    --policy.gradient_checkpointing=true \
    --wandb.enable=false \
    --policy.dtype=bfloat16 \
    --steps=3000 \
    --policy.device=cuda \
    --batch_size=32

Evaluation

lerobot-record \
  --robot.type=so101_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"},   side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30,fourcc: "MJPG"}}" \
  --robot.id=my_awesome_follower_arm \
  --display_data=false \
  --dataset.repo_id=juxi/eval_test123 \
  --dataset.single_task="Put the blue cube on the black box" \
  --policy.path=outputs/pi05_training/checkpoints/last/pretrained_model

GR00T N1.5

Offizielles Tutorial GR00T

Training wie Pi0, Politiktyp gr00t.

F. Cloud-Training, Deployment und Modellexport

1. Auf „Rechenmarkt" klicken, passende GPU wählen – möglichst viele Kerne

2. „Abrechnung nach Nutzung" wählen, Basis-Image „Miniconda/conda3/3.8(ubuntu20.04)/11.8", dann „Sofort erstellen"

3. Auf „JupyterLab" klicken, Terminal öffnen

4. conda-Umgebung initialisieren

conda env list

conda activate base

conda init

5. Dieses Terminal schließen, neues öffnen

Siehe https://www.autodl.com/docs/network_turbo/

source /etc/network_turbo

6. lerobot-Umgebung erstellen

conda create -y -n lerobot python=3.10

conda activate lerobot

git clone https://github.com/Juxi-Technology/lerobot.git

Alternativ: https://github.com/huggingface/lerobot.git – Befehle der neuesten Version können abweichen!

conda install ffmpeg -c conda-forge

7. Ins lerobot-Verzeichnis wechseln, LeRobot mit feetech installieren:

cd ~/lerobot && pip install -e ".[feetech]"

8. Datensatz auf den Cloud-Server importieren

Zwei Fälle: Datensatz wurde bei der Erfassung bereits in die Huggingface-Datenbank hochgeladen bzw. nicht.

① Bereits hochgeladen: über den per Huggingface-Key erhaltenen Zugriff

huggingface-cli login --token ${HUGGINGFACE_TOKEN} --add-to-git-credential

HF_USER=$(huggingface-cli whoami | head -n 1)

echo $HF_USER

export HYDRA_FULL_ERROR=1

② Lokalen Datensatz per FileZilla hochladen: siehe https://www.autodl.com/docs/filezilla/

Einfachste Installation unter Linux:

sudo apt install filezilla

filezilla

FileZilla öffnen, „Datei" → „Standortmanager", „Neuer Standort", „SFTP-Protokoll" wählen

Zurück zu AutoDL: „Anmeldebefehl" kopieren, Informationen einfügen und „Verbinden" klicken

Im lerobot-Verzeichnis des Servers den Ordner data anlegen

Datensatz-Ordner nach rechts ziehen und auf Übertragung warten

9. Datensatz-Training

Siehe [E. Datensatz-Training und -Evaluation] dieses Tutorials, Trainingsbefehl im Cloud-Server ausführen

10. Modellexport

Nach dem Training das trainierte Modell im entsprechenden train-Verzeichnis exportieren

G. Häufige Fragen

Bei diesem Tutorial bitte das empfohlene Repository https://github.com/Juxi-Technology/lerobot.git klonen.

Das empfohlene Repository ist die geprüfte stabile Version; das offizielle Lerobot-Repo wird laufend aktualisiert und kann unerwartete Probleme verursachen (andersartige Dataset-Versionen, andere Befehle).

• Bei RealSense-Tiefenkamera die Befehle entsprechend anpassen
• Auf Jetson: läuft die Evaluation ohne Episoden-/Zeitangabe und wird mit ctrl+z abgebrochen, verlieren Arm und Kamera die Verbindung; nach dem Neuverbinden ändern sich alle Ports.

Episodenzahl und -dauer im Befehl angeben, z. B.:

lerobot-record \
  --robot.type=so101_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"},   side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30,fourcc: "MJPG"}}" \
  --robot.id=my_awesome_follower_arm \
  --teleop.type=so101_leader \
  --teleop.port=/dev/ttyACM1 \
  --teleop.id=my_awesome_leader_arm \
  --display_data=false \
  --dataset.repo_id=juxi/eval_test123 \
  --dataset.single_task="Put the blue cube on the black box" \
  --dataset.episode_time_s=30 \
  --dataset.reset_time_s=30 \
  --dataset.num_episodes=5 \
  --policy.path=outputs/train/act_so101_test/checkpoints/last/pretrained_model
  --dataset.push_to_hub=false

• Bei der Servo-ID-Kalibrierung:

`Motor 'gripper' was not found, Make sure it is connected`

Kabelverbindung zum Servo und Versorgungsspannung sorgfältig prüfen.

• Bei:

Could not connect on port "/dev/ttyACM0"

Existiert /dev/ttyACM0 (ls /dev/ttyACM*), aber keine Verbindung, fehlt die Port-Freigabe: sudo chmod 666 /dev/ttyACM*.

• Bei:

No valid stream found in input file. Is -1 of the desired media type?

ffmpeg 7.1.1 installieren: conda install ffmpeg=7.1.1 -c conda-forge.

• Bei:

ConnectionError: Failed to sync read 'Present_Position' on ids=[1,2,3,4,5,6] after 1 tries. [TxRxResult] There is no status packet!

Prüfen, ob der Arm am angegebenen Port mit Strom versorgt wird und ob ein Bus-Servo-Kabel locker ist. Das Servo mit dunkler LED zeigt das lockere Kabel davor.

• Bei der Kalibrierung:

Magnitude 30841 exceeds 2047 (max for sign_bit_index=11)

Arm aus- und wieder einschalten, erneut kalibrieren. Hilft auch bei MAX-Winkel im Zehntausender-Bereich. Sonst Servo neu kalibrieren (Mittenkalibrierung + ID schreiben).

• Bei der Evaluation:

File exists: 'home/xxxx/.cache/huggingface/lerobot/xxxxx/juxi/eval_xxxx'

Den eval_-Ordner löschen und erneut starten.

• Bei der Evaluation:

`mean` is infinity. You should either initialize with `stats` as an argument or use a pretrained model

Die Schlüssel (front, side ...) in --robot.cameras müssen exakt mit der Aufnahme übereinstimmen.

Servo unter Windows finden (Feetech-Servo-Hostsoftware)

Zum Debuggen kann jeder Windows-PC den Servo per USB programmieren, debuggen oder testen. Dazu die Feetech-Software herunterladen. Für Ubuntu-Systeme kann das FT_SCServo_Debug_Qt-Tool verwendet werden.

[fddebug-master.zip]

Portnummer auswählen, Baudrate auf 1000000 setzen, öffnen und „Search" klicken

ROS2-Simulationssteuerung (kann unabhängig umgesetzt werden)

https://github.com/holmsslk/so-arm-moveit-hardware

Servo-ID und Mittelkalibrierung im Web einstellen

https://bambot.org/feetech.js?lang=zh

1. Je nach Servomodell 0 oder 1 eingeben, dann „Connect" klicken.

2. Die Servos mit den IDs 1 bis 6 scannen; die zugehörige ID lässt sich anhand von FOUND im Scanergebnis bestätigen. Beispiel: Servo-ID 1 im Bild wurde gescannt.

3. ID-Einstellung und Mittelkalibrierung

① Die aktuelle Servo-ID-Eingabe ist die ID des gescannten Servos

② In „ID-Verwaltung" eine Zahl eingeben und „Change ID" klicken, um die ID zu setzen

③ Mittelkalibrierung (Mittelwert des STS3215-Servos ist 2047, der des SCS0009-Servos ist 511)

STS-Servo: 2047 in „Position Control" eingeben und „Set" klicken

SCS-Servo: 511 in „Position Control" eingeben und „Set" klicken.

Verwandte Produkte

SO-ARM101 Entwickler-Kit→SO-ARM101-Robotervisions-Kit→SO-ARM101 TPU-Flex-Greifer→