Spusťte GR00T inferenci bez lokální GPU

Raspberry Pi stačí k řízení přes sériovou sběrnici a stahování snímků ze dvou USB kamer. Nestačí však k provozu tří miliardového parametrového : README společnosti NVIDIA uvádí inferenci GR00T N1.7 na jedné GPU s 16 GB nebo více VRAM. Chcete-li vidět, co váš jemně vyladěný checkpoint dělá na rameni bez nákupu karty, umístěte politiku na pronajatou cloudovou GPU, udržujte robotickou smyčku na stroji s USB porty a posílejte pozorování a akční bloky přes síť.

Funguje to, není to zdarma a cena není rovnoměrně rozložena mezi úkoly. Níže: vlastní server politik NVIDIA, asynchronní zásobník lerobot, aritmetika, která předem určí, zda je váš uplink dostatečně rychlý, a platformní cesta. Vše ověřeno proti hlavní větvi Isaac-GR00T (N1.7 GA) a lerobot 0.6.1 k 23. srpnu 2026.

Proč se politika nevejde na stroj robota

Dvě z pěti politik, které AY-Robots dokáže trénovat, běží na kartě pracovní stanice, tři nikoli. Sloupec níže je na jeden akční krok, a to je číslo, které konkuruje vaší síťové odezvě.

Čtěte to jako rozhodnutí, ne jako zajímavost. s 20 ms na krok běží na robotickém stroji a už na to nikdy nemusíte myslet. s 485 ms strávila třetinu sekundy, než paket opustí vaši budovu. Porovnání a přidávají stranu přesnosti.

Dva již existující klient-server zásobníky

Isaac-GR00T dodává ZeroMQ request-reply server; lerobot dodává gRPC server postavený na asynchronní inferenci. Oba přijímají GR00T kontrolní bod. Seznam podporovaných politik lerobot v async_inference/constants.py je act, smolvla, diffusion, tdmpc, vqbet, pi0, pi05 a groot; jeho seznam robotů je so100_follower, so101_follower, bi_so_follower a omx_follower.

Řádek serializace je důležitější, než se zdá. GR00T's MsgSerializer odmítá payloady ndarray typu object-dtype v obou směrech, protože msgpack_numpy by je jinak předal pickle. lerobot místo toho používá pickle: policy_server.py volá pickle.loads na data požadavku, robot_client.py serializuje pozorování, které odesílá. Obhajitelné v důvěryhodné LAN, neobhajitelné, jakmile je port dosažitelný z internetu.

Trasa A: Vlastní GR00T policy server od NVIDIA

Toto je cesta, kterou NVIDIA dokumentuje pro hardware SO-100 a SO-101, a ta, kterou použijete, pokud váš checkpoint vzešel z examples/finetune.sh s --embodiment-tag NEW_EMBODIMENT. Tyto kroky doplňují to, co původní README vynechává: jak dostat port k robotovi, aniž by byl vystaven všem ostatním.

1. 1
   Nainstalujte GR00T na pronajatý GPU box

   Submoduly jsou vyžadovány a git-lfs musí existovat před klonováním, jinak soubory parquet v demo_data dorazí jako ukazatele. flash-attn a TensorRT jsou součástí výchozí instalace. Úskalí na čerstvém obrazu podu: torchcodec 0.8.0 je jediný podporovaný video backend a načítá pouze FFmpeg 4 až 7. Ubuntu 25.10 a 26.04 dodávají FFmpeg 8, takže GR00T selže s Could not load libtorchcodec. Nainstalujte FFmpeg nižší než 8 a umístěte jeho knihovny do 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
   Ověření proti gated backbone

   Každý checkpoint GR00T N1.7, včetně vašeho vlastního fine-tune, načítá při prvním použití gated nvidia/Cosmos-Reason2-2B. Požádejte o přístup na stránce modelu a přihlaste se na podu, jinak načítání selže s GatedRepoError.

   bash

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

