LeRobot ベース reBot Arm B601-RS 入門

6 自由度ロボットアーム · 複数モータ対応 · 運動学ソルバ · 軌道計画 · 完全オープンソース

今すぐ入手 🖱️

reBot Arm B601-RS は Seeed が立ち上げたオープンソースロボットアームプロジェクトで、エンボディドインテリジェンス学習のハードルを下げることを目的としています。構造設計とコードを余すところなくオープンソース化し、ロボット技術を誰もが利用できるようにしています。

LeRobot は、PyTorch 上で実世界ロボティクス向けのモデル、データセット、ツールを提供することに取り組んでいます。その目的はロボティクスの参入障壁を下げ、誰もがデータセットや事前学習モデルを共有し、貢献し、恩恵を受けられるようにすることです。LeRobot は、模倣学習と強化学習を中心に、実世界で検証された最先端の手法を統合しています。人間によるデモンストレーションを含むデータセット、事前学習済みモデル群、シミュレーション環境を提供しており、ユーザーはロボットを組み立てることなくすぐに始めることができます。

📖 プロジェクト概要

reBot-DevArm（reBot Arm B601 DM および reBot Arm B601 RS） は、エンボディドインテリジェンス学習のハードルを下げることを目的としたロボットアームプロジェクトです。私たちは 「真のオープンソース」 に注力しており、コードだけでなく、以下のすべてを余すところなく公開しています：

• 🦾 2 種類のモータバージョンを備えたオープンソースロボットアーム：同一外観で RoboStride モータ版と Damiao モータ版のすべてのオープンソースファイルを提供します。
• 🛠️ ハードウェア設計図：板金および 3D プリント部品のソースファイル。
• 🔩 BOM（部品表）：すべてのネジ 1 本ごとの仕様と購入リンクまで詳細に記載。
• 💻 ソフトウェアとアルゴリズム：Python SDK、ROS1/2、Isaac Sim、LeRobot など。

reBot ロボットアームの構築

• 5 種類のキットオプションを提供しています：
  • ロボットアーム本体モータキット：ロボットアームに必要なモータとハーネスのみを含みます。
  • ロボットアーム本体構造部品キット：機械的な構造部品のみを含みます。
  • グリッパーコンプリートキット：グリッパー用のモータ、ハーネス、構造部品を含みます。
  • コンプリートアームキット：ロボットアーム本体とグリッパーのすべての部品を含みます。
  • 完成組立済みロボットアーム：完全に組み立て済みのロボットアームです。

reBot-DevArm と reComputer Jetson AI インテリジェントロボットキットは、高精度なロボットアーム制御と強力な AI コンピューティングプラットフォームをシームレスに統合し、包括的なロボット開発ソリューションを提供します。このキットは Jetson Orin または AGX Orin プラットフォームをベースに、reBot-DevArm と LeRobot AI フレームワークを組み合わせることで、教育、研究、産業オートメーションなど複数のシナリオに適用可能なインテリジェントロボットシステムをユーザーに提供します。

この Wiki では、reBot-DevArm のデバッグチュートリアルを提供し、LeRobot フレームワーク内でのデータ収集と学習を実装します。

注意

Seeed Studio のチュートリアルは、公式ドキュメントに基づいて厳密に更新されています。解決できないソフトウェアや環境の問題に遭遇した場合は、まず記事末尾の FAQ を確認するか、カスタマーサービスに連絡して SeeedStudio LeRobot 議論グループに参加してください。こちらでも質問できます：LeRobot GitHub または Discord Channel。

🔧 reBot B601-RS シリーズの特長

1. オープンソース & 低コスト reBot Arm は Seeed Studio によるオープンソースかつ低コストのロボットアームソリューションで、エンボディドインテリジェンス学習のハードルを下げることを目的としています。

2. LeRobot プラットフォームとの統合 LeRobot プラットフォーム との統合を前提に設計されています。このプラットフォームは、実ロボットタスクの模倣学習向けに、PyTorch モデル、データセット、ツール（データ収集、シミュレーション、学習、デプロイを含む）を提供します。

3. 豊富な学習リソース 組立およびキャリブレーションガイド、テストとデータ収集チュートリアル、学習とデプロイのドキュメントなど、包括的なオープンソース学習リソースを提供し、ユーザーが素早く入門してロボットアプリケーションを開発できるよう支援します。

4. Nvidia プラットフォーム互換 reComputer Mini J4012 Orin NX 16GB プラットフォームによるデプロイをサポートします。

初期システム環境

Ubuntu x86 の場合：

• Ubuntu 22.04
• CUDA 12 以上
• Python 3.10
• Torch 2.6

Jetson Orin の場合：

• Jetson JetPack 6.0 および 6.1（6.2 は非対応）
• Python 3.10
• Torch 2.3 以上

LeRobot のインストール

CUDA バージョンに応じて、pytorch、torchvision などの環境をインストールする必要があります。

1. Miniforge のインストール

cd ~
wget "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
bash Miniforge3-$(uname)-$(uname -m).sh

~/miniforge3/bin/conda init bash
source ~/.bashrc

2. Lerobot リポジトリのクローン

mkdir ~/rebot_lerobot
cd ~/rebot_lerobot
git clone https://github.com/Seeed-Projects/lerobot.git

3. Conda 環境の作成と LeRobot のインストール

ヒント

各機能パッケージの詳細な機能については、以下を参照してください：

• lerobot-teleoperator-rebot-arm-102
• lerobot-robot-seeed-b601

lerobot リポジトリにはすでに pyproject.toml が含まれています。conda 環境を作成し、すべての依存関係をインストールします。

cd ~/rebot_lerobot

# Create conda environment (Python 3.10)
conda create -y -n lerobot python=3.10

# Activate environment
conda activate lerobot

# Install lerobot main project (editable mode)
pip install -e ./lerobot

# Add dependency packages
pip install lerobot-teleoperator-rebot-arm-102
pip install lerobot-robot-seeed-b601
pip install motorbridge

4. ffmpeg のインストール

ffmpeg は動画デコード用の依存パッケージです。conda 経由でインストールします：

conda install ffmpeg -c conda-forge

ヒント

バージョンに関する注意：

• デフォルトでは ffmpeg 7.X がインストールされます（libsvtav1 エンコーダをサポート）
• バージョン互換性の問題が発生した場合は、ffmpeg 7.1.1 を指定できます：

  conda install ffmpeg=7.1.1 -c conda-forge

• ffmpeg -encoders | grep svtav1 によって libsvtav1 エンコーダがサポートされているか確認できます

5. Jetson JetPack 6.0+ デバイス向け特別設定

（PC の場合はこのステップをスキップ）Jetson JetPack 6.0+ デバイス向け（このステップを実行する前に、このチュートリアル のステップ 5 に従って Pytorch-gpu と Torchvision をインストールしていることを確認してください）：

conda install -y -c conda-forge "opencv>=4.10.0.84"  # Install OpenCV and other dependencies via conda, for Jetson Jetpack 6.0+ only
conda remove opencv   # Uninstall OpenCV
pip3 install opencv-python==4.10.0.84  # Install specific OpenCV version using pip3
conda install -y -c conda-forge ffmpeg
conda uninstall numpy
pip3 install numpy==1.26.0  # This version must be compatible with torchvision

6. Pytorch と Torchvision の確認

ヒント

Jetson デバイスを使用している場合は、このチュートリアル に従って Pytorch と Torchvision をインストールしてください。

pip で lerobot 環境をインストールすると、元の Pytorch と Torchvision がアンインストールされ、CPU 版がインストールされるため、Python で確認を行う必要があります。

python3

import torch
print(torch.cuda.is_available())#Should output True

出力が True の場合は、exit() と入力して Python を終了し、次のステップに進むことができます。 出力が False の場合は、公式チュートリアル に従って Pytorch と Torchvision を再インストールする必要があります。

ロボットアームのキャリブレーション

次に、リーダーアームとフォロワーアームが同じ物理位置にあるときに同じ位置値を持つようにキャリブレーションするため、reBot B601-RS ロボットに電源とデータケーブルを接続する必要があります。このキャリブレーションは、ある reBot B601-RS ロボットで学習したニューラルネットワークを別のロボットでも動作させるために不可欠です。ロボットアームを再キャリブレーションする必要がある場合は、~/.cache/huggingface/lerobot/calibration/robots または ~/.cache/huggingface/lerobot/calibration/teleoperators 配下のファイルを完全に削除してから、ロボットアームを再キャリブレーションしてください。そうしないと、エラープロンプトが表示されます。ロボットアームのキャリブレーション情報は、このディレクトリ配下の JSON ファイルに保存されます。

