Gerçek Zamanlı Parçalama (RTC)

Gerçek Zamanlı Parçalama (RTC), Pi0, Pi0.5 ve SmolVLA gibi büyük, akış eşleştirmeye dayalı robotik politikaların yüksek çıkarım gecikmesine rağmen pürüzsüz, sürekli ve tepkisel hareket üretmesini sağlar. LeRobot, orijinal çıkarım zamanı yönlendirilmiş modu ve uyumlu Pi05 kontrol noktaları için ucuz sert-önek çıkarımıyla eğitim zamanı eylem koşullandırmasını sağlar.

Bu politikalar, tekil eylemler yerine gelecekteki eylemlerin parçalarını (örneğin, seferinde 50 adım) üretir. Modeller büyük olduğu için, her parçanın üretilmesi, robotun onu yürütmesi için gereken süreden daha uzun sürer. Parçaların körü körüne yürütülmesi, bir sonraki parça geç geldiğinde veya daha önce yürütülen eylemlerle çeliştiğinde duraksamalar, sarsıntılı geçişler veya stratejide ani değişiklikler gibi sorunlara yol açar.

RTC, robotun mevcut parçayı çalıştırmaya devam ederken bir sonraki parçayı asenkron olarak oluşturarak ve yeni parçayı, önceki parçanın zaten çalıştırılmış kısmıyla sorunsuz bir şekilde hizalanacak şekilde yönlendirerek bunu çözer.

RTC Nasıl Çalışır (basitleştirilmiş)

RTC, robotun hareket halindeyken de ileriye dönük düşünmesini sağlar. Robot bir eylem parçasını gerçekleştirirken, RTC bir sonraki parçanın oluşturulmasını erken başlatır. Ancak yeni parça hazır olduğunda robot zaten biraz hareket etmiş olduğundan, RTC'nin yeni parçanın robotun o an yaptığı eylemlerle sorunsuz bir şekilde hizalanmasını sağlaması gerekir.

Bunu yapmak için RTC, yeni parçanın başlangıcını bir inpainting veya “boşluk doldurma” problemi gibi ele alır: yeni parçanın ilk kısmını, robotun devam eden hareketiyle doğal bir şekilde bütünleşecek şekilde nazikçe ayarlar. Sonuç olarak duraksamalar ani sıçramalar olmaz.

Teknik olarak RTC, akış eşleştirme gürültü azaltma sürecine bir yönlendirme terimi ekler; bu terim, yeni parçanın üst üste binen zaman adımlarının, önceki parçanın çalıştırılan kısmına yakın kalmasını sağlar ve genellikle yumuşak bir geçiş maskesi kullanır.

Hızlı Başlangıç

Kurulum

RTC, LeRobot'a yerleşiktir. İhtiyacınız olan politika bağımlılıklarını kurmanız yeterlidir:

# For Pi0 or Pi0.5
pip install -e ".[pi]"

# For SmolVLA
pip install -e ".[smolvla]"

Pi0 ile RTC Kullanımı

Gerçek robotlarda RTC dağıtımı için lerobot-rollout --strategy.type=base --inference.type=rtc komutunu kullanabilirsiniz. Aşağıdaki kod parçası, RTC'nin hattınızda Pi0 ile nasıl çalıştığının basitleştirilmiş bir sözde örneğini sunar:

from lerobot.policies.pi0 import PI0Policy, PI0Config
from lerobot.configs import RTCAttentionSchedule
from lerobot.policies.rtc import RTCConfig, ActionQueue

# Load the Pi0 config so RTC can be enabled before the policy is built
policy_cfg = PI0Config.from_pretrained("lerobot/pi0_base")

# Enable RTC
policy_cfg.rtc_config = RTCConfig(
    enabled=True,
    execution_horizon=10,  # How many steps to blend with previous chunk
    max_guidance_weight=10.0,  # How strongly to enforce consistency
    prefix_attention_schedule=RTCAttentionSchedule.EXP,  # Exponential blend
)

# Load the policy
policy = PI0Policy.from_pretrained("lerobot/pi0_base", config=policy_cfg).to("cuda")

# Now use predict_action_chunk with RTC parameters
inference_delay = 4  # How many steps of inference latency, this value should be calculated based on the inference latency of the policy

# Initialize the action queue
action_queue = ActionQueue(policy_cfg.rtc_config)

