Phân mảnh thời gian thực (RTC)

Real-Time Chunking (RTC) cho phép các chính sách robot lớn dựa trên flow-matching, chẳng hạn như Pi0, Pi0.5 và SmolVLA, tạo ra chuyển động mượt mà, liên tục và phản hồi nhanh dù có độ trễ suy luận cao. LeRobot cung cấp chế độ hướng dẫn tại thời điểm suy luận ban đầu và, đối với các checkpoint Pi05 tương thích, điều kiện hóa hành động tại thời điểm huấn luyện với suy luận hard-prefix rẻ.

Các chính sách này tạo ra các khối hành động tương lai (ví dụ: 50 bước một lúc) thay vì các hành động đơn lẻ. Vì các mô hình có kích thước lớn, việc tạo ra mỗi khối mất nhiều thời gian hơn so với thời gian robot cần để thực thi nó. Việc thực thi các khối một cách ngây thơ dẫn đến các vấn đề như tạm dừng, chuyển động giật cục, hoặc thay đổi chiến lược đột ngột mỗi khi khối tiếp theo đến muộn hoặc không khớp với các hành động đã được thực thi trước đó.

RTC giải quyết vấn đề này bằng cách sinh bất đồng bộ chunk tiếp theo trong khi robot tiếp tục thực thi chunk hiện tại, đồng thời hướng dẫn chunk mới sao cho nó khớp mượt mà với phần của chunk trước đó đã được thực thi.

Cách RTC hoạt động (đơn giản hóa)

RTC cho phép robot suy nghĩ trước trong khi vẫn đang di chuyển. Khi robot đang thực hiện một khối hành động, RTC bắt đầu tạo khối tiếp theo sớm. Nhưng vì robot đã di chuyển một chút vào thời điểm khối mới sẵn sàng, RTC phải đảm bảo rằng khối mới vẫn khớp mượt mà với những gì robot đang thực hiện.

Để làm điều này, RTC coi phần đầu của khối mới như một bài toán inpainting hay “lấp đầy khoảng trống”: nó điều chỉnh nhẹ nhàng phần đầu tiên của khối mới để nó hòa hợp tự nhiên với chuyển động đang diễn ra của robot. Kết quả là không có sự gián đoạn, không có những bước nhảy đột ngột.

Về mặt kỹ thuật, RTC thêm một số hạng dẫn hướng vào quá trình khử nhiễu của flow-matching, buộc các bước thời gian chồng lấn của khối mới phải giữ gần với phần đã thực thi của khối trước đó, thường sử dụng một mặt nạ chuyển tiếp mềm.

Bắt đầu nhanh

Cài đặt

RTC được tích hợp sẵn trong LeRobot. Chỉ cần cài đặt các phụ thuộc của policy mà bạn cần:

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

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

Sử dụng RTC với Pi0

Bạn có thể sử dụng lerobot-rollout --strategy.type=base --inference.type=rtc để triển khai RTC trên các robot thực. Đoạn mã dưới đây cung cấp một ví dụ giả lập đơn giản hóa về cách RTC hoạt động với Pi0 trong pipeline của bạn:

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)

Các tham số chính

RTCConfig có các tham số sau để tinh chỉnh:

mode chọn phương pháp điều kiện theo tiền tố hành động:

• guided (mặc định) áp dụng hướng dẫn Jacobian gốc trong quá trình khử nhiễu và hoạt động với các checkpoint flow-matching thông thường.
• trained hard-inpaints phần prefix của chunk trước với các bước thời gian flow cho từng hành động. Hiện tại, nó yêu cầu một checkpoint Pi05 được huấn luyện với policy.rtc_training_max_delay > 0 và tránh bước truyền ngược guidance.

Local rollout và policy server áp dụng cùng một quy tắc chấp nhận chế độ huấn luyện bảo thủ: rtc_training_max_delay <= execution_horizon <= prediction_steps - rtc_training_max_delay. Đối với Pi05, prediction_steps là chunk_size của checkpoint. Điều này giữ nguyên giới hạn cục bộ hiện có: tiền tố được cấu hình bao phủ độ trễ huấn luyện tối đa và để lại ít nhất bấy nhiêu bước dự đoán nằm ngoài nó. Local rollout ngoài ra còn yêu cầu inference.queue_threshold >= rtc_training_max_delay trước khi kết nối robot; thời điểm của yêu cầu từ xa sử dụng các cài đặt refill riêng của nó.

Ở đây execution_horizon là dung lượng prefix được cung cấp, không phải lượng phát lại giữa các yêu cầu. Pi05 chỉ hard-condition prefix inference_delay. Quy tắc chấp nhận không phải là cam kết về độ trễ hay khẳng định rằng các dung lượng lớn hơn nhất thiết phải thất bại khi chạy; mức độ chồng chéo đo được, các hành động còn lại và các kiểm tra độ mới vẫn quyết định xem một chunk được trả về có thể thực thi hay không. Các chunk thông thường và RTC có hướng dẫn không bị ảnh hưởng bởi quy tắc chỉ áp dụng cho mô hình đã huấn luyện này.

