# Praxis-1

`praxis`, Runway'ın robotlar için açık ağırlıklı Dünya Eylem Modeli olan [Praxis-1](https://runway.com/news/praxis-1-is-now-available)'in LeRobot adaptörüdür. Praxis-1 bir video-eylem modelidir: 27B parametreli bir mixture-of-experts transformer (token başına yaklaşık 3B aktif) olan chunk-causal video difüzyon omurgası, iki rig kamerasının sonraki 1,6 saniyelik videosunu gürültüden arındırırken, omurganın gizli durumlarını okuyan bir eylem uzmanı, eşleşen 24 kartezyen komutu 15 Hz'de gürültüden arındırır. Wan2.2 video oto-encoder'ı ve Qwen3.5-2B metin encoder'ı dondurulmuştur ve halka açık ağırlıklarından gelir. Yayınlanan checkpoint olan `praxis-1-droid`, tek kollu bir DROID rig'ini sürer: dış kamera ve bilek kamerasına sahip bir Franka kol. Daha önceki, yayınlanmamış bir DROID checkpoint'i, farklı ağırlıklara ve başka bir kamera tuvaline sahip aynı mimariye sahiptir; checkpoint'in `config.json` dosyası bunları ayırt eder (bkz. "The checkpoints"). İki YAM kolu için çift kollu checkpoint olan `praxis-1-yam`, aynı düzenle gelir (bkz. "The bimanual YAM checkpoint"). Bir rig'in başlıkları olmadan video omurgası ve eylem uzmanı gövdesi olan `praxis-1-base`, yeni bir tek kollu rig için ince ayarın başlangıcıdır (bkz. "Fine-tune the base checkpoint").

Kaynaklar:

