स्थानीय GPU बिना GR00T इन्फेरेन्स चलाउनुहोस्

एक रास्पबेरी पाई सिरियल बसमा चलाउन र दुई USB क्यामेराबाट फ्रेमहरू तान्न पर्याप्त छ। यो तीन अर्ब प्यारामिटरको चलाउन पर्याप्त छैन: NVIDIA को README ले GR00T N1.7 इन्फरेन्सलाई १६ GB वा सोभन्दा बढी VRAM भएको एउटा GPU मा राख्छ। कार्ड नकिनी आफ्नो फाइन-ट्युन गरिएको चेकपोइन्टले हातमा के गर्छ भनेर हेर्न, नीतिलाई भाडाको क्लाउड GPU मा राख्नुहोस्, रोबोट लूपलाई USB पोर्ट भएको मेसिनमा राख्नुहोस्, र अवलोकन तथा कार्यका खण्डहरू नेटवर्कमा पठाउनुहोस्।

यसले काम गर्छ, यो नि:शुल्क छैन, र यसको मूल्य कार्यहरूमा समान रूपमा फैलिएको छैन। तल: NVIDIA को आफ्नै नीति सर्भर, lerobot को एसिन्क स्ट्याक, तपाईंको अपलिंक पर्याप्त छ कि छैन भनेर अग्रिम बताउने अंकगणित, र प्लेटफर्म मार्ग। यो सबै Isaac-GR00T मुख्य शाखा (N1.7 GA) र lerobot 0.6.1 सँग २३ अगस्ट २०२६ मा जाँच गरिएको थियो।

नीति रोबोट मेसिनमा किन फिट हुँदैन

AY-Robots ले तालिम दिन सक्ने पाँच नीतिहरू मध्ये दुई वर्कस्टेशन कार्डमा चल्छन्, तीन चल्दैनन्। तलको स्तम्भ प्रति कार्य चरणको हो, र त्यो संख्या हो जसले तपाईंको नेटवर्क राउन्ड ट्रिपसँग प्रतिस्पर्धा गर्छ।

यसलाई सामान्य जानकारीको रूपमा नभई निर्णयको रूपमा पढ्नुहोस्। ACT प्रति चरण २० मिलिसेकेन्डमा रोबोट मेसिनमा चल्छ र तपाईंले यसको बारेमा फेरि सोच्नु पर्दैन। Pi0.5 ४८५ मिलिसेकेन्डमा, एउटा प्याकेट तपाईंको भवनबाट बाहिर निस्कनु अघि नै एक तिहाइ सेकेन्ड खर्च गरिसकेको हुन्छ। नीति तुलना र GR00T N1.7 vs Pi0.5 ले शुद्धता पक्ष थप्छ।

पहिले नै अवस्थित दुई क्लाइन्ट-सर्भर स्ट्याकहरू

Isaac-GR00T ले ZeroMQ अनुरोध-प्रतिक्रिया सर्भर पठाउँछ; lerobot ले एसिन्क्रोनस इन्फरेन्स वरिपरि निर्मित gRPC सर्भर पठाउँछ। दुवैले GR00T चेकपोइन्ट स्वीकार गर्छन्। lerobot को समर्थित नीति सूची async_inference/constants.py मा act, smolvla, diffusion, tdmpc, vqbet, pi0, pi05 र groot हुन्; यसको रोबोट सूची so100_follower, so101_follower, bi_so_follower र omx_follower हुन्।

सिरियलाइजेसन पङ्क्ति जति देखिन्छ, त्यो भन्दा बढी महत्त्वपूर्ण छ। GR00T को MsgSerializer दुवै दिशामा वस्तु-डिटाइप एनडीअरे पेलोडहरू अस्वीकार गर्दछ, किनभने msgpack_numpy ले अन्यथा तिनीहरूलाई पिकलमा हस्तान्तरण गर्नेछ। lerobot ले यसको सट्टा पिकल गर्छ: policy_server.py ले pickle.loads अनुरोध डेटामा कल गर्छ, robot_client.py यसले पठाउने अवलोकनलाई पिकल गर्छ। एक विश्वसनीय ल्यानमा रक्षात्मक, एकपटक पोर्ट इन्टरनेटबाट पहुँचयोग्य भएपछि अक्षम्य।