# Start in a separate thread with the following function
def get_actions():
  while True:
    if should_get_actions:

      prev_actions = action_queue.get_left_over()
      obs = get_robot_observations(robot)

      # Generate actions WITH RTC
      actions = policy.predict_action_chunk(
          obs,
          inference_delay=inference_delay,
          prev_chunk_left_over=prev_actions,
      )

      action_queue.merge(
          actions, actions, inference_delay
      )

for step in range(num_steps):
    action = action_queue.get()

    # Execute the first N actions
    execute_actions(action)

Önemli Parametreler

RTCConfig ayarlanabilir şu parametrelere sahiptir:

mode, eylem öneki koşullandırma yöntemini seçer:

• guided (varsayılan), gürültü azaltma sırasında orijinal Jacobian yönlendirmesini uygular ve sıradan akış eşleştirme kontrol noktalarıyla çalışır.
• trained, önceki parçanın önekini eylem başına akış zaman adımlarıyla sert şekilde doldurur (hard-inpaint). Şu anda policy.rtc_training_max_delay > 0 ile eğitilmiş bir Pi05 kontrol noktası gerektirir ve rehberlik geriye yayılım adımından kaçınır.

Yerel rollout ve politika sunucusu, aynı muhafazakâr eğitim modu kabul kuralını uygular: rtc_training_max_delay <= execution_horizon <= prediction_steps - rtc_training_max_delay. Pi05 için prediction_steps, checkpoint’in chunk_size değeridir. Bu, mevcut yerel sınırı korur: yapılandırılmış önek, maksimum eğitim gecikmesini kapsar ve bunun dışında en az bu kadar tahmin adımı bırakır. Yerel rollout, robotun bağlanmasından önce ek olarak inference.queue_threshold >= rtc_training_max_delay koşulunu gerektirir; uzak istek zamanlaması kendi yeniden doldurma ayarlarını kullanır.

Burada execution_horizon, istekler arasındaki oynatma miktarı değil, sağlanan önek kapasitesidir. Pi05 yalnızca inference_delay öneğini sert koşullandırır. Kabul kuralı, bir gecikme garantisi veya daha büyük kapasitelerin çalışma zamanında başarısız olması gerektiğine dair bir iddia değildir; dönen bir parçanın çalıştırılıp çalıştırılamayacağını hâlâ ölçülen örtüşme, kalan eylemler ve güncellik kontrolleri belirler. Düz parçalar ve yönlendirilmiş RTC, bu yalnızca eğitilmiş kuraldan etkilenmez.

execution_horizon: Tutarlılığı korumak için önceki parçadan kaç zaman adımının dikkate alınacağı. Daha yüksek değerler daha akıcı geçişler anlamına gelir ancak potansiyel olarak daha düşük tepkime hızına yol açabilir.

Tipik değerler: 8-12 adım

RTCConfig(execution_horizon=10)

max_guidance_weight: Önceki parça ile tutarlılığın ne kadar güçlü bir şekilde uygulanacağı. Bu, geçişlerin pürüzsüzlüğü ile politikanın tepkisel davranışı arasındaki dengeyi ayarlamak için optimize edilebilen bir hiperparametredir. 10 adımlı akış eşleştirmesi (SmolVLA, Pi0, Pi0.5) için 10.0 değeri optimal bir değerdir.

prefix_attention_schedule: Çakışma bölgesindeki tutarlılığın nasıl ağırlıklandırılacağı.

