# π₀-FAST (Pi0-FAST) π₀-FAST adalah **model Vision-Language-Action untuk kontrol robot umum** yang menggunakan prediksi token berikutnya secara autoregresif untuk memodelkan aksi robot kontinu. ## Ringkasan Model π₀-FAST menggabungkan kekuatan Vision-Language Models dengan pendekatan tokenisasi aksi baru yang disebut **FAST (Frequency-space Action Sequence Tokenization)**. Hal ini memungkinkan pelatihan VLAs autoregressive pada tugas-tugas yang sangat lincah yang tidak mungkin dilakukan dengan diskretisasi berbasis binning standar, sambil melatih **hingga 5x lebih cepat** daripada pendekatan berbasis difusi seperti π₀. An overview of Pi0-FAST ### Mengapa FAST? Pendekatan standar untuk tokenisasi aksi robot menggunakan skema binning sederhana per dimensi dan per langkah waktu. Meskipun memadai untuk perilaku sederhana, pendekatan ini dengan cepat gagal untuk keterampilan kompleks dan lincah yang membutuhkan presisi serta kontrol frekuensi tinggi. FAST menyelesaikan masalah ini dengan mengompresi urutan aksi menggunakan teknik pemrosesan sinyal, menghasilkan urutan token aksi yang padat dan dapat diprediksi secara autoregresif—sama seperti token bahasa. ### Cara Kerja Tokenisasi FAST Tokenizer FAST mengompresi urutan aksi melalui langkah-langkah berikut: 1. **Normalize**: Ambil chunk aksi kontinu dengan bentuk `(H, D)` di mana `H` adalah horizon dan `D` adalah dimensi aksi. Normalisasi menggunakan salah satu metode normalisasi yang didukung (Quantiles direkomendasikan untuk menangani outlier). 2. **Discrete Cosine Transform (DCT)**: Terapkan DCT (melalui scipy) pada setiap dimensi aksi secara terpisah. DCT adalah algoritma kompresi yang umum digunakan dalam codec gambar dan audio (JPEG, MP3). 3. **Kuantisasi**: Bulatkan dan hapus koefisien yang tidak signifikan untuk setiap dimensi aksi, menghasilkan matriks frekuensi yang jarang. 4. **Flatten**: Ratakan matriks menjadi vektor 1D, dengan komponen frekuensi rendah di awal. 5. **Byte Pair Encoding (BPE)**: Latih tokenizer BPE untuk mengompresi koefisien DCT menjadi token aksi yang padat, umumnya mencapai **10x kompresi** dibandingkan pendekatan tokenisasi sebelumnya. Pendekatan ini dapat mengubah **VLM mana pun yang sudah ada** menjadi VLA dengan melatihnya untuk memprediksi token FAST ini. ## Persyaratan Instalasi 1. Install LeRobot dengan mengikuti [Panduan Instalasi](./installation) kami. 2. Instal dependensi π₀-FAST dengan menjalankan: ```bash pip install -e ".[pi]" ``` ## Melatih Tokenizer FAST Kustom Anda memiliki dua opsi untuk tokenizer FAST: 1. **Gunakan tokenizer yang sudah dilatih sebelumnya**: tokenizer `lerobot/fast-action-tokenizer` dilatih pada 1 juta+ urutan aksi robot nyata dan berfungsi sebagai tokenizer serbaguna. 2. **Latih tokenizer Anda sendiri**: Untuk performa maksimal pada dataset spesifik Anda, Anda dapat melakukan finetuning tokenizer pada data Anda sendiri. ### Melatih Tokenizer Anda Sendiri ```bash lerobot-train-tokenizer \ --repo_id "user/my-lerobot-dataset" \ --action_horizon 10 \ --encoded_dims "0:6" \ --vocab_size 1024 \ --scale 10.0 \ --normalization_mode QUANTILES \ --output_dir "./my_fast_tokenizer" \ --push_to_hub true \ --hub_repo_id "username/my-action-tokenizer" ``` ### Parameter Tokenizer Utama | Parameter | Deskripsi | Default | | ---------------------- | --------------------------------------------------------------------------------- | ------------ | | `--repo_id` | ID repositori dataset LeRobot | Wajib | | `--action_horizon` | Jumlah aksi masa depan di setiap chunk | `10` | | `--encoded_dims` | Rentang dimensi yang dipisahkan koma untuk dienkripsi (misalnya, `"0:6,7:23"`) | `"0:6,7:23"` | | `--vocab_size` | Ukuran kosakata BPE | `1024` | | `--scale` | Faktor penskalaan DCT untuk kuantisasi | `10.0` | | `--normalization_mode` | Mode normalisasi (`MEAN_STD`, `MIN_MAX`, `QUANTILES`, `QUANTILE10`, `IDENTITY`) | `QUANTILES` | | `--sample_fraction` | Fraksi chunk yang akan disampel per episode | `0.1` | ## Penggunaan Untuk menggunakan π₀-FAST di LeRobot, tentukan tipe kebijakan sebagai: ```python policy.type=pi0_fast ``` ## Pelatihan Untuk melatih π₀-FAST, Anda dapat menggunakan skrip pelatihan LeRobot: ```bash lerobot-train \ --dataset.repo_id=your_dataset \ --policy.type=pi0_fast \ --output_dir=./outputs/pi0fast_training \ --job_name=pi0fast_training \ --policy.pretrained_path=lerobot/pi0fast-base \ --policy.dtype=bfloat16 \ --policy.gradient_checkpointing=true \ --policy.chunk_size=10 \ --policy.n_action_steps=10 \ --policy.max_action_tokens=256 \ --steps=100000 \ --batch_size=4 \ --policy.device=cuda ``` ### Parameter Pelatihan Utama | Parameter | Deskripsi | Default | | -------------------------------------- | -------------------------------------------------- | ------------------------------- | | `--policy.gradient_checkpointing=true` | Mengurangi penggunaan memori secara signifikan selama pelatihan | `false` | | `--policy.dtype=bfloat16` | Gunakan pelatihan presisi campuran untuk efisiensi | `float32` | | `--policy.chunk_size` | Jumlah langkah aksi untuk diprediksi (cakupan aksi) | `50` | | `--policy.n_action_steps` | Jumlah langkah aksi yang akan dieksekusi | `50` | | `--policy.max_action_tokens` | Jumlah maksimum token FAST per chunk aksi | `256` | | `--policy.action_tokenizer_name` | Tokenizer FAST yang akan digunakan | `lerobot/fast-action-tokenizer` | | `--policy.compile_model=true` | Aktifkan torch.compile untuk pelatihan yang lebih cepat | `false` | | `--policy.optimizer_fused=true` | Gunakan AdamW yang digabungkan; diabaikan saat melanjutkan | `None` | ## Inferensi ### KV-Caching untuk Inferensi Cepat π₀-FAST mendukung **KV-caching**, sebuah optimasi yang banyak digunakan dalam inferensi LLM. Fitur ini meng-cache pasangan key-value dari mekanisme attention, sehingga menghindari komputasi yang redundan selama decoding autoregresif. ```python # KV-caching is enabled by default policy.use_kv_cache=true ``` ### Contoh Inferensi ```python from lerobot.policies.pi0_fast import PI0FastPolicy, PI0FastConfig # Load the policy policy = PI0FastPolicy.from_pretrained("your-model-path") # During inference actions = policy.predict_action_chunk(batch) ``` ## Arsitektur Model π₀-FAST menggunakan arsitektur berbasis PaliGemma: - **Enkoder Visi**: menara visi SigLIP untuk pemahaman gambar - **Model Bahasa**: Gemma 2B untuk memproses instruksi bahasa dan memprediksi token aksi Model menerima gambar, instruksi teks, dan status robot sebagai input, lalu menghasilkan token FAST diskrit yang didekode kembali menjadi aksi kontinu. ## Opsi Konfigurasi | Parameter | Deskripsi | Default | | -------------------- | ----------------------------------------------- | ---------- | | `paligemma_variant` | Varian backbone VLM (`gemma_300m`, `gemma_2b`) | `gemma_2b` | | `max_state_dim` | Dimensi maksimum vektor keadaan (dengan padding) | `32` | | `max_action_dim` | Dimensi vektor aksi maksimum (dipadatkan) | `32` | | `temperature` | Suhu sampling (0.0 untuk greedy) | `0.0` | | `max_decoding_steps` | Langkah dekode maksimum | `256` | | `use_kv_cache` | Aktifkan KV caching untuk inferensi yang lebih cepat | `true` | ## Perbandingan dengan π₀ | Fitur | π₀ | π₀-FAST | | --------------------- | ------------------------- | ---------------------------- | | Representasi Aksi | Flow Matching (Difusi) | Token Autoregresif (FAST) | | Kecepatan Pelatihan | 1x | **5x lebih cepat** | | Kelincahan | Tinggi | Tinggi | | Metode Inferensi | Denois | Dekoding Autoregresif | | KV-Caching | N/A | Didukung | ## Mereproduksi hasil π₀Fast Kami mereproduksi hasil π₀Fast pada benchmark LIBERO menggunakan implementasi LeRobot. Kami mengambil model dasar LeRobot PiFast [lerobot/pi0fast-base](https://huggingface.co/lerobot/pi0fast-base) dan melakukan finetune selama 40k langkah tambahan dalam bfloat16, dengan batch size 256 pada 8 GPU H100 menggunakan [dataset HuggingFace LIBERO](https://huggingface.co/datasets/HuggingFaceVLA/libero). Model yang telah ditala ulang dapat ditemukan di sini: - **π₀Fast LIBERO**: [lerobot/pi0fast-libero](https://huggingface.co/lerobot/pi0fast-libero) Dengan perintah pelatihan berikut: ```bash lerobot-train \ --dataset.repo_id=lerobot/libero \ --output_dir=outputs/libero_pi0fast \ --job_name=libero_pi0fast \ --policy.path=lerobot/pi0fast-base \ --policy.dtype=bfloat16 \ --steps=100000 \ --save_freq=20000 \ --batch_size=4 \ --policy.device=cuda \ --policy.scheduler_warmup_steps=4000 \ --policy.scheduler_decay_steps=100000 \ --policy.scheduler_decay_lr=1e-5 \ --policy.gradient_checkpointing=true \ --policy.chunk_size=10 \ --policy.n_action_steps=10 \ --policy.max_action_tokens=256 \ --policy.empty_cameras=1 ``` Kami kemudian mengevaluasi model yang telah difinetune menggunakan implementasi LeRobot LIBERO, dengan menjalankan perintah berikut: ```bash tasks="libero_object,libero_spatial,libero_goal,libero_10" lerobot-eval \ --policy.path=lerobot/pi0fast-libero \ --policy.max_action_tokens=256 \ --env.type=libero \ --policy.gradient_checkpointing=false \ --env.task=${tasks} \ --eval.batch_size=1 \ --eval.n_episodes=1 \ --rename_map='{"observation.images.image":"observation.images.base_0_rgb","observation.images.image2":"observation.images.left_wrist_0_rgb"}' ``` **Catatan:** Kami mengatur `n_action_steps=10`, serupa dengan implementasi OpenPI asli. ### Hasil Kami memperoleh hasil berikut pada benchmark LIBERO: | Model | LIBERO Spatial | LIBERO Object | Tujuan LIBERO | LIBERO 10 | Rata-rata | | ----------- | -------------- | ------------- | ----------- | --------- | -------- | | **π₀-fast** | 70.0 | 100.0 | 100.0 | 60.0 | **82.5** | Folder output evaluasi lengkap, termasuk video, tersedia [di sini](https://drive.google.com/drive/folders/1HXpwPTRm4hx6g1sF2P7OOqGG0TwPU7LQ?usp=sharing) ## Lisensi Model ini mengikuti **Lisensi Apache 2.0**, yang konsisten dengan [repo OpenPI](https://github.com/Physical-Intelligence/openpi) asli. ## Referensi - [FAST: Tokenisasi Aksi Robot yang Efisien](https://www.physicalintelligence.company/research/fast) - Blog Physical Intelligence - [Repositori OpenPI](https://github.com/Physical-Intelligence/openpi) - Implementasi asli - [Tokenizer FAST di Hugging Face](https://huggingface.co/physical-intelligence/fast) - Tokenizer terlatih