मार्ग A: NVIDIA को आफ्नै GR00T नीति सर्भर

यो NVIDIA ले SO-100 र SO-101 हार्डवेयरका लागि दस्तावेज गरेको मार्ग हो, र यदि तपाईंको चेकपोइन्ट examples/finetune.sh बाट --embodiment-tag NEW_EMBODIMENT सँग आएको हो भने प्रयोग गर्ने मार्ग हो। यी चरणहरूले अपस्ट्रिम README मा छुटेका कुराहरू थप्छन्: पोर्टलाई अरू कसैलाई नदेखाएर रोबोटमा पुर्‍याउने।

1. 1
   भाडाको GPU बक्समा GR00T स्थापना गर्नुहोस्

   सबमोड्युलहरू आवश्यक छन्, र क्लोन गर्नु अघि git-lfs अवस्थित हुनुपर्छ अन्यथा demo_data मा रहेका पारकेट फाइलहरू पोइन्टरको रूपमा आउनेछन्। flash-attn र TensorRT पूर्वनिर्धारित स्थापनासँगै आउँछन्। नयाँ पोड इमेजमा समस्या: torchcodec 0.8.0 मात्र समर्थित भिडियो ब्याकेन्ड हो र यसले FFmpeg 4 देखि 7 सम्म मात्र लोड गर्छ। Ubuntu 25.10 र 26.04 ले FFmpeg 8 सँग आउँछन्, त्यसैले GR00T Could not load libtorchcodec त्रुटिको साथ असफल हुन्छ। 8 भन्दा कमको FFmpeg स्थापना गर्नुहोस् र यसका लाइब्रेरीहरूलाई 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
   गेटेड ब्याकबोन विरुद्ध प्रमाणीकरण गर्नुहोस्

   तपाईंको आफ्नै फाइन-ट्युन सहित प्रत्येक GR00T N1.7 चेकपोइन्टले पहिलो प्रयोगमा गेटेड nvidia/Cosmos-Reason2-2B लोड गर्छ। मोडेल पृष्ठमा पहुँच अनुरोध गर्नुहोस् र पोडमा लग इन गर्नुहोस्, अन्यथा लोडिङ GatedRepoError त्रुटिको साथ असफल हुन्छ।

   bash

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

3. 3
   नीति सर्भर सुरु गर्नुहोस्

   --model-path लाई तपाईंको चेकपोइन्ट डाइरेक्टरीमा देखाउनुहोस्; त्यो मार्गमा सर्भरले --modality-config-path लाई बेवास्ता गर्छ, जुन रिप्ले मार्गमा मात्र पढिन्छ। --model-path लाई छोड्नुहोस् र यसको सट्टा --dataset-path र --execution-horizon पास गर्नुहोस् रेकर्ड गरिएका कार्यहरू रिप्ले गर्ने ReplayPolicy को लागि, जुन तारिङले काम गर्छ भनेर प्रमाणित गर्ने सबैभन्दा सस्तो तरिका हो।

   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
   रोबोट मेसिनमा पोर्ट 5555 टनेल गर्नुहोस्

   माथि उल्लेख गरिए अनुसार, लुपब्याकमा बाइन्ड गर्नुहोस्, र SSH वा WireGuard-शैलीको मेस मार्फत पोर्ट बोक्नुहोस्। यसले ZeroMQ सकेटले प्रदान नगर्ने इन्क्रिप्सन र प्रमाणीकरण प्रदान गर्दछ, लगभग एक मिलिसेकेन्डको लागि।

   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
   सर्भोको छेउमा रोबोट क्लाइन्ट चलाउनुहोस्

   क्लाइन्टलाई आफ्नै uv वातावरण चाहिन्छ: यसलाई lerobot को रोबोट ड्राइभरहरू चाहिन्छ, प्रशिक्षण स्ट्याक होइन। eval_so100.py ले so100_follower, so101_follower र koch_follower आयात गर्छ, त्यसैले तपाईंको पाखुरासँग मिल्ने --robot.type पास गर्नुहोस् (अपस्ट्रिम README ले so101_follower प्रयोग गर्छ)। क्यामेरा कुञ्जीहरू प्रशिक्षणसँग मिल्नुपर्छ: एडाप्टरले ठ्याक्कै front र wrist पढ्छ, र तिनीहरूलाई साट्दा नीतिलाई गलत दृश्य देखाउँछ।

   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"

