Voer GR00T Inferensie Uit Sonder 'n Plaaslike GPU

’n Raspberry Pi is genoeg om ’n oor ’n seriële bus aan te dryf en rame van twee USB-kameras af te trek. Dit is nie genoeg om ’n drie miljard parameter : NVIDIA se README plaas GR00T N1.7 inferensie by een GPU met 16 GB of meer VRAM. Om te sien wat jou fyn-ingestelde kontrolepunt op die arm doen sonder om ’n kaart te koop, plaas die beleid op ’n gehuurde wolk-GPU, hou die robotlus op die masjien met die USB-poorte, en stuur waarnemings en aksiebrokke oor die netwerk.

Dit werk, dit is nie gratis nie, en die prys is nie eweredig oor take versprei nie. Hieronder: NVIDIA se eie beleidbediener, lerobot se asynchrone stapel, die rekenkunde wat vooraf sê of jou oplink vinnig genoeg is, en die platformroete. Alles nagegaan teen die Isaac-GR00T hoofvertakking (N1.7 GA) en lerobot 0.6.1 op 23 Augustus 2026.

Hoekom die beleid nie op die robotmasjien sal pas nie

Twee van die vyf beleide wat AY-Robots kan oplei, loop op 'n werkstasiekaart, drie nie. Die kolom hieronder is per aksiestap, en dit is die getal wat met jou netwerk-rondreis meeding.

Lees dit as 'n besluit, nie as onbenullighede nie. teen 20 ms per stap loop op die robotmasjien en jy dink nooit weer daaraan nie. teen 485 ms het 'n derde van 'n sekonde spandeer voordat 'n pakkie jou gebou verlaat. Die en voeg die akkuraatheidskant by.

Die twee kliënt-bediener-stapels wat reeds bestaan

Isaac-GR00T lewer 'n ZeroMQ-versoek-antwoord-bediener; lerobot lewer 'n gRPC-bediener wat rondom asinchrone inferensie gebou is. Beide aanvaar 'n GR00T kontrolepunt. lerobot se lys van ondersteunde beleide in async_inference/constants.py is act, smolvla, diffusion, tdmpc, vqbet, pi0, pi05 en groot; sy robotlys is so100_follower, so101_follower, bi_so_follower en omx_follower.

Die serialiseringsry is belangriker as wat dit lyk. GR00T se MsgSerializer weier object-dtype ndarray-ladinge in beide rigtings, omdat msgpack_numpy dit andersins aan pickle sou oorhandig. lerobot gebruik eerder pickle: policy_server.py roep pickle.loads op versoekdata, robot_client.py gebruik pickle vir die waarneming wat dit stuur. Verdedigbaar op 'n betroubare LAN, onverdedigbaar sodra die poort vanaf die internet bereikbaar is.

Roete A: NVIDIA se eie GR00T-beleidbediener

Dit is die pad wat NVIDIA dokumenteer vir SO-100 en SO-101 hardeware, en die een om te gebruik as jou kontrolepunt uit examples/finetune.sh met --embodiment-tag NEW_EMBODIMENT. Die stappe voeg by wat die stroomop README uitlaat: om die poort na die robot te kry sonder om dit aan almal anders bloot te stel.

1. 1
   Installeer GR00T op die gehuurde GPU-boks

   Submodules is nodig, en git-lfs moet bestaan voor die kloon of die parquet-lêers in demo_data arriveer as wysers. flash-attn en TensorRT kom met die verstekinstallasie. Die strik op 'n vars pod-beeld: torchcodec 0.8.0 is die enigste ondersteunde video-agterkant en laai slegs FFmpeg 4 tot 7. Ubuntu 25.10 en 26.04 verskaf FFmpeg 8, so GR00T misluk met Could not load libtorchcodec. Installeer 'n FFmpeg onder 8 en plaas sy biblioteke op 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
   Verifieer teen die afgeskermde ruggraat

   Elke GR00T N1.7-kontrolepunt, insluitend jou eie fyninstelling, laai die afgeskermde nvidia/Cosmos-Reason2-2B by eerste gebruik. Versoek toegang op die modelbladsy en meld aan op die pod, anders misluk die laai met 'n GatedRepoError.

   bash

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

