Jalankan Inferensi GR00T Tanpa GPU Lokal

Raspberry Pi cukup untuk menggerakkan melalui bus serial dan mengambil frame dari dua kamera USB. Ini tidak cukup untuk menjalankan model tiga miliar parameter : README NVIDIA menempatkan inferensi GR00T N1.7 pada satu GPU dengan VRAM 16 GB atau lebih. Untuk melihat apa yang dilakukan checkpoint GR00T N1.7 Anda yang telah disetel dengan baik pada lengan tanpa membeli kartu, tempatkan kebijakan pada GPU cloud sewaan, pertahankan loop robot pada mesin dengan port USB, dan kirim observasi serta potongan aksi melalui jaringan.

Ini berfungsi, tidak gratis, dan harganya tidak merata di semua tugas. Di bawah: server kebijakan NVIDIA sendiri, tumpukan asinkron lerobot, perhitungan yang menyatakan sebelumnya apakah uplink Anda cukup cepat, dan rute platform. Semua ini diperiksa terhadap cabang utama Isaac-GR00T (N1.7 GA) dan lerobot 0.6.1 pada 23 Agustus 2026.

Mengapa kebijakan tidak akan muat di mesin robot

Dua dari lima kebijakan AY-Robots yang dapat dilatih berjalan pada kartu workstation, tiga tidak. Kolom di bawah ini adalah per langkah tindakan, dan itulah angka yang bersaing dengan waktu pulang-pergi jaringan Anda.

Bacalah itu sebagai keputusan, bukan hal sepele. pada 20 ms per langkah berjalan di mesin robot dan Anda tidak akan memikirkannya lagi. pada 485 ms telah menghabiskan sepertiga detik sebelum paket meninggalkan gedung Anda. dan menambahkan sisi akurasi.

Dua tumpukan klien-server yang sudah ada

Isaac-GR00T mengirimkan server permintaan-balasan ZeroMQ; lerobot mengirimkan server gRPC yang dibangun di sekitar inferensi asinkron. Keduanya menerima GR00T checkpoint. Daftar kebijakan yang didukung lerobot di async_inference/constants.py adalah act, smolvla, diffusion, tdmpc, vqbet, pi0, pi05 dan groot; daftar robotnya adalah so100_follower, so101_follower, bi_so_follower dan omx_follower.

Baris serialisasi lebih penting dari yang terlihat. GR00T's MsgSerializer menolak payload ndarray object-dtype di kedua arah, karena msgpack_numpy akan menyerahkannya ke pickle. lerobot menggunakan pickle sebagai gantinya: policy_server.py memanggil pickle.loads pada data permintaan, robot_client.py mem-pickle observasi yang dikirimnya. Dapat dipertahankan di LAN yang tepercaya, tidak dapat dipertahankan setelah port dapat dijangkau dari internet.

Rute A: Server kebijakan GR00T milik NVIDIA

Ini adalah jalur yang didokumentasikan NVIDIA untuk perangkat keras SO-100 dan SO-101, dan yang harus digunakan jika checkpoint Anda berasal dari examples/finetune.sh dengan --embodiment-tag NEW_EMBODIMENT. Langkah-langkah ini menambahkan apa yang tidak disebutkan dalam README upstream: mendapatkan port ke robot tanpa mengeksposnya ke orang lain.

1. 1
   Instal GR00T di kotak GPU sewaan

   Submodul diperlukan, dan git-lfs harus ada sebelum kloning atau file parquet di demo_data tiba sebagai pointer. flash-attn dan TensorRT disertakan dengan instalasi default. Jebakan pada image pod yang baru: torchcodec 0.8.0 adalah satu-satunya backend video yang didukung dan hanya memuat FFmpeg 4 hingga 7. Ubuntu 25.10 dan 26.04 mengirimkan FFmpeg 8, sehingga GR00T gagal dengan Could not load libtorchcodec. Instal FFmpeg di bawah 8 dan letakkan pustakanya di LD_LIBRARY_PATH.

   bash

   sudo apt install git-lfs && git lfs install
   curl -LsSf https://astral.sh/uv/install.sh | sh
   sudo apt-get update && sudo apt-get install -y ffmpeg
   
   git clone --recurse-submodules https://github.com/NVIDIA/Isaac-GR00T
   cd Isaac-GR00T
   uv sync --python 3.12
   uv run python -c "import gr00t; print('GR00T installed successfully')"

