# Kebijakan π₀.₅ (Pi05)

π₀.₅ adalah **model Vision-Language-Action dengan generalisasi dunia terbuka**, dari Physical Intelligence. Implementasi LeRobot diadaptasi dari repositori [OpenPI](https://github.com/Physical-Intelligence/openpi) open source mereka.

## Ringkasan Model

π₀.₅ merupakan evolusi signifikan dari π₀, yang dikembangkan oleh [Physical Intelligence](https://www.physicalintelligence.company/blog/pi05) untuk mengatasi tantangan besar dalam robotika: **generalisasi dunia terbuka**. Meskipun robot dapat melakukan tugas-tugas yang mengesankan di lingkungan yang terkendali, π₀.₅ dirancang untuk digeneralisasikan ke lingkungan dan situasi baru yang sama sekali tidak pernah dilihat selama pelatihan.

### Tantangan Generalisasi

Seperti yang dijelaskan oleh Physical Intelligence, tantangan mendasarnya bukanlah melakukan tugas-tugas yang membutuhkan kelincahan atau kehalusan gerak, melainkan generalisasi, yaitu kemampuan untuk melakukan tugas dengan benar di pengaturan baru dengan objek-objek baru. Bayangkan sebuah robot yang membersihkan rumah-rumah yang berbeda: setiap rumah memiliki objek-objek yang berbeda di tempat-tempat yang berbeda. Generalisasi harus terjadi pada beberapa tingkatan:

- **Tingkat Fisik**: Memahami cara mengambil sendok (dengan gagangnya) atau piring (dengan tepinya), bahkan dengan objek yang belum pernah dilihat sebelumnya di lingkungan yang berantakan
- **Tingkat Semantik**: Memahami semantik tugas, di mana meletakkan pakaian dan sepatu (keranjang cucian, bukan di atas tempat tidur), dan alat apa yang tepat untuk membersihkan tumpahan
- **Tingkat Lingkungan**: Beradaptasi dengan lingkungan dunia nyata yang "kacau" seperti rumah, toko kelontong, kantor, dan rumah sakit

### Pelatihan Bersama pada Data Heterogen

Inovasi terobosan dalam π₀.₅ adalah **co-training pada sumber data heterogen**. Model belajar dari:

1. **Data Web Multimodal**: Penamaan gambar, penjawaban pertanyaan visual, deteksi objek
2. **Instruksi Verbal**: Manusia melatih robot melalui tugas-tugas kompleks langkah demi langkah
3. **Perintah Subtugas**: Label perilaku semantik tingkat tinggi (misalnya, "ambil bantal" untuk tempat tidur yang belum dirapikan)
4. **Data Robot Cross-Embodiment**: Data dari berbagai platform robot dengan kemampuan yang berbeda
5. **Data Multi-Lingkungan**: Robot statis yang ditempatkan di banyak rumah yang berbeda
6. **Data Manipulasi Mobile**: ~400 jam demonstrasi robot mobile

Campuran pelatihan yang beragam ini menciptakan "kurikulum" yang memungkinkan generalisasi secara simultan di tingkat fisik, visual, dan semantik.

## Persyaratan Instalasi

1. Install LeRobot dengan mengikuti [Panduan Instalasi](./installation) kami.
2. Instal dependensi Pi0.5 dengan menjalankan:

   ```bash
   pip install -e ".[pi]"
   ```

   Jika Anda menginstal LeRobot dari PyPI:

   ```bash
   pip install 'lerobot[pi]'
   ```

## Penggunaan

Untuk menggunakan π₀.₅ dalam konfigurasi LeRobot Anda, tentukan tipe kebijakan sebagai:

```python
policy.type=pi05
```

## Pelatihan

### Mulai cepat di LIBERO

Lakukan finetuning pada model dasar LIBERO di [lerobot/libero](https://huggingface.co/datasets/lerobot/libero), salinan video-terenkapsulasi berukuran ~1,9 GB dari demonstrasi di balik [hasil di bawah ini](#libero-benchmark-results).

Ia membawa kunci yang dibaca oleh π₀.₅, yang juga merupakan kunci yang dihasilkan oleh lingkungan LIBERO pada saat evaluasi:

| Fitur                     | Bentuk dalam dataset | Bagaimana π₀.₅ mengonsumsinya                                    |
| --------------------------- | -------------------- | ------------------------------------------------------- |
| `observation.images.image`  | 256×256×3, agentview | di-resize menjadi 224×224                                      |
| `observation.images.image2` | 256×256×3, pergelangan tangan     | di-resize menjadi 224×224                                      |
| `observation.state`         | 8                    | dideskretisasi menjadi 256 bin dan ditulis ke dalam prompt   |
| `action`                    | 7                    | di-pad hingga 32 secara internal; loss menggunakan 7 dimensi pertama |

**Tidak ada `--rename_map` yang diperlukan di sini** — kuncinya sudah cocok; lihat [Rename Map and Empty Cameras](./rename_map) jika milik Anda berbeda.

  π₀.₅ menggunakan tokenizer [google/paligemma-3b-pt-224](https://huggingface.co/google/paligemma-3b-pt-224) yang bergerbang — terima lisensinya di Hub dan masuk dengan `hf auth login` sebelum pelatihan.

Ukuran untuk satu GPU 80 GB:

```bash
lerobot-train \
    --dataset.repo_id=lerobot/libero \
    --policy.type=pi05 \
    --policy.pretrained_path=lerobot/pi05_libero_base \
    --policy.normalization_mapping='{"ACTION": "MEAN_STD", "STATE": "MEAN_STD", "VISUAL": "IDENTITY"}' \
    --policy.n_action_steps=10 \
    --policy.empty_cameras=1 \
    --policy.freeze_vision_encoder=false \
    --policy.train_expert_only=false \
    --policy.gradient_checkpointing=true \
    --policy.dtype=bfloat16 \
    --policy.device=cuda \
    --policy.push_to_hub=false \
    --output_dir=./outputs/pi05_libero \
    --job_name=pi05_libero \
    --batch_size=64 \
    --num_workers=8 \
    --steps=30000 \
    --save_freq=5000 \
    --seed=1000
```

**Normalisasi mean/std, bukan [default kuantil](#quantile-statistics) π₀.₅** — sesuai dengan [pi05_libero_finetuned_v044](https://huggingface.co/lerobot/pi05_libero_finetuned_v044), checkpoint yang digunakan untuk mengukur hasil di bawah.

**`--policy.n_action_steps=10` dan `--policy.empty_cameras=1` bersifat eksplisit** karena `--policy.pretrained_path` hanya memuat bobot — `lerobot/pi05_libero_base` menyimpan keduanya, dan jika tidak, nilai akan kembali ke `50` dan `0` (lihat [Memuat checkpoint](#loading-a-checkpoint)).

Lalu, evaluasi checkpoint dengan `lerobot-eval` dan bandingkan dengan tingkat keberhasilan referensi — lihat [LIBERO](./libero).

### Statistik kuantil

π₀.₅ menormalisasi `STATE` dan `ACTION` dengan kuantil, sehingga `meta/stats.json` dalam dataset Anda memerlukan `q01` dan `q99`. Dataset yang lebih lama hanya memiliki `min`/`max`/`mean`/`std` dan akan gagal pada batch pertama:

```
ValueError: QUANTILES normalization mode requires q01 and q99 stats
```

Hitung ulang:

```bash
lerobot-edit-dataset \
    --repo_id your_dataset \
    --new_repo_id your_dataset \
    --operation.type recompute_stats \
    --operation.overwrite true
```

**Hasilnya tersimpan di `$HF_LEROBOT_HOME/your_dataset`**, bukan di cache yang dibaca oleh `--dataset.repo_id` — jadi latih dengan `--dataset.root=$HF_LEROBOT_HOME/your_dataset`, atau tambahkan `--push_to_hub true` di atas.

Atau pertahankan dataset apa adanya dan lewati `--policy.normalization_mapping='{"ACTION": "MEAN_STD", "STATE": "MEAN_STD", "VISUAL": "IDENTITY"}'`.

Merekam, melanjutkan, dan menggabungkan kuantil agregat dari ringkasan per episode, sehingga `meta/stats.json` pada akhirnya menyimpan amplop konservatif (`min` untuk `q <= 50`, `max` untuk `q > 50`) alih-alih kuantil seluruh dataset. Untuk memperkirakan yang terakhir, pindai setiap episode dengan histogram berjalan:

```bash
python src/lerobot/scripts/augment_dataset_quantile_stats.py \
    --repo-id=your_dataset \
    --overwrite \
    --skip-images
```

`--skip-images` mempertahankan statistik gambar yang ada dan menghindari pengunduhan atau dekoding data video ketika hanya `STATE`/`ACTION` yang perlu dihitung ulang, dan `--root` membaca dataset lokal alih-alih dari Hub. Nilai-nilai ini adalah estimasi histogram, yang rentan terhadap error diskritisasi dan rebinning, sehingga dapat berbeda dari nilai konservatif — yang mengubah target ternormalisasi π₀.₅ dan karenanya skala loss-nya. Statistik yang sudah disimpan di dalam checkpoint yang ada tidak terpengaruh.

### Contoh Perintah Pelatihan

Finetune yang sama dengan VLM dibekukan: memori lebih sedikit, dengan sedikit penurunan tingkat keberhasilan. Ganti `--dataset.repo_id` dengan dataset Anda sendiri.

```bash
lerobot-train \
    --dataset.repo_id=lerobot/libero \
    --policy.type=pi05 \
    --policy.pretrained_path=lerobot/pi05_libero_base \
    --policy.normalization_mapping='{"ACTION": "MEAN_STD", "STATE": "MEAN_STD", "VISUAL": "IDENTITY"}' \
    --policy.n_action_steps=10 \
    --policy.empty_cameras=1 \
    --policy.freeze_vision_encoder=true \
    --policy.train_expert_only=true \
    --policy.gradient_checkpointing=true \
    --policy.dtype=bfloat16 \
    --policy.device=cuda \
    --policy.push_to_hub=false \
    --output_dir=./outputs/pi05_libero_expert \
    --job_name=pi05_libero_expert \
    --batch_size=64 \
    --num_workers=8 \
    --steps=30000 \
    --save_freq=5000 \
    --seed=1000
```

### Parameter Pelatihan Utama

- **`--policy.compile_model=true`**: Mengaktifkan kompilasi model untuk pelatihan yang lebih cepat
- **`--policy.gradient_checkpointing=true`**: Mengurangi penggunaan memori secara signifikan selama pelatihan
- **`--policy.dtype=bfloat16`**: Gunakan pelatihan presisi campuran untuk efisiensi
- **`--batch_size=64`**: Ukuran batch untuk pelatihan, sesuaikan ini berdasarkan memori GPU Anda
- **`--policy.pretrained_path=lerobot/pi05_base`**: Model dasar π₀.₅ yang ingin Anda finetune, opsinya adalah:
  - [lerobot/pi05_base](https://huggingface.co/lerobot/pi05_base)
  - [lerobot/pi05_libero_base](https://huggingface.co/lerobot/pi05_libero_base) (dipelatih secara khusus pada dataset Libero)
- **`--policy.optimizer_fused=true`**: Menggunakan fused AdamW untuk langkah optimizer yang lebih cepat; flag ini diabaikan saat melanjutkan run

### RTC saat pelatihan opsional

Pi05 dapat secara opsional mempelajari kondisioning prefix aksi untuk [Real-Time Chunking](./rtc) yang efisien, mengikuti [Training-Time Action Conditioning for Efficient Real-Time Chunking](https://arxiv.org/abs/2512.05964). Atur `policy.rtc_training_max_delay` ke penundaan inferensi terbesar yang diharapkan dalam langkah pengontrol:

```bash
lerobot-train \
    --dataset.repo_id=${HF_USER}/my_dataset \
    --policy.type=pi05 \
    --policy.pretrained_path=lerobot/pi05_base \
    --policy.rtc_training_max_delay=10 \
    --policy.dtype=bfloat16 \
    --policy.device=cuda \
    --batch_size=8 \
    --steps=30000 \
    --output_dir=outputs/pi05_rtc \
    --job_name=pi05_rtc
```

Nilai default adalah `0`, yang menonaktifkan RTC saat pelatihan dan mempertahankan tujuan standar Pi05 tanpa perubahan. Delay yang dikonfigurasi harus lebih kecil dari `chunk_size`. Selama pelatihan, Pi05 mengambil panjang prefix bersih secara independen untuk setiap contoh dan menghitung flow loss hanya pada postfix yang tersisa.

Gunakan checkpoint yang dihasilkan dengan RTC yang telah dilatih secara eksplisit:

```bash
lerobot-rollout \
    --strategy.type=base \
    --policy.path=outputs/pi05_rtc/checkpoints/last/pretrained_model \
    --inference.type=rtc \
    --inference.rtc.mode=trained \
    --inference.rtc.execution_horizon=10 \
    --robot.type=so100_follower \
    --robot.port=/dev/ttyACM0 \
    --task="pick up the cube" \
    --fps=50 \
    --device=cuda
```

Set `inference.rtc.execution_horizon` di antara `rtc_training_max_delay` dan `chunk_size - rtc_training_max_delay` checkpoint, serta `inference.queue_threshold` ke minimal `rtc_training_max_delay`. Lonjakan latensi sekali yang melewati rentang terlatih akan membuang chunk tersebut dan mencoba lagi; rollout berhenti dengan error eksplisit hanya jika delay tetap di luar rentang. Mode default `--inference.rtc.mode=guided` tetap tersedia untuk checkpoint biasa.

### Memuat checkpoint

Kedua bentuk tersebut tidak dapat saling ditukar:

|                                        | `--policy.path`                                | `--policy.pretrained_path`                |
| -------------------------------------- | ---------------------------------------------- | ----------------------------------------- |
| Memuat                                  | weights **dan** `config.json` dari checkpoint | hanya bobot                              |
| Nama fitur                          | dari checkpoint                            | dari dataset Anda, setelah `--rename_map`   |
| Pengaturan yang disimpan, misalnya `n_action_steps` | diwarisi                                      | reset ke nilai default                     |
| `--policy.type`                        | harus dihilangkan                                | wajib                                  |
| `--rename_map`                         | diperlukan saat kunci kamera Anda berbeda            | didukung untuk menormalisasi kunci dataset |

Gunakan `--rename_map` dengan salah satu bentuk pemuatan ketika nama fitur dataset mentah berbeda dari nama fitur kebijakan. Sebagai contoh, perintah fine-tuning RoboMME memetakan kolom mentah `image`, `wrist_image`, `state`, dan `actions` sambil menginisialisasi bobot dengan `--policy.pretrained_path`.

### Penjelasan Parameter Pelatihan

| Parameter               | Default | Deskripsi                                 |
| ----------------------- | ------- | ------------------------------------------- |
| `freeze_vision_encoder` | `false` | Jangan bekukan encoder visual            |
| `train_expert_only`     | `false` | Jangan bekukan VLM, latih semua parameter |

**💡 Tips**: Mengatur `train_expert_only=true` membekukan VLM dan hanya melatih action expert serta proyeksi, sehingga memungkinkan finetuning dengan penggunaan memori yang lebih rendah.

## Memori Pengamatan Jangka Pendek (MEM)

Pi05 dapat secara opsional menggunakan konteks visual dan proprioseptif jangka pendek berdasarkan [MEM](https://arxiv.org/abs/2603.03596). Kedua jalur ini dinonaktifkan secara default, sehingga checkpoint dan perintah pelatihan yang ada mempertahankan perilaku Pi05 single-frame.

Implementasi ini hanya mencakup memori jangka pendek MEM — yaitu encoder video dari bagian III-C dan proyeksi proprioseptif dari bagian III-D. Memori _bahasa_ jangka panjang MEM (bagian III-B), di mana kebijakan tingkat tinggi memprediksi subtask berikutnya dan ringkasan bahasa alami yang terkompresi tentang apa yang telah terjadi sejauh ini, tidak diimplementasikan. Dalam ablation makalah tersebut, memori video saja hanya memulihkan sebagian dari kemajuan tugas MEM penuh pada tugas-tugas jangka panjang.

Mengenalkan memori saat finetuning dari checkpoint yang dipretrain tanpa memori juga sesuai dengan ablasi `MEM-Posttrain-Only` yang lebih lemah dalam paper tersebut. Hasil utama MEM berasal dari pretraining video encoder pada campuran beragam video robot dan non-robot, yang saat ini tidak disediakan oleh checkpoint Pi05 publik mana pun.

Aktifkan saat finetuning dengan:

```bash
lerobot-train \
    --dataset.repo_id=your_dataset \
    --policy.type=pi05 \
    --policy.pretrained_path=lerobot/pi05_base \
    --policy.use_visual_memory=true \
    --policy.memory_frames=6 \
    --policy.memory_stride=30 \
    --policy.memory_temporal_attention_every=4 \
    ...
```

`memory_frames` mencakup observasi saat ini. `memory_stride` diukur dalam **frame dataset**, bukan detik, sehingga skalakan dengan `fps` dataset Anda: MEM melakukan pra-pelatihan pada enam observasi yang berjarak satu detik, yaitu `memory_stride=30` untuk dataset 30 fps (default) tetapi `memory_stride=10` untuk dataset 10 fps seperti `lerobot/robomme`.

Setiap lapisan SigLIP keempat mengganti perhatiannya dengan perhatian ruang-waktu komposit dari MEM: perhatian temporal kausal antar token patch yang cocok, dikomposisikan dengan perhatian spasial standar dan memanfaatkan ulang proyeksi yang telah dilatih sebelumnya, sehingga tidak ada parameter yang dapat dipelajari yang ditambahkan ke menara visual. Token dari bingkai sebelumnya dibuang begitu lapisan terakhir semacam itu dijalankan, sehingga mempertahankan panjang prefiks bahasa/aksi hilir tetap tidak berubah.

Riwayat yang tidak tersedia di awal episode akan di-*pad* dan di-*mask*. Saat inferensi, Pi05 mempertahankan riwayat gambar ber-*stride* yang sama secara internal dan mengosongkannya setiap kali kebijakan di-*reset*.

Proprioception historis adalah opsi independen:

```bash
--policy.use_proprioceptive_memory=true
```

Ketika diaktifkan, satu token keadaan kontinu yang diproyeksikan ditambahkan untuk setiap frame yang dipertahankan, dan keadaan diskrit dihapus dari prompt teks sehingga keadaan hanya direpresentasikan sekali (bagian III-D MEM). Hal ini mengubah format prompt, sehingga aktifkan dari awal pelatihan, bukan di tengah jalan. Memori visual dan proprioseptif menggunakan pengaturan `memory_frames` dan `memory_stride` yang sama, tetapi jalur mana pun dapat diaktifkan secara independen. Latih atau finetune dengan opsi memori yang dipilih; mengaktifkannya hanya saat inferensi tidak memberikan perilaku memori yang dipelajari pada checkpoint single-frame.

Di bawah PEFT, `proprio_history_proj` dilatih dan disimpan secara penuh melalui `modules_to_save`, karena tidak memiliki bobot pra-latih untuk diadaptasi.

Saat inferensi, MEM mempertahankan satu antrean riwayat yang di-batch dan mengasumsikan setiap baris batch berbagi batas episode. `lerobot-eval` memenuhi ini dengan memanggil `policy.reset()` sebelum setiap rollout yang di-batch dan sebelum mereset lingkungan vektor. Baris yang di-reset secara otomatis secara independen dalam batch vektor asinkron tidak didukung; mulai rollout baru agar antrean kebijakan dan aksi lengkap di-reset bersama.

## Aksi Relatif

Secara default, π₀.₅ memprediksi aksi absolut. Anda dapat mengaktifkan **aksi relatif** agar model memprediksi offset relatif terhadap keadaan robot saat ini. Hal ini dapat meningkatkan stabilitas pelatihan untuk konfigurasi tertentu.

Untuk menggunakan aksi relatif, pertama hitung ulang statistik dataset Anda dalam ruang relatif melalui CLI:

```bash
lerobot-edit-dataset \
    --repo_id your_dataset \
    --new_repo_id your_dataset \
    --operation.type recompute_stats \
    --operation.overwrite true \
    --operation.relative_action true \
    --operation.chunk_size 50 \
    --operation.relative_exclude_joints "['gripper']" \
    --push_to_hub true
```

Atau secara ekuivalen dalam Python:

```python
from lerobot.datasets import LeRobotDataset, recompute_stats

dataset = LeRobotDataset("your_dataset")
recompute_stats(dataset, relative_action=True, chunk_size=50, relative_exclude_joints=["gripper"])
dataset.push_to_hub()
```

`chunk_size` harus sesuai dengan `chunk_size` kebijakan Anda (default 50 untuk π₀.₅). `relative_exclude_joints` mencantumkan nama sendi yang harus tetap berada di ruang absolut (misalnya perintah gripper). Gunakan `--push_to_hub true` untuk mengunggah statistik yang diperbarui ke Hub.

Lalu latih dengan aksi relatif diaktifkan:

```bash
lerobot-train \
    --dataset.repo_id=your_dataset \
    --policy.type=pi05 \
    --policy.use_relative_actions=true \
    --policy.relative_exclude_joints='["gripper"]' \
    ...
```

## Hasil Kinerja

### Hasil Benchmark Libero

π₀.₅ telah menunjukkan kinerja yang kuat pada suite benchmark Libero. Untuk membandingkan dan menguji implementasi LeRobot-nya, kami melakukan finetuning pada model dasar libero selama 6k langkah tambahan pada dataset Libero dan membandingkan hasilnya dengan hasil referensi OpenPI.

| Benchmark          | Implementasi LeRobot | Referensi OpenPI |
| ------------------ | ---------------------- | ---------------- |
| **Libero Spatial** | 97.0%                  | 98.8%            |
| **Libero Object**  | 99.0%                  | 98.2%            |
| **Libero Goal**    | 98.0%                  | 98.0%            |
| **Libero 10**      | 96.0%                  | 92.4%            |
| **Rata-rata**        | 97.5%                  | 96.85%           |

Hasil ini menunjukkan kemampuan generalisasi π₀.₅ yang kuat di berbagai tugas manipulasi robotik. Untuk mereproduksi hasil ini, Anda dapat mengikuti instruksi di bagian [Libero](https://huggingface.co/docs/lerobot/libero).

## Lisensi

Model ini mengikuti **Lisensi Apache 2.0**, yang konsisten dengan [repo OpenPI](https://github.com/Physical-Intelligence/openpi) asli.