मार्ग B: lerobot एसिन्क्रोनस अनुमान

lerobot ले फरक समस्या समाधान गर्छ। मोडेलले सोच्दा रोबोटलाई रोक्नुको सट्टा, सर्भरले अर्को खण्ड गणना गर्दा क्लाइन्टले आफूसँग भएको कतार मार्फत अगाडि बढिरहन्छ। यो कार्य खण्डीकरण लाई अझ अगाडि बढाइएको छ, SmolVLA सँग प्रस्तुत गरिएको एसिन्क्रोनस स्ट्याक। यो 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

सर्भर खाली सुरु हुन्छ: यसले कुन नीति सेवा गर्छ भन्ने कुरा ग्राहकको पहिलो ह्यान्डशेकले नभनेसम्म थाहा हुँदैन, जुन भाडाको पोडमा सुविधाजनक हुन्छ। पाखुरा सहज रूपमा चल्छ कि चल्दैन भनेर निर्णय गर्ने दुई नियन्त्रणहरू हुन् actions_per_chunk र chunk_size_threshold (लेरोबोट कागजातहरूले दोस्रोलाई g भन्छन्, SmolVLA पेपर पछि), र कागजात गरिएका मानहरू र पठाइएका मानहरू मेल खाँदैनन्।

तपाईंको लिङ्क पर्याप्त छिटो छ कि छैन भनेर निर्णय गर्ने अंकगणित

मानिसहरू यसलाई छोड्छन् र त्यसपछि एक दिन खर्च गर्छन् । यसले दुई मिनेट लिन्छ र यो प्रायः निर्णायक हुन्छ।

NVIDIA को टिप्पणी गरिएको अवलोकन डिक्टमा eval_so100.py तारमा के जान्छ भनी भन्छ: uint8 मा (480, 640, 3) आकारका दुई एरे, छवटा जोइन्ट फ्लोट, एउटा भाषा स्ट्रिङ। त्यो प्रति फ्रेम 921,600 बाइट, दुई क्यामेराका लागि 1,843,200 बाइट, लगभग 14.7 Mbit हो, र कुनै पनि स्ट्याकले यसलाई JPEG-कम्प्रेस गर्दैन। फर्कने चङ्क 6 फ्लोटको केही दर्जन चरणहरू हो। तपाईंको अपलोडले सबै कुरा निर्धारण गर्छ, तपाईंको डाउनलोडले होइन।

तपाईंले भित्र फिट गर्नुपर्ने बजेट

GR00T SO-100 क्लाइन्ट सिंक्रोनस छ: यसले कल गर्छ policy.get_action(obs), पहिलो action_horizon ३० FPS मा चङ्कका चरणहरू कार्यान्वयन गर्छ, त्यसपछि फेरि कल गर्छ। चङ्कको आकार र होराइजन फरक संख्याहरू हुन्: NVIDIA को डिप्लोयमेन्ट गाइडले १६ को एक्शन चङ्क आकार सिफारिस गर्छ, रियल-टाइम चङ्किङसँग मिलाउँदा कम्तिमा ३२, जबकि eval_so100.py ले ८ को कार्यान्वयन होराइजन प्रदान गर्छ। ३० FPS मा आठ चरणहरू प्रति कल २६७ ms को गति हो, र अरू सबै यस भित्र फिट हुनुपर्छ।

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