2. 2
   Autentikasi terhadap backbone yang digerbang

   Setiap checkpoint GR00T N1.7, termasuk fine-tune Anda sendiri, memuat nvidia/Cosmos-Reason2-2B yang digerbang pada penggunaan pertama. Minta akses di halaman model dan masuk ke pod, atau pemuatan akan gagal dengan GatedRepoError.

   bash

   uv run huggingface-cli login
   # or:  export HF_TOKEN=<your_token>

3. 3
   Mulai server kebijakan

   Arahkan --model-path ke direktori checkpoint Anda; pada jalur tersebut server mengabaikan --modality-config-path, yang hanya dibaca pada jalur replay. Hilangkan --model-path dan berikan --dataset-path ditambah --execution-horizon sebagai gantinya untuk ReplayPolicy yang memutar ulang tindakan yang direkam, cara termurah untuk membuktikan bahwa pengkabelan berfungsi.

   bash

   uv run python gr00t/eval/run_gr00t_server.py \
     --model-path /workspace/so100_finetune/checkpoint-10000 \
     --embodiment-tag NEW_EMBODIMENT \
     --device cuda:0 \
     --host 127.0.0.1 --port 5555

4. 4
   Terowong port 5555 ke mesin robot

   Ikat ke loopback, seperti di atas, dan bawa port melalui SSH atau mesh bergaya WireGuard. Itu menyediakan enkripsi dan autentikasi yang tidak dimiliki soket ZeroMQ, selama sekitar satu milidetik.

   bash

   # on the robot machine
   ssh -N -L 5555:127.0.0.1:5555 root@<pod-host> -p <pod-ssh-port>
   
   # sanity check that something answers
   nc -vz 127.0.0.1 5555

5. 5
   Jalankan klien robot di sebelah servo

   Klien membutuhkan lingkungan uv-nya sendiri: ia menginginkan driver robot lerobot, bukan tumpukan pelatihan. eval_so100.py mengimpor so100_follower, so101_follower, dan koch_follower, jadi berikan --robot.type yang sesuai dengan lengan Anda (README upstream menggunakan so101_follower). Kunci kamera harus sesuai dengan pelatihan: adaptor membaca persis front dan wrist, dan menukarnya akan menunjukkan tampilan yang salah kepada kebijakan.

   bash

   cd gr00t/eval/real_robot/SO100
   uv sync
   uv pip install --no-deps -e ../../../../
   
   uv run --no-sync python eval_so100.py \
     --robot.type=so100_follower \
     --robot.port=/dev/ttyACM0 \
     --robot.id=orange_follower \
     --robot.cameras="{ front: {type: opencv, index_or_path: 6, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30}}" \
     --policy_host=127.0.0.1 \
     --policy_port=5555 \
     --lang_instruction="pick up the red block and put it in the bin"

Rute B: Inferensi Asinkron LeRobot

LeRobot memecahkan masalah yang berbeda. Alih-alih memblokir robot saat model berpikir, klien terus melangkah melalui antrean yang sudah dimilikinya sementara server menghitung bagian berikutnya. Ini adalah pemotongan aksi yang dikembangkan lebih lanjut, tumpukan asinkron yang diperkenalkan dengan SmolVLA. Ini juga berfungsi dengan checkpoint GR00T.

# GPU machine
pip install -e ".[async]"
python -m lerobot.async_inference.policy_server \
     --host=127.0.0.1 \
     --port=8080

# robot machine, after tunnelling 8080
python -m lerobot.async_inference.robot_client \
    --server_address=127.0.0.1:8080 \
    --robot.type=so100_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=follower_so100 \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30}}" \
    --task="pick up the red block and put it in the bin" \
    --policy_type=groot \
    --pretrained_name_or_path=<user>/my_groot_finetune \
    --policy_device=cuda \
    --actions_per_chunk=50 \
    --chunk_size_threshold=0.5 \
    --debug_visualize_queue_size=True

Server dimulai dalam keadaan kosong: ia tidak tahu kebijakan mana yang dilayaninya sampai jabat tangan pertama klien memberitahukannya, yang nyaman pada pod sewaan. Dua pengaturan yang menentukan apakah lengan bergerak dengan mulus adalah actions_per_chunk dan chunk_size_threshold (dokumen lerobot menyebut yang kedua g, mengikuti makalah SmolVLA), dan nilai-nilai yang didokumentasikan serta nilai-nilai yang dikirimkan tidak sesuai.

