# Panduan HW Komputasi untuk Pelatihan LeRobot

Perkiraan ukuran untuk melatih kebijakan LeRobot: berapa banyak VRAM yang dibutuhkan oleh masing-masing kebijakan, bagaimana perkiraan waktu latihannya, dan di mana harus menjalankannya jika perangkat keras lokal tidak mencukupi.

Angka-angka di bawah ini bersifat **indikatif** — angka orde magnitudo untuk memilih perangkat keras, bukan prediksi yang tepat. Throughput sangat bergantung pada I/O dataset, resolusi gambar, ukuran batch, dan jumlah GPU.

## Memori per grup kebijakan

Policies dikelompokkan berdasarkan ukuran backbone; pengelompokan di bawah ini memberikan satu batas VRAM per kelompok alih-alih mengulang angka untuk setiap policy. Memori berskala kira-kira linier dengan ukuran batch; AdamW (default LeRobot) membawa state optimizer yang menambah sekitar 30–100% di atas jalur forward+backward saja.

| Grup      | Kebijakan                                    | VRAM Puncak (BS 8, AdamW) | GPU pemula yang cocok             |
| ---------- | ------------------------------------------- | ----------------------: | --------------------------------- |
| BC Ringan   | `act`, `vqbet`, `tdmpc`                     |                  ~2–6GB | GPU Laptop (RTX 3060), L4, A10G   |
| Diffusion  | `diffusion`, `multi_task_dit`               |                 ~8–14GB | RTX 4070+ / L4 / A10G             |
| VLA Kecil  | `smolvla`                                   |                ~10–16GB | RTX 4080+ / L4 / A10G             |
| VLA Besar  | `pi0`, `pi0_fast`, `pi05`, `xvla`, `wall_x` |                ~24–40GB | A100 40 GB+ (24 GB ketat pada BS 1) |
| Multimodal | `groot`, `eo1`                              |                ~24–40GB | A100 40 GB+                       |
| RL         | `sac`                                       |             config-dep. | Lihat [panduan HIL-SERL](./hilserl)   |

Terbatas memori? Kurangi ukuran batch (~linear), gunakan akumulasi gradien untuk memulihkan batch efektif, atau untuk SmolVLA biarkan `freeze_vision_encoder=True`.

## Waktu pelatihan

Pembelajaran imitasi dalam robotika biasanya konvergen dalam **5–10 epoch pada dataset**, bukan ratusan ribu langkah mentah. Setelah Anda mengetahui jumlah epoch, waktu nyata pada dasarnya adalah:

```text
total_frames    = sum of frames over all episodes      # 50 ep × 30 fps × 30 s ≈ 45,000
steps_per_epoch = ceil(total_frames / (num_gpus × batch_size))
total_steps     = epochs × steps_per_epoch
wall_clock      ≈ total_steps × per_step_time
```

Waktu per langkah bergantung pada kebijakan dan GPU. Angka dalam tabel di bawah ini adalah acuan — pilih baris yang paling mendekati konfigurasi Anda dan skalakan secara linear dengan `total_steps` jika Anda melatih lebih lama atau lebih singkat.

### Skenario umum

Estimasi waktu nyata untuk **5 epoch pada dataset ~50 episode (~45k frame pada 30 fps × 30 s)**, optimizer default (AdamW), gambar 640×480:

| Setup                                | Kebijakan         | Batch | Waktu nyata |
| ------------------------------------ | -------------- | ----- | ---------: |
| Satu RTX 4090 / RTX 3090 (24 GB)   | `act`          | 8     |  ~30–60 menit |
| Satu RTX 4090 / RTX 3090 (24 GB)   | `diffusion`    | 8     |      ~2–4h |
| Satu L4 / A10G (24 GB)             | `act`          | 8     |      ~1–2h |
| Satu L4 / A10G (24 GB)             | `smolvla`      | 4     |      ~3–6h |
| Satu A100 40 GB                    | `smolvla`      | 16    |      ~1–2h |
| Satu A100 40 GB                    | `pi0` / `pi05` | 4     |      ~4–8h |
| Klaster 4× H100 80 GB (`accelerate`) | `diffusion`    | 32    |  ~30–60 menit |
| Klaster 4× H100 80 GB (`accelerate`) | `smolvla`      | 32    |      ~1–2h |
| Apple Silicon M1/M2/M3 Max (MPS)     | `act`          | 4     |     ~6–14h |

Angka-angka ini bersifat perkiraan orde magnitudo. Eksekusi nyata dapat menyimpang ±50% tergantung pada resolusi gambar, I/O dataset, threading dataloader, dan SKU GPU yang tepat. Angka-angka ini berguna sebagai intuisi "apakah eksekusi ini akan memakan waktu satu jam atau satu hari?", bukan sebagai SLA.

### Multi-GPU sangat penting

`accelerate launch --num_processes=N` adalah cara termudah untuk memangkas waktu pelatihan. Setiap langkah optimizer memproses `N × batch_size` sampel dalam waktu nyata yang kurang lebih sama dengan satu langkah pada GPU tunggal, sehingga 4 GPU ≈ percepatan 4× untuk eksekusi yang terikat komputasi. Lihat panduan [Multi GPU training](./multi_gpu_training) untuk pengaturan lengkap.