• LINEAR: inference_delay'den execution_horizon'a doğru doğrusal azalma
• EXP: Üstel azalma (başlangıç için önerilir)
• ONES: Tüm execution_horizon boyunca tam ağırlık
• ZEROS: İkili (inference_delay'e kadar tam ağırlık, ardından sıfır)

inference_delay: Sisteminizin sahip olduğu çıkarım gecikmesi adım sayısı. Bu, çalışma zamanında değişebileceğinden yapılandırmaya değil, predict_action_chunk() fonksiyonuna iletilir.

RTC'nin Çevrimdışı Test Edilmesi

Gerçek bir robot üzerinde çalıştırmadan önce, RTC'yi veri seti örnekleriyle test edin ve nasıl çalıştığını görselleştirin:

python examples/rtc/eval_dataset.py \
    --policy.path=lerobot/pi0_libero_finetuned \
    --dataset.repo_id=HuggingFaceVLA/libero \
    --rtc.execution_horizon=10 \
    --rtc.max_guidance_weight=10.0 \
    --device=cuda

Uygun bir eğitim zamanı RTC Pi05 kontrol noktasını değerlendirirken --rtc.mode=trained ekleyin. Desteklenmeyen politikalar, yönlendirilmiş RTC'ye geri düşmek yerine eğitimli modu reddeder.

Betik, standart üretimi (sol) RTC ile (sağ) karşılaştırarak gürültü azaltma sürecinin bir görselleştirmesini oluşturur. RTC grafiklerinde, ilk birkaç adımın (mavi/mor çizgiler) parçalar arasında pürüzsüz bir geçiş sağlamak üzere kırmızı gerçek değer yörüngesine (önceki parçanın kuyruğu) uyması için nasıl yönlendirildiğini görebilirsiniz.

Gerçek Bir Robotla RTC Testi

lerobot-rollout \
    --strategy.type=base \
    --policy.path=${HF_USERNAME}/policy_repo_id \
    --inference.type=rtc \
    --inference.rtc.mode=guided \
    --inference.rtc.execution_horizon=10 \
    --inference.rtc.max_guidance_weight=10.0 \
    --robot.type=so100_follower \
    --robot.port=/dev/tty.usbmodem58FA0834591 \
    --robot.cameras="{ gripper: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30}, front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}}" \
    --task="Move green small object into the purple platform" \
    --duration=120 \
    --device=cuda

Eğitim zamanı RTC Pi05 kontrol noktası için modu trained olarak değiştirin. Kontrol noktası, desteklediği maksimum gecikmeyi kaydeder ve rollout, ölçülen gecikmeyi buna göre doğrular:

lerobot-rollout \
    --strategy.type=base \
    --policy.path=${HF_USERNAME}/pi05_training_rtc \
    --inference.type=rtc \
    --inference.rtc.mode=trained \
    --inference.rtc.execution_horizon=10 \
    --robot.type=so100_follower \
    --robot.port=/dev/tty.usbmodem58FA0834591 \
    --task="Move green small object into the purple platform" \
    --duration=120 \
    --device=cuda

RTC'nin uzak çıkarımla ilişkisi

--inference.type=rtc yerel RTC'dir: çıkarım, rollout sürecinde bir arka plan iş parçacığında çalışır ve hiçbir taşıma kullanmaz. Aynı makinede bir politika sunucusu ve bir robot istemcisini ayrı süreçler olarak çalıştırmak, bunun yerine uzak arka ucu kullanır.

Her iki asenkron arka uç da desteklenen robotlarda aynı sınırlandırılmış bekleme ve kapatma davranışını kullanır. Zaman aşımı varsayılanları için yerel RTC bütçeleri bölümüne bakın. Bekleme, RTC’nin önek, gecikme veya tazelik kontrollerini gevşetmez.

Hem RTC hem de uzaktan çıkarım gerçek zamanlı robot kontrolünü iyileştirir ancak farklı sorunları çözer.

Uzak çıkarım, checkpoint müzakere edilen RTC modunu destekliyorsa RTC kullanabilir. Düz parçalar da isteğe bağlı imleç hizalama ve karıştırmayı destekler; modlar, uyumluluk ve ayarlar için uzak çıkarım kılavuzuna bakın.

Gelişmiş: Hata Ayıklama İzleme

RTC, çıkarım sırasında neler olduğunu anlamanıza yardımcı olmak için yerleşik hata ayıklama izleme içerir:

# Enable debug tracking
policy_cfg.rtc_config.debug = True
policy_cfg.rtc_config.debug_maxlen = 100
policy.init_rtc_processor()  # re-create the RTC processor so the new debug settings take effect

# After inference, access debug data
debug_data = policy.rtc_processor.get_all_debug_steps()

# Visualize denoising steps, corrections, etc.
from lerobot.policies.rtc.debug_visualizer import RTCDebugVisualizer
visualizer = RTCDebugVisualizer()
# ... create plots

Çevrimdışı RTC görselleştirmesinin tam bir örneği için examples/rtc/eval_dataset.py dosyasına bakın.

Referanslar

• Yumuşak Robot Politikleri - Gerçek robot sonuçlarıyla mükemmel teknik açıklama
• Physical Intelligence - Gerçek Zamanlı Parçalama - Orijinal makale ve araştırma
• Kinetix RTC Uygulaması - Physical Intelligence'tan referans uygulama
• Eğitim Zamanı Eylem Koşullandırması - Eğitim sırasında temiz önek koşullandırması ile verimli RTC
• RLDX-1 - Eğitim zamanı RTC entegrasyonu için kullanılan PyTorch referansı