स्थानीय GPU के बिना GR00T इन्फेरेंस चलाएँ

एक रास्पबेरी पाई एक को एक सीरियल बस पर चलाने और दो USB कैमरों से फ़्रेम खींचने के लिए पर्याप्त है। यह तीन अरब पैरामीटर वाले : NVIDIA का README GR00T N1.7 अनुमान को 16 GB या उससे अधिक VRAM वाले एक GPU पर रखता है। यह देखने के लिए कि आपका फाइन-ट्यून किया गया चेकपॉइंट बिना कार्ड खरीदे आर्म पर क्या करता है, पॉलिसी को किराए के क्लाउड GPU पर रखें, रोबोट लूप को USB पोर्ट वाली मशीन पर रखें, और नेटवर्क पर ऑब्ज़र्वेशन और एक्शन चंक्स भेजें।

यह काम करता है, यह मुफ़्त नहीं है, और कीमत सभी कार्यों में समान रूप से वितरित नहीं है। नीचे: NVIDIA का अपना पॉलिसी सर्वर, lerobot का एसिंक स्टैक, वह अंकगणित जो पहले से बताता है कि आपका अपलिंक पर्याप्त तेज़ है या नहीं, और प्लेटफ़ॉर्म रूट। यह सब 23 अगस्त 2026 को Isaac-GR00T मुख्य शाखा (N1.7 GA) और lerobot 0.6.1 के विरुद्ध जाँचा गया।

पॉलिसी रोबोट मशीन पर क्यों फिट नहीं होगी

AY-Robots प्रशिक्षित कर सकने वाली पाँच नीतियों में से दो वर्कस्टेशन कार्ड पर चलती हैं, तीन नहीं। नीचे दिया गया कॉलम प्रति एक्शन स्टेप है, और यह वह संख्या है जो आपके नेटवर्क राउंड ट्रिप के साथ प्रतिस्पर्धा करती है।

इसे एक निर्णय के रूप में पढ़ें, न कि सामान्य जानकारी के रूप में। ACT 20 ms प्रति चरण पर रोबोट मशीन पर चलता है और आपको इसके बारे में फिर कभी सोचने की आवश्यकता नहीं होती है। Pi0.5 485 ms पर एक पैकेट आपके भवन से निकलने से पहले एक सेकंड का एक तिहाई हिस्सा खर्च कर चुका होता है। नीति तुलना और 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 अन्यथा उन्हें पिकल को सौंप देगा। लेरोबोट इसके बजाय पिकल करता है: 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 के साथ विफल हो जाता है। FFmpeg 8 से नीचे का संस्करण स्थापित करें और उसकी लाइब्रेरीज़ को 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 या वायरगार्ड-शैली के मेश पर ले जाएं। यह एन्क्रिप्शन और प्रमाणीकरण प्रदान करता है जो 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
   सर्वो के बगल में रोबोट क्लाइंट चलाएँ

   क्लाइंट को अपने स्वयं के यूवी वातावरण की आवश्यकता है: इसे लेरोबोट के रोबोट ड्राइवर चाहिए, न कि प्रशिक्षण स्टैक। 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 कहते हैं, स्मोलवीएलए पेपर के बाद), और दस्तावेज़ित मान और शिप किए गए मान सहमत नहीं हैं।

वह अंकगणित जो यह तय करता है कि आपका लिंक पर्याप्त तेज़ है या नहीं

लोग इसे छोड़ देते हैं और फिर एक दिन इस पर खर्च करते हैं . इसमें दो मिनट लगते हैं और यह लगभग हमेशा निर्णायक होता है।

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 चंक के स्टेप्स को 30 FPS पर निष्पादित करता है, फिर से कॉल करता है। चंक का आकार और होराइजन अलग-अलग संख्याएँ हैं: NVIDIA की डिप्लॉयमेंट गाइड 16 के एक्शन चंक आकार की सिफारिश करती है, रियल-टाइम चंकिंग के साथ संयुक्त होने पर कम से कम 32, जबकि eval_so100.py 8 का निष्पादन होराइजन प्रदान करता है। 30 FPS पर आठ स्टेप्स प्रति कॉल 267 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
   क्लाइंट का अपना विलंबता लॉग पढ़ें

   लेरोबोट रोबोट क्लाइंट हर चंक के लिए सर्वर-टू-क्लाइंट विलंबता और डीसीरियलाइज़ेशन समय को लॉग करता है। रूट 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 को रनपॉड के मूल्य निर्धारण पृष्ठ से ली गई थीं, और स्पॉट बाज़ार बदलते रहते हैं। 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। एक इन्फेरेंस सत्र लागत के मामले में प्रशिक्षण रन से तभी बेहतर होता है जब आप इसे रोकते हैं, जिसके लिए आइडल वॉचडॉग होता है। देखें बिलिंग दस्तावेज़ और मूल्य निर्धारण पृष्ठ.

यदि आप नहीं चाहते कि नेटवर्क लूप में हो

रिमोट इन्फेरेंस हार्डवेयर की समस्या को हल करता है और विलंबता (latency) की समस्या पैदा करता है। कभी-कभी बेहतर जवाब एक ऐसी नीति होती है जो आपके पास मौजूद हार्डवेयर के अनुकूल हो।

• ACT, लगभग 80 M पैरामीटर और प्रति एक्शन स्टेप 20 ms, न्यूनतम 50 एपिसोड, कोई भी 24 GB कार्ड। एक दोहराव वाले एकल-कार्य सेटअप पर यह अक्सर एक रिमोट 3 B मॉडल को हरा देता है, क्योंकि यह कभी भी पैकेट का इंतजार नहीं करता।
• SmolVLA, लगभग 450 M पैरामीटर और प्रति एक्शन स्टेप 245 ms, न्यूनतम 30 एपिसोड। यह भाषा कंडीशनिंग को बरकरार रखता है जिसकी ACT में कमी है, और lerobot डॉक्स इसे इन्फेरेंस समय पर लगभग 2 GB पर रखते हैं, जबकि PI0 के लिए यह लगभग 14 GB है।
• ACT vs GR00T N1.7 व्यापार के सटीकता वाले आधे हिस्से के लिए।

एक मध्य मार्ग भी है: क्लाउड में प्रशिक्षित करें, स्थानीय रूप से मूल्यांकन करें। फाइन-ट्यूनिंग को 80 GB कार्ड की आवश्यकता होती है और उसे विलंबता की परवाह नहीं होती, इसलिए SO-100 पर GR00T N1.7 को दूरस्थ रूप से प्रशिक्षित करना निर्विवाद है। केवल मूल्यांकन लूप में वास्तविक समय की बाधा होती है; प्रशिक्षण दस्तावेज़ और मॉडल-और-आर्म मैट्रिक्स उस आधे हिस्से को कवर करते हैं।

अक्सर पूछे जाने वाले प्रश्न

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

3 B के लिए दूरस्थ इन्फरेंस पॉलिसी एक हल की गई इंजीनियरिंग समस्या है जिसके साथ एक अनसुलझी भौतिकी समस्या जुड़ी हुई है। इंजीनियरिंग दो कमांड और एक SSH टनल है। भौतिकी यह है कि एक 1.8 MB ऑब्जरवेशन को दूसरे देश में एक GPU तक पहुंचना होता है और हाथ के एक्शन खत्म होने से पहले वापस आना होता है। कुछ भी किराए पर लेने से पहले अंकगणित करें, एक ऐसा कार्य चुनें जो बासी ऑब्जरवेशन को सहन करता हो, और लिंक में सुधार की उम्मीद करने के बजाय निष्पादन क्षितिज को बढ़ाएं।

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