# π₀.₅ (Pi05) Politikası

π₀.₅, Physical Intelligence tarafından geliştirilen, **genel dünya genellemesine sahip bir Vision-Language-Action modelidir**. LeRobot uygulaması, açık kaynaklı [OpenPI](https://github.com/Physical-Intelligence/openpi) deposundan uyarlanmıştır.

## Model Genel Bakış

π₀.₅, [Physical Intelligence](https://www.physicalintelligence.company/blog/pi05) tarafından robotikteki büyük bir zorluk olan **açık dünya genelleme** sorununu ele almak üzere π₀'dan önemli bir evrim olarak geliştirilmiştir. Robotlar kontrollü ortamlarda etkileyici görevler gerçekleştirebilse de π₀.₅, eğitim sırasında hiç görülmemiş tamamen yeni ortamlara ve durumlara genelleme yapacak şekilde tasarlanmıştır.

### Genelleme Zorluğu

Physical Intelligence'in açıkladığı üzere, temel zorluk çeviklik veya maharetle ilgili görevleri yerine getirmek değil, genellemedir; yani yeni ortamlarda ve yeni nesnelerle görevleri doğru şekilde yerine getirme yeteneğidir. Farklı evleri temizleyen bir robotu düşünün: her evde farklı nesneler farklı yerlerde bulunur. Genelleme birden çok düzeyde gerçekleşmelidir:

- **Fiziksel Seviye**: Kalabalık ortamlarda, daha önce görülmemiş nesnelerle bile bir kaşığı (sapından) veya tabağı (kenarından) nasıl tutulacağını anlama
- **Anlamsal Seviye**: Görevin anlamını anlama, kıyafetlerin ve ayakkabıların nereye konulacağı (yatak yerine çamaşır sepeti) ve dökülenleri temizlemek için hangi araçların uygun olduğu
- **Ortam Seviyesi**: Evler, marketler, ofisler ve hastaneler gibi "dağınık" gerçek dünya ortamlarına uyum sağlama

### Heterojen Verilerde Ortak Eğitim

π₀.₅'teki çığır açan yenilik **heterojen veri kaynakları üzerinde eş-eğitim**. Model şunlardan öğrenir:

1. **Çok Modlu Web Verisi**: Görsel açıklama, görsel soru-cevap, nesne algılama
2. **Sözel Talimatlar**: İnsanların robotları karmaşık görevlerde adım adım yönlendirmesi
3. **Alt Görev Komutları**: Yüksek düzey anlamsal davranış etiketleri (örneğin, düzensiz bir yatak için "yastığı al")
4. **Çeşitli Vücutlu Robot Verisi**: Farklı yeteneklere sahip çeşitli robot platformlarından gelen veriler
5. **Çevreler Arası Veri**: Birçok farklı eve dağıtılmış statik robotlar
6. **Mobil Manipülasyon Verisi**: ~400 saatlik mobil robot demonstrasyonu

Bu çeşitli eğitim karışımı, fiziksel, görsel ve anlamsal düzeylerde aynı anda genelleme yapmayı mümkün kılan bir "müfredat" oluşturur.

## Kurulum Gereksinimleri

1. LeRobot'u [Yükleme Kılavuzumuz](./installation)’u takip ederek yükleyin.
2. Pi0.5 bağımlılıklarını yüklemek için şunu çalıştırın:

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

   PyPI'den LeRobot'u yüklediyseniz:

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

## Kullanım

LeRobot yapılandırmanızda π₀.₅'i kullanmak için politika türünü şu şekilde belirtin:

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

## Eğitim

### LIBERO'da Hızlı Başlangıç

LIBERO taban modelini, [aşağıdaki sonuçların](#libero-benchmark-results) arkasındaki gösterimlerin ~1,9 GB boyutunda video kodlanmış bir kopyası olan [lerobot/libero](https://huggingface.co/datasets/lerobot/libero) üzerinde ince ayarlayın.

π₀.₅'in okuduğu anahtarları taşır; bunlar, değerlendirme sırasında LIBERO ortamının ürettiği anahtarlarla aynıdır:

| Özellik                     | Veri setindeki şekil | π₀.₅ bunu nasıl tüketir                                    |
| --------------------------- | -------------------- | ------------------------------------------------------- |
| `observation.images.image`  | 256×256×3, agentview | 224×224 boyutuna yeniden boyutlandırıldı                                      |
| `observation.images.image2` | 256×256×3, bilek     | 224×224 boyutuna yeniden boyutlandırıldı                                      |
| `observation.state`         | 8                    | 256 bina ayrıştırılarak istemciye yazılır   |
| `action`                    | 7                    | içeride 32'ye doldurulur; kayıp ilk 7 boyutu kullanır |

**Burada `--rename_map` gerekmez** — anahtarlar zaten eşleşiyor; sizinkiler farklıysa [Rename Map and Empty Cameras](./rename_map) bölümüne bakın.

  π₀.₅, [google/paligemma-3b-pt-224](https://huggingface.co/google/paligemma-3b-pt-224) tokenizer'ını kullanır — eğitimden önce Hub'da lisansını kabul edin ve `hf auth login` ile oturum açın.

Tek bir 80 GB GPU için boyutlandırıldı:

```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
```

**Ortalama/standart sapma normalizasyonu, [π₀.₅'in varsayılan çeyreklik değeri](#quantile-statistics) değil** — aşağıdaki sonuçların ölçüldüğü [pi05_libero_finetuned_v044](https://huggingface.co/lerobot/pi05_libero_finetuned_v044) kontrol noktasıyla uyumlu.

**`--policy.n_action_steps=10` and `--policy.empty_cameras=1` are explicit** because `--policy.pretrained_path` loads weights only — `lerobot/pi05_libero_base` stores both, and they would otherwise fall back to `50` and `0` (see [Loading a checkpoint](#loading-a-checkpoint)).

Ardından bir kontrol noktasını `lerobot-eval` ile değerlendirin ve referans başarı oranlarıyla karşılaştırın — bkz. [LIBERO](./libero).

### Quantil istatistikleri

π₀.₅, `STATE` ve `ACTION` değerlerini çeyrekler (quantile) ile normalize eder; bu nedenle veri setinizin `meta/stats.json` dosyasında `q01` ve `q99` alanları bulunmalıdır. Eski veri setlerinde yalnızca `min`/`max`/`mean`/`std` bilgileri yer alır ve ilk batch'te hata oluşur:

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

Yeniden hesaplayın:

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

**The result lands in `$HF_LEROBOT_HOME/your_dataset`**, not the cache `--dataset.repo_id` reads — so train with `--dataset.root=$HF_LEROBOT_HOME/your_dataset`, or add `--push_to_hub true` above.

Veya veri setini olduğu gibi bırakın ve `--policy.normalization_mapping='{"ACTION": "MEAN_STD", "STATE": "MEAN_STD", "VISUAL": "IDENTITY"}'` parametresini iletin.

Bölüm başına özetlerden toplanan toplam çeyrekleri (quantile) kaydetme, devam ettirme ve birleştirme, böylece `meta/stats.json` tüm veri setinin çeyrekleri yerine muhafazakâr bir zarfı (`q <= 50` için `min`, `q > 50` için `max`) içersin. Sonuncusunu tahmin etmek için, her bölümü akan bir histogramla tarayın:

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

`--skip-images` mevcut görüntü istatistiklerini korur ve yalnızca `STATE`/`ACTION` yeniden hesaplanacaksa video verisinin indirilmesini veya çözümlenmesini önler; `--root` ise Hub yerine yerel bir veri setini okur. Bu değerler histogram tahminleridir, ayrıklaştırma ve yeniden sınıflandırma hatasına tabidir; bu nedenle muhafazakâr olanlardan farklılık gösterebilir. Bu durum π₀.₅'in normalize edilmiş hedeflerini ve dolayısıyla kayıp ölçeğini değiştirir. Mevcut bir checkpoint içinde zaten kaydedilmiş istatistikler etkilenmez.

### Eğitim Komutu Örneği

VLM dondurulmuş olarak aynı ince ayar: daha az bellek, başarı oranında bazı kayıplara mal oluyor. `--dataset.repo_id` parametresini kendi veri setinizle değiştirin.

```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
```

### Temel Eğitim Parametreleri

- **`--policy.compile_model=true`**: Daha hızlı eğitim için model derlemesini etkinleştirir
- **`--policy.gradient_checkpointing=true`**: Eğitim sırasında bellek kullanımını önemli ölçüde azaltır
- **`--policy.dtype=bfloat16`**: Verimlilik için karma hassasiyetli eğitim kullanın
- **`--batch_size=64`**: Eğitim için batch boyutu, bunu GPU belleğinize göre ayarlayın
- **`--policy.pretrained_path=lerobot/pi05_base`**: İnce ayar yapmak istediğiniz temel π₀.₅ modeli, seçenekler şunlardır:
  - [lerobot/pi05_base](https://huggingface.co/lerobot/pi05_base)
  - [lerobot/pi05_libero_base](https://huggingface.co/lerobot/pi05_libero_base) (özellikle Libero veri setinde eğitildi)
- **`--policy.optimizer_fused=true`**: Daha hızlı optimizasyon adımları için birleşik AdamW kullanır; bu bayrak, bir çalışmayı sürdürürken yoksayılır

### Opsiyonel eğitim zamanı RTC

Pi05, [Training-Time Action Conditioning for Efficient Real-Time Chunking](https://arxiv.org/abs/2512.05964) çalışmasına uygun olarak, verimli [Real-Time Chunking](./rtc) için isteğe bağlı olarak aksiyon-önek koşullandırma öğrenebilir. `policy.rtc_training_max_delay` parametresini, denetleyici adımlarında beklenen en büyük çıkarım gecikmesine ayarlayın:

```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
```

Varsayılan değer `0`'dır; bu, eğitim zamanı RTC'yi devre dışı bırakır ve standart Pi05 hedefini değiştirmez. Yapılandırılan gecikme, `chunk_size`'dan küçük olmalıdır. Eğitim sırasında Pi05, her örnek için temiz bir önek uzunluğunu bağımsız olarak örnekler ve akış kaybını yalnızca kalan sonek üzerinde hesaplar.

Eğitilmiş RTC'yi açıkça kullanarak elde edilen kontrol noktasını kullanın:

```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
```

`inference.rtc.execution_horizon` değerini, checkpoint'in `rtc_training_max_delay` ile `chunk_size - rtc_training_max_delay` değerleri arasında ve `inference.queue_threshold` değerini en az `rtc_training_max_delay` olacak şekilde ayarlayın. Eğitilen aralığın ötesinde tek seferlik bir gecikme sıçraması, ilgili chunk'ı atar ve yeniden dener; gecikme aralık dışında kaldığı sürece rollout açık bir hata ile durur. Varsayılan `--inference.rtc.mode=guided` modu, sıradan checkpoint'ler için kullanılabilir kalmaya devam eder.

### Kontrol noktası yükleme

Bu iki form birbirinin yerine kullanılamaz:

|                                        | `--policy.path`                                | `--policy.pretrained_path`                |
| -------------------------------------- | ---------------------------------------------- | ----------------------------------------- |
| Yükler                                  | weights **ve** checkpoint'ın `config.json` | sadece ağırlıklar                              |
| Özellik adları                          | kontrol noktasından                            | veri setinizden, `--rename_map` sonrasında   |
| Depolanan ayarlar, örn. `n_action_steps` | miras alınan                                      | varsayılanlara sıfırla                     |
| `--policy.type`                        | atlanmalıdır                                | zorunlu                                  |
| `--rename_map`                         | kamera anahtarlarınız farklı olduğunda gereklidir            | veri seti anahtarlarını standartlaştırmak için desteklenir |

Ham veri seti özellik adları, politika özellik adlarından farklıysa `--rename_map` parametresini her iki yükleme biçimiyle birlikte kullanın. Örneğin, RoboMME ince ayar komutu, ağırlıkları `--policy.pretrained_path` ile başlatırken ham `image`, `wrist_image`, `state` ve `actions` sütunlarını eşler.

### Eğitim Parametreleri Açıklaması

| Parametre               | Varsayılan | Açıklama                                 |
| ----------------------- | ------- | ------------------------------------------- |
| `freeze_vision_encoder` | `false` | Görüntü kodlayıcısını dondurmayın            |
| `train_expert_only`     | `false` | VLM'yi dondurmayın, tüm parametreleri eğitin |

**💡 İpucu**: `train_expert_only=true` ayarlandığında VLM dondurulur ve yalnızca eylem uzmanı ile projeksiyonlar eğitilir; bu da azaltılmış bellek kullanımıyla ince ayar yapılmasına olanak tanır.

## Kısa Ufuklu Gözlem Belleği (MEM)

Pi05, isteğe bağlı olarak [MEM](https://arxiv.org/abs/2603.03596) tabanlı kısa ufuklu görsel ve proprioseptif bağlam kullanabilir. Her iki yol da varsayılan olarak devre dışıdır, bu nedenle mevcut checkpoint'ler ve eğitim komutları tek kareli Pi05 davranışını korur.

Bu, yalnızca MEM'in kısa vadeli hafızasını uygular — III-C bölümündeki video kodlayıcı ve III-D bölümündeki proprioseptif projeksiyon. Yüksek düzey bir politikanın bir sonraki alt görevi ve şimdiye kadar olanların sıkıştırılmış doğal dil özetini tahmin ettiği, III-B bölümündeki MEM'in uzun vadeli _dil_ hafızası uygulanmamıştır. Makalenin ablasyonlarında, yalnızca video hafızası, uzun vadeli görevlerde tam MEM'in görev ilerlemesinin yalnızca bir kısmını geri kazanır.

Kontrol noktasından ince ayar yaparken, bellek olmadan ön eğitilmiş bir kontrol noktasından bellek eklemek, makalenin daha zayıf `MEM-Posttrain-Only` ablesiyonuna da karşılık gelir. MEM'in başlıca sonuçları, robot ve robot olmayan videoların çeşitli bir karışımında video kodlayıcısının ön eğitilmesinden kaynaklanmaktadır; bu, şu anda hiçbir halka açık Pi05 kontrol noktası tarafından sağlanmamaktadır.

İnce ayarlama sırasında şu şekilde etkinleştirin:

```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` mevcut gözlemi içerir. `memory_stride` saniye değil, **veri seti kareleri** cinsinden ölçülür; bu nedenle veri setinizin `fps` değerine göre ölçeklendirin: MEM, bir saniye arayla altı gözlem üzerinde ön eğitim alır; bu, 30 fps'lik bir veri seti için (varsayılan) `memory_stride=30`, `lerobot/robomme` gibi 10 fps'lik bir veri seti için ise `memory_stride=10` demektir.

Her dördüncü SigLIP katmanı, dikkatini MEM'in bileşik uzay-zaman dikkatiyle değiştirir: eşleşen yama belirteçleri arasında nedensel zaman dikkati, standart uzamsal dikkatle bileştirilir ve önceden eğitilmiş projeksiyonlar yeniden kullanılır, böylece görme kulesine öğrenilebilir parametre eklenmez. Son bu katman çalıştıktan sonra geçmiş kare belirteçleri atılır, bu da aşağı akıştaki dil/aksiyon öneki uzunluğunu değiştirmez.

Bir epizodun başlangıcında kullanılamayan geçmiş, dolgu (padding) ile doldurulur ve maskelenir. Çıkarım sırasında Pi05, içsel olarak aynı aralıklı (strided) görüntü geçmişini korur ve politika sıfırlandığında bunu temizler.

Geçmiş propriosepsiyon bağımsız bir seçenektir:

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

Etkinleştirildiğinde, her tutulan kare için bir yansıtılmış sürekli durum jetonu eklenir ve ayrıklaştırılmış durum, durumun tam olarak bir kez temsil edilmesini sağlamak üzere metin isteminden kaldırılır (MEM bölümü III-D). Bu, istem biçimini değiştirdiğinden, eğitim sırasında yarıda değil, eğitimin başından itibaren etkinleştirilmelidir. Görsel ve proprioseptif bellek aynı `memory_frames` ve `memory_stride` ayarlarını kullanır, ancak her iki yol da bağımsız olarak etkinleştirilebilir. Seçilen bellek seçenekleriyle eğitim veya ince ayar yapın; bunları yalnızca çıkarım sırasında etkinleştirmek, tek karelik bir kontrol noktasının öğrenilmiş bellek davranışını sağlamaz.

PEFT altında, önceden eğitilmiş ağırlıkları olmadığı için `proprio_history_proj`, `modules_to_save` üzerinden tam olarak eğitilir ve kaydedilir.

Çıkarım sırasında MEM, tek bir toplu geçmiş kuyruğu tutar ve her toplu satırın bölüm sınırlarını paylaştığını varsayar. `lerobot-eval`, her toplu dağıtım (rollout) öncesinde ve vektörel ortamı sıfırlamadan önce `policy.reset()` çağrısını yaparak bu koşulu sağlar. Asenkron vektörel bir toplu işlemde satırların bağımsız olarak otomatik sıfırlanması desteklenmez; tüm politika ve eylem kuyruklarının birlikte sıfırlanması için yeni bir dağıtım başlatın.

## Göreceli Eylemler

Varsayılan olarak, π₀.₅ mutlak eylemleri tahmin eder. Modelin mevcut robot durumuna göre ofsetleri tahmin etmesi için **göreli eylemleri** etkinleştirebilirsiniz. Bu, belirli kurulumlarda eğitim kararlılığını iyileştirebilir.

Göreceli eylemleri kullanmak için, önce veri seti istatistiklerinizi CLI aracılığıyla göreceli uzayda yeniden hesaplayın:

```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
```

Veya eşdeğer olarak Python'da:

```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`, politikanızın `chunk_size` değeriyle (π₀.₅ için varsayılan 50) eşleşmelidir. `relative_exclude_joints`, mutlak uzayda kalması gereken eklem adlarını (ör. kavrama komutları) listeler. Güncellenen istatistikleri Hub'a yüklemek için `--push_to_hub true` kullanın.

Ardından göreli eylemler etkinleştirilerek eğitim yapın:

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

## Performans Sonuçları

### Libero Benchmark Sonuçları

π₀.₅, Libero benchmark setinde güçlü bir performans sergilemiştir. LeRobot uygulamasını karşılaştırmak ve test etmek için, libero temel modelini Libero veri setinde ek olarak 6k adım boyunca ince ayarladık ve sonuçları OpenPI referans sonuçlarıyla karşılaştırdık.

| Karma          | LeRobot Uygulaması | OpenPI Referansı |
| ------------------ | ---------------------- | ---------------- |
| **Libero Spatial** | 97.0%                  | 98.8%            |
| **Libero Object**  | 99.0%                  | 98.2%            |
| **Libero Hedefi**    | 98.0%                  | 98.0%            |
| **Libero 10**      | 96.0%                  | 92.4%            |
| **Ortalama**        | 97.5%                  | 96.85%           |

Bu sonuçlar, π₀.₅'in çeşitli robotik manipülasyon görevleri arasında güçlü genelleme yeteneklerini göstermektedir. Bu sonuçları yeniden üretmek için [Libero](https://huggingface.co/docs/lerobot/libero) bölümündeki talimatları izleyebilirsiniz.

## Lisans

Bu model, orijinal [OpenPI deposu](https://github.com/Physical-Intelligence/openpi) ile tutarlı olarak **Apache 2.0 Lisansı**'na uyar.