| Kaynak     | Bağlantı                                                                                           | Kullanım alanı                                                              |
| ------------ | ---------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- |
| Duyuru | [runway.com/news/praxis-1-is-now-available](https://runway.com/news/praxis-1-is-now-available) | Yöntem özeti                                                       |
| Ağırlıklar      | [Praxis-1 koleksiyonu](https://huggingface.co/collections/runwayml/praxis-1)                    | `runwayml/praxis-1-droid-lerobot` ve diğer dönüştürülen kontrol noktaları |
| Kod         | [runwayml/praxis-1-oss](https://github.com/runwayml/praxis-1-oss)                              | Orijinal çıkarım, simülasyon ve eğitim                                     |
| Simülatör    | [PyPI'deki praxis-sim](https://pypi.org/project/praxis-sim/)                                     | MuJoCo kurulumu ve değerlendirme paketleri                              |
| Wan2.2 VAE   | [Wan-AI/Wan2.2-TI2V-5B](https://huggingface.co/Wan-AI/Wan2.2-TI2V-5B)                          | `Wan2.2_VAE.pth` (donmuş)                                             |
| Metin kodlayıcı | [Qwen/Qwen3.5-2B](https://huggingface.co/Qwen/Qwen3.5-2B)                                      | Dondurulmuş                                                                |

Model kodu, `lerobot/policies/praxis/praxis_core` altında ağaç içinde yer alır (praxis deposunun 8dad1a4 commit'inden satır içi alınmış, `praxis-1-droid`'in canvas kuralı eklenmiş, import yolları yeniden yazılmıştır; dosya başlıkları üst akış commit'lerini belirtir). MuJoCo simülasyonu, PyPI'daki `praxis-sim` paketidir (praxis deposunun `packages/praxis-sim` altında geliştirilmiştir, torch içermez); LeRobot'un bunun için bir ortamı yoktur.

## Kurulum

```bash
pip install -e ".[praxis,dataset]"   # the policy; `lerobot-eval` and `lerobot-train` also need `dataset`
```

Dönüştürülen checkpoint'ler Hub'da: `--policy.path=runwayml/praxis-1-droid-lerobot`, yayınlanan tek kollu checkpoint'i (54 GB, bir kez indirilir) yükler. `runwayml/praxis-1-yam-lerobot` iki kollu checkpoint'tir. `runwayml/praxis-1-base-lerobot` ise önce `init_heads.py` çalıştırılması gereken taban modeldir.

Politika, LeRobot 0.7'nin kilitlediği sürümlerde (yazım sırasında 0.7.1: CUDA 13.2 ile torch 2.15.0, transformers 5.22.2, triton 3.9) çalışır. Aşağıdaki sonuçlar, bu yığın üzerinde (aynı komutları veren transformers 5.22.1 ve 5.22.2 ile) ve LeRobot 0.6'nın yığınında (CUDA 12.8 ile torch 2.11.0, transformers 5.5.4) ölçülmüştür; komutlar, her birinde praxis deposundakilerle bit düzeyinde eşittir.

Kontrol noktası doğrulama kurulumunun isteğe bağlı çekirdekleri. `flash-attn-4`, kontrol noktası yapılandırmasının `flash` dikkat arka ucunu (FlashAttention-4 CuTe çekirdeğiyle esnek dikkat) sağlar; yoksa politika, esnek dikkatin Triton çekirdeğini kullanır. `flash-linear-attention` ve `causal-conv1d`, Qwen3.5'in doğrusal-dikkat katmanlarının hızlı çekirdekleridir; bunlar olmadan `transformers`, PyTorch uygulamasını çalıştırır. Üçü de modeli değil, çıktıların son bitlerini değiştirir:

```bash
pip install "flash-attn-4[cu13]==4.0.0b36"        # the CUDA 13 build for torch 2.15; "flash-attn-4==4.0.0b36" on a CUDA 12 torch
pip install "flash-linear-attention==0.6.0"       # 0.5.0 does not run on triton 3.9
CAUSAL_CONV1D_FORCE_BUILD=TRUE MAX_JOBS=16 pip install --no-build-isolation "causal-conv1d==1.6.1"   # compiles against torch; the praxis repository's setup
```

Çıkarım işlemi, 80 GB belleğe sahip tek bir GPU gerektirir (ağırlıklar bfloat16'da 54 GB'dır).

Veri merkezi Blackwell GPU'larında (B200 ve GB200 SM100, B300 ve GB300 SM103; Jetson Thor, SM110, aynı FlashAttention-4 ileri geçişine sahip):

- B300 ve GB300, LeRobot 0.7'nin kilitlediği torch 2.15.0+cu132 gibi CUDA 12.9 veya üzeri için derlenmiş bir torch sürümü gerektirir. MoE uzmanları `torch._grouped_mm` çağrısı yapar ve LeRobot 0.6'nın kullandığı torch 2.11.0+cu128 derlemesinde bunun için bir SM103 çekirdeği yoktur: praxis deposundaki pipeline'da olduğu gibi, ilk politika çağrısı `RuntimeError: cutlass cannot run, error 7` hatasıyla başarısız olur. B200 ise her iki yığın üzerinde de çalışır.
- FlashAttention-4, blok-sparse maskeleri yalnızca 256 token'lık bloklarda kabul eder (aksi halde `ValueError: Block sparse tensorsforward have block size 128, which must be a multiple of 256` hatası verir). `flash` arka ucu, bu GPU'larda checkpoint'in 128 olan `backbone.attention.flex_block_size` yerine omurga maskelerini 256 token'lık bloklarda oluşturur. Blok boyutu yalnızca token çiftlerini gruplar: mask fonksiyonu yine de her çifti belirler. praxis deposu, checkpoint'in `config.json` dosyasında `"flex_block_size": 256` ile aynı işlemi gerçekleştirir. `triton` arka ucu ise checkpoint'in 128 değerini korur.

RTX Blackwell GPU'larında (hesaplama yeteneği 12.x; RTX PRO 6000 Blackwell, ağırlıkların gerektirdiği 96 GB'a sahip) FlashAttention-4'ün herhangi bir blok boyutunda blok-sparse ileri (forward) işlemi yoktur (checkpoint'in 128 token'lık bloklarıyla `Block sparsity requires sparse_block_size[1]=128 to match tile_n=64` hatasını verir), bu nedenle `flash` arka ucu (backend) bu GPU'larda çalışamaz. `attention_backend="auto"`, bu GPU'larda `flash-attn-4` kurulu olsa bile `triton`'u seçer ve `"flash"`, politika (policy) oluşturulurken bir `ValueError` fırlatır. Praxis deposu, checkpoint'in `flash` ayarıyla ilk çağrısında başarısız olur ve checkpoint'in `config.json` dosyasında `"backend": "triton"` kullanıldığında aynı şekilde çalışır. İki arka uç son bitlerde (last bits) farklılık gösterdiğinden, bu GPU'lardaki çalıştırmaları başka yerlerdeki `triton` çalıştırmalarıyla karşılaştırın. RTX PRO 6000'de başka hiçbir şey değişmez: aşağıdaki her iki yığın (stack)ın da torch derlemeleri SM120 çekirdeklerini (MoE'nin `torch._grouped_mm`'i dahil) içerir ve `praxis-1-droid`'in ayarlarıyla çıkarım (inference) yaklaşık 62 GB'da zirve yapar.

Bu kurallar, FlashAttention-4'ün kendi kontrollerini takip eder. Aşağıdaki eşitlik sonuçları, bir GB300, bir B200 ve bir RTX PRO 6000 Blackwell üzerinde ölçülmüştür.

> [!WARNING]
> `transformers` 5.4.0 ile 5.5.4 (LeRobot 0.6; 5.6.0'da düzeltildi ve LeRobot 0.7, 5.22'yi sabitler) Hub checkpoint'i `Qwen/Qwen3.5-2B`'yi yüklerken, 320 dil modeli tensörünün tamamının eksik olduğunu raporlar (eşleştirme yapmadan önce depolanan `model.language_model.*` adlarını yeniden adlandırır) ve bunları sessizce rastgele başlatır. Politikanın metin kodlayıcısı bunu algılar ve tensörleri depolanan adlarıyla yükler, logda bir uyarı verir. Rastgele bırakılan bir metin kodlayıcı, hâlâ hareket eden ama nadiren başarılı olan bir politika üretir (ilk çalışmamızda 56 guard epizodunun 7'si).

## Girdiler ve çıktılar

| Özellik                             | Biçim | Anlam                                                                                                                                                                                                                    |
| ----------------------------------- | ----- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `observation.images.exterior`       | RGB   | Sabit kamera. Herhangi bir boyut; ön işleyici, kontrol noktası karosunu oluşturur (`praxis-1-droid` için kenar yumuşatmalı uyum kuralıyla 224 x 416, önceki DROID kontrol noktası için 256 x 416). Anahtar, `exterior_image_key` tarafından ayarlanır. |
| `observation.images.wrist`          | RGB   | Bilek kamerası. `wrist_image_key` tarafından ayarlanır.                                                                                                                                                                            |
| `observation.state`                 | (7,)  | `[x, y, z, roll, pitch, yaw, gripper]`: robot taban çerçevesinde Franka flanş durumu (metre, radyan cinsinden dış x-y-z Euler açıları, DROID sözleşmesi) ve [0, 1] aralığında gripper.                                  |
| `task`                              | str   | Metin kodlayıcıya olduğu gibi verilen talimat.                                                                                                                                                                       |
| `action`                            | (7,)  | Aynı yedi değer: sonraki 15 Hz tikinin mutlak hedef pozu ve kavrayıcısı.                                                                                                                                        |
| `observation.scene_seed` (isteğe bağlı) | (1,)  | Bölümün sahne tohumu. `k` parçasının örnekleyici tohumu `seed + seed_stride * scene_seed + k`'dir.                                                                                                                     |

Politika kendi geçmişini tutar: parti içindeki her ortam için son 25 gözlemden oluşan bir halka tampon (çalıştırılan parça ve mevcut kare), bir sonraki çağrıya bağlam olarak beslenir; bu nedenle `n_obs_steps` 1 olarak kalır ve `select_action`, o tikin gözlemiyle her 15 Hz tikinde çağrılmalıdır. Bir bağlam penceresinin ilk çağrısı 21 komut döndürür, sonraki her çağrı 24 komut döndürür. `n_action_steps` 24'ün altında olduğunda, praxis'te olduğu gibi her çağrı bağlamsız bir soğuk başlangıçtır. `drop_queued_actions` (örneğin bir yuvarlanmanın ortasında yeni bir talimat) de zaman bağlamını yeniden başlatır, çünkü model tüm önceki parçanın çalıştırılmış olmasına koşullanır. Tüm parçaları çalıştıran bir çağıran (`predict_action_chunk`), önceki çağrısından bu yana çalıştırılan kareleri en eskiden yeniye doğru bir yığın olarak devreder: `(B, T, 3, H, W)` kameralar ve `(B, T, 7)` durumlar; bir sonraki parça, o zaman tik başına bir çağrı yuvarlanmasının parçası olur. Bir bağlam penceresinin ilk parçası 21 gerçek komuta sahiptir ve son komutla 24'e doldurulur; doldurulmuş satırları sırasında gözlemlenen kareler atılır, böylece bağlam, 21 gerçek komutu çalıştıran bir çağıranın bağlamı olur. Tek kareli bir parça çağrısı bağlamı yeniden başlatır.

### İşleyiciler

Önişleyici, girdileri praxis verileri ve serve kodunun yaptığı gibi, kaydedilmiş ve denetlenebilir adımlar olarak hazırlar:

| Adım                           | Does                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| ------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `PraxisTileViewsProcessorStep` | Her kamera görünümü, kontrol noktasının (`video.antialias`) kuralına göre tuvalin kendi karoselini oluşturur. `praxis-1-droid`: yerel 720 x 1280 en-boy oranına merkezden kırpma, 234 x 416 boyutuna tek bir antialiased bilineer yeniden boyutlandırma (o boyutta gönderilen bir görünüm için yok), 224 x 416 boyutuna merkezden kesme. Önceki DROID kontrol noktası: karo en-boy oranına merkezden kırpma, 256 x 416 boyutuna tek bir düz bilineer yeniden boyutlandırma. uint8 seviyeleri; karo boyutunda zaten olan bir görünüm olduğu gibi geçer. |
| `PraxisPoseProcessorStep`      | DROID duruşu `[x, y, z, roll, pitch, yaw, gripper]`, praxis duruşu8 `[x, y, z, qw, qx, qy, qz, gripper]` (durum ve bir eğitim grubunun eylemleri) haline gelir.                                                                                                                                                                                                                                                                                   |
| `PraxisTokenizerProcessorStep` | Talimat, Qwen3.5-2B metin kodlayıcısının (`observation.language.tokens`, `.attention_mask`) token kimlikleri ve dikkat maskesi olarak dönüştürülür; tokenizasyon, praxis metin kodlayıcısının tokenize ettiği şekilde yapılır. Donmuş kodlayıcı ve gömme önbelleği politika içinde kalır.                                                                                                                                                                                          |
| `PraxisCommandProcessorStep`   | (postprocessor) Politikanın komutu, praxis tel pozu `[x, y, z, rotation 3 x 3]` ve gripper, CPU üzerinde DROID 7 değerine dönüşür.                                                                                                                                                                                                                                                                                                     |

Birlikte, politika karoları ve pose8 satırlarını görür ve tel pozlarını üretir; bu, praxis `Session`'ın tükettiği ve ürettiği şeyin tam olarak kendisidir. q99 eylem normalizasyonu, ortalama/std propriyo normalizasyonu ve göreli-eylem çözümü oturumun içinde kalır: bunlar, her yürütülen parçanın başındaki pose'a sabitlenir ve oturum bunları rollout boyunca takip eder; istatistikleri ise checkpoint'in (`PraxisConfig.model_config["normalization"]`) istatistikleridir; standart normalizör adımları kimliktir. Politika ayrıca ham 7 değerli pose'u, ham kamera karelerini ve `task` dizgisini de kabul eder, böylece pipeline olmadan da çağrılabilir: karo boyutundaki kareler karolar olarak alınır, diğer boyutlar checkpoint'in tuval kuralından geçer (`praxis-1-droid`'in sığdırma kuralı idempotent değildir, bu nedenle bir karo asla iki kez bu kuraldan geçirilmez) ve token içermeyen bir görev, politika tarafından tokenize edilir. Karolar, otoencoder onları okuyana kadar pipeline'ın onları koyduğu cihazda kalır ve komutlar CPU'da geri döner: hiçbir şey cihaz sınırını iki kez geçmez.

## Kontrol noktaları

| Kontrol Noktası                                | Karolar                  | Yeniden boyutlandır                                         | Önerilen örnekleyici (`praxis-1-droid` için `PraxisConfig` varsayılanları)                                                                         |
| ----------------------------------------- | ---------------------- | ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| `praxis-1-droid` (yayınlandı)               | 224 x 416              | antialiased uyum kuralı (`video.antialias: true`) | 2 Euler adımı, 12.5 akış kaydırması, videoda 4.0 metin yönlendirmesi ve eylemlerde yönlendirme yok (1.0), 1 bağlam parçası                              |
| YAM, `praxis-1-yam` (bimanuel, yayınlandı)  | 256 x 416, üç karo | YAM uyum kuralı (`video.antialias: true`)         | 2 adım, 1.0 akış kayması, metin yönlendirmesi yok, 1 bağlam parçası (dönüştürücü bunları yazar)                                                     |
| Taban, `praxis-1-base` (baş yok)          | `init_heads.py` tarafından ayarlanır | `init_heads.py` tarafından ayarlanır                         | ince ayarın seçimi; DROID kurulumu `praxis-1-droid`'in                                                                             |
| Daha önceki DROID kontrol noktası (yayınlanmamış) | 256 x 416              | düz ikili doğrusal yeniden boyutlandırma                          | 2 adım, 8.0 kaydırma, metin yönlendirmesi yok, 3 bağlam parçası (praxis); aşağıdaki sonuçlar 1.0 kaydırma, 3.0 eylem yönlendirmesi ve 1 bağlam parçası kullanılarak elde edilmiştir |

Tuval, dönüştürücü aracılığıyla checkpoint'in `config.json` dosyasından (`video.tile_height`, `video.antialias`) gelir; örnekleyici ayarları `PraxisConfig` alanlarıdır, bu nedenle önceki DROID checkpoint'inin bir çalıştırması kendi ayarlarını (`--policy.t_shift=8.0 --policy.cfg_video_scale=1.0 --policy.max_context_chunks=3`) iletir.

## Kontrol noktasını dönüştürün

Bir praxis checkpoint, `config.json`, 17 safetensors parçası, `model.safetensors.index.json` ve `SHA256SUMS` içeren bir dizindir. Bunu bir LeRobot policy dizinine dönüştürün:

```bash
python examples/praxis/convert_checkpoint.py \
    --checkpoint /path/to/praxis-1-droid --out outputs/praxis-1-droid --link
```

Rig, checkpoint'in `embodiment` değerinden gelir: bimanual checkpoint, üç kamera anahtarını (`--camera-keys` ile yeniden adlandırılabilir) ve checkpoint'inin serve ayarlarını alır. Temel checkpoint, `init_heads.py` tarafından tamamlanan, işlemciler içermeyen bir dizin alır. `runwayml/praxis-1-droid-lerobot` ve diğer dönüştürülmüş checkpoint'ler bu script'in çıktısıdır.

`--link` 54 GB’i kopyalamak yerine shard’ları sembolik bağlantılarla bağlar. Dizin, LeRobot `config.json` dosyasını, shard’ları, indeksi ve kendi `SHA256SUMS` dosyasını (`sha256sum -c` bu dizinde geçer) içerir (LeRobot politikaları, transformers yerleşiminde shard’lı safetensors dosyalarını okur ve yazar; `PraxisPolicy.save_pretrained` 5 GB’lık shard’lar yazar) ve iki işlemci dosyasını içerir. `--vae-id` ve `--text-encoder-id` dondurulmuş parçaların nereden geldiğini belirler (varsayılan olarak Hub kimlikleri).

## Sonuçlar

Aşağıdaki kapalı döngü sayıları, praxis deposunun MuJoCo kurulumundan (Franka + Robotiq 2F-85, 512 x 288 kameralar, 15 Hz içeren `praxis-sim` paketi) ve sabit değerlendirme setlerinden gelmektedir; bir bölümün LeRobot tohumu, sahne tohumudur. `lerobot-eval` üzerinden setleri çalıştıran ortam, LeRobot'ın bir parçası değildir.

Örnekleme sırasında politika, praxis'in çalıştığı sayısal ayarları sabitler (cuDNN benchmark modu yok, MoE yönlendirici için float32 matmuller, cuDNN'de TF32'ye izin verilir) ve ardından host ayarlarını geri yükler; bu nedenle `--tf32`, `torch.backends.cudnn.benchmark` ve batch boyutu çıktıları değiştirmez.

`droid_guard` paketi (7 DROID görevi x 8 sahne, 56 bölüm, örnekleyici tohumu 0), daha önceki, yayınlanmamış DROID kontrol noktası (256 x 416 karolar) ve o dönemde praxis deposundaki örnekleyici ayarları (2 Euler adımı, akış kayması 1.0, eylem yönlendirmesi 3.0, video yönlendirmesi yok, 1 bağlam parçası) ile `flash` dikkat arka ucu kullanılarak, tek bir H100 80 GB üzerinde (yaklaşık 10 dakika). Aynı bölümler beş farklı şekilde çalıştırıldı: praxis deposunun kendi koşucusu kendi ortamında (torch 2.13, transformers 5.2.0, causal-conv1d), aynı koşucu ve `lerobot-eval` LeRobot 0.6 yığınında (torch 2.11, transformers 5.5.4) ve her ikisi de LeRobot 0.7'nin kilitlediği yığında (CUDA 13.2 ile torch 2.15, triton 3.9, flash-linear-attention 0.6.0; o dönemde transformers 5.16.1). torch 2.15 çalıştırmalarının transformers 5.22.1 ile tekrarlanması, hem praxis koşucusu hem de `lerobot-eval` için birebir aynı komutları ve aynı 46/56 bölüm sonuçlarını verirken, 5.22.2 (LeRobot 0.7.1'in kilitlediği sürüm) `praxis-1-droid` ve YAM kontrol noktası için aynı komutları veriyor: transformers sürümü sayılara yansımıyor.

| Görev              | praxis runner, praxis env | praxis runner, torch 2.11 | `lerobot-eval`, torch 2.11 | praxis runner, torch 2.15 | `lerobot-eval`, torch 2.15 |
| ----------------- | ------------------------: | ------------------------: | -------------------------: | ------------------------: | -------------------------: |
| lift_cube         |                       7/8 |                       7/8 |                        6/8 |                       7/8 |                        8/8 |
| cube_on_plate     |                       8/8 |                       8/8 |                        8/8 |                       8/8 |                        8/8 |
| block_in_bowl     |                       8/8 |                       8/8 |                        8/8 |                       8/8 |                        8/8 |
| block_out_of_bowl |                       7/8 |                       6/8 |                        7/8 |                       7/8 |                        6/8 |
| move_block        |                       7/8 |                       7/8 |                        6/8 |                       7/8 |                        7/8 |
| stack_block       |                       7/8 |                       8/8 |                        7/8 |                       8/8 |                        6/8 |
| press_button      |                       1/8 |                       0/8 |                        3/8 |                       1/8 |                        3/8 |
| **Toplam**         |            **45/56** 80 % |            **44/56** 79 % |             **45/56** 80 % |            **46/56** 82 % |             **46/56** 82 % |

56 bölüm boyunca eşleştirildi (`praxis_sim.compare`), `lerobot-eval` referans değerinden çıkarıldı:

| Karşılaştırma                                              | Fark | %95 bootstrap aralığı | Kazanılan / Kaybedilen | McNemar p |
| ------------------------------------------------------- | ---------: | ----------------------- | ---------- | --------: |
| torch 2.11: `lerobot-eval` vs praxis runner, praxis env |     +0.0 % | [-10.7 %, +10.7 %]      | 5 / 5      |      1.00 |
| torch 2.11: `lerobot-eval` vs praxis runner, aynı yığın |     +1.8 % | [-8.9 %, +12.5 %]       | 6 / 5      |      1.00 |
| torch 2.15: `lerobot-eval` vs praxis runner, praxis env |     +1.8 % | [-10.7 %, +14.3 %]      | 6 / 5      |      1.00 |
| torch 2.15: `lerobot-eval` vs praxis runner, aynı yığın |     +0.0 % | [-10.7 %, +10.7 %]      | 4 / 4      |      1.00 |

Her aralık sıfırı içerir: LeRobot politikası ve ortamı, praxis deposunun sonuçlarını yeniden üretir ve ne yazılım yığını (çekirdekler, transformers sürümü) ne de test çerçevesi, bu sonuçları epizotlar arası gürültünün ötesinde değiştirir. praxis çalıştırıcısının kendisi, yığınlar arasında aynı miktarda değişir (56'nın 44'ünden 46'sına). `press_button`, bu kontrol noktası için her kurulumda zordur.

Girdiler aynı olduğunda, politika her iki yığın üzerinde de praxis hattıyla bit düzeyinde eşittir (aşağıya bakın); iki yığın arasında, aynı girdilerin komutları en fazla 0.04 (flash) ve 0.02 (triton) kadar farklılık gösterir ve bu da bireysel bölümleri etkileyen unsurdur.

### `praxis-1-droid`, yayınlanan kontrol noktası

`praxis-1-droid` ile aynı 56 bölüm (224 x 416 kenar yumuşatmalı karolar), önerilen ayarlarında (2 Euler adımı, akış kayması 12.5, video yönlendirmesi 4.0, eylem yönlendirmesi yok, 1 bağlam parçası) ve `flash` arka ucuyla, tek bir H100 80 GB üzerinde: praxis deposunun çalıştırıcısı (praxis ortamında, güncel örnekleyiciyle `main`: torch 2.13, transformers 5.2.0), LeRobot 0.6 yığınındaki `lerobot-eval` (torch 2.11, transformers 5.5.4) ve LeRobot 0.7'nin kilitlediği yığında (CUDA 13.2 ile torch 2.15, transformers 5.22.1) hem çalıştırıcı hem de `lerobot-eval`.

| Görev              | praxis runner, praxis env | `lerobot-eval`, torch 2.11 | praxis runner, torch 2.15 | `lerobot-eval`, torch 2.15 |
| ----------------- | ------------------------: | -------------------------: | ------------------------: | -------------------------: |
| lift_cube         |                       7/8 |                        8/8 |                       8/8 |                        8/8 |
| cube_on_plate     |                       8/8 |                        7/8 |                       8/8 |                        8/8 |
| block_in_bowl     |                       8/8 |                        8/8 |                       8/8 |                        8/8 |
| block_out_of_bowl |                       8/8 |                        8/8 |                       7/8 |                        8/8 |
| move_block        |                       7/8 |                        8/8 |                       8/8 |                        8/8 |
| stack_block       |                       8/8 |                        7/8 |                       8/8 |                        6/8 |
| press_button      |                       8/8 |                        8/8 |                       7/8 |                        8/8 |
| **Toplam**         |            **54/56** 96 % |             **54/56** 96 % |            **54/56** 96 % |             **54/56** 96 % |

56 bölümün eşleştirilmesi sonucunda, `lerobot-eval` ile praxis runner arasındaki fark her iki yığında da +0,0 puandır (95 % bootstrap aralığı [-7,1 %, +7,1 %], 2 kazanma / 2 kaybetme, her biri için McNemar p 1,00). Değişen bölümler iki yığında aynı olanlar değildir: torch 2.15 çekirdekleri komutları en fazla 0,02 kaydırır ve birkaç sınırda bölüm buna uyar. Ayarlarıyla `praxis-1-droid`, önceki DROID checkpoint'inin ayarlarıyla büyük ölçüde başarısız olduğu `press_button` görevini çözer.

## praxis deposuyla uyumluluk

- Aynı süreçteki aynı gözlemler üzerinde, LeRobot politikası ve praxis `Session`, bit düzeyinde eş metin gömme değerleri, VAE latentleri, propriosepsiyon, örneklenen eylemler ve komutlar verir (aynı yüklenen ağırlıklar). `tests/policies/praxis/test_praxis.py`, bu kontrolü CPU üzerinde küçük bir rastgele model üzerinde tekrarlar.
- Süreçler arasında, orijinal `praxis` paketi üzerinden yürütülen praxis hattı ve LeRobot politikası, gerçek checkpoint üzerinde hem `flash` hem de `triton` arka uçlarında (iki arka uç, komutlarda birbirinden en fazla 0.055 farkla ayrılır) bit düzeyinde eşit komutlar verir; bu durum LeRobot 0.6 yığınında (torch 2.11.0+cu128, transformers 5.5.4, flash-attn-4 4.0.0b36) ve LeRobot 0.7'nin kilitlediği yığında (torch 2.15.0+cu132, transformers 5.22.1 ve 5.22.2, triton 3.9, flash-attn-4 4.0.0b36) geçerlidir. Referansın kendisi iki yığın arasında değişir (`flash` üzerinde en fazla 0.019, `triton` üzerinde 0.015); politika her birinde ona bit bit eşlik eder.
- `praxis-1-droid`: praxis deposunun `main` dalındaki praxis hattına karşı yapılan süreçler arası kontrol, politikayı çağıran sekiz farklı yöntemde, her iki backend ve her iki yığın üzerinde bit düzeyinde eşittir: kaydedilmiş işlemci hatları üzerinden (`lerobot-eval`'ın yaptığı gibi), hatlar olmadan ham kareler ve 7 değerli poz üzerinde, bir partide iki ortam (farklı talimatlar ve sahne tohumları) ile, `predict_action_chunk` üzerinden (soğuk başlangıç ve yürütülen karelerin bir yığın olarak verilmesiyle sonraki parça), `n_action_steps=12` ile (yürütülen karelere koşullu olarak 12 komutta bir parça), eylem yönlendirmesi açıkken (`cfg_scale=3`) ve üç bağlam parçasıyla 70 komut üzerinde (derinlik 0'dan 3'e). Kontrol, `lerobot-eval`'ın varsayılan TF32 ve cuDNN benchmark bayrakları altında geçerlidir: politika, örneklemeyi yaparken praxis sayısal değerlerini sabitler ve bayrakları ana makineye geri verir. Karo adımı, karelerin cihazı ne olursa olsun tuvali CPU üzerinde hesaplar: CUDA kenar yumuşatmalı yeniden boyutlandırma, piksellerin yaklaşık üçte birinde bir seviye farklı yuvarlar ve bu durum, adım bunu yapmadan önce komutları en fazla 0.02 kaydırdı.
- Eğitim: yayınlanan ağırlıklarda, praxis deposundaki `PraxisPolicy.forward` ve `praxis.train.objective` aynı pencere ve rastgele çekimler için aynı kaybı (ve video ile eylem terimlerini) bit bit aynı şekilde verir ve eylem uzmanının tüm 200 tensöründe aynı gradyanları üretir. Raporlanan MoE denge metriği, her iki taraftaki çalışmalarda bir veya iki float32 ulp kadar değişir (denge istatistiğinde deterministik olmayan bir indirgeme; bu, kayba 1e-4 ağırlığıyla girer).
- GB300 (SM103, aarch64 ana bilgisayar): yığında LeRobot 0.7 kilitleri (torch 2.15.0+cu132, cuDNN 9.26, transformers 5.22.1, triton 3.9, flash-attn-4 4.0.0b36, flash-linear-attention 0.6.0) ile praxis deposunun `main` dalına karşı süreçler arası kontrol, her iki arka uçta da (`flash`, her iki tarafta 256 jetonlu maske bloklarıyla) bit düzeyinde eşittir: `praxis-1-droid` için politikanın yedi farklı çağrı yönteminde (`lerobot-eval`'ın bayrakları altındaki kaydedilmiş boru hatları, ham 720 x 1280 kareler, bir partide iki ortam, kare yığınlarıyla `predict_action_chunk`, `n_action_steps=12`, `cfg_scale=3` ve üç bağlam parçasıyla 94 komut), `praxis-1-yam` için boru hatları üzerinden, ham karelerle ve iki ortamla, ayrıca `praxis-1-base`'ten yeniden oluşturulan DROID kurulumu için. `forward`, yayınlanan ağırlıklarla praxis hedefinin kaybını ve tüm 200 eylem-uzmanı tensörünün gradyanlarını bit bit verir.
- RTX PRO 6000 Blackwell (SM120, 96 GB, x86_64 host), her iki tarafta `triton`: LeRobot 0.6 yığınında (torch 2.11.0+cu128, cuDNN 9.19, transformers 5.5.4, triton 3.6, flash-linear-attention 0.5.0) ve LeRobot 0.7'nin kilitlediği yığında (torch 2.15.0+cu132, cuDNN 9.26, transformers 5.22.1, triton 3.9, flash-linear-attention 0.6.0 ve causal-conv1d 1.6.1, böylece Qwen3.5 kendi çekirdeklerini çalıştırır), her ikisinde de `flash-attn-4` 4.0.0b36 yüklü; praxis deposunun `main` dalına karşı süreçler arası kontrol, GB300'deki gibi bit düzeyinde eşittir: yedide (463 komut, bağlam derinlikleri 0'dan 3'e) `praxis-1-droid`, üçte `praxis-1-yam` ve `praxis-1-base`'ten yeniden derlenen DROID kurulumu (altı baş tensörü ve yapılandırması, praxis deposundaki `init_heads` ile eşittir). `forward`, her iki yığında da praxis hedefinin kaybını ve tüm 200 eylem-uzmanı tensörünün gradyanlarını bit bit verir; her iki tarafta da omurga dondurulmuştur (54 GB'lık gradyanları, ağırlıkların yanına sığmaz). LeRobot 0.6 yığında praxis tarafı, yukarıdaki uyarıdaki Qwen3.5 düzeltmesine de ihtiyaç duyar: praxis-1, transformers 5.2.0'ı sabitler ve 5.5.4 altında metin kodlayıcısı rastgele kalır. LeRobot 0.6 yığında `droid_guard` üzerinde `praxis-1-droid` ile kapalı döngü: `lerobot-eval` 53/56 (%94,6), praxis çalıştırıcısı 54/56 (%96,4, H100 ve GB300'deki gibi); eşleştirilmiş karşılaştırmada -1,8 puan, %95 aralık [-8,9, +5,4], 2 kazanma / 3 kaybetme, McNemar p 1,00. `lerobot-train` üzerinden bir LoRA ince ayarı (r 16, alpha 32, varsayılan hedefler, adım başına bir pencere) tek GPU'da çalışır: 5,5M eğitilebilir parametre, adım başına 1,1 sn, 62 GB.
- B200 (SM100, x86_64 host): LeRobot 0.6 yığınında (torch 2.11.0+cu128, cuDNN 9.19, transformers 5.5.4, triton 3.6) ve LeRobot 0.7'nin kilitlediği yığında (torch 2.15.0+cu132, cuDNN 9.26, transformers 5.22.1, triton 3.9, flash-linear-attention 0.6.0), her ikisinde de `flash-attn-4` 4.0.0b36 kullanılarak, praxis deposunun `main` dalına karşı yapılan süreçler arası kontrol, GB300'deki durumlarla uyumlu olarak her iki backendde de (`flash`, her iki tarafta da 256 jetonluk maske bloklarıyla) bit düzeyinde eşittir: `praxis-1-droid` yedide (backend ve yığın başına 463 komut, bağlam derinlikleri 0'dan 3'e), `praxis-1-yam` üçte ve `praxis-1-base`'den yeniden derlenen DROID düzeneğinde (altı baş tensörü ve yapılandırması, praxis deposundaki `init_heads` ile eşittir). İki backend, komutlarda en fazla 0.19 fark gösterir. `forward`, her iki backendde ve her iki yığında da, eğitilmiş omurga ile praxis hedefinin kaybını, video ve eylem terimlerini ve tüm 200 eylem uzmanı tensörünün gradyanlarını bit bit verir. `lerobot-train` üzerinden yapılan bir LoRA ince ayarı, tek GPU'da çalışır (adım başına 1,2 sn, 62 GB) ve adaptör ile birleştirilmiş kontrol noktası `lerobot-eval`'da yüklenir.
- B200 üzerinde kapalı döngü (`droid_guard`, `praxis-1-droid`, `flash`): praxis çalıştırıcısı, torch 2.15 yığında 54/56, torch 2.11 yığında 55/56 puan alıyor; `lerobot-eval` ise 53/56 ve 51/56 (eşleştirilmiş: -1.8 puan, %95 aralık [-8.9, +5.4]; ve -7.1 puan, [-14.3, -1.8], 0 kazanma / 4 kayıp, McNemar p 0.125). Her test çerçevesi (harness) epizot epizot kendini tekrarladığından, fark çalıştırmalar arası gürültü değildir ve politika da değildir: `lerobot-eval`, durumu ve komutları DROID 7 değerleri olarak float32 ile taşır (`PraxisSimGymEnv`, duruş ve komut işleyici adımları), oysa praxis çalıştırıcısı oturumun duruşlarını ve komutlarını olduğu gibi iletir. Gidiş-dönüş bir duruşu yaklaşık 1e-7 kadar kaydırır ve bir epizot boyunca fark başka bir yörüngeye dönüşerek büyür. Durum ve komutları aynı float32 dönüşümünden geçiren praxis çalıştırıcısı, her iki yığında da 56 epizodun tamamında `lerobot-eval` sonucunu verir.
- praxis deposunun kendi ortamına (torch 2.13.0+cu130, transformers 5.2.0, causal-conv1d) karşı çıktılar bit düzeyinde eşit değildir: çekirdekler farklıdır, Qwen3.5 gömme değeri bfloat16'da en fazla 0.125 sapma gösterir ve eylemlerin son bitleri buna uyar. Bu nedenle depo-arası kontrol, yukarıdaki eşleşmiş kapalı döngü değerlendirmesidir.
- Simülasyon 4x çok örneklemeli (multisampling) olarak render edilir ve aynı sahnenin render'ları arasında kare başına birkaç piksel farklılık gösterir; bu nedenle aynı politikanın iki kapalı döngülü bölümü, ağırlıklar tamamen aynı olsa bile ilk chunk'tan sonra ayrışır. Eşleştirilmiş bölümler kare kare değil, istatistiksel olarak karşılaştırılır.

## İki elle kullanılan YAM kontrol noktası

`praxis-1-yam` (`"embodiment": "bimanual"`, `runwayml/praxis-1-yam-lerobot`) üst kamera ve iki bilek kamerası (16:10 ZED görüntüleri, 1920 x 1200) ile iki YAM kolunu sürer. Aynı model bunu çalıştırır; checkpoint, uzman baş genişliklerinde (kol başına 20 eylem değeri: `[xyz, rot6d, gripper]`), üç karoluk tuvalde ve normalizasyonda farklılık gösterir. LeRobot adaptörü, praxis deposundaki `praxis/bimanual.py` dosyasını (satışa sunulmuş hali `praxis_core/bimanual.py`) takip eder:

| Anahtar                                                                                              | Biçim | Anlam                                                                                                                                                                                                                                      |
| ------------------------------------------------------------------------------------------------ | ----- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `observation.images.top_left`, `observation.images.wrist_left`, `observation.images.wrist_right` | RGB   | Tuval sırasındaki üç görünüm (`camera_keys`). Herhangi bir 16:10 boyutu; işlemci, YAM sığdırma kuralıyla 256 x 416 karolarını oluşturur (görünümler birlikte 416 px'lik bir kutuya sığdırılır, ardından 32 px'lik bir kırpma uygulanır).                                                     |
| `observation.state`                                                                              | (14,) | Sol kolun, ardından sağ kolun `[x, y, z, roll, pitch, yaw, gripper]` değerleri, rig'in dünya çerçevesinde (`pose_frame: rig`, flanş dönüşü yok); gripper'lar rig'in bildirdiği gibi (kırpılmamış). 16 değer (kol başına pose8) de geçer. |
| `action`                                                                                         | (14,) | Aynı 14 değer: her kolun bir sonraki 15 Hz tikindeki mutlak hedefi. `select_action` 26 değer yayar (her kolun tel pozu ve kavrayıcısı); komut adımı bunları dönüştürür.                                                        |

Kontrol noktasının sunum ayarları (praxis deposunun `configs/serve_yam.yaml` dosyası: 2 Euler adımı, 1.0 akış kayması, metin yönlendirmesi yok, 1 bağlam parçası, iki elle kullanılan iskeletin kontrol modu yok) dönüştürücünün yapılandırmaya yazdığı değerlerdir, bu nedenle `--policy.path=runwayml/praxis-1-yam-lerobot` bu ayarları çalıştırır. İfadeler metin kodlayıcıya olduğu gibi iletilir; kontrol noktası, "Pick up the pen from the center of the table, then place the pen in the bag" gibi, sonu nokta ile bitmeyen açıklamalar üzerinde eğitilmiştir.

Parite: gerçek checkpoint üzerinde, LeRobot politikası ve praxis hattının `BimanualServeSession` bileşeni, aynı üç görünüm, poz ve talimat için (22 tik: soğuk başlangıç parçası ve derinlik-1 parçasının ilk komutu) kaydedilen hatlar üzerinden, bunlar olmadan ham karelerde ve bir partide farklı talimatlara sahip iki ortamda bit düzeyinde eşit komutlar üretir. Küçük model testi, bu kontrolü praxis `Session` karşılaştırmasıyla CPU üzerinde tekrarlar.

Sınırlamalar: YAM rig'inin simülasyonu olmadığından kapalı döngü bir test paketi yoktur; praxis deposunda henüz iki kollu bir eğitim tarifi bulunmadığı için `forward` (ince ayar) yalnızca tek kolludur.

## Eğitim

`lerobot-train`, praxis deposunun (`praxis/train`) hedefiyle politikayı ince ayar yapar: video ve eylemlerin ortak akış-eşleştirme kaybı, metin ve proprioseptif dropout, MoE dizge-dengeleme terimi ve her optimizör adımından sonraki yönlendirme-yanlılığı güncellemesi. Aynı pencere ve rastgele çekilişler verildiğinde, `PraxisPolicy.forward`, yayınlanan kontrol noktasında praxis eğitimcisinin hedefiyle bit-bite eşittir. Bir pencere, her iki kameranın 93 ardışık karesidir (21, 24, 24, 24'lük parçalar) ve her karenin gözlemlenen ile komut edilen flanş duruşunu ve talimatı içerir; politika bunu `observation_delta_indices` / `action_delta_indices` (93 kare) ile beyan eder ve pencereleri `drop_n_last_frames` (93, böylece örnekleyici tarifin pencere başlangıçlarını çeker) ile bölümlerin içinde tutar. Kamera karoları, praxis veri modülünde olduğu gibi, kontrol noktasının tuval kuralını (`video.antialias`) izler. `forward` ve kaybının geriye yayılımı (aktivite-kontrol noktası yeniden hesaplama dahil), başlatıcının neyi ayarladığından bağımsız olarak praxis sayısal değerleri altında çalışır, `lerobot-train --tf32` de dahil: otomatik döküm yoktur (MoE yönlendirici puanları float32 olarak kalır), float32 matris çarpımlarında TF32 yoktur. Görülen eğitim penceresi sayısı, politikanın bir tamponudur (`train_counter`): çekilişleri tohumlar, kontrol noktası ve adaptörle birlikte taşınır ve yeniden başlatılan bir çalıştırma diziyi devam ettirir; ayrılmış bir değerlendirme bunu ilerletmez.

### Veriler

Tarif, DROID üzerinde eğitim yapar. `lerobot/droid_1.0.1`, Kartezyen pozları altı artı bir sütun olarak tutar; [PR #11](https://huggingface.co/datasets/lerobot/droid_1.0.1/discussions/11)'in 7 boyutlu `observation.state.cartesian` ve `action.cartesian` sütunları bunları önceden birleştirir (birleştirilene kadar `--dataset.revision=refs/pr/11` kullanın). Veri setinin kendi `observation.state` ve `action` alanları eklem uzayındadır; yeniden adlandırma haritası, Kartezyen sütunları yerlerine koyar (yeniden adlandırılan bir anahtar, mevcut birini değiştirir) ve iki kamerayı da politikanın okuduğu anahtarların altına yerleştirir:

```bash
RENAME='{"observation.state.cartesian":"observation.state","action.cartesian":"action",
"observation.images.exterior_1_left":"observation.images.exterior","observation.images.wrist_left":"observation.images.wrist"}'
```

`lerobot-train`, haritayı ham batch'e ve işlemci hattı içinde bir kez daha uygular; bu nedenle anahtarları değiştirmemelidir (`observation.state` adını başka bir adla eşleştirmek geri alınır).

DROID bölümlerinin yaklaşık yarısında talimat yoktur ve bazıları bir pencereden daha kısadır; tarif bunları hariç tutar. `examples/praxis/select_droid_episodes.py`, `--dataset.episodes` için listeyi yazar:

```bash
python examples/praxis/select_droid_episodes.py --repo-id lerobot/droid_1.0.1 \
    --revision refs/pr/11 --out droid_episodes.json
```

Hub kopyası 180x320 videoları saklar; kontrol noktası 1280x720 DROID kayıtları üzerinde eğitilmiştir. Hub kopyasındaki karolar, daha az detaya sahip yükseltmelerdir ve bu durum bir duman testi için uygundur. Sadık bir ince ayar için, `praxis/train/README.md` dosyasında praxis deposunun açıkladığı gibi ham videoları içeren yerel bir kopya oluşturun ve `--dataset.root` parametresini bu kopyaya yönlendirin.

### Tam ince ayar

Ağırlıklar bfloat16 formatındadır; optimizör ön ayarı `praxis_adamw`, stokastik yuvarlama içeren AdamW'dir (sadece AdamW, 3e-6 güncellemelerini yuvarlayarak siler), zamanlayıcı ise doğrusal bir ısınma ve 3e-7'ye kadar kosinüs sönümlemesidir. Ayrıca her transformer bloğu, geriye yayılım sırasında ileri geçişini yeniden hesaplar (`activation_checkpointing`, varsayılan olarak açıktır). Ağırlıklar, gradyanlar ve optimizör anları parametre başına 8 bayt yer kaplar; 27.2B için bu 218 GB eder ve FSDP tarafından GPU'lara bölünür: tam bir ince ayar için en az 4 x 80 GB gerekir. praxis tarifi, 1.200 adım için adım başına 96 pencere kullanır; 8 GPU'da bu `--batch_size=1 --accelerator.gradient_accumulation.steps=12` demektir. `lerobot-train`, mikro toplamları sayar (bir döngü adımı, her GPU'da bir toplam demektir) ve zamanlayıcıyı mikro toplam başına ilerletir; bu nedenle 1.200 güncelleme `--steps=14400` olur, ısınma ve sönümleme de mikro adımlarla yapılır.

```bash
torchrun --nproc-per-node=8 $(which lerobot-train) \
    --dataset.repo_id=lerobot/droid_1.0.1 --dataset.revision=refs/pr/11 \
    --dataset.episodes="$(cat droid_episodes.json)" --rename_map="$RENAME" \
    --policy.path=runwayml/praxis-1-droid-lerobot --policy.device=cuda --policy.push_to_hub=false \
    --parallelism.dp_shard=8 --accelerator.fsdp.mixed_precision_policy.reduce_dtype=float32 \
    --batch_size=1 --accelerator.gradient_accumulation.steps=12 --steps=14400 \
    --policy.scheduler_warmup_steps=600 --policy.scheduler_decay_steps=14400 \
    --num_workers=8 --save_freq=100 --output_dir=outputs/train/praxis_droid
```

Tek bir kayıt, 54 GB'lık parçalı modeli (`pretrained_model/`, `PraxisPolicy.from_pretrained` ve `lerobot-eval` ile yüklenebilir) ve yaklaşık 108 GB'lık optimizör durumunu içerir. `PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True`, praxis eğitimcisinde olduğu gibi ayıracı parçalanmasını önler.

8 x H100 80 GB üzerinde `praxis-1-droid` ile, GPU başına bir pencere ve 256 DROID bölümü (Hub videoları) için `--dataset.episodes` değeriyle, 1.000 optimizasyon adımı ölçüldü: ilk adım (çekirdekleri derler) sonrasında adım başına 3,7 sn, rank başına 48,5 GB GPU belleği, rank başına 8 işçiyle veri yükleyicinin yetişmesi. Kayıp, ilk yüz adımda 0,216'dan son yüz adımda 0,190'a düşüyor (video 0,191'den 0,171'e, eylem 0,025'ten 0,019'a). Bir kontrol noktası, FSDP üzerinden parçalı modeli ve optimizör durumunu yaklaşık iki dakikada kaydediyor. İnce ayarlanmış kontrol noktası, taban modelin 54'üne karşı `droid_guard` üzerinde 56'da 50 puan alıyor: Hub videoları 180x320 ölçeklendirmeler olduğundan, bunlar üzerinde yapılan ince ayar, politikanın eğitim gördüğü 1280x720 kayıtlardan uzaklaşmasına neden oluyor.

### LoRA

PEFT üzerinden adaptörler (`pip install -e ".[peft]"`). Varsayılan hedefler, praxis `expert` grubu ve eylem uzmanının dikkat ile MLP projeksiyonlarıdır (`PraxisPolicy.PEFT_TARGETS`); omurga dikkat çıktı projeksiyonları ikinci gruptur ve `--peft.target_modules` ile geçirilir. MoE uzman ağırlıkları doğrusal katmanlar değildir ve adaptör almaz. Temel ağırlıklar dondurulduğunda bir LoRA çalışması daha az GPU üzerinde sığar:

```bash
torchrun --nproc-per-node=4 $(which lerobot-train) ... --parallelism.dp_shard=4 \
    --peft.r=16 --peft.lora_alpha=32 --output_dir=outputs/train/praxis_lora
```

`--peft.full_training_modules` parametresini ayarlanmamış bırakın: politikanın varsayılan `modules_to_save` değeri, adaptörün taşıması gereken eğitim sayacıdır (yapılandırma, bunu içermeyen bir adaptörü reddeder); kabul ettiği tek diğer modüller, temel kontrol noktasından ince ayar için (aşağıda) rig'ın üç baş modülüdür. MoE yönlendirme önyargıları temele aittir ve PEFT altında sabit kalır. 4 x H100 üzerinde r 16, alpha 32 ve varsayılan hedeflerle ölçüldü (`--parallelism.dp_shard=4`): 5,5M eğitilebilir parametre, GPU başına bir pencere ile adım başına 2,3 sn, rank başına 30 GB GPU belleği, 22 MB adaptör; `--parallelism.dp_replicate` ile `dp_shard` (HSDP) da çalışır. Donmuş omurga video terimini sahiplendiği için toplam kayıp 500 adım boyunca 0,22 civarında kalır; eylem terimi 0,026'dan 0,022'ye düşer. O çalışmanın adaptörü, `lerobot-eval` tarafından temel üzerine yüklendiğinde `droid_guard` üzerinde 56'da 52 puan alır.

Checkpoint, adaptörü (`adapter_config.json`, `adapter_model.safetensors`) içerir; `lerobot-eval`, bunu `--policy.path` üzerinden taban modelin üzerine yükler. Simülasyon, sunucu ve `from_pretrained` için düz bir checkpoint elde etmek için adaptörü ağırlıklara katlayın:

```bash
python examples/praxis/merge_praxis_adapter.py --base runwayml/praxis-1-droid-lerobot \
    --adapter outputs/train/praxis_lora/checkpoints/last/pretrained_model --out outputs/praxis-1-droid-lora
```

### praxis eğitimcisinden farklar

Amaç, pencere tarifi, optimizör ve zamanlama praxis'ininkilerdir. Veriler, praxis dosya okuyucusu yerine `LeRobotDataset`'ten gelir; rastgele çekimler LeRobot tohumu, çağrı sayısı, sıra ve parti konumundan tohumlanır (bu sayede kayıplar yeniden üretilebilir, ancak praxis çalışmasının adım adım aynısı değildir) ve denetim noktaları LeRobot denetim noktalarıdır. Taşınmayanlar: sabit çekimlerle aşırı öğrenme modu ve `no_sync`.

### Temel kontrol noktasını ince ayar yapın

`praxis-1-base` (`"embodiment": "base"`, `runwayml/praxis-1-base-lerobot`), ön eğitimin sonundaki video omurgası ve eylem uzmanı gövdesidir; bir rig'in altı baş tensörü (`action_encoder.w1`, `embed_proprio`, `head`, ağırlıklar ve önyargılar) ve optimizör durumu içermez. Bir politika olarak yüklenmez; tek kollu rig'iniz için ince ayarın başlangıcına dönüştürmek için iki betik kullanılır: praxis deposunun `compute_norm_stats.py` ve `init_heads.py` dosyalarının LeRobot biçimleri:

```bash
# the normalization statistics of your data: 1 % / 99 % quantiles of the relative actions and the
# mean and std of the proprio over random training windows (no video is read)
python examples/praxis/compute_norm_stats.py --repo-id lerobot/droid_1.0.1 --revision refs/pr/11 \
    --state-key observation.state.cartesian --action-key action.cartesian \
    --episodes droid_episodes.json --n-windows 2000 --out stats.json
# the base plus six new head tensors (`--seed`) and the rig fields: a policy directory that loads
python examples/praxis/init_heads.py --base runwayml/praxis-1-base-lerobot --out outputs/praxis-1-myrig \
    --stats stats.json --tile-height 224 --tile-width 416 --antialias --link
# then the full fine-tune command above with --policy.path=outputs/praxis-1-myrig, or LoRA with the
# six new head tensors trained in full next to the adapters:
torchrun --nproc-per-node=4 $(which lerobot-train) ... --policy.path=outputs/praxis-1-myrig \
    --parallelism.dp_shard=4 --peft.r=16 --peft.lora_alpha=32 \
    --peft.full_training_modules='["train_counter","action_expert.action_encoder.w1","action_expert.embed_proprio","action_expert.head"]'
```

State ve action sütunları, kare başına DROID duruşunu ve gripper `[x, y, z, roll, pitch, yaw, gripper]` değerlerini (veri setinin kendi sütunları veya yeniden adlandırma haritası) içerir. `--stats-from <single-arm checkpoint>` parametresi ise mevcut bir normalizasyon bloğunu (DROID rig) kopyalar. Taban ve yayınlanan checkpoint'in istatistiklerinden yeniden oluşturulan DROID rig, `praxis-1-droid` ile birebir aynı yapıya sahiptir ve head tensörleri, aynı seed için praxis deposundaki `init_heads.py` dosyasındaki tensörlerle bit bit aynıdır. Yukarıdaki çalıştırmaların DROID alt kümesinde, gripper 0 ve 1 olarak sabitlenmişken `compute_norm_stats.py`, checkpoint'in istatistiklerini xyz çeyrek değerlerinde 0,01 m hassasiyetle yeniden üretir. Praxis deposunun kendi taban ince ayarı (`configs/finetune_base.yaml`, 8 GPU'da bir gün) bu tabandan `droid_guard` üzerinde %62,5 başarıya ulaşırken, yaklaşık 40 kat daha fazla pencereyle eğitilen `praxis-1-droid` %91 başarıya ulaşmaktadır: taban, yeni bir rig için bir başlangıç noktasıdır, yayınlanan checkpoint'in yerini almaz. Tam ince ayar, tüm ağırlıkları `optimizer_lr` ile eğitir; LoRA altında adaptörler ve altı head tensörü eğitilir (`PraxisPolicy.PEFT_HEAD_MODULES`, `full_training_modules`'ün kabul ettiği sayacı dışındaki tek modüllerdir) ve gövdenin geri kalanı dondurulur; praxis tarifi başına ait head-only ısınma adımları ve head öğrenme oranı ölçeği taşınmamıştır.

## Bilinen sınırlar

- İki platform: tek kollu DROID kontrol noktası (`embodiment: single_arm`) ve çift kollu YAM platformu (`bimanual`). İnce ayar ve simülasyon tek kollu yapılandırma ile gerçekleştirilir.
- Praxis, empedans denetleyicili bir kol için Kartezyen duruş hedefleri üretir; LeRobot'un robot sınıfları bir Franka içermediğinden, gerçek robot kullanımı, Kartezyen hedefleri uygulayan bir istemci üzerinden gerçekleştirilir.
- Bir `select_action` partisi, ortamlarını sıralı olarak çalıştırır (ortam başına bir model çağrısı).
- Uzak sunum desteklenmez. Varsayılan parça çalıştırıcısı (`lerobot/inference/policy_runner.py`), geçmiş gözlemlere koşullanan bir politikayı reddeder ve Praxis, çalıştırılan parçaların karelerine koşullanır (`chunk_inference_spec` içinde `current_observation_only=False`); karolar adımı ayrıca kamera karelerini kontrol noktasının tuvaline yeniden boyutlandırır, bu nedenle `validate_chunk_input_features` tarafından kontrol edilen şekillerle eşleşmezler. Politikayı süreç içi çalıştırın (`lerobot-eval`, bir robot istemcisi).

