LeRobot documentation

Pembelajaran Imitasi pada Robot Dunia Nyata

LeRobot

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.7.0).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Pembelajaran Imitasi pada Robot Dunia Nyata

Tutorial ini akan menjelaskan cara melatih jaringan saraf untuk mengendalikan robot sungguhan secara otonom.

Anda akan belajar:

Cara merekam dan memvisualisasikan dataset Anda.
Cara melatih kebijakan menggunakan data Anda dan menyiapkannya untuk evaluasi.
Cara mengevaluasi kebijakan Anda dan memvisualisasikan hasilnya.

Dengan mengikuti langkah-langkah ini, Anda akan dapat mereplikasi tugas, seperti mengambil blok Lego dan meletakkannya ke dalam wadah dengan tingkat keberhasilan yang tinggi, seperti yang ditunjukkan dalam video di bawah ini.

Video: pickup lego block task

Tutorial ini tidak terikat pada robot tertentu: kami memandu Anda melalui perintah dan potongan API yang dapat Anda sesuaikan untuk platform apa pun yang didukung.

Selama pengumpulan data, Anda akan menggunakan perangkat “teleoperation”, seperti lengan pemimpin atau keyboard, untuk mengoperasikan robot secara jarak jauh dan merekam trajektori gerakannya.

Setelah Anda mengumpulkan cukup banyak trajektori, Anda akan melatih jaringan saraf untuk meniru trajektori tersebut dan menerapkan model yang telah dilatih agar robot Anda dapat melakukan tugas secara otonom.

Jika Anda mengalami masalah di titik mana pun, bergabunglah ke komunitas Discord kami untuk mendapatkan dukungan.

Ingin dengan cepat mendapatkan perintah yang tepat untuk konfigurasi Anda? notebook quickstart memungkinkan Anda mengonfigurasi robot sekali dan menghasilkan semua perintah di bawah ini yang siap ditempelkan.

Menyiapkan dan Mengkalibrasi

Jika Anda belum mengatur dan mengkalibrasi robot serta perangkat teleop Anda, silakan lakukan dengan mengikuti tutorial untuk robot Anda, misalnya SO-101, OpenArm, Koch atau LeKiwi. Semua robot yang didukung tercantum di bawah Robots di bilah sisi.

Teleoperasi

Pada contoh ini, kami akan mendemonstrasikan cara melakukan teleoperasi robot SO101. Untuk setiap perintah, kami juga menyediakan contoh API yang sesuai.

Perhatikan bahwa id yang terkait dengan robot digunakan untuk menyimpan file kalibrasi. Penting untuk menggunakan id yang sama saat melakukan teleoperasi, perekaman, dan evaluasi ketika menggunakan setup yang sama.

Perintah

Contoh API

Perintah teleoperate akan secara otomatis:

Identifikasi kalibrasi yang hilang dan mulai prosedur kalibrasi.
Hubungkan robot dan perangkat teleop, lalu mulai teleoperation.

Kamera

Untuk menambahkan kamera ke pengaturan Anda, ikuti Panduan ini.

Teleoperasi dengan kamera

Dengan rerun, Anda dapat melakukan teleoperasi kembali sambil secara bersamaan memvisualisasikan umpan kamera dan posisi sendi. Contoh ini menggunakan dua kamera, wrist dan top; kami mempertahankan pengaturan kamera yang sama untuk sisa tutorial.

Perintah

Contoh API

Rekam dataset

Setelah Anda terbiasa dengan teleoperation, Anda dapat merekam dataset pertama Anda.

Kami menggunakan fitur Hugging Face hub untuk mengunggah dataset Anda. Jika Anda belum pernah menggunakan Hub sebelumnya, pastikan Anda dapat login via cli menggunakan token dengan akses tulis; token ini dapat dibuat dari pengaturan Hugging Face.

Tambahkan token Anda ke CLI dengan menjalankan perintah ini:

hf auth login --token ${HUGGINGFACE_TOKEN} --add-to-git-credential

Lalu simpan nama repositori Hugging Face Anda dalam sebuah variabel:

HF_USER=$(NO_COLOR=1 hf auth whoami | awk -F': *' 'NR==1 {print $2}')
echo $HF_USER

Sekarang Anda dapat merekam dataset. Untuk merekam 5 episode dan mengunggah dataset Anda ke hub, sesuaikan kode di bawah ini untuk robot Anda dan jalankan perintah atau contoh API.

Perintah

Contoh API

lerobot-record \
    --robot.type=so101_follower \
    --robot.port=/dev/tty.usbmodem585A0076841 \
    --robot.id=my_awesome_follower_arm \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 1920, height: 1080, fps: 30}}" \
    --robot.cameras="{ wrist: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, top: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30}}" \
    --teleop.type=so101_leader \
    --teleop.port=/dev/tty.usbmodem58760431551 \
    --teleop.id=my_awesome_leader_arm \
    --display_data=true \
    --dataset.repo_id=${HF_USER}/record-test \
    --dataset.num_episodes=5 \
    --dataset.single_task="Grab the black cube" \
    --dataset.streaming_encoding=true \
    --dataset.encoder_threads=2
# Optional: --dataset.rgb_encoder.vcodec=auto

from lerobot.cameras.opencv import OpenCVCameraConfig
from lerobot.datasets.lerobot_dataset import LeRobotDataset
from lerobot.utils.feature_utils import hw_to_dataset_features
from lerobot.robots.so_follower import SO101Follower, SO101FollowerConfig
from lerobot.teleoperators.so_leader.config_so_leader import SO101LeaderConfig
from lerobot.teleoperators.so_leader.so_leader import SO101Leader
from lerobot.common.control_utils import init_keyboard_listener
from lerobot.utils.utils import log_say
from lerobot.utils.visualization_utils import init_visualization
from lerobot.scripts.lerobot_record import record_loop
from lerobot.processor import make_default_processors

NUM_EPISODES = 5
FPS = 30
EPISODE_TIME_SEC = 60
RESET_TIME_SEC = 10
TASK_DESCRIPTION = "My task description"

def main():
    # Create robot configuration
    robot_config = SO101FollowerConfig(
        port="/dev/tty.usbmodem5AB90687491",
        id="my_follower_arm",
        cameras={
            "wrist": OpenCVCameraConfig(index_or_path=0, width=640, height=480, fps=30),
            "top": OpenCVCameraConfig(index_or_path=1, width=640, height=480, fps=30)
        }
    )

    teleop_config = SO101LeaderConfig(
        port="/dev/tty.usbmodem5AB90689011",
        id="my_leader_arm",
    )

    # Initialize the robot and teleoperator
    robot = SO101Follower(robot_config)
    teleop = SO101Leader(teleop_config)

    # Configure the dataset features
    action_features = hw_to_dataset_features(robot.action_features, "action")
    obs_features = hw_to_dataset_features(robot.observation_features, "observation")
    dataset_features = {**action_features, **obs_features}

    # Create the dataset
    dataset = LeRobotDataset.create(
        repo_id="<hf_username>/<dataset_repo_id>",
        fps=FPS,
        features=dataset_features,
        robot_type=robot.name,
        use_videos=True,
        image_writer_threads=4,
    )

    # Initialize the keyboard listener and rerun visualization
    _, events = init_keyboard_listener()
    init_visualization("rerun", session_name="recording")

    # Connect the robot and teleoperator
    robot.connect()
    teleop.connect()

    # Create the required processors
    teleop_action_processor, robot_action_processor, robot_observation_processor = make_default_processors()

    episode_idx = 0
    while episode_idx < NUM_EPISODES and not events["stop_recording"]:
        log_say(f"Recording episode {episode_idx + 1} of {NUM_EPISODES}")

        record_loop(
            robot=robot,
            events=events,
            fps=FPS,
            teleop_action_processor=teleop_action_processor,
            robot_action_processor=robot_action_processor,
            robot_observation_processor=robot_observation_processor,
            teleop=teleop,
            dataset=dataset,
            control_time_s=EPISODE_TIME_SEC,
            single_task=TASK_DESCRIPTION,
            display_data=True,
        )

        # Reset the environment if not stopping or re-recording
        if not events["stop_recording"] and (episode_idx < NUM_EPISODES - 1 or events["rerecord_episode"]):
            log_say("Reset the environment")
            record_loop(
                robot=robot,
                events=events,
                fps=FPS,
                teleop_action_processor=teleop_action_processor,
                robot_action_processor=robot_action_processor,
                robot_observation_processor=robot_observation_processor,
                teleop=teleop,
                control_time_s=RESET_TIME_SEC,
                single_task=TASK_DESCRIPTION,
                display_data=True,
            )

        if events["rerecord_episode"]:
            log_say("Re-recording episode")
            events["rerecord_episode"] = False
            events["exit_early"] = False
            dataset.clear_episode_buffer()
            continue

        dataset.save_episode()
        episode_idx += 1

    # finalize dataset
    log_say("Finalizing dataset...")
    dataset.finalize()
    # Clean up
    log_say("Stop recording")
    robot.disconnect()
    teleop.disconnect()
    dataset.push_to_hub()