होराइजन बढाउनु एउटा सीधा समाधान हो र यो नि:शुल्क छैन: पाखुराले अब पुरानो भइसकेको अवलोकनमा कार्य गर्छ। सैद्धान्तिक समाधान भनेको रियल-टाइम चङ्किङ हो, जसले हालको चङ्क चलिरहेको बेला अर्को चङ्क गणना गर्छ, कार्यान्वयन गर्न ग्यारेन्टी गरिएका कार्यहरूलाई स्थिर गर्छ र बाँकीलाई इनपेन्ट गर्छ; RTC पेपरले यसलाई कुनै पुन: प्रशिक्षण बिना अनुमान ढिलाइमा बलियो भएको रिपोर्ट गर्छ। पहिले त्यो कहाँ छ जाँच गर्नुहोस्। NVIDIA ले RTC लाई प्रयोगात्मक, एउटा निम्न-स्तरको मोडेल प्रिमिटिभको रूपमा चिन्ह लगाउँछ जुन action_head.get_action(..., options={"rtc_overlap_steps": ..., "rtc_frozen_steps": ...}), Gr00tPolicy वा सर्भर-क्लाइन्ट मार्गमा तार नगरिएको, जहाँ options प्रयोग नगरिएको छ, कुनै परीक्षण र कुनै उदाहरण बिना। नीति सर्भरमा तपाईंले एसिन्क्रोनस कार्यान्वयन पाउनुहुन्छ, RTC होइन।

विश्वास गर्नु अघि यसलाई नाप्नुहोस्

माथिका प्रत्येक संख्या एक अनुमान हो। चार आदेशहरूले यसलाई मापनमा परिणत गर्दछ, जुन कहिल्यै काम नगर्ने कार्यमा पोड-घण्टा प्रतिबद्ध गर्नु अघि चलाउन लायक छ।

1. 1
   कच्चा राउन्ड ट्रिप प्राप्त गर्नुहोस्

   पोड विरुद्ध, CDN विरुद्ध होइन। औसत जस्तै विचलनलाई नजिकबाट हेर्नुहोस्: जिटरले हातलाई अड्काउँछ, औसत विलम्बताले होइन।

   bash

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

2. 2
   तपाईंसँग भएको अपलिंक नाप्नुहोस्, तपाईंले तिरेको होइन

   आवासीय अपलोड सामान्यतया डाउनलोडको एक अंश हुन्छ, र यो माथिको ब्यान्डविथ तालिकामा भएको संख्या हो।

   bash

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

3. 3
   क्लाइन्टको आफ्नै विलम्बता लग पढ्नुहोस्

   LeRobot रोबोट क्लाइन्टले प्रत्येक खण्डको लागि सर्भर-देखि-क्लाइन्ट विलम्बता र डिसेरियलाइजेसन समय लग गर्दछ। मार्ग B मा तपाईंलाई कुनै बाह्य उपकरणको आवश्यकता पर्दैन।

   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
   कार्य कतार खाली भएको हेर्नुहोस्

   --debug_visualize_queue_size=True पास गर्नुहोस् र क्लाइन्टले रनटाइममा कतारको आकार प्लट गर्दछ। यदि यो बारम्बार शून्यमा पुग्छ भने तपाईं बजेट बाहिर हुनुहुन्छ: fps घटाउनुहोस्, actions_per_chunk बढाउनुहोस्, वा chunk_size_threshold बढाउनुहोस् ताकि अवलोकनहरू धेरै पटक बाहिर जान्छन्।

   bash

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

रिमोट इन्फरेन्स वास्तवमा केका लागि राम्रो छ

यदि रिमोट रन प्रत्येक एपिसोडमा एउटै बिन्दुमा अड्किन्छ भने, नेटवर्क सम्भवतः कारण होइन। प्रत्येक पटक एउटै जोइन्ट कोणमा हिचकिचाउने नीति सामान्यतया डेटा समस्या हो; हेर्नुहोस् असफलता-मोड पृष्ठहरू, विशेष गरी एउटै सेटअपमा मात्र काम गर्ने नीति र हानि घट्छ तर नीतिले केही गर्दैन.

आफैं गर्ने बनाम AY-Robots मा गर्ने

रिमोट इन्फरेन्स सत्रको लागत कति हुन्छ

दुईवटा संख्या महत्त्वपूर्ण छन्: कार्डको प्रति घण्टा दर, र तपाईंले यसलाई कति समयसम्म चलाउनुहुन्छ। पहिलो प्रकाशित हुन्छ; दोस्रोले मानिसहरूलाई चकित पार्छ।