Aritmetika yang menentukan apakah tautan Anda cukup cepat

Orang-orang melewatkan ini dan kemudian menghabiskan sehari untuk . Ini memakan waktu dua menit dan hampir selalu menentukan.

Dict observasi yang dikomentari di NVIDIA's eval_so100.py mengatakan apa yang dikirim melalui jaringan: dua array dengan bentuk (480, 640, 3) dalam uint8, enam float sendi, sebuah string bahasa. Itu adalah 921.600 byte per bingkai, 1.843.200 byte untuk dua kamera, sekitar 14,7 Mbit, dan tidak ada tumpukan yang mengompresnya dengan JPEG. Potongan data yang kembali adalah beberapa lusin langkah dari 6 float. Unggahan Anda yang menentukan segalanya, bukan unduhan Anda.

Anggaran yang harus Anda penuhi

Klien GR00T SO-100 bersifat sinkron: ia memanggil policy.get_action(obs), mengeksekusi action_horizon langkah dari chunk pada 30 FPS, lalu memanggil lagi. Ukuran chunk dan horizon adalah angka yang berbeda: panduan deployment NVIDIA merekomendasikan ukuran chunk aksi 16, setidaknya 32 jika digabungkan dengan chunking real-time, sementara eval_so100.py mengirimkan horizon eksekusi 8. Delapan langkah pada 30 FPS adalah 267 ms gerakan per panggilan, dan semua hal lain harus muat di dalamnya.

observation upload   14.7 Mbit / 100 Mbit/s   = 147 ms
network round trip                            =  30 ms
model inference (AY-Robots figure, N1.7)      = 152 ms
action chunk return + deserialize             =  ~2 ms
                                                -------
total per call                                  331 ms

budget at action_horizon = 8   ->  267 ms   FAIL, arm pauses ~64 ms per chunk
budget at action_horizon = 16  ->  533 ms   fits, with headroom
budget at action_horizon = 32  -> 1067 ms   fits, observations now ~1 s stale

Meningkatkan horizon adalah solusi kasar dan bukan tanpa biaya: lengan bertindak berdasarkan observasi yang sudah usang. Solusi berprinsip adalah chunking real-time (RTC), yang menghitung chunk berikutnya saat chunk saat ini berjalan, membekukan tindakan yang dijamin akan dieksekusi dan mengisi sisanya; makalah RTC melaporkannya sebagai tangguh terhadap penundaan inferensi tanpa pelatihan ulang. Periksa statusnya terlebih dahulu. NVIDIA menandai RTC sebagai eksperimental, sebuah primitif model tingkat rendah yang dapat diakses melalui action_head.get_action(..., options={"rtc_overlap_steps": ..., "rtc_frozen_steps": ...}), tidak terhubung ke Gr00tPolicy atau jalur server-klien, di mana options tidak digunakan, tanpa pengujian dan tanpa contoh. Melalui server kebijakan, Anda mendapatkan eksekusi asinkron, bukan RTC.

Ukur sebelum Anda percaya

Setiap angka di atas adalah prediksi. Empat perintah mengubahnya menjadi pengukuran, yang patut dijalankan sebelum mengalokasikan pod-hour untuk tugas yang tidak akan pernah berhasil.

1. 1
   Dapatkan waktu pulang-pergi mentah

   Terhadap pod, bukan CDN. Perhatikan deviasi sedekat mungkin dengan rata-rata: jitter menyebabkan lengan tersendat, bukan latensi rata-rata.

   bash

   ping -c 50 <pod-host>
   # the mdev column is the number that predicts stutter

2. 2
   Ukur uplink yang Anda miliki, bukan yang Anda bayar

   Unggahan residensial biasanya sebagian kecil dari unduhan, dan itu adalah angka dalam tabel bandwidth di atas.

   bash

   # on the pod
   iperf3 -s
   
   # on the robot machine, -R omitted so this measures upload
   iperf3 -c <pod-host> -t 30

3. 3
   Baca log latensi klien sendiri

   Klien robot lerobot mencatat latensi server-ke-klien dan waktu deserialisasi untuk setiap chunk. Pada rute B Anda tidak memerlukan alat eksternal.

   text

   Received action chunk for step #240 | Latest action: #232 |
     Incoming actions: 240:289 |
     Network latency (server->client): 187.44ms |
     Deserialization time: 3.10ms