フォロワーアームのキャリブレーション

ヒント

フォロワーに接続できない場合は、Getting Started の Wiki に移動し、motorbridge が提供するインターフェースを使用してロボットアームが正常に動作しているかテストしてみてください。

B601-RS は組み立て後に 1 回だけキャリブレーションすれば十分です。以下がキャリブレーションコマンドです。ゼロ位置（グリッパーを完全に閉じた状態）については図を参照してください。

# follower
sudo ip link set can0 down 2>/dev/null
sudo ip link set can0 type can bitrate 1000000
sudo ip link set can0 up

lerobot-calibrate \
    --robot.type=seeed_b601_rs_follower \
    --robot.port=can0 \
    --robot.id=follower1 \
    --robot.can_adapter=socketcan

Jetson（Jetpack 6.x）を使用する場合は、以下の手順で Jetson に対応する CAN ポート番号を確認してください。

for i in /sys/class/net/can*; do
    [ "$(basename "$(readlink -f "$i/device/driver" 2>/dev/null)")" = "pcan" ] && basename "$i"
done

出力:

cam2  # also maybe can0,can1,can x

以降のすべてのフォロワー用コマンドのポート番号は、ここで得られた出力と一致している必要があります。

Jetson に PCAN ドライバがない場合、通信は常に失敗します。Quick Start セクションの Jetson PCAN ドライバインストールガイドを参照してください。

リーダーアームのキャリブレーション

キャリブレーション手順は非常に重要であり、ロボットアームが正常に動作するかどうかに直接影響します。必ず手順に厳密に従ってください。

rebot 102 leader

ヒント

reBot 102 leader キャリブレーション注意事項:

• キャリブレーション開始時、reBot Arm 102 上の各サーボの現在位置はゼロにリセットされます
• joint_ranges（関節リミット）はキャリブレーションデータではなく、設定ファイル config_rebot_arm_102_leader.py から取得されます
• ある関節が常にリミット付近で引っかかっているように見える場合は、まず joint_ranges の設定を確認してください
• 関節の回転方向は設定ファイルで定義されています。方向が合わない場合は、再キャリブレーションではなく設定ファイルを修正してください
• reBot 102 leader は USB-UART モジュールを使用しており、通常は /dev/ttyUSB* にマッピングされます
• 実際のポート番号は ls /dev/ttyUSB* で確認してください

初回接続時には、/dev/ttyACM0 が見つからないというエラーが出る場合があります。これは brltty がシリアルポートを占有しているためです。以下の手順を実行してください。

sudo dmesg | grep ttyUSB #Check the last line shows "disconnected"
sudo apt remove brltty #Remove brltty

プロンプトに従い、上図に示すゼロ位置までリーダーアームを動かします。

sudo chmod 666 /dev/ttyUSB0

lerobot-calibrate \
    --teleop.type=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader

そのまま静止させ、キャリブレーションが完了するまで Enter キーを押し続けてください。 キャリブレーション後、次のコマンドを入力してリーダーアームをテストします。

python ./lerobot-teleoperator-rebot-arm-102/examples/read_raw_angles.py \
      --port /dev/ttyUSB0

#If you observe terminal output similar to the following printing continuously, and when at the zero position shown above, all joint output values are 0, then leader calibration is complete.
#shoulder_pan=    0.00  shoulder_lift=    0.00  elbow_flex=    0.00  wrist_flex=    0.00  wrist_yaw=    0.00  wrist_roll=    0.00  gripper=    0.00

テレオペレーション

危険

すべてのロボットアームの動作シーンにおいて、同じレベルの注意が必要です！

テレオペレーション中に、マスタースレーブロボットアームで電源断、電源接触不良、信号線の脱落などが発生した場合は、まずプログラムコードを停止し、ロボットアームをホームのゼロ位置に戻す必要があります。その後で電源を再接続し、プログラムを再起動してください。これにより、データの乱れによるロボットアームの暴走や潜在的な安全上の危険を防ぐことができます。

まずシリアルポートに権限を付与します：

# leader
sudo chmod 666 /dev/ttyUSB*
# follower
sudo ip link set can0 down 2>/dev/null
sudo ip link set can0 type can bitrate 1000000
sudo ip link set can0 up

テレオペレーションを実行します：

lerobot-teleoperate \
    --robot.type=seeed_b601_rs_follower \
    --robot.port=can0 \
    --robot.id=follower1 \
    --robot.can_adapter=socketcan \
    --teleop.type=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader

カメラを追加する

RealSense D435i/D405 を使用する場合

RealSense 深度カメラは LeRobot に RGB-D 認識機能を提供でき、物体認識、点群再構成、テーブルトップマニピュレーションなどのタスクに適しています。ここで推奨するモデルは RealSense D405 と RealSense D435i です。

RealSense D405

RealSense D405 は短距離ステレオ深度カメラであり、テーブルトップロボットマニピュレーションなどの高精度な近距離タスク向けに設計されており、一般的な動作範囲は 7 cm ～ 50 cm です。

RealSense D435i

RealSense D435i は深度センシング、RGB 画像、および IMU を組み合わせており、3D 再構成、SLAM、ロボットによる環境認識などの中距離から近距離のアプリケーションに適しています。

1. カメラ用ブランチに切り替える

現在のカメラサポートは DepthCameraSupport ブランチで提供されています：

git checkout DepthCameraSupport
git pull origin DepthCameraSupport

現在のブランチを確認します：

git branch --show-current

期待される出力：

DepthCameraSupport

2. RealSense をインストールする：

RealSense のみを使用する場合：

pip install -e ".[realsense]"

3. 権限を付与する

sudo chmod a+rw /dev/bus/usb/*/*

4. カメラを検出する

lerobot-find-cameras realsense

このステップでは以下が出力されます：

• カメラモデル
• シリアル番号
• USB 情報
• デフォルトのストリーム設定

5. RealSense の例

デュアル RealSense テスト：

lerobot-teleoperate \
    --robot.type=seeed_b601_rs_follower \
    --robot.port=can0 \
    --robot.id=follower1 \
    --robot.can_adapter=socketcan \
    --robot.cameras='{
    d435i_color: {
      type: realsense_d435i_color,
      serial_number_or_name: "419522072950",
      width: 640,
      height: 480,
      fps: 30,
      color_mode: rgb,
      color_stream_format: rgb8,
      rotation: 0,
      warmup_s: 1
    },
    d435i_depth: {
      type: realsense_d435i_depth,
      serial_number_or_name: "419522072950",
      width: 640,
      height: 480,
      fps: 30,
      max_depth_m: 2.0,
      depth_alpha: 0.2,
      rotation: 0,
      warmup_s: 5
    },
    d405_color: {
      type: realsense_d405_color,
      serial_number_or_name: "409122273421",
      width: 640,
      height: 480,
      fps: 30,
      color_mode: rgb,
      color_stream_format: rgb8,
      rotation: 0,
      warmup_s: 1
    },
    d405_depth: {
      type: realsense_d405_depth,
      serial_number_or_name: "409122273421",
      width: 640,
      height: 480,
      fps: 30,
      depth_alpha: 0.03,
      rotation: 0,
      warmup_s: 5
    }
  }' \
    --teleop.type=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader \
    --display_data=true

6. パラメータに関する注意事項

• depth_alpha は深度画像のスケーリング係数を制御し、表示結果や対象距離範囲に応じて調整できます。
• 3 台以上の深度カメラを接続する場合は、全体の安定性を高めるために fps を 15 に下げることを推奨します。
• 安定性とリアルタイム性のバランスを取るため、解像度は 640x480 に保つことを推奨します。

Orbbec Gemini2 Depth Camera を使用する場合

今すぐ入手 🖱️

正確な深度からカラーへのアライメントを備えた同期RGBおよび深度ストリームを提供します。ステレオ深度センシングと内蔵6軸IMUを組み合わせることで、物体検出、3D認識、マッピング、ナビゲーションなどのロボットタスクに非常に適しています。コンパクトな設計と完全な Orbbec SDK サポートにより、研究用途と実運用の両方に適用できます。

Gemini 336 は Gemini 330 シリーズの新しいメンバーです。Gemini 335 の優れた深度性能を受け継ぎつつ、反射の多い屋内エリア、高ダイナミックシーンの暗部、明るい屋外環境における深度画像品質をさらに向上させています。ロボットアプリケーション向けには、認識、自己位置推定、マニピュレーションなどのタスクに対して、より安定した高品質な深度データを提供できます。

• 🚀 ステップ 1: Orbbec SDK の依存関係をインストールする

1. カメラ用ブランチに切り替える

現在のカメラサポートは DepthCameraSupport ブランチで利用できます：

git checkout DepthCameraSupport
git pull origin DepthCameraSupport

現在のブランチを確認します：

git branch --show-current

期待される出力：

DepthCameraSupport

2. Orbbec をインストールする

pip install -e ".[orbbec]"

3. 権限を付与する

sudo chmod a+rw /dev/bus/usb/*/*

