# ROBOMETER

ROBOMETER, **genel amaçlı video-dil robotik ödül modelidir**. Bir yörünge videosu ve görev açıklamasından yoğun, kare düzeyinde görev ilerlemesini ve kare düzeyinde başarıyı tahmin eder.

**Makale**: [ROBOMETER: Scaling General-Purpose Robotic Reward Models via Trajectory Comparisons](https://arxiv.org/abs/2603.02115) **Proje**: [robometer.github.io](https://robometer.github.io/) **Orijinal kod**: [github.com/robometer/robometer](https://github.com/robometer/robometer) **Kontrol noktası**: [lerobot/Robometer-4B](https://huggingface.co/lerobot/Robometer-4B)

## Genel Bakış

ROBOMETER, `Qwen/Qwen3-VL-4B-Instruct` üzerine inşa edilmiştir ve üç hafif tahmin kafası ekler:

- **İlerleme başlığı**: `[0, 1]` aralığında kare başına görev ilerlemesini tahmin eder.
- **Başarı başlığı**: Kare başına görev başarı olasılığını tahmin eder.
- **Tercih başlığı**: eğitim sırasında, iki yörüngeden hangisinin görevi daha iyi tamamladığını tahmin eder.

Makale, ROBOMETER'ı bileşik bir amaçla eğitir:

```text
L = L_pref + L_prog + L_succ
```

LeRobot entegrasyonu şu anda yalnızca **çalıştırma (inference)** modundadır. Yayımlanan `Robometer-4B` kontrol noktasının yeniden eşleme yapılmadan yüklenmesini sağlamak için tercih başlığını (preference head) korur; ancak `compute_reward()` yalnızca ilerleme veya başarı başlığına (progress or success head) sorgu gönderir.

## LeRobot Entegrasyonunun Kapsamı

- LeRobot üzerinden standart `reward_model.type=robometer` yapılandırması.
- Qwen3-VL görüntü ve metin ön işleme `RobometerEncoderProcessorStep` üzerinden.
- `PreTrainedRewardModel` üzerinden LeRobot ödül modeli kaydetme/yükleme API'leri.
- İçsel olarak yoğun, kare düzeyinde ilerleme ve başarı tahminleri.
- Aşağıdaki LeRobot ödül modeli kullanımında `compute_reward()` üzerinden bir skaler ödül.

Bu sayfa, yayımlanmış ROBOMETER kontrol noktasının sıfır atışlı ödül modeli olarak kullanılmasına odaklanır. ROBOMETER'ı sıfırdan eğitmek, mevcut LeRobot entegrasyonunun kapsamı dışındadır.

## Kurulum Gereksinimleri

1. LeRobot'u [Yükleme Kılavuzu](./installation)'nu izleyerek yükleyin.
2. ROBOMETER bağımlılıklarını yükleyin:

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

`uv` aracını doğrudan kaynak kodundan kullanıyorsanız:

```bash
uv sync --extra robometer
```

ROBOMETER, Qwen3-VL-4B omurgasını kullandığından GPU çıkarımı (inference) şiddetle önerilir.

## Model Girdileri ve Çıktıları

ROBOMETER şunları bekler:

- Bir yörünge videosu veya kare dizisi.
- Doğal dilde bir görev açıklaması.

LeRobot veri setlerinde ön işleyici şunları okur:

| Yapılandırma alanı              | Varsayılan                  | Anlam                                               |
| ------------------------- | ------------------------ | ----------------------------------------------------- |
| `reward_model.image_key`  | `observation.images.top` | ROBOMETER tarafından kullanılan kamera/video gözlemi            |
| `reward_model.task_key`   | `task`                   | Görev dizgesini depolayan tamamlayıcı verileri girin |
| `reward_model.max_frames` | `8`                      | ROBOMETER'a iletilen maksimum kare sayısı          |

Model, kare bazında ilerlemeyi ve başarıyı içsel olarak tahmin eder. LeRobot ödül API'si örnek başına bir skaler döndürür:

- `reward_output="progress"` (varsayılan): son kare ilerlemesini, `[0, 1]` aralığına sınırlanmış olarak döndürür.
- `reward_output="success"`: son kare başarı olasılığı `success_threshold` değerinin üzerindeyse `1.0`, aksi takdirde `0.0` döndürür.

## Kullanım

### Ödül Modelini Doğrudan Yükle

```python
from lerobot.rewards.robometer import RobometerConfig, RobometerRewardModel

cfg = RobometerConfig(
    pretrained_path="lerobot/Robometer-4B",
    device="cuda",
    reward_output="progress",
)
reward_model = RobometerRewardModel.from_pretrained(cfg.pretrained_path, config=cfg)
```

### Kareleri Kodla ve Ödülü Hesapla

Doğrudan bir Python çağrısı için, kareleri `uint8` dizileri olarak ve şekli `(T, H, W, C)` olan bir görev dizgesi olarak sağlayın:

```python
from lerobot.rewards.robometer.modeling_robometer import ROBOMETER_FEATURE_PREFIX
from lerobot.rewards.robometer.processor_robometer import RobometerEncoderProcessorStep

# frames: np.ndarray, shape (T, H, W, C), dtype uint8
# task: str
encoder = RobometerEncoderProcessorStep(
    base_model_id=cfg.base_model_id,
    use_multi_image=cfg.use_multi_image,
    use_per_frame_progress_token=cfg.use_per_frame_progress_token,
    max_frames=cfg.max_frames,
)

encoded = encoder.encode_samples([(frames, task)])
batch = {f"{ROBOMETER_FEATURE_PREFIX}{key}": value for key, value in encoded.items()}

reward = reward_model.compute_reward(batch)
```

`reward`, `(batch_size,)` biçiminde bir tensördür.

### Ödül Fabrikasını kullanın

ROBOMETER'ı ödül fabrikası üzerinden de örnekleyebilirsiniz:

```python
from lerobot.rewards import make_reward_model, make_reward_model_config, make_reward_pre_post_processors

cfg = make_reward_model_config(
    "robometer",
    pretrained_path="lerobot/Robometer-4B",
    device="cuda",
    image_key="observation.images.top",
)
reward_model = make_reward_model(cfg)
preprocessor, postprocessor = make_reward_pre_post_processors(cfg)
```

Önişleyici, Qwen-VL tensörlerini `observation.robometer.*` ad alanı altında yazar ve `compute_reward()` bu kodlanmış tensörleri okur.

## Yapılandırma Notları

### Backbone ve Sözlük

Yayınlanan checkpoint, Qwen3-VL-4B omurgasını kullanır. ROBOMETER, tokenizer'a beş özel tokenı sabit bir sırayla ekler:

```text
<|split_token|>
<|reward_token|>
<|pref_token|>
<|sim_token|>
<|prog_token|>
```

`<|prog_token|>`, her kareden sonra eklenir ve kare bazlı ilerleme ve başarı tahmini için kullanılan gizli durum konumudur. `<|split_token|>` ve `<|pref_token|>`, makalenin çiftli yörünge tercih hedefi tarafından kullanılır. `<|reward_token|>` ve `<|sim_token|>`, kontrol noktası uyumluluğu için korunur.

LeRobot yapılandırması, modelin önce temel Qwen ağırlıklarını indirmeden `config.json` dosyasından yeniden yükleyebilmesi için yeniden boyutlandırılmış sözlükle birlikte serileştirilmiş bir `vlm_config` saklar. `Qwen/Qwen3-VL-4B-Instruct` için tokenizör uzunluğu `151669`'dur ve beş ROBOMETER token'ı, kontrol noktası sözlük boyutunu `151674` olarak üretir.

### İlerleme Tahmini

Yayınlanan checkpoint'te ilerleme ayrık (discrete) olarak temsil edilir. İlerleme başlığı, `[0, 1]` aralığında eşit aralıklı `progress_discrete_bins=10` kutu merkezine karşılık gelen logitleri üretir. LeRobot, bu logitlere softmax uygulayarak kutu merkezleri üzerinden beklenti alarak bunları sürekli bir değere dönüştürür; bu, upstream ROBOMETER uygulamasıyla uyumludur.

### Başarı Tahmini

Success başlığı, kare başına ham logitler üretir. LeRobot bunları `sigmoid` ile olasılıklara dönüştürür. `reward_output="success"` olduğunda, `compute_reward()` son karedeki success olasılığını `success_threshold` ile eşikler.

## Kısıtlamalar

- Mevcut LeRobot entegrasyonu yalnızca çıkarım (inference) içindir; ROBOMETER eğitimi veya tercih çifti (preference-pair) eğitimi uygulamaz.
- `compute_reward()`, ROBOMETER içsel olarak kare bazında ilerleme ve başarı tahmini yapsa da, LeRobot ödül modeli API'si için örnek başına bir skaler döndürür.
- ROBOMETER video-dil tabanlıdır; temas kuvvetleri veya nesne pozları gibi ayrıcalıklı robot durumlarını kullanmaz.

## Referanslar

- [ROBOMETER projesi](https://robometer.github.io/)
- [ROBOMETER makalesi](https://arxiv.org/abs/2603.02115)
- [Özgün ROBOMETER kodu](https://github.com/robometer/robometer)
- [Yayınlanan ROBOMETER-4B kontrol noktası](https://huggingface.co/lerobot/Robometer-4B)
- [Qwen3-VL-4B-Instruct](https://huggingface.co/Qwen/Qwen3-VL-4B-Instruct)

## Atıf

```bibtex
@inproceedings{liang2026robometer,
title = {Robometer: Scaling General-Purpose Robotic Reward Models via Trajectory Comparisons},
author={Anthony Liang and Yigit Korkmaz and Jiahui Zhang and Minyoung Hwang and Abrar Anwar and Sidhant Kaushik and Aditya Shah and Alex S. Huang and Luke Zettlemoyer and Dieter Fox and Yu Xiang and Anqi Li and Andreea Bobu and Abhishek Gupta and Stephen Tu and Erdem Biyik and Jesse Zhang},
year={2026},
booktitle={Robotics: Science and Systems 2026},
}
```

## Lisans

Bu LeRobot entegrasyonu, LeRobot tarafından kullanılan **Apache 2.0 Lisansı**'nı takip eder. Orijinal uygulamanın ve yayınlanan checkpoint'lerin lisansları için ROBOMETER'in upstream kod ve model sayfalarını kontrol edin.