4. 4
   Perhatikan antrean aksi mengering

   Lewati --debug_visualize_queue_size=True dan klien akan memplot ukuran antrean saat runtime. Jika berulang kali mencapai nol, Anda kehabisan anggaran: turunkan fps, naikkan actions_per_chunk, atau naikkan chunk_size_threshold agar observasi lebih sering keluar.

   bash

   python -m lerobot.async_inference.robot_client \
       ... \
       --debug_visualize_queue_size=True

Untuk apa sebenarnya inferensi jarak jauh itu berguna

Jika eksekusi jarak jauh tersendat pada titik yang sama di setiap episode, jaringan mungkin bukan penyebabnya. Kebijakan yang ragu-ragu pada sudut sendi yang sama setiap kali biasanya merupakan masalah data; lihat halaman mode kegagalan, khususnya kebijakan yang hanya berfungsi dalam satu pengaturan dan loss turun tetapi kebijakan tidak melakukan apa-apa.

Melakukannya sendiri vs melakukannya di AY-Robots

Berapa biaya sesi inferensi jarak jauh

Dua angka penting: tarif per jam kartu, dan berapa lama Anda membiarkannya berjalan. Yang pertama dipublikasikan; yang kedua mengejutkan orang.

Tarif tersebut dibaca dari halaman harga Runpod pada 23 Agustus 2026, dan pasar spot bergerak. AY-Robots mengutip seluruh jalankan sebagai gantinya: 3 hingga 6 jam dengan 1.20 hingga 2.00 USD per jam pada tingkat A100 atau H100, sekitar 4 hingga 12 USD untuk jalankan GR00T atau Pi0.5; 2 hingga 5 jam dengan 0.30 hingga 0.60 USD per jam pada tingkat 24 GB, 1 hingga 3 USD untuk SmolVLA atau ACT. Sesi inferensi mengalahkan jalankan pelatihan dalam biaya hanya jika Anda menghentikannya, itulah fungsi idle watchdog. Lihat dokumen penagihan dan halaman harga.

Jika Anda lebih suka tidak melibatkan jaringan dalam loop

Inferensi jarak jauh memecahkan masalah perangkat keras dan menciptakan masalah latensi. Terkadang jawaban yang lebih baik adalah kebijakan yang sesuai dengan perangkat keras yang Anda miliki.

• ACT, sekitar 80 juta parameter dan 20 ms per langkah aksi, 50 episode minimum, kartu 24 GB apa pun. Dalam pengaturan tugas tunggal yang berulang, ini sering mengalahkan model 3 B jarak jauh, karena tidak pernah menunggu paket.
• SmolVLA, sekitar 450 juta parameter dan 245 ms per langkah aksi, 30 episode minimum. Ini mempertahankan pengkondisian bahasa yang tidak dimiliki ACT, dan dokumen lerobot menempatkannya sekitar 2 GB pada waktu inferensi dibandingkan sekitar 14 GB untuk PI0.
• ACT vs GR00T N1.7 untuk separuh akurasi dari pertukaran.

Ada juga jalan tengah: latih di cloud, evaluasi secara lokal. Penyetelan halus membutuhkan kartu 80 GB dan tidak peduli dengan latensi, jadi melatih GR00T N1.7 pada SO-100 secara jarak jauh tidak kontroversial. Hanya loop evaluasi yang memiliki batasan waktu nyata; dokumen pelatihan dan matriks model dan lengan mencakup separuh itu.

Pertanyaan yang sering diajukan

Versi singkat

Inferensi jarak jauh untuk 3 B policy adalah masalah rekayasa yang terpecahkan dengan masalah fisika yang belum terpecahkan. Rekayasa tersebut adalah dua perintah dan terowongan SSH. Fisikanya adalah bahwa observasi 1.8 MB harus mencapai GPU di negara lain dan kembali sebelum lengan kehabisan tindakan. Lakukan perhitungan sebelum menyewa apa pun, pilih tugas yang mentolerir observasi yang usang, dan tingkatkan horizon eksekusi daripada berharap tautan membaik.

Jika Anda belum merekam dataset, rekam dataset pertama Anda dan panduan pengaturan SO-100 didahulukan, dan entri format dataset LeRobot menjelaskan apa yang direkam oleh perekam. Latar belakangnya ada di model aksi bahasa-visi dan karya kebijakan pencocokan aliran; entri arena menautkan setiap angka benchmark ke sumber.