4. カメラを検出する

lerobot-find-cameras orbbec

このステップでは次の情報が出力されます：

• カメラモデル
• シリアル番号
• USB 情報
• デフォルトのストリーム構成

5. Orbbec のサンプル

単一 Orbbec テスト：

lerobot-teleoperate \
    --robot.type=seeed_b601_rs_follower \
    --robot.port=can0 \
    --robot.id=follower1 \
    --robot.can_adapter=socketcan \
    --robot.cameras="{
    orbbec_color: {
      type: orbbec_color,
      serial_number_or_name: "CP9JA530003A",
      width: 640,
      height: 480,
      fps: 30,
      color_mode: rgb,
      rotation: 0,
      warmup_s: 1
    },
    orbbec_depth: {
      type: orbbec_depth,
      serial_number_or_name: "CP9JA530003A",
      width: 640,
      height: 400,
      fps: 30,
      depth_alpha: 0.2,
      rotation: 0,
      warmup_s: 5
    }
  }" \
    --teleop.type=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader \
    --display_data=true

6. パラメータに関する注意事項

• depth_alpha は深度画像のスケーリング係数を制御します。0.2 を良い出発点として、表示結果に基づいて微調整してください。
• 3 台以上の深度カメラを接続する場合は、安定性を高めるために fps を 15 に下げることを推奨します。
• より安定した表示とデータ転送のために、解像度は 640x480 に保つことを推奨します。

7. よくある問題

次のようなエラーが表示される場合：

No Orbbec camera found for 'XXXX'

通常これは、設定内のシリアル番号が現在接続されているデバイスと一致していないことを意味します。次を実行します：

lerobot-find-cameras orbbec

その後、実際の serial を確認し、コマンド内の serial_number_or_name を更新してください。

💡 著者と貢献

• 著者: Zhang Jiaquan, Wang Wenzhao - South China Normal University

汎用カメラを使用する場合

カメラをインスタンス化するには、カメラ識別子が必要です。この識別子は、コンピュータを再起動したりカメラを再接続したりすると変更される場合があり、この挙動は主にオペレーティングシステムに依存します。

システムに接続されているカメラのインデックスを見つけるには、次のスクリプトを実行します：

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

ターミナルには関連するカメラ情報が表示されます。

--- Detected Cameras ---
Camera #0:
  Name: OpenCV Camera @ 0
  Type: OpenCV
  Id: 0
  Backend api: AVFOUNDATION
  Default stream profile:
    Format: 16.0
    Width: 1920
    Height: 1080
    Fps: 15.0
--------------------
(more cameras ...)

各カメラで撮影された画像は、~/lerobot/outputs/captured_images ディレクトリで見つけることができます。

警告

Intel RealSense カメラを macOS で使用する場合、"Error finding RealSense cameras: failed to set power state" というエラーが発生することがあります。これは同じコマンドを sudo 権限で実行することで解決できます。ただし、macOS での RealSense カメラの使用は不安定であることに注意してください。

その後、次のコードを実行することで、テレオペレーション中にコンピュータ上でカメラ映像を表示できるようになります。これは、最初のデータセットを記録する前にセットアップを準備するのに役立ちます。

lerobot-teleoperate \
    --robot.type=seeed_b601_rs_follower \
    --robot.port=can0 \
    --robot.id=follower1 \
    --robot.can_adapter=socketcan \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --teleop.type=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader \
    --display_data=true

ヒント

fourcc: "MJPG" 形式の画像は圧縮されています。より高い解像度を試すことができ、YUYV 形式を試すこともできます。ただし、後者は画像の解像度と FPS を低下させ、ロボットアームの動作にラグが生じます。現在、MJPG 形式では、1920*1080 の解像度で 30FPS を維持しながら 3 台のカメラをサポートできます。しかし、同じ USB HUB を介して 2 台のカメラをコンピュータに接続することは依然として推奨されません。

さらに多くのカメラがある場合は、--robot.cameras パラメータを変更して追加できます。index_or_path の形式には注意する必要があり、これは python -m lerobot.find_cameras opencv によって出力されるカメラ ID の末尾の数字によって決まります。

例えば、カメラを追加したい場合：

lerobot-teleoperate \
    --robot.type=seeed_b601_rs_follower \
    --robot.port=can0 \
    --robot.id=follower1 \
    --robot.can_adapter=socketcan \
    --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=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader \
    --display_data=true

データセット収集

データセットをローカルに保存したい場合

lerobot-record \
    --robot.type=seeed_b601_rs_follower \
    --robot.port=can0 \
    --robot.id=follower1 \
    --robot.can_adapter=socketcan \
    --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=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader \
    --display_data=true \
    --dataset.repo_id=seeed_rebot_b601_rs/test \
    --dataset.num_episodes=5 \
    --dataset.single_task="Grab the black cube" \
    --dataset.push_to_hub=false \
    --dataset.episode_time_s=30 \
    --dataset.reset_time_s=30

その中で、repo_id は任意に変更でき、push_to_hub=false とします。最終的に、データセットはホームフォルダ内の ~/.cache/huggingface/lerobot ディレクトリに保存され、前述の seeed_rebot_b601_rs/test フォルダが作成されます。

データセットをアップロードするために Hugging Face Hub の機能を使用したい場合

• データセットをアップロードするために Hugging Face Hub の機能を使用したいが、これまでに行ったことがない場合は、Hugging Face settings から生成できる書き込み権限付きトークンを使用してログインしていることを確認してください：

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

これらのコマンドを実行するために、Hugging Face リポジトリ名を変数に保存します：

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

5 エピソードを記録し、データセットを Hub にアップロードします：

lerobot-record \
    --robot.type=seeed_b601_rs_follower \
    --robot.port=can0 \
    --robot.id=follower1 \
    --robot.can_adapter=socketcan \
    --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=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader \
    --display_data=true \
    --dataset.repo_id=${HF_USER}/record-test \
    --dataset.num_episodes=5 \
    --dataset.single_task="Grab the black cube" \
    --dataset.push_to_hub=true \
    --dataset.episode_time_s=30 \
    --dataset.reset_time_s=30

次のような行が多数表示されます：

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)

Record 関数

record 関数は、ロボットの動作中にデータを取得および管理するための一連のツールを提供します。

1. データ保存

• データは LeRobotDataset 形式で保存され、記録中にディスクに保存されます。
• デフォルトでは、記録後にデータセットはあなたの Hugging Face ページにプッシュされます。
• アップロードを無効にするには、--dataset.push_to_hub=False を使用します。

2. チェックポイントと再開

• チェックポイントは記録中に自動的に作成されます。
• 中断後に再開するには、同じコマンドを --resume=true を付けて再実行します。

⚠️ 重要な注意：再開する際は、--dataset.num_episodes を「データセット全体の目標エピソード数」ではなく、「追加で記録したいエピソード数」に設定してください。

• 最初から記録をやり直したい場合は、データセットディレクトリを手動で削除します。

3. 記録パラメータ

コマンドライン引数を使ってデータ記録の流れを設定します：

パラメータ	説明	デフォルト
--dataset.episode_time_s	1エピソードあたりの継続時間（秒）	60
--dataset.reset_time_s	各エピソード後の環境リセット時間（秒）	60
--dataset.num_episodes	記録するエピソードの総数	50

4. 記録中のキーボード操作

キーボードショートカットを使ってデータ記録の流れを制御します：

キー	動作
→（右矢印）	現在のエピソード／リセットを早期終了し、次へ進む。
←（左矢印）	現在のエピソードをキャンセルし、録り直す。
ESC	セッションを即座に停止し、動画をエンコードしてデータセットをアップロードする。

ヒント