execution_horizon: Số bước thời gian từ khối trước đó cần duy trì để đảm bảo tính nhất quán. Giá trị cao hơn cho phép chuyển tiếp mượt mà hơn nhưng có thể làm giảm độ phản hồi.

Giá trị điển hình: 8-12 bước

RTCConfig(execution_horizon=10)

max_guidance_weight: Mức độ mạnh mẽ khi thực thi tính nhất quán với khối dữ liệu trước đó. Đây là một siêu tham số có thể được điều chỉnh để cân bằng giữa độ mượt mà của các chuyển tiếp và khả năng phản ứng của chính sách. Đối với 10 bước flow matching (SmolVLA, Pi0, Pi0.5), giá trị 10.0 là giá trị tối ưu.

prefix_attention_schedule: Cách gán trọng số cho tính nhất quán trong vùng chồng lấn.

• LINEAR: Suy giảm tuyến tính từ inference_delay đến execution_horizon
• EXP: Suy giảm mũ (khuyến nghị để bắt đầu)
• ONES: Trọng số đầy đủ trên toàn bộ execution_horizon
• ZEROS: Nhị phân (toàn bộ trọng số cho đến inference_delay, sau đó là số không)

inference_delay: Số bước thời gian của độ trễ suy luận mà hệ thống của bạn có. Tham số này được truyền vào predict_action_chunk() thay vì cấu hình, vì nó có thể thay đổi trong thời gian chạy.

Kiểm tra RTC ngoại tuyến

Trước khi chạy trên robot thực, hãy kiểm tra RTC với các mẫu dữ liệu để trực quan hóa cách nó hoạt động:

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

Thêm --rtc.mode=trained khi đánh giá một checkpoint RTC Pi05 tương thích được huấn luyện trong quá trình training. Các policy không hỗ trợ sẽ từ chối chế độ trained thay vì quay lại RTC có hướng dẫn.

Script tạo ra một hình ảnh trực quan hóa quá trình khử nhiễu, so sánh giữa chế độ sinh chuẩn (bên trái) và RTC (bên phải). Trong các biểu đồ RTC, bạn có thể thấy cách một vài bước đầu tiên (đường màu xanh dương/tím) được dẫn dắt để khớp với quỹ đạo thực tế màu đỏ (phần đuôi của chunk trước), đảm bảo sự chuyển tiếp mượt mà giữa các chunk.

Kiểm thử RTC với Robot thực

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

Đối với checkpoint RTC Pi05 tại thời điểm huấn luyện, hãy đổi chế độ thành trained. Checkpoint ghi lại độ trễ tối đa được hỗ trợ, và rollout sẽ kiểm tra độ trễ đo được so với giá trị này:

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

Mối quan hệ giữa RTC và suy luận từ xa

--inference.type=rtc là RTC cục bộ: suy luận chạy trong một luồng nền trong tiến trình rollout và không sử dụng transport. Việc chạy một policy server và một robot client như các tiến trình riêng biệt trên cùng một máy sẽ sử dụng backend từ xa thay thế.

Cả hai backend bất đồng bộ đều sử dụng cùng một hành vi chờ có giới hạn và tắt trên các robot được hỗ trợ. Xem ngân sách RTC cục bộ để biết các giá trị mặc định của timeout. Việc chờ không làm nới lỏng các kiểm tra tiền tố, độ trễ hoặc độ mới của RTC.

Cả RTC và suy luận từ xa đều cải thiện việc điều khiển robot thời gian thực, nhưng chúng giải quyết những vấn đề khác nhau.

Remote inference có thể sử dụng RTC khi checkpoint hỗ trợ chế độ RTC đã đàm phán. Các chunk thông thường cũng hỗ trợ việc căn chỉnh con trỏ và trộn tùy chọn; xem hướng dẫn remote inference để biết về các chế độ, tính tương thích và điều chỉnh.

Nâng cao: Theo dõi gỡ lỗi

RTC bao gồm theo dõi gỡ lỗi tích hợp sẵn để giúp bạn hiểu những gì đang xảy ra trong quá trình suy luận:

# 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

Xem examples/rtc/eval_dataset.py để có một ví dụ hoàn chỉnh về trực quan hóa RTC ngoại tuyến.

Tham khảo

• Chính sách robot mượt như bơ - Giải thích kỹ thuật xuất sắc với kết quả trên robot thực
• Physical Intelligence - Chồng ghép thời gian thực - Bài báo gốc và nghiên cứu
• Triển khai Kinetix RTC - Bản triển khai tham chiếu từ Physical Intelligence
• Điều kiện hóa hành động tại thời điểm huấn luyện - RTC hiệu quả với điều kiện hóa tiền tố sạch trong quá trình huấn luyện
• RLDX-1 - Tham chiếu PyTorch được sử dụng cho tích hợp RTC trong quá trình huấn luyện