3. 3
   Spusťte policy server

   Nasměrujte --model-path na váš adresář checkpointu; na této cestě server ignoruje --modality-config-path, který se čte pouze na cestě pro přehrávání. Vyřaďte --model-path a místo toho předejte --dataset-path plus --execution-horizon pro ReplayPolicy, která přehrává zaznamenané akce, což je nejlevnější způsob, jak ověřit funkčnost zapojení.

   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
   Tunelujte port 5555 k robotickému stroji

   Vytvořte vazbu na loopback, jak je uvedeno výše, a přeneste port přes SSH nebo síť ve stylu WireGuard. To zajišťuje šifrování a autentizaci, které ZeroMQ socket neposkytuje, a to za přibližně milisekundu.

   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
   Spusťte klienta robota vedle serv

   Klient potřebuje své vlastní uv prostředí: chce ovladače robotů lerobot, nikoli tréninkový stack. eval_so100.py importuje so100_follower, so101_follower a koch_follower, takže předejte --robot.type odpovídající vaší paži (původní README používá so101_follower). Klíče kamer musí odpovídat tréninku: adaptér čte přesně front a wrist, a jejich prohození ukáže politice špatný pohled.

   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"

Trasa B: asynchronní inference lerobot

lerobot řeší jiný problém. Namísto blokování robota, zatímco model přemýšlí, klient pokračuje v procházení fronty, kterou již má, zatímco server počítá další chunk. Toto je chunkování akcí posunuté dál, asynchronní stack představený se SmolVLA. Funguje to i s GR00T checkpointem.

# 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 se spouští prázdný: neví, jakou politiku obsluhuje, dokud mu to neřekne první handshake klienta, což je výhodné na pronajatém podu. Dva parametry, které rozhodují, zda se rameno pohybuje plynule, jsou actions_per_chunk a chunk_size_threshold (dokumentace lerobot nazývá druhý parametr g, podle článku SmolVLA), a dokumentované hodnoty se neshodují s dodanými hodnotami.

Aritmetika, která rozhoduje, zda je vaše připojení dostatečně rychlé

Lidé to přeskočí a pak stráví den s . Trvá to dvě minuty a téměř vždy je to rozhodující.

Komentovaný slovník pozorování v NVIDIA eval_so100.py říká, co jde po drátu: dvě pole tvaru (480, 640, 3) v uint8, šest kloubových floatů, jazykový řetězec. To je 921 600 bajtů na snímek, 1 843 200 bajtů pro dvě kamery, asi 14.7 Mbit, a ani jeden stack to nekomprimuje do JPEG. Vrácený chunk je několik desítek kroků po 6 floatech. Váš upload rozhoduje o všem, ne váš download.

Rozpočet, do kterého se musíte vejít

Klient GR00T SO-100 je synchronní: volá policy.get_action(obs), provede prvních action_horizon kroků bloku při 30 FPS a poté volá znovu. Velikost bloku a horizont jsou různá čísla: průvodce nasazením NVIDIA doporučuje velikost bloku akcí 16, alespoň 32 v kombinaci s chunkingem v reálném čase, zatímco eval_so100.py dodává horizont provádění 8. Osm kroků při 30 FPS je 267 ms pohybu na jedno volání a vše ostatní se do toho musí vejít.

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

Zvýšení horizontu je hrubé řešení a není zadarmo: rameno reaguje na pozorování, které je nyní staré. Principálním řešením je chunking v reálném čase, který vypočítá další blok, zatímco běží ten aktuální, zmrazí akce, které jsou zaručeny k provedení, a zbytek doplní; článek o RTC uvádí, že je robustní vůči zpoždění inference bez nutnosti přeškolení. Nejprve zkontrolujte, jak to vypadá. NVIDIA označuje RTC jako experimentální, nízkoúrovňovou modelovou primitivu dostupnou přes action_head.get_action(..., options={"rtc_overlap_steps": ..., "rtc_frozen_steps": ...}), která není zapojena do Gr00tPolicy ani do cesty server-klient, kde je options nepoužito, bez testů a bez příkladu. Přes policy server získáte asynchronní provádění, nikoli RTC.

Změřte to, než tomu budete věřit

Každé číslo výše je předpověď. Čtyři příkazy z ní udělají měření, které stojí za to spustit, než se zavážete k pod-hodině na úkol, který by nikdy nefungoval.

1. 1
   Získejte syrovou dobu odezvy

   Proti podu, ne CDN. Sledujte odchylku stejně pozorně jako průměr: chvění způsobuje zadrhávání ramene, nikoli průměrná latence.

   bash

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

2. 2
   Změřte uplink, který máte, ne ten, za který platíte

   Domácí upload je obvykle zlomek downloadu, a je to číslo v tabulce šířky pásma výše.

   bash

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