キーボード入力が反応しない場合は、pynput のバージョンを 1.6.8 などにダウングレードする必要があるかもしれません。

pip install pynput==1.6.8

データ収集のヒント

• タスクの提案：さまざまな位置にある物体を把持し、ビンに入れる。
• スケール：50エピソード以上を記録する（位置ごとに10エピソード）。
• 一貫性：
  • カメラは固定したままにする。
  • 同じ把持動作を維持する。
  • 操作対象の物体がカメラ映像内に見えるようにする。
• 段階的な拡張：
  • まずは信頼性の高い把持ができるようにしてから、（新しい位置、把持手法、カメラ調整などの）バリエーションを追加する。
  • 失敗を防ぐため、複雑さを急激に増やすことは避ける。

💡 経験則：画面上のカメラ画像だけを見て、自分自身でタスクを実行できる状態であるべきです。

この重要なトピックをさらに深く知りたい場合は、「良いデータセットとは何か」について執筆したブログ記事を参照してください。

トラブルシューティング

Linux 固有の問題： 記録中に Right Arrow/Left Arrow/ESC キーが反応しない場合：

• $DISPLAY 環境変数が設定されているか確認します（pynput limitations を参照）。

データセットの可視化

echo ${HF_USER}/rebot_test

データをアップロードしている場合は、次のコマンドでローカルでも可視化できます：

lerobot-dataset-viz \
  --repo-id ${HF_USER}/rebot_test \
  --episode-index 0 \
  --display-compressed-images=false

--dataset.push_to_hub=false を使用してデータをアップロードしていない場合でも、次のコマンドでローカル可視化が可能です：

lerobot-dataset-viz \
  --repo-id seeed_rebot_b601_rs/test \
  --episode-index 0 \
  --display-compressed-images=false

ここで、seeed_rebot_b601_rs/test はデータ収集時に定義したカスタムの repo_id 名です。

エピソードのリプレイ

ヒント

不安定なため、スキップしても試してみても構いません。

ここでは、ロボット上で最初のデータセットをリプレイしてみましょう：

lerobot-replay \
    --robot.type=seeed_b601_rs_follower \
    --robot.port=can0 \
    --robot.can_adapter=socketcan \
    --robot.id=follower1 \
    --dataset.repo_id=seeed_rebot_b601_rs/test \
    --dataset.episode=0

この時点で、ロボットは記録時にテレオペレーションで行ったのと同じ動作を実行するはずです。

学習と評価

ACT

公式チュートリアル ACT を参照してください。

学習（トレーニング）

ロボットを制御するポリシーを学習させるには、python -m lerobot.scripts.train スクリプトを使用します。いくつかのパラメータ指定が必須です。以下はコマンド例です：

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

ローカルデータセットで学習したい場合は、repo_id がデータ収集時に使用した名前と一致していることを確認し、--policy.push_to_hub=false を追加してください。

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

ヒント

RTX 50 シリーズ GPU を使用している場合は、torchvision のプレビュー版で不足している API を回避するために、--dataset.video_backend=pyav を追加する必要があります。学習コマンドは次のようになります：

lerobot-train \
  --dataset.repo_id=seeed_rebot_b601_rs/test \
  --dataset.video_backend=pyav \
  --policy.type=act \
  --output_dir=outputs/train/act_rebot_test \
  --policy.device=cuda \
  --wandb.enable=false \
  --policy.push_to_hub=false \
  --steps=300000

コマンドの説明

• データセット指定：--dataset.repo_id=${HF_USER}/rebot_test パラメータでデータセットを指定します。
• 学習ステップ数：--steps=300000 を使って学習ステップ数を変更します。アルゴリズムのデフォルトは 800000 ステップです。タスクの難易度に応じて調整してください。よく分からない場合は多めに設定して構いません。学習中にチェックポイントが生成されるため、評価は任意のチェックポイントから再開できます。
• ポリシータイプ：policy.type=act でポリシーを指定します。同様に、[act, diffusion, pi0, pi0fast, sac, smolvla] などのポリシーを切り替えることもできます。これにより configuration_act.py から設定が読み込まれます。重要な点として、このポリシーは、モータ状態・モータアクション・カメラ台数といった情報がすでにデータセットに保存されているため、ロボットに合わせて自動的に適応します。
• デバイス選択：Nvidia GPU 上で学習しているため policy.device=cuda を指定していますが、Apple Silicon で学習する場合は policy.device=mps を使用できます。
• 可視化ツール：学習曲線を Weights and Biases で可視化するために wandb.enable=true を指定しています。これは任意ですが、使用する場合は wandb login を実行してログインしておいてください。

評価

ポリシーのチェックポイントを入力として、lerobot/record.py の record 関数を使用できます。例えば、次のコマンドを実行して 10 エピソード分の評価を記録します：

lerobot-record \
  --robot.type=seeed_b601_rs_follower \
  --robot.port=can0 \
  --robot.can_adapter=socketcan \
  --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=follower1 \
  --display_data=false \
  --dataset.repo_id=seeed/eval_test123 \
  --dataset.single_task="Put lego brick into the transparent box" \
  --policy.path=outputs/train/act_rebot_test/checkpoints/last/pretrained_model

1. --policy.path パラメータは、ポリシー学習結果の重みファイルへのパスを示します（例：outputs/train/act_rebot_test/checkpoints/last/pretrained_model）。モデル学習結果の重みファイルを Hub にアップロードした場合は、モデルリポジトリ（例：${HF_USER}/act_rebot_test）を使用することもできます。
2. データセット名 dataset.repo_id は eval_ で始まります。この操作により、評価中の動画とデータが別々に記録され、seeed/eval_test123 のような eval_ で始まるフォルダに保存されます。
3. 評価フェーズ中に File exists: 'home/xxxx/.cache/huggingface/lerobot/xxxxx/seeed/eval_xxxx' が発生した場合は、まず eval_ で始まるフォルダを削除してから、再度プログラムを実行してください。
4. mean is infinity. You should either initialize with stats as an argument or use a pretrained model が発生した場合は、--robot.cameras パラメータ内の front や side といったキーワードが、データセット収集時に使用したものと厳密に一致している必要がある点に注意してください。

SmolVLA

公式チュートリアル SmolVLA を参照してください。

SmolVLA は Hugging Face が提供する軽量なロボット基盤モデルです。自分で記録した LeRobot データセットを使って素早くファインチューニングし、実機ロボットで結果を得られるように設計されています。

簡単に言うと、その入出力は次のとおりです：

• 入力：マルチカメラ映像 + ロボットの現在状態（センサー／関節など）+ 自然言語によるタスク指示
• 出力：ロボットアームにタスクを実行させるための連続的なアクションチャンク

pip install -e ".[smolvla]"

データセット収集（推奨）

SmolVLA は「基盤モデル」です。自分のテーブル上で、自分のカメラ・グリッパ・物体に対して良好に動作させるには、通常、自前のデータでファインチューニングする必要があります。

• まずは約 50 エピソードから始めます（少なすぎると学習や汎化がうまくいかない可能性があります）。
• タスクに「変数」（例：テーブル上のキューブ位置の違い）がある場合は、それぞれのバリエーションに十分なデモを用意してください：
  • 例：5 つの位置 × 各 10 エピソード = 50 エピソード
• 経験則：25 エピソードだけの記録では不十分であることが多いです。データの質と量の両方が重要です。

学習（トレーニング）

事前学習済み 450M モデルである smolvla_base を出発点として、自分のデータセットでファインチューニングします。公式の例では 20k ステップ学習し、単一の A100 では約 4 時間かかります（あくまで参考値であり、実際の時間はハードウェアによって異なります）。

GPU が利用できない場合は、Colab ノートブック経由での学習を検討してください（公式チュートリアルを参照）。

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

ヒント：

• メモリが不足する場合は、まず --batch_size を小さくしてください。動作することを確認したら、徐々に増やしていきます。
• 利用可能なパラメータ一覧：lerobot-train --help

評価

評価フェーズでは、ファインチューニング済みモデルを読み込み、ロボットにタスクを実行させ、その評価プロセスを新しいデータセットとして記録します（動画の振り返りや結果分析のため）。

lerobot-record \
  --robot.type=seeed_b601_rs_follower \
  --robot.port=can0 \
  --robot.can_adapter=socketcan \
  --robot.id=follower1 \
  --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="Grasp a lego block and put it in the bin." \
  --dataset.repo_id=${HF_USER}/eval_DATASET_NAME_test \
  --dataset.episode_time_s=50 \
  --dataset.num_episodes=10 \
  --policy.path=${HF_USER}/FINETUNE_MODEL_NAME