if __name__ == "__main__":
    main()

Nama kamera yang Anda pilih (di sini wrist dan top) menjadi kunci dataset observation.images.wrist dan observation.images.top. Kebijakan yang dilatih pada dataset ini mengharapkan nama kamera dan resolusi yang sama saat Anda mendeploynya, jadi gunakan kembali nilai --robot.cameras yang sama di setiap langkah tutorial ini. Jika nama harus berbeda, lihat Rename Map.

lerobot-record menambahkan tanggal dan waktu sesi ke akhir --dataset.repo_id, sehingga setiap rekaman memiliki nama unik: ${HF_USER}/record-test disimpan sebagai ${HF_USER}/record-test_YYYYMMDD_HHMMSS (misalnya record-test_20260929_143012). Temukan nama lengkapnya di profil Hugging Face Anda atau dengan ls ~/.cache/huggingface/lerobot/${HF_USER}, dan gunakan nama tersebut di mana pun perintah di bawah ini menyebutkan record-test_YYYYMMDD_HHMMSS. Untuk mempertahankan nama persis yang Anda berikan, tambahkan --dataset.no_stamp=true.

Unggah dataset

Secara lokal, dataset Anda disimpan di folder ini: ~/.cache/huggingface/lerobot/{repo-id}. Pada akhir perekaman data, dataset Anda akan diunggah ke halaman Hugging Face Anda (misalnya https://huggingface.co/datasets/${HF_USER}/record-test_YYYYMMDD_HHMMSS) yang dapat Anda peroleh dengan menjalankan:

echo https://huggingface.co/datasets/${HF_USER}/record-test_YYYYMMDD_HHMMSS

Dataset Anda akan secara otomatis diberi tag LeRobot agar mudah ditemukan oleh komunitas, dan Anda juga dapat menambahkan tag kustom, misalnya --dataset.tags='["tutorial"]'.

Anda dapat mencari dataset LeRobot lainnya di hub dengan mencari tag LeRobot.

Anda juga dapat mendorong dataset lokal Anda ke Hub secara manual, dengan menjalankan:

hf upload ${HF_USER}/record-test_YYYYMMDD_HHMMSS ~/.cache/huggingface/lerobot/${HF_USER}/record-test_YYYYMMDD_HHMMSS --repo-type dataset

Fungsi rekaman

lerobot-record menyediakan serangkaian alat untuk menangkap dan mengelola data selama operasi robot:

1. Penyimpanan Data

Data disimpan menggunakan format LeRobotDataset dan disimpan di disk selama proses perekaman.
Secara default, dataset didorong ke halaman Hugging Face Anda setelah perekaman.
- Untuk menonaktifkan pengunggahan, gunakan --dataset.push_to_hub=False.

2. Pengecekan dan Penuan

Checkpoint dibuat secara otomatis selama proses perekaman.
Jika terjadi masalah atau Anda ingin merekam episode tambahan dalam dataset yang sama, Anda dapat melanjutkan dengan menjalankan ulang perintah yang sama menggunakan --resume=true. Sertakan nama dataset lengkap, termasuk timestamp-nya (--dataset.repo_id=${HF_USER}/record-test_YYYYMMDD_HHMMSS). Saat melanjutkan perekaman, --dataset.num_episodes harus diatur ke jumlah episode tambahan yang akan direkam, bukan ke jumlah total episode yang ditargetkan dalam dataset! Pastikan Anda juga mengatur --dataset.root="local_path", yaitu jalur lokal untuk menyimpan bagian baru dari dataset dan diperlukan untuk melanjutkan.
Menjalankan ulang perintah tanpa --resume=true akan memulai dataset baru dengan timestamp baru. Jika Anda menggunakan --dataset.no_stamp=true, hapus terlebih dahulu direktori dataset yang sudah ada.

3. Parameter Perekaman

Atur aliran perekaman data menggunakan argumen baris perintah:

--dataset.episode_time_s=60 Durasi setiap episode perekaman data (default: 60 detik).
--dataset.reset_time_s=60 Durasi untuk mereset lingkungan setelah setiap episode (default: 60 detik).
--dataset.num_episodes=50 Total jumlah episode yang akan direkam (default: 50).

4. Kontrol Papan Ketik Saat Merekam

Kontrol alur perekaman data menggunakan pintasan keyboard:

Tekan Panah Kanan (→) atau n: Hentikan dini episode saat ini atau atur ulang waktu dan pindah ke episode berikutnya.
Tekan Tombol Panah Kiri (←) atau r: Batalkan episode saat ini dan rekam ulang.
Tekan Escape (ESC) atau q: Hentikan sesi secara langsung, encode video, dan unggah dataset.

Pintasan alur kontrol ini berfungsi pada sesi X11, Wayland, dan headless/SSH. Ketika backend keyboard global tidak tersedia (Wayland, mesin headless, atau macOS tanpa izin Accessibility), lerobot-record secara otomatis membaca tombol yang sama dari terminal — jalankan dari terminal interaktif dan pastikan terminal tetap fokus. Anda juga dapat menggunakan ekuivalen huruf n (berikutnya, sama dengan →), r (rekam ulang, sama dengan ←) dan q (keluar, sama dengan ESC). Tidak diperlukan pengaturan $DISPLAY.

Hal ini hanya berlaku untuk alur kontrol perekaman. Teleoperasi keyboard (mengendalikan robot dengan keyboard) masih memerlukan backend key global, sehingga hanya berfungsi pada sesi X11, desktop Windows, atau macOS dengan izin Accessibility/Input Monitoring — tidak pada Wayland atau sesi headless.

Tips untuk mengumpulkan data

Setelah Anda terbiasa dengan perekaman data, Anda dapat membuat dataset yang lebih besar untuk pelatihan. Tugas awal yang baik adalah menggenggam objek di berbagai lokasi dan meletakkannya ke dalam wadah. Kami menyarankan untuk merekam setidaknya 50 episode, dengan 10 episode per lokasi. Jaga agar kamera tetap diam dan pertahankan perilaku penggengaman yang konsisten selama perekaman. Pastikan juga objek yang Anda manipulasi terlihat oleh kamera. Aturan praktis yang baik adalah Anda harus mampu melakukan tugas tersebut sendiri hanya dengan melihat gambar dari kamera.

Pada bagian-bagian berikut, Anda akan melatih jaringan saraf Anda. Setelah mencapai kinerja pegangan yang andal, Anda dapat mulai memperkenalkan lebih banyak variasi selama pengumpulan data, seperti lokasi pegangan tambahan, teknik pegangan yang berbeda, dan mengubah posisi kamera.

Hindari menambahkan terlalu banyak variasi terlalu cepat, karena hal itu dapat menghambat hasil Anda.

Jika Anda ingin mendalami topik penting ini, Anda dapat membaca artikel blog yang kami tulis tentang apa yang membuat dataset menjadi baik.

Pelaporan cadence

lerobot-record mengatur tempo loop pada --dataset.fps dan melaporkan apa yang benar-benar dicapai: ringkasan satu baris untuk setiap episode yang Anda simpan, dan blok untuk seluruh sesi saat perekaman berakhir — termasuk saat Ctrl-C.

Cadence (episode 0): 29.88 Hz vs 30 Hz target · 600 ticks, 20.0 s measured · 8/599 ticks over the 33.3 ms budget (work mean 18.4 ms, worst 45.1 ms)
Cadence (episode 1): 29.88 Hz vs 30 Hz target · 600 ticks, 20.0 s measured · 8/599 ticks over the 33.3 ms budget (work mean 18.4 ms, worst 45.1 ms)
Cadence summary — whole run, 2 episodes · target 30 Hz (33.3 ms budget per tick): 1200 ticks, 1198 judged
  effective cadence: 29.88 Hz over 40.1 s measured
  ticks over the 33.3 ms work budget: 16/1198 (1.3%) — work mean 18.4 ms, worst 45.1 ms
  loop-body steps (share of measured work):
    observe      mean  13.65 ms · worst  40.20 ms ·  74.4% of work · 1200 calls
    process_obs  mean   0.30 ms · worst   0.30 ms ·   1.6% of work · 1200 calls
    teleop       mean   1.80 ms · worst   1.80 ms ·   9.8% of work · 1200 calls
    send         mean   0.90 ms · worst   0.90 ms ·   4.9% of work · 1200 calls
    record       mean   1.70 ms · worst   1.90 ms ·   9.3% of work · 1200 calls
  pacing headroom: 15.1 ms slept per tick on average (max 16.7 ms) — near zero means the loop is saturated

Ini layak dibaca sebelum Anda melatih pada dataset. Stempel waktu sebuah frame diturunkan dari indeksnya, sehingga sesi yang berjalan pada 25 Hz tetap menghasilkan dataset yang menyatakan 30 — gerakan yang direkam hanya lebih cepat dari kenyataan. Di atas, observe adalah 74% dari kerja loop dan worst adalah 40 ms pada anggaran 33,3 ms: kamera-lah yang mendorong 16 tick tersebut melewati batas. Ruang napas pacing yang mendekati nol berarti tidak ada lagi yang tersisa untuk menyerap tick yang lambat.

Fase reset antar episode diatur dengan cara yang sama, tetapi sengaja tidak dimasukkan ke dalam angka-angka ini, karena fase tersebut tidak merekam apa pun. lerobot-teleoperate dan lerobot-replay melaporkan dengan cara yang sama, dan lerobot-rollout menambahkan baris-baris khusus interpolasi yang dijelaskan dalam Laporan Cadence.

Pemecahan masalah:

Pada Linux, tombol alur kontrol perekaman (tombol panah, Escape) berfungsi di X11, Wayland, dan sesi headless/SSH selama lerobot-record dijalankan di terminal interaktif — tidak perlu pengaturan $DISPLAY. Jika tombol tidak berefek, pastikan Anda berada di terminal interaktif (TTY), bukan sesi piped/non-TTY, dan bahwa terminal tersebut sedang difokuskan; ekuivalen huruf n / r / q juga berfungsi. Teleoperation keyboard (berbeda dengan alur kontrol perekaman) masih memerlukan backend kunci global — sesi X11, desktop Windows, atau macOS dengan izin Accessibility/Input Monitoring — dan tidak tersedia di Wayland atau mesin headless. Lihat batasan pynput.

Visualisasi dataset

Dataset Anda diunggah ke Hub secara default (kecuali Anda meneruskan --dataset.push_to_hub=False), sehingga Anda dapat membukanya di LeRobot Dataset Visualizer segera: masukkan repo id Anda di halaman beranda-nya, atau langsung ke episode pertama dengan tautan yang dicetak ini:

echo "https://huggingface.co/spaces/lerobot/visualize_dataset?path=/${HF_USER}/record-test_YYYYMMDD_HHMMSS/episode_0"

Masuk ke visualizer untuk membuka dataset privat. Lihat Jelajahi Dataset di Browser untuk panduan langkah demi langkah.

Putar ulang episode

Fitur yang berguna adalah fungsi replay, yang memungkinkan Anda memutar ulang episode apa pun yang telah Anda rekam atau episode dari dataset mana pun. Fungsi ini membantu Anda menguji keterulangan tindakan robot Anda dan menilai kemampuan transfer antar robot dengan model yang sama.

Anda dapat memutar ulang episode pertama di robot Anda dengan menggunakan perintah di bawah ini atau dengan contoh API:

Perintah

Contoh API

Robot Anda harus mereplikasi gerakan yang mirip dengan gerakan yang Anda rekam. Sebagai contoh, lihat video ini di mana kami menggunakan replay pada robot ALOHA dari Trossen Robotics.

Melatih kebijakan

Untuk melatih kebijakan guna mengendalikan robot Anda, gunakan skrip lerobot-train. Beberapa argumen diperlukan. Berikut adalah contoh perintah:

lerobot-train \
  --dataset.repo_id=${HF_USER}/record-test_YYYYMMDD_HHMMSS \
  --policy.type=act \
  --output_dir=outputs/train/act_so101_test \
  --job_name=act_so101_test \
  --policy.device=cuda \
  --trackio.enable=true \
  --policy.repo_id=${HF_USER}/my_policy

Mari kita jelaskan perintahnya:

Kami menyediakan dataset yang direkam sebelumnya sebagai argumen dengan --dataset.repo_id=${HF_USER}/record-test_YYYYMMDD_HHMMSS (gunakan nama lengkap dataset Anda, termasuk timestamp).
Kami memberikan kebijakan dengan policy.type=act. Ini memuat konfigurasi dari configuration_act.py. Pentingnya, kebijakan ini akan secara otomatis beradaptasi dengan jumlah keadaan motor, aksi motor, dan kamera robot Anda (misalnya wrist dan top) yang telah disimpan dalam dataset Anda.
Kami menyediakan policy.device=cuda karena kami melatih pada GPU Nvidia, tetapi Anda dapat menggunakan policy.device=mps untuk melatih pada Apple silicon.
Kami menyediakan trackio.enable=true untuk menggunakan Trackio dalam memvisualisasikan plot pelatihan. Ini bersifat opsional. Jalankan trackio show --project lerobot untuk membuka dasbor, atau berikan --trackio.space_id=<user>/<space> untuk menyinkronkan run ke Hugging Face Space.
Kami tidak mengatur --steps, sehingga pelatihan berjalan selama 100.000 langkah secara default. Itu biasanya lebih dari yang dibutuhkan dataset kecil: pembelajaran imitasi umumnya konvergen dalam 5–10 epoch pada data. Lihat Panduan Komputasi & Perangkat Keras untuk mengubah epoch menjadi nilai --steps sesuai ukuran dataset dan ukuran batch Anda.

Pelatihan seharusnya memakan waktu beberapa jam. Anda akan menemukan checkpoint di outputs/train/act_so101_test/checkpoints.

Untuk melanjutkan pelatihan dari checkpoint, berikut adalah contoh perintah untuk melanjutkan dari checkpoint last dari kebijakan act_so101_test:

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

--config_path juga menerima id repo Hub: jika sebuah run telah mendorong checkpoint-nya ke Hub (dengan --save_checkpoint_to_hub=true), Anda dapat melanjutkan langsung dari repo tersebut — checkpoint terkininya akan diunduh dan pelatihan dilanjutkan, dengan memulihkan optimizer, scheduler, penghitung langkah, dan urutan data:

lerobot-train --config_path=${HF_USER}/my_policy --resume=true

Jika Anda tidak ingin mendorong model Anda ke hub setelah pelatihan, gunakan --policy.push_to_hub=false.

Selain itu, Anda dapat menyediakan tags tambahan atau menentukan license untuk model Anda, atau membuat repo model menjadi private dengan menambahkan ini: --policy.private=true --policy.tags=\[so101,tutorial\] --policy.license=mit

Melatih menggunakan Google Colab

Jika komputer lokal Anda tidak memiliki GPU yang bertenaga, Anda dapat memanfaatkan Google Colab untuk melatih model Anda dengan mengikuti notebook pelatihan ACT.

Melatih menggunakan Hugging Face Jobs

Hugging Face Jobs memungkinkan Anda memilih hardware dengan mudah dan menjalankan pelatihan di cloud. Jadi, jika Anda tidak memiliki GPU yang bertenaga, membutuhkan lebih banyak VRAM, atau hanya ingin melatih model jauh lebih cepat, gunakan HF Jobs! Biayanya sesuai pemakaian dan Anda cukup membayar untuk setiap detik penggunaan. Anda dapat melihat harga dan informasi tambahan di sini.

lerobot-train dijalankan secara lokal secara default. Untuk menjalankannya di GPU HuggingFace, berikan --job.target dengan nama hardware flavor:

lerobot-train \
  --dataset.repo_id=${HF_USER}/record-test_YYYYMMDD_HHMMSS \
  --policy.type=act \
  --policy.repo_id=${HF_USER}/my_policy \
  --job.target=a10g-small

Daftarkan rasa dan harga yang tersedia dengan hf jobs hardware. Eksekusi akan mengalirkan log-nya ke terminal Anda; tekan Ctrl-C untuk melepas (pekerjaan tetap berjalan di cloud). Sambungkan kembali atau batalkan dengan:

hf jobs logs <job-id>
hf jobs cancel <job-id>

Jika dataset Anda hanya ada secara lokal (belum ada di Hub), dataset tersebut akan otomatis didorong ke repo Hub private agar job dapat mengunduhnya melalui repo_id (tidak ada yang dibuat publik). Model yang telah dilatih akan didorong ke repo model di akhir run. Untuk juga mendorong setiap checkpoint antara ke Hub saat disimpan (sehingga Anda dapat memantau kemajuan di tengah run), tambahkan --save_checkpoint_to_hub=true — ini memerlukan runtime image yang mencakup fitur ini.

Setiap job (dan dataset apa pun yang di-push oleh run) diberi tag lerobot sehingga mudah ditemukan di Hub. Tambahkan tag Anda sendiri dengan --job.tags '["my-tag"]'.

Secara default, pekerjaan dibatasi hingga 2d (48 jam) waktu berjalan. Ubah batas ini dengan string durasi HF Jobs, misalnya --job.timeout=4h untuk gagal lebih cepat atau --job.timeout=7d untuk eksekusi yang lebih lama.

Catatan: repo model dibuat di awal (repo ini menyimpan konfigurasi pelatihan yang di-staging untuk dijalankan oleh job). Jika sebuah run gagal sebelum model di-push, repo tersebut tetap ada di Hub agar dapat Anda periksa — repo tidak dihapus secara otomatis, sehingga kegagalan berulang dapat meninggalkan repo kosong. Hapus satu repo dengan hf repos delete <repo-id>.

Prasyarat: jalankan hf auth login sebelum mengirim. Untuk Trackio, berikan --trackio.space_id=<user>/<space> — Space akan dibuat jika belum ada dan HF_TOKEN dari job diteruskan secara otomatis.

Melanjutkan pada sebuah job. Menambahkan --job.target ke perintah resume akan menjalankan resume di cloud — perintah yang sama berfungsi baik secara lokal maupun jarak jauh. Repo checkpoint adalah sumber kebenaran, dan checkpoint baru melanjutkan garis keturunan di repo yang sama:

# resume a Hub run on a job (its checkpoints are already on the Hub)
lerobot-train --config_path=${HF_USER}/my_policy --resume=true --job.target=a10g-small

# resume a LOCAL run on a job — the checkpoint is uploaded to a private Hub repo first,
# then the job resumes from it (a local-only dataset is uploaded the same way)
lerobot-train \
  --config_path=outputs/train/act_so101_test/checkpoints/last/pretrained_model/train_config.json \
  --resume=true \
  --job.target=a10g-small

Pengaturan pekerjaan berasal dari perintah saat ini, sehingga timpa --job.target, --job.timeout, dll. sesuai kebutuhan; agar jalannya yang dilanjutkan dapat dilanjutkan kembali di kemudian hari, pertahankan --save_checkpoint_to_hub=true.

Unggah checkpoint kebijakan

Setelah pelatihan selesai, unggah checkpoint terbaru dengan:

hf upload ${HF_USER}/act_so101_test \
  outputs/train/act_so101_test/checkpoints/last/pretrained_model

Anda juga dapat mengunggah checkpoint antara dengan:

CKPT=010000
hf upload ${HF_USER}/act_so101_test${CKPT} \
  outputs/train/act_so101_test/checkpoints/${CKPT}/pretrained_model

Jalankan inferensi dan evaluasi kebijakan Anda

Gunakan lerobot-rollout untuk mendeploy kebijakan yang telah dilatih pada robot Anda. Anda dapat memilih strategi yang berbeda sesuai kebutuhan Anda.

Gunakan --robot.id yang sama (agar kalibrasi ditemukan), --robot.cameras yang sama, dan deskripsi tugas yang sama seperti pada dataset yang Anda rekam. Dataset yang direkam oleh lerobot-rollout harus memiliki nama yang diawali dengan rollout_, dan seperti lerobot-record, ia menambahkan timestamp ke nama tersebut.

Contoh di bawah memuat model dari --policy.path. Untuk mengunci versi yang di-push secara spesifik — berguna setelah --save_checkpoint_to_hub=true telah mengomitm beberapa checkpoint — tambahkan --policy.pretrained_revision dengan hash commit, branch, atau tag. Setiap checkpoint yang di-push diberi tag sesuai langkahnya (mis. --policy.pretrained_revision=010000), sehingga Anda dapat memulihkan checkpoint berdasarkan langkah tanpa perlu mencari sha commit-nya.

Mode dasar (tanpa perekaman)

Mode Sentry (dengan perekaman)

Flag --strategy.type memilih mode eksekusi:

base: Rollout otonom tanpa perekaman data (berguna untuk evaluasi cepat)
sentry: Perekaman berkelanjutan dengan unggah otomatis (berguna untuk evaluasi skala besar)
highlight: Perekaman ring buffer dengan penyimpanan ketukan (berguna untuk menangkap peristiwa menarik)
dagger: Pengumpulan data dengan human-in-the-loop (lihat Pengumpulan Data HIL)
episodic: Perekaman kebijakan yang berorientasi pada episode dengan fase reset di antara episode

Semua strategi mendukung --inference.type=rtc untuk eksekusi yang mulus dengan model VLA lambat (Pi0, Pi0.5, SmolVLA). Lihat Policy Deployment untuk setiap strategi dan flag-nya.

Update on GitHub

←Lembar contekan LeLab - Lerobot GUI→