3. 3
   Begin die beleidbediener

   Wys --model-path na jou kontrolepuntgids; op daardie pad ignoreer die bediener --modality-config-path, wat slegs op die herhalingspad gelees word. Laat --model-path weg en gee --dataset-path plus --execution-horizon in plaas daarvan vir 'n ReplayPolicy wat opgeneemde aksies herhaal, die goedkoopste manier om te bewys die bedrading werk.

   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
   Tonnel poort 5555 na die robotmasjien

   Bind aan lusrug, soos hierbo, en dra die poort oor SSH of 'n WireGuard-styl netwerk. Dit verskaf die enkripsie en verifikasie wat die ZeroMQ-sok nie doen nie, vir ongeveer 'n millisekonde.

   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
   Loop die robotkliënt langs die servos

   Die kliënt benodig sy eie uv-omgewing: dit wil lerobot se robotbestuurders hê, nie die opleidingsstapel nie. eval_so100.py importeer so100_follower, so101_follower en koch_follower, so gee die --robot.type wat by jou arm pas (die stroomop README gebruik so101_follower). Kameraleutels moet ooreenstem met opleiding: die adapter lees presies front en wrist, en om dit om te ruil wys die beleid die verkeerde aansig.

   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"

Roete B: lerobot asinchrone inferensie

lerobot los 'n ander probleem op. In plaas daarvan om die robot te blokkeer terwyl die model dink, hou die kliënt aan om deur die tou te stap wat dit reeds het terwyl die bediener die volgende stuk bereken. Dit is aksie-segmentering verder geneem, die asinchrone stapel wat met SmolVLA bekendgestel is. Dit werk ook met 'n GR00T-kontrolepunt.

# 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

Die bediener begin leeg: dit weet nie watter beleid dit bedien voordat die kliënt se eerste handdruk dit vertel nie, wat gerieflik is op 'n gehuurde pod. Die twee knoppe wat besluit of die arm glad beweeg, is actions_per_chunk en chunk_size_threshold (die lerobot-dokumente noem die tweede een g, na die SmolVLA-artikel), en die gedokumenteerde waardes en die verskafde waardes stem nie ooreen nie.

Die rekenkunde wat besluit of jou skakel vinnig genoeg is

Mense slaan dit oor en spandeer dan 'n dag aan 'n beleid wat in die middel van beweging vries. Dit neem twee minute en is byna altyd deurslaggewend.

Die gekommentarieerde waarnemingswoordeboek in NVIDIA se eval_so100.py sê wat oor die draad gaan: twee skikkings van vorm (480, 640, 3) in uint8, ses gewrigs-dryfpunte, 'n taalstring. Dit is 921,600 grepe per raam, 1,843,200 grepe vir twee kameras, ongeveer 14.7 Mbit, en geen van die stapels JPEG-komprimeer dit nie. Die brokkie wat terugkom, is 'n paar dosyn stappe van 6 dryfpunte. Jou oplaai besluit alles, nie jou aflaai nie.

Die begroting waarbinne jy moet pas

Die GR00T SO-100 kliënt is sinchronies: dit roep policy.get_action(obs), voer die eerste action_horizon stappe van die brokkie teen 30 FPS uit, en roep dan weer. Brokkiegrootte en horison is verskillende getalle: NVIDIA se ontplooiingsgids beveel 'n aksiebrokkiegrootte van 16 aan, ten minste 32 wanneer dit met intydse brokkies gekombineer word, terwyl eval_so100.py 'n uitvoeringshorison van 8 verskaf. Agt stappe teen 30 FPS is 267 ms se beweging per oproep, en al die ander moet daarbinne pas.

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

Die verhoging van die horison is die bot oplossing en nie 'n gratis een nie: die arm reageer op 'n waarneming wat nou oud is. Die beginselvaste oplossing is intydse brokkies, wat die volgende brokkie bereken terwyl die huidige een loop, die aksies wat gewaarborg is om uit te voer vries en die res invul; die RTC-artikel rapporteer dit as robuust teen inferensievertraging sonder heropleiding. Kyk eers waar dit staan. NVIDIA merk RTC as eksperimenteel, 'n laevlak modelprimitief bereikbaar via action_head.get_action(..., options={"rtc_overlap_steps": ..., "rtc_frozen_steps": ...}), nie in Gr00tPolicy of die bediener-kliënt-pad bedraad nie, waar options ongebruik is, sonder toetse en geen voorbeeld nie. Oor 'n beleidbediener kry jy asinchrone uitvoering, nie RTC nie.

Meet dit voordat jy dit vertrou

Elke getal hierbo is 'n voorspelling. Vier opdragte verander dit in 'n meting, wat die moeite werd is om uit te voer voordat 'n pod-uur toegewys word aan 'n taak wat nooit sou werk nie.

1. 1
   Kry die rou heen-en-weer tyd

   Teen die pod, nie 'n CDN nie. Kyk na die afwyking so noukeurig soos die gemiddelde: rukkerigheid laat 'n arm hakkel, nie gemiddelde latensie nie.

   bash

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