パラメータの設定方法：

• --robot.port: マシンで認識されているシリアルポートに変更します（一般的には can0 や /dev/ttyACM0）。
• --robot.id: ロボット ID（キャリブレーション／記録時に使用したものと一致している必要があります）。
• --robot.cameras: 実際のカメラの index_or_path に変更し、カメラキー（例：front、side）がデータセット記録時に使用したものと完全に一致していることを確認します。
• --dataset.single_task: データセット記録時に使用したタスク記述と一致させる必要があります。
• --dataset.repo_id: 評価結果の出力データセット名。Hugging Face にログインしている場合は、自分のアカウント配下に作成／アップロードされます。
• --policy.path:
  • モデルがローカルの場合：トレーニング出力ディレクトリ配下の重みパスを指定します（例：outputs/train/my_smolvla/checkpoints/last/pretrained_model）
  • モデルが Hub 上にある場合：${HF_USER}/FINETUNE_MODEL_NAME を指定します

任意：評価エピソードの合間に「手動テレオペで微調整」したい場合は、テレオペを追加できます（自分のデバイスと設定に合わせて記入）：

--teleop.type=rebot_arm_102_leader \
--teleop.port=/dev/ttyUSB0 \
--teleop.id=rebot_arm_102_leader

Pi0

公式チュートリアル Pi0 を参照してください。

π₀（Pi0）は、より「汎用的な」ロボット制御のために Physical Intelligence が提案した Vision-Language-Action モデルです。カメラ画像を見て自然言語の指示を理解し、そのうえでロボットアームを制御するアクションを出力できるものと考えるとよいでしょう。

LeRobot での利用はとても簡単で、トレーニング時にポリシータイプを --policy.type=pi0 に設定するだけです（ACT セクションで説明した一般的なトレーニング／評価の概念を繰り返す必要はありません）。

pip install -e ".[pi]"

ヒント

古いバージョンの LeRobot（例：0.4.0）を使用している場合、GitHub ソースから pi 依存関係をインストールする必要があるかもしれません（公式ドキュメント側で今後のパッチで修正予定です）：

pip install "lerobot[pi]@git+https://github.com/huggingface/lerobot.git"

トレーニング

lerobot-train \
  --policy.type=pi0 \
  --dataset.repo_id=${HF_USER}/my_dataset \
  --job_name=pi0_training \
  --output_dir=outputs/pi0_training \
  --policy.pretrained_path=lerobot/pi0_base \
  --policy.repo_id=${HF_USER}/my_pi0_policy \
  --policy.compile_model=true \
  --policy.gradient_checkpointing=true \
  --policy.dtype=bfloat16 \
  --policy.freeze_vision_encoder=false \
  --policy.train_expert_only=false \
  --steps=3000 \
  --policy.device=cuda \
  --batch_size=32 \
  --wandb.enable=false

共通パラメータ（Pi0 固有／よく調整するもののみ）：

• --policy.pretrained_path=lerobot/pi0_base: ベースモデル。公式からは lerobot/pi0_libero（Libero データセット向けバージョン）も提供されており、タスクに応じて切り替えを試せます。
• --policy.compile_model=true: コンパイル最適化を有効化し、トレーニングが高速になる場合があります（初回コンパイルは遅くなります）。
• --policy.gradient_checkpointing=true: VRAM を大きく節約でき、VRAM が厳しい場合に適しています。
• --policy.dtype=bfloat16: 混合精度で、速度／VRAM の両面でより扱いやすくなります（ハードウェアが対応している場合に推奨）。
• --policy.train_expert_only=true（VRAM 節約テクニック）：大きなモデル（VLM）部分を凍結し、「アクションエキスパート」と射影層のみを学習します。より多くの VRAM を節約できますが、学習可能な容量は制限されます。まずは入門や小規模データでの素早い実験に適しています。

評価

lerobot-record \
  --robot.type=seeed_b601_rs_follower \
  --robot.port=can0 \
  --robot.can_adapter=socketcan \
  --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=follower1 \
  --display_data=false \
  --dataset.repo_id=${HF_USER}/eval_my_pi0_test \
  --dataset.single_task="Put lego brick into the transparent box" \
  --dataset.episode_time_s=50 \
  --dataset.num_episodes=10 \
  --policy.path=outputs/pi0_training/checkpoints/last/pretrained_model

Pi0.5

公式チュートリアル Pi0.5 を参照してください。

π₀.₅（Pi0.5）も Physical Intelligence が提案した Vision-Language-Action モデルで、π₀ の「アップグレード版」と理解できます。特に オープンワールド一般化 能力の強化に重点が置かれており、学習時に見た固定シナリオでうまく動くだけでなく、新しい部屋・新しい物体・新しい配置でも、より安定してタスクを完了できることを目指しています。

ここでいう「一般化」は、おおまかに次の 3 つのレベルに分けられます（理解のための例）：

• 物理レイヤー：見慣れないスプーン／皿でも、どこを持てばよいか（柄／縁）を理解して把持し、散らかった環境でも動作できること。
• 意味レイヤー：「どこに物を置くべきか／どの道具を使うべきか」を理解すること。例：靴は下駄箱、服は洗濯かごに入れる、など。
• 環境レイヤー：家庭・オフィス・病院など、より現実的な「散らかった」シナリオに適応できること。

LeRobot で利用するには、ポリシータイプを --policy.type=pi05 に設定するだけです。

pip install -e ".[pi]"

ヒント

古いバージョンの LeRobot（例：0.4.0）を使用している場合、GitHub ソースから pi 依存関係をインストールする必要があるかもしれません（公式ドキュメント側で今後のパッチで修正予定です）：

pip install "lerobot[pi]@git+https://github.com/huggingface/lerobot.git"

トレーニング

lerobot-train \
  --dataset.repo_id=${HF_USER}/my_dataset \
  --policy.type=pi05 \
  --output_dir=outputs/pi05_training \
  --job_name=pi05_training \
  --policy.repo_id=${HF_USER}/my_pi05_policy \
  --policy.pretrained_path=lerobot/pi05_base \
  --policy.compile_model=true \
  --policy.gradient_checkpointing=true \
  --policy.dtype=bfloat16 \
  --policy.freeze_vision_encoder=false \
  --policy.train_expert_only=false \
  --steps=3000 \
  --policy.device=cuda \
  --batch_size=32 \
  --wandb.enable=false

共通パラメータ（Pi0.5 関連）：

• --policy.pretrained_path=lerobot/pi05_base: ベースモデル。公式からは lerobot/pi05_libero も提供されています。
• --policy.train_expert_only=true（VRAM 節約テクニック）：大きなモデル（VLM）部分を凍結し、「アクションエキスパート」と射影層のみを学習します。
• --policy.normalization_mapping=...: データセットの正規化統計が一致していない／欠けている場合、このマッピングを使って正規化方法を強制できます。

データセットに分位点統計が含まれていない場合（バージョン／フォーマットによっては必須）、公式からは変換スクリプトによるアプローチも提供されています。トレーニング前にデータセット統計を補完／変換してください（詳細は公式ドキュメントを参照）。

評価

lerobot-record \
  --robot.type=seeed_b601_rs_follower \
  --robot.port=can0 \
  --robot.can_adapter=socketcan \
  --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=follower1 \
  --display_data=false \
  --dataset.repo_id=${HF_USER}/eval_my_pi05_test \
  --dataset.single_task="Put lego brick into the transparent box" \
  --dataset.episode_time_s=50 \
  --dataset.num_episodes=10 \
  --policy.path=outputs/pi05_training/checkpoints/last/pretrained_model

GR00T N1.5

公式チュートリアル GR00T N1.5 を参照してください。

GR00T N1.5 は、より汎用的なロボットの推論とスキル学習のために NVIDIA が提供するオープンな基盤モデルです。これは クロスエンボディメント モデルであり、言語 や 画像 などのマルチモーダル入力を受け取り、異なる環境にまたがってマニピュレーションタスクを実行できます。

LeRobot での利用の要点は、ポリシータイプを --policy.type=groot に設定することです。注意：GR00T N1.5 は現時点で環境要件が高く（FlashAttention に依存し、CUDA GPU が必要）、まずは ACT／Pi0 を動かしてから GR00T を試すことを推奨します。

インストール（重要）