3. 3
   Přečtěte si vlastní log latence klienta

   Robotický klient lerobot zaznamenává latenci server-klient a dobu deserializace pro každý chunk. Na trase B nepotřebujete žádné externí nástroje.

   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
   Sledujte vyprazdňování fronty akcí

   Předejte --debug_visualize_queue_size=True a klient vykreslí velikost fronty za běhu. Pokud opakovaně dosáhne nuly, vyčerpali jste rozpočet: snižte fps, zvyšte actions_per_chunk, nebo zvyšte chunk_size_threshold, aby pozorování odcházela častěji.

   bash

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

K čemu je vzdálená inference skutečně dobrá

Pokud se vzdálený běh zadrhává ve stejném bodě v každé epizodě, síť pravděpodobně není příčinou. Politika, která pokaždé váhá ve stejném úhlu kloubu, je obvykle problém s daty; viz stránky s režimy selhání, zejména politika, která funguje pouze v jednom nastavení a ztráta klesá, ale politika nic nedělá.

Dělat to sami vs. dělat to na AY-Robots

Co stojí vzdálená inference

Důležitá jsou dvě čísla: hodinová sazba karty a jak dlouho ji necháte běžet. První je zveřejněno; druhé lidi překvapuje.

Tyto sazby byly načteny z cenové stránky Runpodu 23. srpna 2026 a spotové trhy se pohybují. AY-Robots místo toho uvádí cenu za celý běh: 3 až 6 hodin za 1.20 až 2.00 USD za hodinu na úrovni A100 nebo H100, přibližně 4 až 12 USD za běh GR00T nebo Pi0.5; 2 až 5 hodin za 0.30 až 0.60 USD za hodinu na úrovni 24 GB, 1 až 3 USD za SmolVLA nebo ACT. Inference relace překoná tréninkový běh v nákladech pouze tehdy, pokud ji zastavíte, k čemuž slouží idle watchdog. Viz dokumentace k fakturaci a stránka s cenami.

Pokud byste raději neměli síť v cyklu

Vzdálená inference řeší hardwarový problém a vytváří problém s latencí. Někdy je lepší odpovědí politika, která odpovídá hardwaru, který máte.

• ACT, přibližně 80 milionů parametrů a 20 ms na akční krok, minimálně 50 epizod, jakákoli 24 GB karta. V opakujícím se nastavení s jednou úlohou často překonává vzdálený 3 B model, protože nikdy nečeká na paket.
• SmolVLA, přibližně 450 milionů parametrů a 245 ms na akční krok, minimálně 30 epizod. Zachovává jazykové podmínění, které ACT postrádá, a dokumentace lerobot uvádí jeho velikost přibližně 2 GB v době inference oproti zhruba 14 GB pro PI0.
• ACT vs GR00T N1.7 pro přesnost, což je jedna polovina kompromisu.

Existuje také střední cesta: trénovat v cloudu, vyhodnocovat lokálně. Jemné ladění potřebuje 80 GB kartu a nezajímá se o latenci, takže trénování GR00T N1.7 na SO-100 vzdáleně je nesporné. Pouze vyhodnocovací smyčka má omezení v reálném čase; dokumentace k trénování a matice modelů a ramen pokrývají tuto polovinu.

Často kladené otázky

Stručná verze

Vzdálená inference pro 3 B politika je vyřešený inženýrský problém s nevyřešeným fyzikálním problémem. Inženýrství spočívá ve dvou příkazech a SSH tunelu. Fyzika spočívá v tom, že pozorování o velikosti 1.8 MB musí dosáhnout GPU v jiné zemi a vrátit se dříve, než rameno vyčerpá akce. Proveďte výpočty před pronájmem čehokoli, vyberte úkol, který toleruje zastaralé pozorování, a zvyšte horizont provádění, spíše než doufat, že se spojení zlepší.

Pokud jste ještě nezaznamenali datovou sadu, zaznamenejte svou první datovou sadu a průvodce nastavením SO-100 jsou na prvním místě a formát datové sady LeRobot položka vysvětluje, co zapisuje záznamník. Pozadí je v modelech vize-jazyk-akce a práci s politikou flow-matching; položka arény odkazuje každé číslo benchmarku na zdroj.