# OpenGalaxea G0.5

G0.5 adalah model vision-language-action Qwen3.5-2B yang dapat menghasilkan penalaran dan tindakan embodied dalam satu stream. LeRobot mengekspos fase tindakan sebagai System 1 dan fase chain-of-thought native opsional sebagai System 2. Keduanya bukan model terpisah: runtime memperoleh keduanya dari satu panggilan inferensi, dan tindakan tetap dikondisikan pada penalaran.

## Ringkasan Model

Transformers mencakup backbone multimodal Qwen3.5 native, vision tower, dan processor. Namun, G0.5 bukan checkpoint `Qwen3_5ForConditionalGeneration` standar: ia menambahkan jalur proprioception/action, action expert, flow-matching head, ActionCodec, dan decode CoT/action terpadu. LeRobot mengimplementasikan komponen-komponen G0.5 tersebut secara native dan memuat checkpoint yang telah dikonversi tanpa paket Python OpenGalaxea, Hydra, atau OmegaConf.

### Cakupan Integrasi LeRobot

- Konfigurasi standar `policy.type=g05` dan pemuatan checkpoint Hub.
- Generasi aksi ActionCodec kontinu native dan diskrit.
- Penalaran dan generasi aksi System 2 opsional dalam satu lintasan yang sama.
- Prosesor kamera, state, aksi, normalisasi, dan prompt yang dapat diserialisasi.
- Fine-tuning melalui `lerobot-train` dan inferensi melalui `lerobot-rollout`.
- LIBERO, RoboTwin, SO-101, dan kontrak checkpoint R1 Lite/Pro yang dirilis.