公式ドキュメントにあるように、GR00T N1.5 を動作させるには flash-attn が必要であり、CUDA 対応デバイス でのみ使用できます。

推奨手順（順番に実行）：

1. まずインストールガイドに従ってベース環境（Python、CUDA、ドライバなど）を構築します。このステップでは lerobot をインストールしないでください。
2. PyTorch をインストールします（バージョン範囲は公式要件に従う）：

pip install "torch>=2.2.1,<2.8.0" "torchvision>=0.21.0,<0.23.0"

ヒント

RTX 50 シリーズを使用している場合は、Python=3.10、CUDA=12.8、Torch=2.7.1 が必要です

pip install torch==2.7.1 torchvision==0.22.1 torchaudio==2.7.1 --index-url https://download.pytorch.org/whl/cu128

3. flash-attn の依存関係と flash-attn 本体をインストールします：

pip install ninja "packaging>=24.2,<26.0"
pip install "flash-attn>=2.5.9,<3.0.0" --no-build-isolation
python -c "import flash_attn; print(f'Flash Attention {flash_attn.__version__} imported successfully')"

ヒント

RTX 50 シリーズを使用している場合は、次が必要です: flash_attn=2.8.0

pip install flash_attn==2.8.0.post2 torch==2.7.1 --no-build-isolation

4. LeRobot の groot 依存関係をインストールします：

pip install "lerobot[groot]"

ヒント

flash-attn のインストールに失敗する場合、多くは (1) PyTorch と CUDA のバージョン不一致、(2) ビルド依存関係の不足、(3) 環境が新しすぎる／古すぎる、のいずれかが原因です。この場合は、まず公式の GR00T ドキュメントと PyTorch インストールガイドを参照してください。

学習（ファインチューニング）

公式ではマルチ GPU 学習の例（accelerate launch --multi_gpu ...）が提供されています。GPU が 1 枚しかない場合は、まずシングルプロセスモードでの実行も試せます（対応状況／パラメータの詳細は公式ドキュメントに従います）。

マルチ GPU（変数は置き換えが必要）：

accelerate launch \
  --multi_gpu \
  --num_processes=$NUM_GPUS \
  $(which lerobot-train) \
  --output_dir=$OUTPUT_DIR \
  --save_checkpoint=true \
  --batch_size=$BATCH_SIZE \
  --steps=$NUM_STEPS \
  --save_freq=$SAVE_FREQ \
  --log_freq=$LOG_FREQ \
  --policy.push_to_hub=true \
  --policy.type=groot \
  --policy.repo_id=$REPO_ID \
  --policy.tune_diffusion_model=false \
  --dataset.repo_id=$DATASET_ID \
  --wandb.enable=true \
  --wandb.disable_artifact=true \
  --job_name=$JOB_NAME

パラメータの説明（よく変更するもの）：

• --dataset.repo_id: 学習用データセット（Hub 上の username/dataset_name または対応するローカルキャッシュの repo_id）。
• --output_dir: 学習結果の出力ディレクトリ（ここに重み／チェックポイントが保存されます）。
• --steps, --batch_size: 学習ステップ数とバッチサイズ。大規模モデルは VRAM に敏感なため、動作しない場合はまず batch_size を小さくしてください。
• --policy.repo_id: モデルを Hub にプッシュしたい場合、作成したいモデルリポジトリ名を指定します。

評価（ロボット上での実行）

学習後は、他のポリシーと同様に lerobot-record を使って評価／記録を行えます。reBot B601-RS シングルアームユーザーは、次のコマンドを参照してください：

lerobot-record \
  --robot.type=seeed_b601_rs_follower \
  --robot.port=can0 \
  --robot.can_adapter=socketcan \
  --robot.cameras='{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30} }' \
  --robot.id=follower1 \
  --display_data=true \
  --dataset.repo_id=${HF_USER}/eval_groot_rebot \
  --dataset.num_episodes=10 \
  --dataset.single_task="Grab the black cube and put it in the box" \
  --policy.path=${HF_USER}/groot-rebot \
  --dataset.episode_time_s=30 \
  --dataset.reset_time_s=10

ライセンス：このモデルは Apache 2.0 ライセンスに従います（元の GR00T リポジトリと同一）。

（オプション）PEFT による効率的なファインチューニング

PEFT（Parameter-Efficient Fine-Tuning）は、大規模事前学習モデルを新しいタスクに適応させるための「パラメータ効率の良い適応」手法とツールの集合であり、すべてのモデルパラメータを更新することなく適応を行えます。LeRobot の事前学習済みポリシー（SmolVLA や π₀ など）に対しては、通常は少数の「アダプタ」パラメータ（LoRA など）だけを学習することで、VRAM 使用量と学習コストを抑えつつ、ほぼフルファインチューニングに近い結果を得ることができます。

インストール

PEFT 関連パラメータを使用するには、LeRobot のオプション依存関係 peft をインストールします：

# Method 1: Source installation (in the lerobot root directory)
pip install -e ".[peft]"

# Method 2: pip installation
pip install "lerobot[peft]"

より多くの適応手法や概念の説明については、公式ドキュメントを参照してください： 🤗 PEFT ドキュメント

例：SmolVLA を LoRA でファインチューニングする（Libero の libero_spatial サブタスク）

以下の例では、HuggingFaceVLA/libero データセット上で lerobot/smolvla_base に対して LoRA ファインチューニングを行う方法を示します。パラメータ名は現行の LeRobot バージョンに基づいており、lerobot-train --help も併せて参照してください。

lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --policy.repo_id=${HF_USER}/my_libero_smolvla_peft \
  --dataset.repo_id=HuggingFaceVLA/libero \
  --env.type=libero \
  --env.task=libero_spatial \
  --output_dir=outputs/train/my_libero_smolvla_peft \
  --job_name=my_libero_smolvla_peft \
  --policy.device=cuda \
  --steps=10000 \
  --batch_size=32 \
  --optimizer.lr=1e-3 \
  --peft.method_type=LORA \
  --peft.r=64

主要な PEFT パラメータ

• --peft.method_type: 使用する PEFT 手法を選択します。LoRA（Low-Rank Adapter）は最も一般的に使われる手法の 1 つです。
• --peft.r: LoRA のランク。一般に、ランクが高いほど表現力は強くなりますが、パラメータ数と VRAM 使用量も増加します。

LoRA を注入する層の指定（オプション）

デフォルトでは、PEFT は通常、モデルの最も重要な射影層（例：Attention の q_proj、v_proj など）に LoRA を注入し、さらに状態／行動に関連する射影層もカバーする場合があります。別の層を対象にしたい場合は、--peft.target_modules を使って対象層を指定します。

よく使われるパターンには次のようなものがあります：

1. モジュール名のサフィックスリストによる指定（例）：

--peft.target_modules="['q_proj', 'v_proj']"

2. 正規表現を用いる方法（例：実際のモジュール名に応じて調整してください）：

--peft.target_modules='(model\\.vlm_with_expert\\.lm_expert\\..*\\.(down|gate|up)_proj|.*\\.(state_proj|action_in_proj|action_out_proj|action_time_mlp_in|action_time_mlp_out))'

特定の層をフル学習させる指定（オプション）

特定のモジュールを（LoRA のみを注入するのではなく）「フル学習」させたい場合は、--peft.full_training_modules で指定します。例えば、state_proj のみをフル学習させるには：

--peft.full_training_modules="['state_proj']"

学習率の推奨値（経験則）

LoRA の学習率は、通常フルファインチューニングより 1 桁大きくできます（一般的な経験則：およそ 10 倍）。例えば、フルファインチューニングでは 1e-4 がよく使われますが、LoRA では 1e-3 から始められます。学習率減衰（スケジューラ）を有効にしている場合、最終的な学習率も目安として 1e-4 前後に設定されることが多いです。

（オプション）マルチ GPU 学習

1. 学習手順

方法 1：コマンドライン引数によるマルチ GPU 学習

まず、lerobot 環境に学習加速システムをインストールします：

pip install accelerate

次に、以下のコマンドを実行してマルチ GPU 学習を開始します：

accelerate launch \
  --multi_gpu \
  --num_processes=2 \
  $(which lerobot-train) \
  --dataset.repo_id=${HF_USER}/my_dataset \
  --policy.type=act \
  --policy.repo_id=${HF_USER}/my_trained_policy \
  --output_dir=outputs/train/act_multi_gpu \
  --job_name=act_multi_gpu \
  --wandb.enable=true

主要な accelerate パラメータの説明：

