स्थानिक जीपीयूशिवाय GR00T अनुमान चालवा

एक रास्पबेरी पाई ला सिरीयल बसद्वारे चालवण्यासाठी आणि दोन USB कॅमेऱ्यांमधून फ्रेम्स घेण्यासाठी पुरेसा आहे. तीन अब्ज पॅरामीटरचे चालवण्यासाठी ते पुरेसे नाही: NVIDIA च्या README नुसार GR00T N1.7 इन्फरन्ससाठी 16 GB किंवा अधिक VRAM असलेले एक GPU लागते. कार्ड न विकत घेता तुमच्या फाइन-ट्यून केलेल्या चेकपॉईंटचे आर्मवर काय कार्य आहे हे पाहण्यासाठी, पॉलिसी भाड्याच्या क्लाउड GPU वर ठेवा, रोबोट लूप USB पोर्ट असलेल्या मशीनवर ठेवा आणि निरीक्षणे (observations) व ॲक्शन चंक्स नेटवर्कवरून पाठवा.

हे कार्य करते, ते विनामूल्य नाही आणि त्याची किंमत सर्व कार्यांवर समान रीतीने विभागलेली नाही. खालीलप्रमाणे: 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 अन्यथा त्यांना पिकलकडे देईल. त्याऐवजी lerobot पिकल वापरते: policy_server.py विनंती डेटावर pickle.loads कॉल करते, robot_client.py ते पाठवलेले निरीक्षण पिकल करते. विश्वसनीय लॅनवर सुरक्षित, एकदा पोर्ट इंटरनेटवरून पोहोचण्यायोग्य झाल्यावर असुरक्षित.

मार्ग अ: NVIDIA चा स्वतःचा GR00T पॉलिसी सर्व्हर

SO-100 आणि SO-101 हार्डवेअरसाठी NVIDIA ने दस्तऐवजीकरण केलेला हा मार्ग आहे, आणि जर तुमचा चेकपॉईंट 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
   सर्व्होच्या शेजारी रोबोट क्लायंट चालवा

   क्लायंटला स्वतःचे 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 (lerobot डॉक्स दुसऱ्याला 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 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
   क्लायंटचा स्वतःचा लेटन्सी लॉग वाचा

   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 रोजी रनपॉडच्या किमतींच्या पानावरून घेतले होते आणि स्पॉट मार्केट बदलतात. 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, अंदाजे 80 दशलक्ष पॅरामीटर्स आणि प्रति ॲक्शन स्टेप 20 मिसेकंद, किमान 50 एपिसोड्स, कोणतीही 24 GB कार्ड. एका पुनरावृत्तीच्या सिंगल-टास्क सेटअपमध्ये, ते रिमोट 3 B मॉडेलला वारंवार हरवते, कारण ते कधीही पॅकेटची वाट पाहत नाही.
• SmolVLA, अंदाजे 450 दशलक्ष पॅरामीटर्स आणि प्रति ॲक्शन स्टेप 245 मिसेकंद, किमान 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 पर्यंत पोहोचले पाहिजे आणि रोबोटचा हात क्रिया संपण्यापूर्वी परत आले पाहिजे. काहीही भाड्याने घेण्यापूर्वी गणित करा, जुन्या निरीक्षणाला सहन करणारे कार्य निवडा आणि लिंक सुधारण्याची आशा करण्याऐवजी एक्झिक्यूशन होरायझन वाढवा.

जर तुम्ही अजून डेटासेट रेकॉर्ड केला नसेल, तर आणि आधी येतात, आणि एंट्रीमध्ये रेकॉर्डर काय लिहितो हे स्पष्ट केले आहे. पार्श्वभूमी आणि मध्ये आहे; प्रत्येक बेंचमार्क नंबरला स्रोताशी जोडते.