Titik data referensi pada klaster 4×H100 80 GB (`accelerate launch --num_processes=4`), 5000 langkah, batch 32, AdamW, dataset [`imstevenpmwork/super_poulain_draft`](https://huggingface.co/datasets/imstevenpmwork/super_poulain_draft) (~50 episode, ~640×480 gambar):

| Kebijakan      | Waktu nyata | `update_s` | `dataloading_s` | Utilisasi GPU | Flag yang menonjol                                                                                                                  |
| ----------- | ---------- | ---------: | --------------: | -------- | ------------------------------------------------------------------------------------------------------------------------------ |
| `diffusion` | 16m 17s    |      0.167 |           0.015 | ~90%     | default (pelatihan dari awal)                                                                                               |
| `smolvla`   | 27m 49s    |      0.312 |           0.011 | ~80%     | `--policy.path=lerobot/smolvla_base`, `freeze_vision_encoder=false`, `train_expert_only=false`                                 |
| `pi05`      | 3h 41m     |      2.548 |           0.014 | ~95%     | `--policy.pretrained_path=lerobot/pi05_base`, `gradient_checkpointing=true`, `dtype=bfloat16`, vision encoder + expert dilatih |

Log pelatihan memisahkan iterasi penuh menjadi `dataloading_s` (`next(dl_iter)`), `preprocessing_s` (konversi gambar dan pipeline kebijakan), serta `update_s` (pembaruan optimizer). `step_s` mencakup ketiga bagian tersebut dan menggerakkan `samples_per_s`. Benchmark di atas dibuat sebelum pemisahan ini, sehingga `dataloading_s` di dalamnya mencakup preprocessing.

### Jadwal dan checkpoint

Jika Anda mempersingkat pelatihan (misalnya 5k–10k langkah pada dataset kecil), persingkat juga jadwal LR dengan `--policy.scheduler_decay_steps≈--steps`. Jika tidak, LR akan tetap dekat puncaknya dan tidak pernah meluruh. Hal yang sama berlaku untuk `--save_freq`.

## Di mana untuk dijalankan

VRAM adalah filter pertama. Dalam satu tier, pilih berdasarkan anggaran dan ketersediaan — kolom `$`–`$$$$` bersifat relatif; periksa harga terkini di penyedia yang Anda gunakan.

| Kelas                      | VRAM  | Tier   | Nyaman untuk                                             |
| -------------------------- | ----- | ------ | ----------------------------------------------------------- |
| RTX 3090 / 4090 (konsumen) | 24 GB | `$`    | Light BC, Diffusion, SmolVLA. Ketat untuk VLAs pada batch 1.    |
| L4 / A10G (cloud)          | 24 GB | `$–$$` | Sampul yang sama; umum di Google Cloud, RunPod, AWS `g5/g6`. |
| A100 40 GB                 | 40 GB | `$$$`  | Setiap kebijakan pada ukuran batch yang wajar.                       |
| A100 80 GB / H100 80 GB    | 80 GB | `$$$$` | Klaster multi-GPU; batch besar untuk VLA.                 |
| **Hanya CPU**               | —     | —      | Jangan melatih. Gunakan Colab atau sewa GPU.                       |

### Hugging Face Pekerjaan

[Hugging Face Jobs](https://huggingface.co/docs/hub/jobs) memungkinkan Anda menjalankan pelatihan pada infrastruktur HF yang dikelola, dengan penagihan per detik, tanpa perlu memiliki GPU. `lerobot-train` mengirimkan dan mengalirkan pekerjaan untuk Anda — cukup tambahkan `--job.target=<flavor>` ke perintah pelatihan biasa:

```bash
lerobot-train \
  --policy.type=act --dataset.repo_id=<USER>/<DATASET> \
  --policy.repo_id=<USER>/act_<task> \
  --job.target=a10g-large
```

Catatan:

- Jalankan `hf auth login` sekali sebelum mengirim, pekerjaan akan berjalan di bawah token Anda.
- `--job.target` dipetakan ke tabel di atas: `t4-small`/`t4-medium` (T4, hanya ACT), `l4x1`/`l4x4` (L4 24 GB), `a10g-small/large/largex2/largex4` (A10G 24 GB scaled out), `a100-large` (A100). Daftarkan katalog saat ini beserta harganya melalui `hf jobs hardware`, atau lihat [https://huggingface.co/docs/hub/jobs](https://huggingface.co/docs/hub/jobs).
- Job secara default menggunakan timeout `2d` (48 jam). Timpa dengan `--job.timeout=4h` (atau string durasi valid lainnya) untuk memperpendek atau memperpanjang timeout. Job akan berhenti secara otomatis ketika perintah selesai.
- Untuk panduan lengkap — unggah dataset, streaming checkpoint, melanjutkan run pada job — lihat [panduan pelatihan imitation-learning](./il_robots#train-using-hugging-face-jobs).