• --multi_gpu: マルチ GPU 学習を有効化
• --num_processes=2: 使用する GPU 数（通常は GPU の枚数と同じ）
• --mixed_precision=fp16: fp16 混合精度を使用（ハードウェアが対応していれば bf16 も可）

bf16 にはハードウェアの対応が必要であり、すべての GPU で利用できるわけではない点に注意してください。

精度の種類	ハードウェアサポート
fp16	ほぼすべての NVIDIA GPU でサポート
bf16	新しい GPU（Ampere アーキテクチャ以降）のみサポート

GPU が bf16 をサポートしていない場合は、accelerate の設定で fp16 を選択するか、コマンドラインで明示的に fp16 を指定してください。

方法 2：Accelerate の設定ファイルを使う（オプション）

頻繁にマルチ GPU 学習を行う場合は、上記の学習設定を保存して、毎回コマンドラインで入力しなくて済むようにできます。

ヒント：このセクションの内容がよく分からない場合や、とりあえずすぐに始めたいだけの場合は、 このセクションは飛ばして、方法 1（コマンドライン引数）を使って構いません。

accelerate config の目的は次のとおりです：

ハードウェア環境（GPU 数、混合精度など）を設定ファイルとして保存し、 今後 accelerate launch を実行する際に、これらのパラメータを毎回入力しなくて済むようにすることです。

LeRobot の学習ロジック自体は一切変更せず、単に繰り返しのパラメータ入力を減らすだけです。

マルチ GPU をたまにしか使わない場合や、今回が初めての試行であれば、無理に使う必要はまったくありません。

---

次を実行します：

accelerate config

対話的な設定プロセスでは、一般的な単一マシン・マルチ GPU のケースでは次のように選択できます：

• Compute environment: This machine
• Number of machines: 1
• Number of processes: 使用する GPU 数（通常は GPU の枚数と同じ）
• GPU ids to use: Enter キーをそのまま押下（すべての GPU を使用することを意味します）
• Mixed precision:
  • fp16 を推奨
  • GPU が bf16 をサポートしていることが確実な場合は、bf16 を選択してもよい

設定後は、次のようにして学習を実行できます：

accelerate launch $(which lerobot-train) \
  --dataset.repo_id=${HF_USER}/my_dataset \
  --policy.type=act \
  --policy.repo_id=${HF_USER}/my_trained_policy \
  --output_dir=outputs/train/act_multi_gpu \
  --job_name=act_multi_gpu \
  --wandb.enable=true

マルチ GPU 学習が学習パラメータに与える影響と調整戦略

LeRobot は、ユーザーに知らせずに学習挙動が変わってしまうことを避けるため、GPU 数に応じて学習率や学習ステップ数を自動調整しません。これは、他の一般的な分散学習フレームワークとは異なります。

マルチ GPU 学習向けにハイパーパラメータを調整したい場合は、次の手順に従って手動で行う必要があります。

ステップ数への影響と調整戦略

マルチ GPU では有効バッチサイズ（batch_size × num_gpus）が増加するため：

直感的に理解するために言い換えると：学習が「歩くこと」のようなものだとすると、1 枚の GPU は 1 メートルの 1 歩を進み、2 枚の GPU は 1 歩で 2 メートル進むイメージです。同じ距離（モデルが学習するデータ量）に到達するには、2 GPU 学習ではステップ数を半分にすべきです。同様に、n 枚の GPU なら 1/n になります。

したがって、複数 GPU で学習する場合は、学習ステップ数を適切に減らす必要があります。

シングル GPU 学習：

• batch_size = 8
• steps = 100000

デュアル GPU 学習（有効バッチサイズが 16 になる場合）：

• batch_size がまだ 8 に設定されている場合
• steps は 50000 まで減らすことができます

accelerate launch --num_processes=2 $(which lerobot-train) \
  --batch_size=8 \
  --steps=50000 \
  --dataset.repo_id=lerobot/pusht \
  --policy=act

学習率への影響と調整戦略

複数 GPU を使用する場合、各ステップ更新で使用されるサンプル数が増加します。

モデルの「学習スピード」を単一 GPU と同程度に保ちたい場合は、 通常、GPU の数に比例して学習率を増やす必要があります。

• 新しい学習率 = 単一 GPU の学習率 × GPU の数

例：

単一 GPU の学習率（optimizer.lr）が 1e-4 の場合、 2 枚の GPU を使用するときは 2e-4 に変更できます：

accelerate launch --num_processes=2 $(which lerobot-train) \
  --optimizer.lr=2e-4 \
  --dataset.repo_id=lerobot/pusht \
  --policy=act

注意：

これらは必須のルールではなく、一般的なベストプラクティスです。

調整方法に自信がない場合は、次のようにすることもできます：

• 学習率を変更しない
• 学習ステップ数を変更しない

学習プロセスが安定している限り、結果は依然として有用です。

より高度な設定やトラブルシューティングについては、Accelerate のドキュメントを参照してください。多数の GPU での学習についてさらに知りたい場合は、この優れたガイドを確認してください：Ultrascale Playbook。

（オプション）デプロイのために Async Inference を使用する

async inference を使わない場合、LeRobot の制御フローは従来の逐次的／同期推論として理解できます：ポリシーがアクションチャンクを予測し、それを実行し、その後次の予測を待ちます。モデルが大きくなると、ロボットが新しいアクションチャンクを待つ間に顕著な一時停止が発生することがあります。async inference の目的は、次のアクションチャンクを事前に計算しながらロボットに現在のアクションチャンクを実行させることで、アイドル時間を減らし応答性を向上させることです。async inference は、ACT、OpenVLA、Pi0、SmolVLA など、アクションチャンクを出力する LeRobot 対応ポリシーに適用されます。推論と実際の制御が分離されているため、async inference によって、より高性能なマシンをリモートでロボット推論に利用することも可能になります。

async inference についてさらに詳しくは、Hugging Face のこのブログ記事を参照してください。

ここで、いくつかの基本概念を紹介します：

• Client: ロボットアームとカメラに接続し、観測（画像、ロボット姿勢など）を収集してサーバーに送信します。また、サーバーからアクションチャンクを受信し、順番に実行します。
• Server: 計算リソースを提供するデバイスです。カメラとロボットのデータを受信し、アクションチャンクを推論（計算）してクライアントに送り返します。ロボットとカメラに接続された同じデバイスでも、同一 LAN 上の別のコンピュータでも、クラウドサーバーでもかまいません。
• Action chunk: サーバー側の推論によってポリシーから生成される、一連のロボットアームのアクションコマンドです。
• Synchronous inference: 1 つのチャンクを予測し、1 つのチャンクを実行します。次のチャンクが推論されるのを待つ間、ロボットにはアイドルギャップが生じます。モデルが大きく計算資源が不足している場合、この推論ギャップは顕著になり、アームが動いては一時停止（推論）、そして再び動く、という挙動になります。
• Asynchronous inference: 同期推論とは異なり、ロボットが現在のチャンクを実行している間に、サーバーはすでに次のチャンクを計算しています。重なり合う部分をブレンドすることで、より応答性の高い制御を実現します。

Async Inference デプロイの 3 つのシナリオ

1. 単一マシンでのデプロイ

ロボット、カメラ、クライアント、サーバーがすべて同じデバイス上にあります。 これは最も単純なケースで、サーバーは 127.0.0.1 で待ち受け、クライアントも 127.0.0.1:port に接続します。公式ドキュメントのコマンド例はこのシナリオに従っています。

2. LAN 内でのデプロイ

ロボットとカメラは軽量なデバイスに接続され、ポリシーサーバーは同一 LAN 上の別の高性能デバイス上で動作します。 この場合、サーバーは他のマシンからアクセス可能なアドレスで待ち受ける必要があり、クライアントは 127.0.0.1 ではなくサーバーの LAN IP に接続する必要があります。

3. ネットワーク越し／クラウドでのデプロイ

ポリシーサーバーはパブリックにアクセス可能なクラウドホスト上で動作し、クライアントはパブリックネットワーク経由で接続します。 この方法では、クラウドホスト上のより強力な GPU を活用できます。ネットワーク環境が良好であれば、往復時間（ネットワークレイテンシ）は推論時間と比べて相対的に小さい場合もありますが、これは実際のネットワーク環境に依存します。