2. 2
   Meet die oplink wat jy het, nie die een waarvoor jy betaal nie

   Residensiële oplaai is gewoonlik 'n fraksie van aflaai, en dit is die getal in die bandwydtetabel hierbo.

   bash

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

3. 3
   Lees die kliënt se eie latensielog

   Die LeRobot robotkliënt teken bediener-na-kliënt latensie en deserialiseringstyd vir elke brokkie aan. Op roete B benodig jy geen eksterne gereedskap nie.

   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
   Kyk hoe die aksie-tou leegloop

   Gee --debug_visualize_queue_size=True deur en die kliënt teken die tougrootte tydens uitvoering. As dit herhaaldelik nul bereik, is jy buite begroting: verlaag fps, verhoog actions_per_chunk, of verhoog chunk_size_threshold sodat waarnemings meer gereeld uitgaan.

   bash

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

Waarvoor afgeleë inferensie eintlik goed is

As 'n afgeleë uitvoering by dieselfde punt in elke episode hakkel, is die netwerk waarskynlik nie die oorsaak nie. 'n Beleid wat elke keer by dieselfde gewrigshoek aarsel, is gewoonlik 'n dataprobbleem; sien die bladsye vir mislukkingsmodusse, in besonder 'n beleid wat slegs in een opstelling werk en verlies daal maar die beleid doen niks.

Om dit self te doen teenoor om dit op AY-Robots te doen

Wat 'n afgeleë inferensie-sessie kos

Twee getalle maak saak: die uurlikse tarief van die kaart, en hoe lank jy dit laat loop. Die eerste is gepubliseer; die tweede verras mense.

Daardie tariewe is op 23 Augustus 2026 van Runpod se prysbladsy gelees, en spotmarkte beweeg. AY-Robots kwoteer eerder 'n hele lopie: 3 tot 6 uur teen 1.20 tot 2.00 USD per uur op die A100- of H100-vlak, ongeveer 4 tot 12 USD vir 'n GR00T- of Pi0.5-lopie; 2 tot 5 uur teen 0.30 tot 0.60 USD per uur op die 24 GB-vlak, 1 tot 3 USD vir SmolVLA of ACT. 'n Inferensiesessie klop 'n opleidingslopie slegs op koste as jy dit stop, wat is waarvoor die ledige waghond is. Sien die fakturering dokumente en die prysbladsy.

As jy eerder nie die netwerk in die lus wil hê nie

Afgeleë inferensie los 'n hardewareprobleem op en skep 'n latensieprobleem. Soms is die beter antwoord 'n beleid wat pas by die hardeware wat jy het.

• ACT, ongeveer 80 M parameters en 20 ms per aksiestap, 50 episodes minimum, enige 24 GB kaart. Op 'n herhalende enkel-taak opstelling oortref dit gereeld 'n afgeleë 3 B model, omdat dit nooit vir 'n pakkie wag nie.
• SmolVLA, ongeveer 450 M parameters en 245 ms per aksiestap, 30 episodes minimum. Dit behou die taalkondisionering wat ACT kort, en die lerobot-dokumente plaas dit op ongeveer 2 GB tydens inferensie teenoor ongeveer 14 GB vir PI0.
• ACT vs GR00T N1.7 vir die akkuraatheidskant van die afweging.

Daar is ook 'n middeweg: oefen in die wolk, evalueer plaaslik. Fyninstelling benodig die 80 GB kaart en gee nie om oor latensie nie, so opleiding van GR00T N1.7 op 'n SO-100 op afstand is onkontroversieel. Slegs die evaluasielus het 'n intydse beperking; die opleidingsdokumente en model-en-arm matriks dek daardie helfte.

Gereelde vrae

Die kort weergawe

Afstandsinferensie vir 'n 3 B beleid is 'n opgeloste ingenieurs-probleem met 'n onopgeloste fisika-probleem daaraan verbonde. Die ingenieurswese is twee opdragte en 'n SSH-tonnel. Die fisika is dat 'n 1.8 MB waarneming 'n GPU in 'n ander land moet bereik en terugkom voordat die arm se aksies opraak. Doen die berekeninge voordat jy enigiets huur, kies 'n taak wat 'n verouderde waarneming verdra, en verhoog die uitvoeringshorison eerder as om te hoop die skakel verbeter.

As jy nog nie 'n datastel opgeneem het nie, neem jou eerste datastel op en die SO-100 opstelgids kom eerste, en die LeRobot datastelformaat inskrywing verduidelik wat die opnemer skryf. Agtergrond is in visie-taal-aksie modelle en die vloeipas-beleidswerk; die arena-inskrywing koppel elke maatstafnommer aan 'n bron.