π₀-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 π₀.

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 kami.

2. Instal dependensi π₀-FAST dengan menjalankan:

   Disalin

   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

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

Penggunaan

Untuk menggunakan π₀-FAST di LeRobot, tentukan tipe kebijakan sebagai:

policy.type=pi0_fast

Pelatihan

Untuk melatih π₀-FAST, Anda dapat menggunakan skrip pelatihan LeRobot:

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

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.

# KV-caching is enabled by default
policy.use_kv_cache=true

Contoh Inferensi

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

Perbandingan dengan π₀

Mereproduksi hasil π₀Fast

Kami mereproduksi hasil π₀Fast pada benchmark LIBERO menggunakan implementasi LeRobot. Kami mengambil model dasar LeRobot PiFast lerobot/pi0fast-base dan melakukan finetune selama 40k langkah tambahan dalam bfloat16, dengan batch size 256 pada 8 GPU H100 menggunakan dataset HuggingFace LIBERO.

Model yang telah ditala ulang dapat ditemukan di sini:

• π₀Fast LIBERO: lerobot/pi0fast-libero

Dengan perintah pelatihan berikut:

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:

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:

Folder output evaluasi lengkap, termasuk video, tersedia di sini

Lisensi

Model ini mengikuti Lisensi Apache 2.0, yang konsisten dengan repo OpenPI asli.

Referensi

• FAST: Tokenisasi Aksi Robot yang Efisien - Blog Physical Intelligence
• Repositori OpenPI - Implementasi asli
• Tokenizer FAST di Hugging Face - Tokenizer terlatih