セキュリティに関する注意: LeRobot の async inference パイプラインには、認証されていない gRPC + pickle デシリアライズのリスクがあります。サーバーが重要な情報やサービスをホストしている場合、パブリックネットワーク上にデプロイするときにサービスをインターネットに直接公開することは推奨されません。より安全な方法は、VPN や SSH トンネリング、少なくともセキュリティグループの送信元 IP をクライアントのパブリック IP に制限することです。

Async Inference デプロイの開始

ステップ 1: 環境構成

まず、pip を使用して async inference に必要な追加依存関係をインストールします。クライアントとサーバーの両方で、追加依存関係付きの lerobot をインストールする必要があります：

pip install -e ".[async]"

ステップ 2: ネットワーク構成と確認

1. プロキシの問題

ターミナルにプロキシの環境変数が設定されていて接続問題が発生する場合は、一時的にそれらを解除できます：

unset http_proxy https_proxy ftp_proxy all_proxy HTTP_PROXY HTTPS_PROXY FTP_PROXY ALL_PROXY

注意：上記のコマンドは現在のターミナルセッションにのみ影響します。新しいターミナルウィンドウを開いた場合は、再度実行する必要があります。

2. ファイアウォール／セキュリティグループでポートを許可する

• 単一マシンでのデプロイ：通常はスキップできます。
• LAN デプロイ：サーバー側で待ち受けポートを許可する必要があります。 LAN 上で待ち受けポートを許可する例（サーバー上で実行）：

sudo ufw allow 8080/tcp

• クラウドデプロイ：クラウドサーバーのセキュリティグループでポートを許可し、可能であれば送信元 IP を制限する必要があります。

クラウドサーバー上で実行している場合： サーバー管理ページのセキュリティグループでポート 8080 を許可するか、すでに許可されている別のポートを使用します。方法はクラウドプロバイダによって異なります。

3. IP アドレスの確認

単一マシンでのデプロイではこのステップはスキップできます（IP は常に 127.0.0.1 です）。

4. 接続テスト

• 単一マシンでのデプロイ：このステップはスキップします。
• LAN／クラウドデプロイ：クライアントがサーバーポートにアクセスできるかどうかをテストすることを推奨します：

nc -vz <LAN_IP_address> 8080

nc -vz <server_public_IP> 8080

ステップ 3: サービスを起動する

シナリオ A: 単一マシンでのデプロイ

1 つのターミナルでローカルサービスを起動します：

python -m lerobot.async_inference.policy_server \
  --model_path=outputs/train/act_rebot_test/checkpoints/last/pretrained_model \
  --server_address=127.0.0.1:8080

正常に起動したら、このターミナルは開いたままにして、別のターミナルを新しく作成して他のコマンドを実行する必要があります。

シナリオ B: LAN デプロイ

サーバー上で実行します：

python -m lerobot.async_inference.policy_server \
  --model_path=outputs/train/act_rebot_test/checkpoints/last/pretrained_model \
  --server_address=0.0.0.0:8080

クライアントが接続する際、--server_address にはサーバーの LAN IP アドレス <LAN_IP_address>:8080 を指定する必要があります。

シナリオ C: クラウドサーバーでのデプロイ

サーバー上で実行します：

python -m lerobot.async_inference.policy_server \
  --model_path=outputs/train/act_rebot_test/checkpoints/last/pretrained_model \
  --server_address=0.0.0.0:8080

クライアントが接続する際、--server_address にはサーバーのパブリック IP アドレス <server_public_IP>:8080 を指定する必要があります。

ステップ 4: 推論パラメータを選択する

クライアント側で実行します：

python -m lerobot.async_inference.robot_client \
  --robot.type=seeed_b601_rs_follower \
  --robot.port=can0 \
  --robot.can_adapter=socketcan \
  --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=follower1 \
  --server_address=127.0.0.1:8080 \
  --actions_per_chunk=50 \
  --chunk_size_threshold=0.5 \
  --fixed_update_fps=30 \
  --visualize_action_queue=false

主要なパラメータの説明：

• --server_address: サーバーアドレス。単一マシンの場合は 127.0.0.1:port を使用し、LAN／クラウドの場合はサーバーの IP を使用します。
• --actions_per_chunk: 各アクションチャンクのサイズ（アクション数）。値が大きいほど推論頻度は低くなりますが、1 回の推論あたりの結果はより安定します。値が小さいほど動きは滑らかになりますが、サーバーの推論負荷は増加します。
• --chunk_size_threshold: 古いアクションチャンクと新しいアクションチャンクのブレンド閾値です。古いチャンクの実行がこの割合に達したときに、新しいチャンクとのブレンドが開始されます。
• --fixed_update_fps: 制御コマンドの送信頻度であり、ロボットアームの動きの滑らかさに対応します。
• --visualize_action_queue: 実行時にアクションキューのサイズを可視化するかどうか。有効にすると、キューが頻繁に底をついていないかをより直感的に確認でき、actions_per_chunk と chunk_size_threshold の調整に役立ちます。

ステップ 5: ロボットの挙動に基づいてパラメータを調整する

async inference では、同期推論には存在しない追加パラメータが 2 つあり、調整が必要です：

• --actions_per_chunk: 各アクションチャンクのサイズです。ロボットの動きがぎくしゃく／カクつく場合はこの値を大きくし、ロボットの応答に明らかな遅延がある場合はこの値を小さくします。
• --chunk_size_threshold: 古いアクションチャンクと新しいアクションチャンクのブレンド閾値です。通常は 0.5 から試し始めます。

async inference では、サーバーのアクションチャンク生成速度がクライアントの消費速度以上であるようにバランスを取る必要があります。そうでない場合、アクションキューが空になり、ロボットがカクつき始めます（これはキューの可視化カーブが底に張り付くことで確認できます）。

FAQ

• このドキュメントのチュートリアルに従っている場合は、推奨されている GitHub リポジトリ https://github.com/Seeed-Projects/lerobot.git を git clone してください。本ドキュメントで推奨しているリポジトリは検証済みの安定版であり、公式の LeRobot リポジトリは常に最新バージョンへ更新されているため、データセットバージョンの違いやコマンドの違いなど、予期しない問題が発生する可能性があります。

• 次のエラーが発生した場合:

  Could not connect on port "/dev/ttyUSB0" or "/dev/ttyACM0"

  そして、ls /dev/ttyUSB* または ls /dev/ttyACM* を実行したときにデバイスが存在することが確認できる場合は、シリアルポートの権限付与を忘れていることを意味します。ターミナルで sudo chmod 666 /dev/ttyUSB* /dev/ttyACM* を入力して修正してください。

• 次のエラーが発生した場合:

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

  conda install ffmpeg=7.1.1 -c conda-forge を使用して ffmpeg 7.1.1 をインストールしてください。

• 50 セットのデータで ACT をトレーニングするには、RTX 3060（8GB）を搭載したノート PC では約 6 時間、RTX 4090 または A100 GPU を搭載したコンピュータでは約 2～3 時間かかります。

• データ収集中は、カメラの位置、角度、および周囲の照明が安定していることを確認してください。カメラに映り込む不安定な背景や歩行者の量を減らしてください。展開環境の変化が大きすぎると、ロボットアームが正しく把持できなくなる可能性があります。

• データ収集コマンドでは、十分なデータを収集できるように num-episodes パラメータが設定されていることを確認してください。途中で手動で一時停止しないでください。データの平均値と分散はデータ収集完了後にのみ計算され、これらはトレーニングに必要です。

• プログラムが USB カメラから画像データを読み取れないと表示する場合は、USB カメラがハブ経由で接続されていないことを確認してください。USB カメラは、画像伝送速度を確保するために、必ずデバイスに直接接続する必要があります。

ヒント

解決できないソフトウェアの問題や環境依存関係の問題が発生した場合は、このチュートリアルの最後にある FAQ セクションを確認することに加えて、速やかに LeRobot platform または LeRobot Discord channel に問題を報告してください。

参考文献

Seeed Studio 英語 Wiki: Lerobot で SO100Arm ロボットアームを使用する方法

TheRobotStudio プロジェクト: SO-ARM10x

Huggingface プロジェクト: LeRobot

Dnsty: Jetson Containers

Jetson AI Lab

Diffusion Policy

ACT or ALOHA

TDMPC

VQ-BeT

技術サポート & 製品ディスカッション

弊社製品をお選びいただきありがとうございます。私たちは、製品をできるだけスムーズにご利用いただけるよう、さまざまなサポートを提供しています。お好みやニーズに応じて選択できる、複数のコミュニケーションチャネルをご用意しています。