> [!WARNING]
> Kode integrasi G0.5 (`src/lerobot/policies/g05`) dan checkpoint menggunakan [G0.5 Community License](https://huggingface.co/OpenGalaxea/G05/blob/main/licenses/LICENSE-G0.5), termasuk pembatasan non-komersial; Apache-2.0 tidak berlaku untuk materi tersebut. Checkpoint yang dikonversi menyertakan lisensi tersebut sebagai `LICENSE` bersama dengan `NOTICE`-nya, dan tidak didukung oleh Galaxea.

## Checkpoint

### Kontrak Input dan Output

| Checkpoint       | Jalur aksi yang dirilis                       | Raw → tata letak kebijakan                          | Kamera                               | Diperkirakan | Dijalankan | Normalisasi    |
| ---------------- | ------------------------------------------ | -------------------------------------------- | ------------------------------------- | --------: | -------: | ---------------- |
| `g05_base`       | AR ActionCodec atau flow yang dipilih secara eksplisit | R1 Lite/Pro sendi → tata letak seluruh tubuh 27D   | kepala + kedua pergelangan tangan, riwayat 6 langkah    |        32 |       16 | z-score bertahap |
| `g05_libero`     | Aliran kontinu                            | kanan EEF 6 + gripper 1 → tata letak grup 20D | luar, pergelangan tangan kanan                 |        32 |       10 | stepwise q01/q99 |
| `g05_robotwin20` | Aliran kontinu                            | dua lengan 6+gripper → tata letak grup 20D      | tinggi, pergelangan tangan kiri, pergelangan tangan kanan         |        32 |        8 | stepwise q01/q99 |
| `g05_so101`      | Flow atau AR ActionCodec + CoT native        | sendi lengan kanan 6 → tata letak grup 20D      | luar, pergelangan tangan kiri + kanan opsional |        32 |       16 | stepwise q01/q99 |

Setiap checkpoint yang dikonversi menyimpan konfigurasi model dan prosesor yang telah diselesaikan, metadata ActionCodec, statistik, template prompt yang persis, dan lisensi.

### Checkpoint yang Dikonversi

| Repository               | Kontrak                     |
| ------------------------ | ---------------------------- |
| `lerobot/g05_base`       | 27D base, prosesor R1 Lite  |
| `lerobot/g05_libero`     | 20D LIBERO                   |
| `lerobot/g05_robotwin20` | 20D RoboTwin                 |
| `lerobot/g05_so101`      | 20D SO-101 (profil `so100`) |

Checkpoint ini dirilis di bawah [Lisensi Komunitas G0.5](https://huggingface.co/OpenGalaxea/G05/blob/main/licenses/LICENSE-G0.5) non-komersial; lihat [Lisensi](#license).

`lerobot/g05_base` menyediakan bobot model 27D tersebut, kedua kepala aksi, tokenizer ActionCodec, dan kontrak pemroses/statistik R1 Lite enam langkah yang dirilis.

## Persyaratan Instalasi

Instal LeRobot dengan dependensi Transformers G0.5:

```bash
uv sync --extra g05 --extra test
```

> [!TIP]
> Install [`flash-linear-attention`](https://github.com/fla-org/flash-linear-attention) untuk pelatihan dan inferensi di GPU. Sebagian besar lapisan decoder Qwen3.5 menggunakan Gated DeltaNet linear attention, dan tanpa pustaka ini Transformers akan kembali ke kernel PyTorch yang jauh lebih lambat, dengan log "The fast path is not available". Pustaka ini murni Triton, sehingga terpasang tanpa proses build:
>
> ```bash
> uv pip install flash-linear-attention
> ```
>
> Pelatihan berjalan sekitar 1,5x lebih cepat dengannya dan menggunakan memori lebih sedikit, dengan kerugian yang identik. Langkah pertama memakan waktu sekitar 20 detik lebih lama saat Triton mengompilasi kernel-nya.

SO-100 dan SO-101 berbagi token `so100` embodiment yang dirilis serta kontrak lengan kanan enam sendi. Kamera pergelangan tangan kiri yang hilang di-zero-pad.

## Penggunaan

Muat checkpoint yang sesuai dengan target embodiment menggunakan opsi standar `--policy.path`. Konfigurasi yang dikemas memilih action head, urutan kamera, dimensi, normalisasi, dan horizon eksekusi yang benar.

### Runtime Sistem 1 dan Sistem 2 Interaktif

G0.5 menghasilkan penalaran dan tindakan dari satu aliran inferensi: rantai pemikiran dihasilkan pada jalur yang sama dengan chunk, dan tindakan dikondisikan berdasarkannya.

`policy.runtime_system` pada checkpoint memilih jalur. Sistem 1 mengeksekusi ActionCodec atau chunk flow yang dipilih secara langsung dan tidak menghasilkan CoT:

```bash
lerobot-rollout \
  --policy.path=lerobot/g05_so101 \
  --policy.runtime_system=system1 \
  --task="pick up the cup" \
  --fps=30
```

System 2 hanya tersedia ketika metadata checkpoint yang dikemas memiliki `predict_cot=true`. Chain of thought-nya dikembalikan sebagai prediksi kebijakan: `predict_action_chunk` mengembalikan batch `PolicyOutput` yang berisi chunk di bawah `"action"` dan, di bawah `"prediction"`, subtask CoT untuk setiap env (`language["subtask"]`, satu string per env) serta kotak sebagai fraksi xyxy [0, 1] pada `policy.config.bbox_camera` (`boxes[camera]`, satu jawaban per env), dan `select_action` mengembalikannya bersama aksi pertama dari setiap chunk. Model tidak lagi menyebut nama kamera: target BBox-nya semuanya digambar pada kamera tersebut selama pelatihan. System 1 tidak menghasilkan CoT dan hanya mengembalikan aksi mentah.

```python
output = policy.predict_action_chunk(batch)
print(output["prediction"])
# {"language": {"subtask": ["grasp the cup"]},
#  "boxes": {"observation.images.top": [{"detections": [{"label": "cup", "bbox": [...]}]}]}}
```

Dengan `--display_data=true`, `lerobot-rollout` menampilkan subtask dan menggambar kotak di atas kamera bbox di Rerun atau Foxglove.

#### Mengendalikan sesi dari stdin

`--interactive=true` menggerakkan rollout dengan perintah bergaya chat sementara perangkat keras dan kebijakan tetap terhubung dan hangat. Robot tidak akan bergerak sampai Anda mengetik `/start`, yang menjadikan ini cara aman untuk menyalakan SO-101 fisik: konfirmasi indeks kamera dan port lengan terlebih dahulu, lalu mulai.

```bash
lerobot-rollout \
  --interactive=true \
  --policy.path=lerobot/g05_so101 \
  --policy.device=cuda \
  --robot.type=so101_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.id=my_follower \
  --robot.cameras='{exterior: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, wrist_right: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30}}' \
  --task="pick up the cube" \
  --fps=30
```

| Perintah                  | Efek                                                         |
| ------------------------ | -------------------------------------------------------------- |
| `/start`                 | mulai (atau mulai ulang) loop kontrol kebijakan                     |
| `/subtask <text>`        | atur instruksi yang diikuti oleh kebijakan                         |
| `/vqa <text>`            | tidak didukung pada G0.5 (lihat [di bawah](#why-vqa-is-not-supported)) |
| `/autosteer <goal>\|off` | biarkan kebijakan memilih sub-tugasnya sendiri menuju tujuan tingkat tinggi  |
| `/reset`                 | berhenti bergerak, kembali ke posisi awal, pulihkan tugas    |
| `/stop`                  | mengakhiri sesi dan mematikan                                  |
| `/help`                  | tampilkan daftar perintah                                          |

`/autosteer` membutuhkan checkpoint dengan `predict_cot=true` dan jawaban dari observasi langsung, sehingga ditolak sampai `/start` berjalan. Subtask yang dipilih dicetak sebagai `Autosteer subtask:`, dan `--autosteer_interval_s` mengatur berapa detik gerakan yang berlalu antara dua kueri perencanaan ulang.

Pilih runtime yang sesuai dengan cara tugas diberikan, sebagaimana G0.5 dilatih:

- **Tugas tingkat tinggi, tanpa pengendalian:** pertahankan Sistem 2. Setiap chunk memprediksi subtask saat ini dari tugas, lalu bertindak di atasnya.
- **`/subtask` atau `/autosteer`:** gunakan `--policy.runtime_system=system1`. Subtask menjadi task dan policy bertindak langsung padanya; `/autosteer` masih merencanakan setiap subtask dari goal dengan query System 2. System 2 pada subtask-as-task akan merencanakan subtask dari subtask, sebuah prompt yang tidak dilatihkan padanya.

#### Memilih rantai pemikiran

`--policy.runtime_cot_fields` memilih format chain-of-thought mana dari yang dilatih pada G0.5 yang akan dihasilkan oleh System 2 sebelum setiap chunk. Aksi memperhatikan seluruh chain of thought, sehingga apa pun yang dikandungnya akan mengondisikan aksi tersebut.

| `runtime_cot_fields`    | Instruksi yang dilatih                | Rantai pemikiran yang dihasilkan |
| ----------------------- | ---------------------------------- | -------------------------- |
| `["subtask"]` (default) | `predict subtask`                  | subtugas                |
| `["bbox", "subtask"]`   | `predict bbox, subtask and action` | kotak, kemudian subtask    |

Sebagai contoh, `["bbox", "subtask"]` menghasilkan:

```text
BBox: cube <loc0397><loc0717><loc0625><loc0895>|Subtask: pick up the blue cube
```

- **`["subtask"]`** menghasilkan jumlah token per chunk paling sedikit, sehingga menjadi pilihan yang lebih cepat.
- **`["bbox", "subtask"]`** terlebih dahulu mengidentifikasi objek-objek yang relevan, yang menjadi dasar bagi subtask dan aksi dalam adegan. Setiap kotak berisi label diikuti oleh empat token lokasi dalam urutan `y1, x1, y2, x2`; token `<locNNNN>` adalah koordinat sebagai pecahan dari gambar dikalikan 1024. Kotak-kotak merujuk pada kamera BBox (`--policy.cot_bbox_camera`, secara default slot kamera non-kosong pertama).

`lerobot/g05_base` dan `lerobot/g05_so101` dilatih pada kedua format; checkpoint LIBERO dan RoboTwin memiliki `predict_cot=false` dan tidak memiliki System 2. Fine-tune hanya menghasilkan kotak yang berguna jika dataset-nya memiliki anotasi `vqa` yang grounded pada kamera BBox (lihat [Requirements Data](#data-requirements)).

#### Mengapa `/vqa` tidak didukung

Kepala teks G0.5 bukanlah asisten visi-bahasa umum. Model ini dilatih untuk hanya mengeluarkan format chain-of-thought di atas, setelah salah satu instruksi tetapnya, dan prompt-nya tidak memiliki slot untuk pertanyaan bebas. Pertanyaan `/vqa` hanya dapat mengambil tempat tugas, sehingga model akan membalas dengan subtask (dan kotak) untuk "tugas" tersebut, bukan jawaban. `/autosteer` berhasil karena tujuannya adalah sebuah tugas, yang memang diharapkan oleh slot tersebut.

Dalam mode interaktif, `--duration` membatasi setiap segmen `/start`, bukan seluruh sesi.

## Kebutuhan Data

Dataset harus mengekspos fitur state, action, camera, dan task yang sesuai dengan kontrak checkpoint yang dipilih. Nama kamera bebas: `--policy.camera_order` mencantumkan kamera dataset yang memberi makan setiap slot gambar checkpoint, dan `null` meninggalkan slot kosong (diisi nol). Untuk SO-101, slotnya adalah exterior, left wrist, dan right wrist; left wrist bersifat opsional.

Pelatihan System 2 language targets juga memerlukan field CoT yang telah diberi anotasi pada checkpoint. Perekaman LeRobot normal menyediakan supervisi aksi tetapi tidak mensintesis label CoT. Buat kolom bahasa `subtask` dan `vqa` yang berdasar pada konteks dengan `lerobot-annotate` seperti yang dijelaskan dalam [annotation pipeline](./annotation_pipeline).

## Pelatihan

G0.5 mengimplementasikan permukaan pelatihan LeRobot secara native: `forward` menghitung cross entropy token asisten dan kerugian flow-matching, kebijakan mengekspos grup optimizer VLM/visi/aksi, dan checkpoint dapat disimpan, dilanjutkan, dan dimuat oleh skrip LeRobot yang normal. Tujuan ini mempertahankan `ar.ce_weight` yang dikemas, `ar.ce_z_loss_scale` opsional, dan `fm.fm_weight`; kerugian autoregressive secara bersama-sama mencakup target teks CoT dan ActionCodec. Sebagai contoh, lakukan fine-tuning checkpoint SO-101 pada dataset LeRobot:

### Contoh Perintah Pelatihan

```bash
export HF_USER=your_hf_username

lerobot-train \
  --dataset.repo_id=${HF_USER}/my_so101_dataset_annotated \
  --policy.path=lerobot/g05_so101 \
  --policy.device=cuda \
  --policy.use_language_recipe=true \
  --policy.cot_bbox_camera=observation.images.exterior \
  --policy.repo_id=${HF_USER}/g05_so101_finetuned \
  --policy.private=true \
  --output_dir=outputs/train/g05_so101 \
  --job_name=g05_so101 \
  --batch_size=16 \
  --steps=10000 \
  --save_freq=1000
```

Resep bawaan mencampurkan tiga jenis sampel, seperti campuran pelatihan hulu:

- 4/6 chain of thought: tugasnya, lalu target BBox dan/atau Subtask untuk anotasi `subtask` dan `vqa` grounded yang aktif pada timestamp tersebut, lalu aksi-aksinya.
- 1/6 subtask sebagai task: subtask yang aktif adalah instruksi, langsung ke tindakan. Inilah yang dilihat kebijakan setelah `/subtask` atau `/autosteer` menetapkan subtask.
- 1/6 polos: tugas langsung ke tindakan, prompt Sistem 1.

Contoh chain-of-thought tanpa anotasi pada timestamp-nya melatih prompt polos.

Buat kolom bahasa `subtask` dan `vqa` yang berdasar pada data menggunakan `lerobot-annotate` seperti yang dijelaskan dalam [pipeline anotasi](./annotation_pipeline). Resep bawaan membaca kotak yang diannotasi pada kamera BBox: `--policy.cot_bbox_camera`, yang secara default menggunakan slot kamera non-kosong pertama. Koordinat kotak harus berupa pecahan `[0, 1]` dari lebar dan tinggi gambar, yang merupakan format yang disimpan oleh `lerobot-annotate`; kotak dalam piksel akan ditolak. Sampaikan YAML eksternal yang eksplisit melalui `--policy.recipe_path=/path/to/recipe.yaml` untuk melatih resep yang berbeda: file ini dibaca sekali ke dalam `policy.recipe` saat konfigurasi dibangun, sehingga checkpoint yang disimpan tetap mempertahankan resep yang digunakan saat pelatihan meskipun file tersebut berubah kemudian.

### Menyesuaikan ulang checkpoint dasar pada robot lain

`lerobot/g05_base` dapat dihaluskan (fine-tuned) pada robot yang belum pernah dilihatnya. Sebutkan nama robot dengan `--policy.embodiment`, misalnya `robot_type` dari dataset; nama tersebut adalah teks `Embodiment:` dari prompt. Flag ini wajib: tanpa flag ini, checkpoint akan mempertahankan embodiment dan tabel slot miliknya sendiri. Sendi ditempatkan dalam tata letak dasar dari nama sendi dataset: sendi dengan awalan `left_` ditempatkan di lengan kiri dan yang lainnya di lengan kanan, sendi yang namanya mengandung `gripper` mengambil slot gripper lengan tersebut, dan sisanya mengisi sembilan slot kontrolnya secara berurutan. Lengan 5-sendi dengan gripper dengan demikian mengisi slot lengan kanan 10-14 dan gripper kanan, dan lengan 7-DoF mengisi 10-16 dan gripper. Atur `--policy.state_slots` dan `--policy.action_slots` untuk menempatkan sendi secara eksplisit. Slot yang dipecahkan disimpan bersama checkpoint yang telah dihaluskan.

Contoh di bawah ini melakukan fine-tuning pada robot satu lengan yang direkam dengan kamera `front` dan kamera `wrist`. Slot gambar pada checkpoint dasar adalah tampilan kepala, pergelangan tangan kiri, dan pergelangan tangan kanan; karena hanya ada satu lengan di sisi kanan, kamera pergelangan tangannya menempati slot pergelangan tangan kanan, sementara slot pergelangan tangan kiri tetap kosong. Flag bernilai list mengambil JSON yang diberi tanda kutip.

```bash
lerobot-train \
  --dataset.repo_id=${HF_USER}/my_robot_dataset_annotated \
  --policy.path=lerobot/g05_base \
  --policy.embodiment=my_robot \
  --policy.camera_order='["observation.images.front", null, "observation.images.wrist"]' \
  --policy.n_obs_steps=1 \
  --policy.use_language_recipe=true \
  --policy.device=cuda \
  --policy.repo_id=${HF_USER}/g05_my_robot_finetuned \
  --output_dir=outputs/train/g05_my_robot \
  --job_name=g05_my_robot \
  --batch_size=16 \
  --steps=10000
```

`--policy.n_obs_steps=1` memberi satu frame per kamera, seperti yang dilakukan fine-tune upstream; riwayat enam langkah dari checkpoint dasar mengalikan jumlah gambar per sampel dengan enam.

Normalisasi menggunakan statistik dari dataset itu sendiri (z-score untuk checkpoint dasar; jalankan `--policy.normalization_mapping='{"VISUAL": "IDENTITY", "STATE": "QUANTILES", "ACTION": "QUANTILES"}'` untuk q01/q99). Gripper tetap absolut (`relative_exclude_joints=["gripper"]` di checkpoint dasar), sementara sendi lengan dilatih sebagai delta. Target BBox berasal dari jawaban `vqa` yang berakar pada anotasi di `observation.images.front`, slot kamera non-kosong pertama.

Resep SO-101 menggunakan AdamW pada `8e-5` dengan 1.000 langkah pemanasan. Konfigurasi LIBERO dan RoboTwin yang dikemas menggunakan resep `1e-5` yang dirilis, masing-masing dengan 1.000 dan 500 langkah pemanasan. Semua profil mempertahankan grup parameter dan pengali laju pembelajaran G0.5. Timpa mereka untuk melatih dengan resep optimasi yang berbeda:

```bash
--policy.optimizer_lr=2e-5 \
--policy.optimizer_backbone_lr_multiplier=0.5 \
--policy.optimizer_vision_lr_multiplier=0.1
```

Lanjutkan run yang disimpan dengan checkpoint LeRobot standar:

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

## Parameter Konfigurasi Utama

| Parameter                                   | Deskripsi                                                       |
| ------------------------------------------- | ----------------------------------------------------------------- |
| `policy.embodiment`                         | Nama robot yang ditulis dalam prompt; memilih tabel slot yang dirilis   |
| `policy.state_slots`, `policy.action_slots` | Slot kebijakan-eksplisit tata letak untuk setiap nilai state/action mentah        |
| `policy.camera_order`                       | Dataset kamera per slot gambar checkpoint; `null` membiarkannya kosong  |
| `policy.action_head`                        | Menggunakan jalur aksi `flow` atau `actioncodec` dari checkpoint         |
| `policy.runtime_system`                     | Memilih penalaran dan tindakan langsung System 1 atau terpadu System 2  |
| `policy.runtime_cot_fields`                 | Rantai pemikiran Sistem 2: `["subtask"]` atau `["bbox", "subtask"]` |
| `policy.dtype`                              | `bfloat16` (presisi campuran yang dirilis di CUDA) atau `float32`        |
| `policy.chunk_size`                         | Jumlah aksi yang diprediksi di setiap chunk                         |
| `policy.n_action_steps`                     | Jumlah aksi yang dieksekusi sebelum perencanaan ulang                      |
| `policy.use_language_recipe`                | Aktifkan resep pengawasan bahasa bawaan G0.5                |
| `policy.recipe_path`                        | Recipe YAML dibaca sekali ke dalam `policy.recipe` (tidak disimpan)            |
| `policy.optimizer_backbone_lr_multiplier`   | Pengali laju pembelajaran untuk tulang punggung bahasa                |
| `policy.optimizer_vision_lr_multiplier`     | Pengali laju pembelajaran untuk menara visual                     |

Kepala aksi, dimensi, horizon, mode prosesor, dan normalisasi berasal dari checkpoint; penggantian yang tidak kompatibel ditolak saat pemuatan.

## Evaluasi

Dengan simulator LIBERO yang sudah terpasang, evaluasi checkpoint LIBERO dengan nama kamera dan kontrol relatifnya:

```bash
lerobot-eval \
  --policy.path=lerobot/g05_libero \
  --policy.device=cuda \
  --env.type=libero \
  --env.task=libero_10 \
  --env.control_mode=relative \
  --env.observation_height=512 \
  --env.observation_width=512 \
  '--env.camera_name_mapping={"agentview_image": "image", "robot0_eye_in_hand_image": "wrist_image"}' \
  --eval.batch_size=1 \
  --eval.n_episodes=5 \
  --seed=0 \
  --output_dir=outputs/g05-libero-lerobot-eval
```

## Referensi

- [Model OpenGalaxea G0.5](https://huggingface.co/OpenGalaxea/G05)
- [Repositori OpenGalaxea G0.5](https://github.com/OpenGalaxea/GalaxeaVLA)
- [Pipeline anotasi bahasa LeRobot](./annotation_pipeline)

## Lisensi

Kode integrasi G0.5 di bawah `src/lerobot/policies/g05` diadaptasi dari implementasi Galaxea dan, seperti bobot checkpoint, berlisensi [G0.5 Community License](https://huggingface.co/OpenGalaxea/G05/blob/main/licenses/LICENSE-G0.5), bukan Apache-2.0 milik LeRobot. Tinjau dan setujui lisensi tersebut sebelum mengunduh atau menggunakan checkpoint.

Fine-tune merupakan karya turunan dari G0.5. Saat Anda mendistribusikannya kembali, sertakan file `LICENSE` dan `NOTICE` dari checkpoint yang menjadi sumbernya: LeRobot tidak menyalin file-file tersebut untuk Anda, tetapi model card yang dihasilkan mencantumkan lisensinya.