यी दरहरू 23 अगस्ट 2026 मा Runpod को मूल्य निर्धारण पृष्ठबाट पढिएका थिए, र स्पट बजारहरू परिवर्तन भइरहन्छन्। AY-Robots ले यसको सट्टामा पूरै रनको लागि उद्धृत गर्दछ: A100 वा H100 टियरमा प्रति घण्टा 1.20 देखि 2.00 USD मा 3 देखि 6 घण्टा, GR00T वा Pi0.5 रनको लागि लगभग 4 देखि 12 USD; 24 GB टियरमा प्रति घण्टा 0.30 देखि 0.60 USD मा 2 देखि 5 घण्टा, SmolVLA वा ACT को लागि 1 देखि 3 USD। एक इन्फरेन्स सत्रले प्रशिक्षण रनलाई लागतमा मात्र जित्छ यदि तपाईंले यसलाई रोक्नुभयो भने, जसको लागि आइडल वाचडग हो। हेर्नुहोस् बिलिङ कागजातहरू र मूल्य निर्धारण पृष्ठ।

यदि तपाईं नेटवर्कलाई लुपमा राख्न चाहनुहुन्न भने

रिमोट इन्फरेन्सले हार्डवेयर समस्या समाधान गर्छ र लेटेन्सी समस्या सिर्जना गर्छ। कहिलेकाहीँ राम्रो जवाफ भनेको तपाईंसँग भएको हार्डवेयरमा मिल्ने नीति हो।

• ACT, लगभग ८० मिलियन प्यारामिटर र प्रति कार्य चरण २० मिलिसेकेन्ड, न्यूनतम ५० एपिसोड, कुनै पनि २४ GB कार्ड। दोहोरिने एकल-कार्य सेटअपमा यसले प्रायः रिमोट ३ B मोडेललाई जित्छ, किनभने यसले कहिल्यै प्याकेटको लागि पर्खदैन।
• SmolVLA, लगभग ४५० मिलियन प्यारामिटर र प्रति कार्य चरण २४५ मिलिसेकेन्ड, न्यूनतम ३० एपिसोड। यसले ACT मा नभएको भाषा कन्डिसनिङ राख्छ, र lerobot कागजातहरूले यसलाई इन्फरेन्स समयमा लगभग २ GB मा राख्छ जबकि PI0 को लागि लगभग १४ GB लाग्छ।
• ACT vs GR00T N1.7 व्यापारको शुद्धता आधाको लागि।

एउटा मध्य मार्ग पनि छ: क्लाउडमा तालिम दिनुहोस्, स्थानीय रूपमा मूल्याङ्कन गर्नुहोस्। लाई ८० GB कार्ड चाहिन्छ र लेटेन्सीको वास्ता गर्दैन, त्यसैले रिमोटली विवादरहित छ। केवल मूल्याङ्कन लूपमा वास्तविक-समयको बाधा हुन्छ; र ले त्यो आधा भाग समेट्छ।

बारम्बार सोधिने प्रश्नहरू

संक्षिप्त संस्करण

3 B को लागि टाढाको अनुमान नीति एउटा समाधान गरिएको इन्जिनियरिङ समस्या हो जसमा एउटा समाधान नभएको भौतिक विज्ञानको समस्या जोडिएको छ। इन्जिनियरिङ भनेको दुई कमाण्ड र एउटा SSH टनेल हो। भौतिक विज्ञान भनेको 1.8 MB को अवलोकन अर्को देशको GPU मा पुग्नुपर्छ र हातले कार्यहरू समाप्त गर्नु अघि फर्कनुपर्छ। कुनै पनि कुरा भाडामा लिनु अघि हिसाब गर्नुहोस्, बासी अवलोकन सहन सक्ने कार्य छान्नुहोस्, र लिङ्क सुधार हुने आशा गर्नुको सट्टा कार्यान्वयन क्षितिज बढाउनुहोस्।

यदि तपाईंले अहिलेसम्म डेटासेट रेकर्ड गर्नुभएको छैन भने, आफ्नो पहिलो डेटासेट रेकर्ड गर्नुहोस् र SO-100 सेटअप गाइड पहिले आउँछन्, र LeRobot डेटासेट ढाँचा प्रविष्टिले रेकर्डरले के लेख्छ भनेर व्याख्या गर्छ। पृष्ठभूमि दृष्टि-भाषा-कार्य मोडेलहरू र फ्लो-म्याचिङ नीति कार्य मा छ; एरेना प्रविष्टि ले प्रत्येक बेन्चमार्क नम्बरलाई स्रोतसँग जोड्छ।