अपने SO-100 डेटासेट पर GR00T N1.7 को कैसे प्रशिक्षित करें

NVIDIA आपके पास मौजूद आर्म के लिए एक फाइन-ट्यूनिंग उदाहरण प्रदान करता है। Isaac-GR00T रिपॉजिटरी के अंदर demo_data/cube_to_bowl_5 नामक एक फ़ोल्डर है: पाँच एपिसोड, 30 एफपीएस पर 4,148 फ़्रेम, पहले से ही LeRobot v2.1 के रूप में लिखे गए हैं, जिसमें एक मिलान मोडेलिटी कॉन्फ़िग है examples/SO100/ के तहत। इसका meta/info.json रिपोर्ट करता है robot_type: so101_follower, जो LeRobot में उसी कॉन्फ़िग क्लास के समान है so100_follower। यह वास्तव में उपयोगी है, क्योंकि इसका मतलब है कि GR00T N1.7 के लिए संदर्भ पथ एक छह-डिग्री-ऑफ-फ्रीडम हॉबी आर्म पर मॉडल लिखने वाले लोगों द्वारा बनाए रखा जाता है। यह एक छोटा किया गया मानवरूपी डेमो नहीं है, यह वही आर्म है।

बुरी खबर यह है कि I recorded 60 episodes और the arm does the task के बीच की दूरी। इस पाइपलाइन में लगभग छह जगहें हैं जहाँ यह चुपचाप विफल हो जाती है बजाय जोर से विफल होने के, और उनमें से चार फाइलें ऐसी हैं जिन्हें ज्यादातर लोग कभी नहीं खोलते: meta/modality.json, पायथन डेटा कॉन्फ़िग, meta/relative_stats.json, और डेटासेट की अपनी संस्करण स्ट्रिंग। यह मार्गदर्शिका वास्तविक कमांड के साथ मैन्युअल मार्ग को शुरू से अंत तक बताती है, फिर उसी कार्य को AY-Robots पर एक फॉर्म के रूप में दिखाती है। नीचे दी गई सभी जानकारी 20 अगस्त 2026 तक Isaac-GR00T मुख्य शाखा (n1.7-रिलीज़ लाइन) और 3 अगस्त 2026 को PyPI पर प्रकाशित lerobot 0.6.1 के विरुद्ध जाँची गई थी। अपस्ट्रीम तेजी से आगे बढ़ता है, और जहाँ एक फ़्लैग का नाम बदला गया था, यह लेख ऐसा कहता है।

GR00T N1.7 वास्तव में क्या है

GR00T N1.7 एक विजन-लैंग्वेज-एक्शन मॉडल है जिसमें मूल GR00T N1 पेपर में वर्णित डुअल-सिस्टम लेआउट है: एक विजन-लैंग्वेज मॉड्यूल जो कैमरों और निर्देशों को पढ़ता है, और एक डिफ्यूजन ट्रांसफार्मर जो उसे निरंतर मोटर कमांड के एक हिस्से में बदल देता है। N1.7 ने पहले आधे हिस्से को बदल दिया। N1.6 का ईगल बैकबोन हटा दिया गया है, इसे nvidia/Cosmos-Reason2-2B के साथ एक Qwen3-VL आर्किटेक्चर पर बदल दिया गया है, और मॉडल को रोबोट डेटा के अतिरिक्त लगभग 20,000 घंटे के ईगोसेंट्रिक मानव वीडियो पर प्रीट्रेन किया गया था। NVIDIA की अपनी रिपोर्ट में यह आंकड़ा 20,854 घंटे बताया गया है और यह रिपोर्ट किया गया है कि 1k से 20k घंटे तक जाने से औसत कार्य पूर्णता दोगुनी से अधिक हो जाती है।

दूसरा आधा हिस्सा भी बदल गया, उन तरीकों से जो आपके रन के लिए मायने रखते हैं। एक्शन हेड 32 डिफ्यूजन लेयर्स से घटकर 16 हो गया, अनुमानित एक्शन चंक 16 स्टेप्स से बढ़कर 40 हो गया, और अधिकतम स्टेट और एक्शन चौड़ाई 29 से बढ़कर 132 हो गई। ये तीनों संख्याएँ रिपॉजिटरी README में चेंजलॉग से आती हैं; NVIDIA की अपनी लॉन्च पोस्ट अभी भी सिस्टम 1 को 32-लेयर DiT के रूप में वर्णित करती है, इसलिए जहाँ दोनों असहमत हों, उस रेपो पर भरोसा करें जिसे आप क्लोन करने वाले हैं। एक्शन डिफ़ॉल्ट रूप से एक सापेक्ष एंड-इफेक्टर स्पेस में व्यक्त किए जाते हैं, वर्तमान पोज़ से डेल्टा के रूप में न कि पूर्ण लक्ष्यों के रूप में, यही वह है जो मानव वीडियो से सीखे गए मैनिपुलेशन प्रायर को रोबोट नियंत्रण में स्थानांतरित करने देता है। हेड स्वयं एक फ्लो-मैचिंग डिफ्यूजन ट्रांसफार्मर है, जो Pi0.5 के समान परिवार का है लेकिन इसके सामने एक अलग बैकबोन है। यदि आप अभी भी पिछली पीढ़ी पर हैं, तो N1.7 बनाम N1.5 यह बताता है कि क्या अपग्रेड आपकी पाइपलाइन को फिर से बनाने को उचित ठहराता है।

वे अंतिम तीन पंक्तियाँ लोगों द्वारा बताई गई अधिकांश निराशा को समझाती हैं। मुख्य 27.9 ms एक H100 पर एक TensorRT इंजन है जिसमें एक कैमरा और चार डिनोइजिंग स्टेप्स हैं। उसी कार्ड पर प्लेन PyTorch 85.8 ms है, और मॉडल कार्ड इस अंतर को 3.08x बताता है। किसी भी संख्या में सर्विंग लेयर, दूसरा कैमरा या नेटवर्क हॉप शामिल नहीं है। AY-Robots द्वारा अपने सर्व किए गए GR00T N1.7 के लिए उद्धृत 152 ms प्रति एक्शन स्टेप वह आंकड़ा है जिसमें सर्विंग लूप में है, और एक सार्वजनिक-इंटरनेट राउंड ट्रिप इसके ऊपर बैठता है। इस पर अंत में और अधिक। अन्य मॉडलों के बगल में संख्याओं के लिए, GR00T N1.7 बनाम Pi0.5 और GR00T N1.7 बनाम SmolVLA उन्हें साथ-साथ रखते हैं।

कुछ भी टाइप करने से पहले रन को क्या चाहिए

चरण 0: एपिसोड स्वयं

नीचे दी गई सभी बातें यह मानती हैं कि आपने पहले ही एपिसोड रिकॉर्ड कर लिए हैं। यदि आपने नहीं किए हैं, तो वह वास्तविक पहला कदम है और यही तय करता है कि परिणाम कितना अच्छा हो सकता है, क्योंकि इमिटेशन लर्निंग डेटा में मौजूद जानकारी को पुनः प्राप्त नहीं कर सकता है। पहले दोनों भुजाओं को कैलिब्रेट करें, फिर फॉलोअर को एक लीडर आर्म जबकि lerobot-record पारकेट फ़ाइलें और कैमरा स्ट्रीम लिखता है। यदि कैलिब्रेशन बंद है, तो आपके डेटासेट में संयुक्त मान उस रोबोट से थोड़ा अलग रोबोट का वर्णन करते हैं जो बाद में पॉलिसी को निष्पादित करेगा, और कोई भी प्रशिक्षण इसे ठीक नहीं कर सकता है।

lerobot-record \
    --robot.type=so100_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_follower_arm \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30}}" \
    --teleop.type=so100_leader \
    --teleop.port=/dev/ttyACM1 \
    --teleop.id=my_leader_arm \
    --dataset.repo_id=${HF_USER}/cube-into-bowl \
    --dataset.num_episodes=60 \
    --dataset.single_task="put the cube in the yellow bowl" \
    --display_data=true

LeRobot की अपनी सलाह है कि कम से कम 50 एपिसोड रिकॉर्ड करें, जिसमें प्रति वस्तु स्थान लगभग 10 हों, कैमरों को स्थिर रखें, और ग्रैस्पिंग व्यवहार को सुसंगत रखें। भिन्नता बाद में जोड़ें, शुरुआत में नहीं। याद रखने योग्य अंगूठे का नियम: यदि आप केवल कैमरा छवियों से स्वयं कार्य नहीं कर सकते, तो पॉलिसी भी नहीं कर सकती। आर्म-विशिष्ट सेटअप के लिए, SO-100 गेटिंग स्टार्टेड और SO-100 LeRobot पेज पोर्ट, कैलिब्रेशन और कैमरा इंडेक्स को कवर करते हैं। AY-Robots पर आप ब्राउज़र का उपयोग करके इंटरनेट पर भी यह कर सकते हैं टेलीऑपरेशन और सीधे सत्र से रिकॉर्ड करें।

चरण 1: डेटासेट LeRobot v2.1 होना चाहिए

यह सबसे आम बाधा है। LeRobot का मुख्य पर वर्तमान CODEBASE_VERSION v3.0 है, इसलिए आज आप किसी भी वर्तमान टूलचेन के साथ जो कुछ भी रिकॉर्ड करते हैं वह v3.0 के रूप में आता है। GR00T का लोडर v2 की अपेक्षा करता है। रिपॉजिटरी स्पष्ट रूप से बताती है कि क्यों: DROID, LIBERO और Bridge जैसे कई अपस्ट्रीम डेटासेट v2 में प्रकाशित होते हैं, और दोनों के लिए मूल समर्थन की योजना है लेकिन इसे शिप नहीं किया गया है। इसलिए रूपांतरण आपकी जिम्मेदारी है, और यह एक ठोस कारण से अपने स्वयं के वर्चुअलएनवी में चलता है: scripts/lerobot_conversion अपना स्वयं का पायप्रोजेक्ट रखता है जो Python 3.10 या 3.11 मांगता है और लेरोबोट को एक गिट कमिट पर पिन करता है, जबकि Isaac-GR00T को Python 3.12 की आवश्यकता होती है। कनवर्टर को रिपॉजिटरी रूट से इंस्टॉल करें और आपको gr00t पैकेज मिलता है, जो एक गलती है जिसके बारे में इसकी README चेतावनी देती है। यदि आप इस प्रारूप से नए हैं, तो LeRobot डेटासेट शब्दावली प्रविष्टि बताती है कि वास्तव में इसके अंदर क्या है।

# from the Isaac-GR00T repo root
cd scripts/lerobot_conversion
uv venv
source .venv/bin/activate
uv pip install -e . --verbose

# pulls the dataset from the Hub and writes a v2.1 copy into the default cache
python convert_v3_to_v2.py --repo-id <your-hf-user>/<your-dataset>

# or, back in the repo root, keep it next to the SO-100 example
uv run --project scripts/lerobot_conversion \
  python scripts/lerobot_conversion/convert_v3_to_v2.py \
  --repo-id <your-hf-user>/<your-dataset> \
  --root examples/SO100/my_dataset_lerobot

रूपांतरण के बाद GR00T जिस संरचना को चाहता है वह क्लासिक v2 लेआउट है: meta/info.json, meta/episodes.jsonl, meta/tasks.jsonl, data/chunk-000/ के तहत पारके फाइलें, videos/chunk-000/observation.images./ के तहत MP4 फाइलें, और एक अतिरिक्त फाइल जो मानक LeRobot में नहीं होती है। वह अतिरिक्त फाइल ही है जहाँ अधिकांश शेष विफलताएँ रहती हैं।

चरण 2: modality.json, वे छह संख्याएँ जो सब कुछ तय करती हैं

एक LeRobot डेटासेट में रोबोट की स्थिति और क्रिया को फ्लैट float32 एरे के रूप में संग्रहीत किया जाता है। एक SO-100 के लिए दोनों का आकार [6] होता है: पाँच आर्म जॉइंट्स और एक ग्रिपर। डेमो डेटासेट उन्हें shoulder_pan.pos, shoulder_lift.pos, elbow_flex.pos, wrist_flex.pos, wrist_roll.pos, gripper.pos नाम देता है, लेकिन वे नाम info.json में रहते हैं और पारके फाइल में कुछ भी यह नहीं बताता कि कौन सा इंडेक्स कौन सा है। meta/modality.json वह मैपिंग प्रदान करता है, और GR00T इसके बिना प्रशिक्षित नहीं होगा। यहाँ वह फाइल है जिसे रिपॉजिटरी SO-100 के लिए भेजती है, हूबहू।

{
  "state": {
    "single_arm": {
      "start": 0,
      "end": 5
    },
    "gripper": {
      "start": 5,
      "end": 6
    }
  },
  "action": {
    "single_arm": {
      "start": 0,
      "end": 5
    },
    "gripper": {
      "start": 5,
      "end": 6
    }
  },
  "video": {
    "front": {
      "original_key": "observation.images.front"
    },
    "wrist": {
      "original_key": "observation.images.wrist"
    }
  },
  "annotation": {
    "human.task_description": {
      "original_key": "task_index"
    }
  }
}

इसे अपने परिवर्तित डेटासेट में meta/modality.json पर कॉपी करें और वीडियो कुंजियों का नाम बदलकर वह रखें जो आपके कैमरों का वास्तविक नाम है। यदि आपने 'top' नामक एक सिंगल ओवरहेड कैमरे से रिकॉर्ड किया है, तो 'original_key' 'observation.images.top' है और अनुकूल नाम वह है जिसे आपका डेटा कॉन्फ़िग संदर्भित करेगा। दोनों को सहमत होना होगा, और उनमें से कोई भी आपके लिए दूसरे की जाँच नहीं करता है। भाषा एनोटेशन और भी बुरा है, क्योंकि एक ही कुंजी को तीन स्थानों पर दिखना होता है।

चरण 3: डेटा कॉन्फ़िग, सापेक्ष आर्म और निरपेक्ष ग्रिपर

मोडेलिटी कॉन्फ़िग JSON के बजाय एक Python फ़ाइल है, क्योंकि यह यह भी तय करती है कि प्रत्येक एक्शन ग्रुप को कैसे दर्शाया जाता है। यह N1.7 वर्कफ़्लो का वह हिस्सा है जो N1.5 में उसी रूप में मौजूद नहीं था, और वह हिस्सा जिसे दो बार पढ़ना उचित है। शिप किए गए SO-100 कॉन्फ़िग पांच आर्म जॉइंट्स को वर्तमान स्थिति से रिलेटिव डेल्टा के रूप में और ग्रिपर को एक एब्सोल्यूट लक्ष्य स्थिति के रूप में अनुमानित करता है, क्योंकि एक बाइनरी ओपन-या-क्लोज्ड सिग्नल डेल्टा की तुलना में लक्ष्य के रूप में बेहतर व्यवहार करता है।

from gr00t.configs.data.embodiment_configs import register_modality_config
from gr00t.data.embodiment_tags import EmbodimentTag
from gr00t.data.types import (
    ActionConfig, ActionFormat, ActionRepresentation, ActionType, ModalityConfig,
)

so100_config = {
    "video": ModalityConfig(
        delta_indices=[0],                       # current frame only
        modality_keys=["front", "wrist"],        # must match modality.json
    ),
    "state": ModalityConfig(
        delta_indices=[0],
        modality_keys=["single_arm", "gripper"],
    ),
    "action": ModalityConfig(
        delta_indices=list(range(0, 16)),        # predict 16 future steps
        modality_keys=["single_arm", "gripper"],
        action_configs=[
            ActionConfig(rep=ActionRepresentation.RELATIVE,   # arm joints
                         type=ActionType.NON_EEF,
                         format=ActionFormat.DEFAULT),
            ActionConfig(rep=ActionRepresentation.ABSOLUTE,   # gripper
                         type=ActionType.NON_EEF,
                         format=ActionFormat.DEFAULT),
        ],
    ),
    "language": ModalityConfig(
        delta_indices=[0],
        modality_keys=["annotation.human.task_description"],
    ),
}

register_modality_config(so100_config, embodiment_tag=EmbodimentTag.NEW_EMBODIMENT)

यहां दो विवरण हैं जो आपको पता न होने पर एक दिन का नुकसान करा सकते हैं। पहला, action_configs स्थितिजन्य है: दस्तावेज़ों को modality_keys के समान लंबाई और समान क्रम की आवश्यकता होती है, और वे इसे गलत करने के परिणाम के बारे में स्पष्ट हैं, जो यह है कि गलत प्रतिनिधित्व चुपचाप लागू हो जाता है। आपका ग्रिपर डेल्टा के रूप में प्रशिक्षित होता है और आपकी भुजा एक पूर्ण लक्ष्य के रूप में, और कोई त्रुटि संदेश नहीं होता है। दूसरा, register_modality_config यह दावा करता है कि टैग पहले से पंजीकृत नहीं है, इसलिए उसी Python प्रक्रिया में दूसरा NEW_EMBODIMENT कॉन्फ़िग Embodiment tag ... already registered के साथ समाप्त हो जाता है। आप इनमें से दो को एक स्क्रिप्ट में आयात नहीं कर सकते। एक तीसरा नियम बाद में, डिप्लॉयमेंट पर लागू होता है: एक्शन delta_indices शून्य से शुरू होने वाली सन्निहित सीमा होनी चाहिए। [0, 4, 8] जैसी एक विरल विंडो को अस्वीकार कर दिया जाता है, क्योंकि डाउनस्ट्रीम में सब कुछ अनुमानित चंक को रैखिक रूप से अनुक्रमित करता है और अन्यथा गलत पंक्तियों को निष्पादित करेगा।

चरण 4: वातावरण

N1.7 ने रिपॉजिटरी को और Python 3.12 में स्थानांतरित कर दिया है। पुराना conda प्लस pip install -e . पाथ अभी भी README के एक ढह चुके अनुभाग में मौजूद है, लेकिन यह चेतावनी देता है कि GPU निर्भरताओं, जिनमें flash-attn और TensorRT शामिल हैं, को मैन्युअल इंस्टॉलेशन की आवश्यकता हो सकती है। uv का उपयोग करें जब तक कि आपके पास ऐसा न करने का कोई विशेष कारण न हो। flash-attn के संबंध में, एक विवरण भ्रम से बचाता है: आपको Installing flash-attn हर uv run पर मुद्रित होता हुआ दिखाई देगा। यह फिर से नहीं बन रहा है। uv एक URL-पिन किए गए व्हील को फिर से मान्य कर रहा है जो पहले से ही कैश किया गया है, और इसमें दो या तीन सेकंड लगते हैं।

1. 1
   git-lfs स्थापित करें, फिर सबमॉड्यूल के साथ क्लोन करें

   git-lfs आवश्यक है, वैकल्पिक नहीं। इसके बिना demo_data/ में पारके फ़ाइलें पॉइंटर स्टब्स के रूप में आती हैं, और फ़ाइल सूची में मौजूद दिखने वाले डेटासेट पर डेमो रन विफल हो जाता है।

   bash

   sudo apt install git-lfs && git lfs install
   git clone --recurse-submodules https://github.com/NVIDIA/Isaac-GR00T
   cd Isaac-GR00T

2. 2
   uv स्थापित करें और वातावरण को सिंक करें

   डिफ़ॉल्ट इंस्टॉलेशन GPU निर्भरताओं को खींचता है जिसमें flash-attn और TensorRT शामिल हैं। एक नई A100 या H100 इमेज पर यह सबसे लंबा एकल चरण है, इसलिए इसे किसी और चीज़ पर ध्यान देना शुरू करने से पहले करें।

   bash

   curl -LsSf https://astral.sh/uv/install.sh | sh
   sudo apt-get update && sudo apt-get install -y ffmpeg
   uv sync --python 3.12
   uv run python -c "import gr00t; print('GR00T installed successfully')"

3. 3
   Hugging Face के विरुद्ध प्रमाणित करें

   इसे पहले प्रशिक्षण लॉन्च से पहले करें, न कि आठ मिनट बाद विफल होने पर।

   bash

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

4. 4
   भेजे गए SO-100 डेमो डेटा पर सैनिटी-चेक

   अपनी खुद की रिकॉर्डिंग को छूने से पहले, demo_data/cube_to_bowl_5 पर 2000 चरण चलाएँ। इसमें पाँच एपिसोड हैं, यह तेज़ी से समाप्त होता है, और यह आपके डेटा के बजाय वातावरण को सिद्ध करता है। यदि यह रन विफल हो जाता है, तो आपके डेटासेट के लिए कुछ भी मदद नहीं करेगा।

   bash

   CUDA_VISIBLE_DEVICES=0 uv run python \
       gr00t/experiment/launch_finetune.py \
       --base-model-path nvidia/GR00T-N1.7-3B \
       --dataset-path demo_data/cube_to_bowl_5 \
       --embodiment-tag NEW_EMBODIMENT \
       --modality-config-path examples/SO100/so100_config.py \
       --num-gpus 1 \
       --output-dir /tmp/test_finetune \
       --max-steps 2000 \
       --global-batch-size 32 \
       --dataloader-num-workers 4

चरण 5: फाइन-ट्यून कमांड और इसके फ़्लैग वास्तव में डिफ़ॉल्ट रूप से क्या होते हैं

डेमो डेटासेट को अपने डेटासेट से बदलें और वे नॉब जोड़ें जो आप वास्तव में चाहते हैं। नीचे वह पूर्ण रूप है जिसका उपयोग रिपॉजिटरी अपने नए-एम्बॉडमेंट ट्यूटोरियल में करती है, जिसमें ऑग्मेंटेशन और चेकपॉइंटिंग फ़्लैग शामिल हैं जिन्हें संक्षिप्त README उदाहरण छोड़ देता है। यह संकीर्ण अर्थ में है: भाषा बैकबोन और विज़ुअल एनकोडर जमे रहते हैं, और जो प्रशिक्षित होता है वह प्रोजेक्टर और डिफ्यूजन एक्शन हेड है।

export NUM_GPUS=1
CUDA_VISIBLE_DEVICES=0 uv run python \
    gr00t/experiment/launch_finetune.py \
    --base-model-path nvidia/GR00T-N1.7-3B \
    --dataset-path ./my_dataset_lerobot \
    --embodiment-tag NEW_EMBODIMENT \
    --modality-config-path examples/SO100/so100_config.py \
    --num-gpus $NUM_GPUS \
    --output-dir /tmp/so100 \
    --save-total-limit 5 \
    --save-steps 2000 \
    --max-steps 20000 \
    --use-wandb \
    --global-batch-size 32 \
    --color-jitter-params brightness 0.3 contrast 0.4 saturation 0.5 hue 0.08 \
    --dataloader-num-workers 4

वह आखिरी पंक्ति कोई टाइपो नहीं है। launch_finetune.py एक डेटाक्लास से जनरेट किया गया टायरो सीएलआई है, और उस डेटाक्लास में कोई सीड फ़ील्ड नहीं है। README में अलग से बताया गया है कि नॉन-डिटरमिनिस्टिक इमेज ऑग्मेंटेशन के कारण रन के बीच 5 से 6 प्रतिशत का अंतर होता है। एक जैसे फ़्लैग वाले दो रन एक जैसे चेकपॉइंट नहीं बनाएंगे, जो यह तय करते समय बहुत मायने रखता है कि क्या हाइपरपैरामीटर परिवर्तन से मदद मिली या आप भाग्यशाली थे। तुलना के लिए, lerobot का अपना ट्रेनर डिफ़ॉल्ट रूप से सीड 1000 पर सेट होता है, और LeRobot GR00T रेसिपी स्पष्ट रूप से --seed=42 पास करती है।

20000-स्टेप रन की लागत क्या है

GR00T N1.7 को 80 GB कार्ड की आवश्यकता होती है, इसलिए लागत के प्रश्न का एक सीमित उत्तर है। AY-Robots पर groot1.7 ट्रेनर A100 80 GB या H100 80 GB टियर पर चलता है, जहाँ स्पॉट मार्केट में एक रन को 1.20 से 2.00 USD प्रति घंटे की दर से 3 से 6 घंटे लगते हैं। यह डिफ़ॉल्ट 20000-स्टेप जॉब के लिए लगभग 4 से 12 USD है। वही कार्य SmolVLA या ACT 24 GB कार्ड पर 0.30 से 0.60 USD प्रति घंटे और 1 से 3 USD प्रति रन की लागत पर होता है। यही वास्तविक समझौता है: GR00T प्रति प्रयास लगभग चार गुना अधिक महंगा है, और आप इसे अपनी डेस्क के नीचे 4090 पर नहीं चला सकते।

50 का-एपिसोड न्यूनतम एक आधार है, लक्ष्य नहीं। NVIDIA का अपना FAQ अधिक मांग वाला है: एक साधारण निश्चित-स्थान पिक एंड प्लेस के लिए लगभग 100 ट्रेजेक्टरी, जटिल या बहु-चरणीय दृश्यों के लिए 500 या अधिक, और सूक्ष्म हेरफेर के लिए 100 से 500। यदि आप 20 एपिसोड पर हैं, तो शाम को ट्यूनिंग करने के बजाय दोपहर रिकॉर्डिंग में बिताएं। डेटा संग्रह गाइड बताता है कि एक उपयोगी एपिसोड को बेकार एपिसोड से क्या अलग करता है, अपना पहला डेटासेट रिकॉर्ड करें इसका संक्षिप्त संस्करण है, और SO-100 डेटा संग्रह आर्म-विशिष्ट संस्करण है।

चरण 6: हाथ को छूने से पहले ओपन-लूप मूल्यांकन

ताज़ा चेकपॉइंट किसी भौतिक आर्म पर यह जानने के लिए न डालें कि प्रशिक्षण काम किया या नहीं। पहले ओपन-लूप मूल्यांकन चलाएँ। यह एक रिकॉर्ड किए गए एपिसोड को फिर से चलाता है, मॉडल से प्रत्येक चरण पर क्रियाओं के लिए पूछता है, और MSE और MAE के साथ ग्राउंड ट्रुथ के मुकाबले भविष्यवाणी को प्लॉट करता है। इसमें कुछ भी खर्च नहीं होता है और यह चरण 2 और 3 से मैपिंग की गलतियों को पकड़ लेता है।

uv run python gr00t/eval/open_loop_eval.py \
    --dataset-path ./my_dataset_lerobot \
    --embodiment-tag NEW_EMBODIMENT \
    --model-path /tmp/so100/checkpoint-20000 \
    --traj-ids 0 \
    --execution-horizon 16 \
    --steps 400 \
    --modality-keys single_arm gripper

रिपॉजिटरी जानबूझकर कस्टम डेटा के लिए एक लक्ष्य MSE प्रकाशित करने से इनकार करती है, और यह सही निर्णय है: यह संख्या आपकी एक्शन इकाइयों, आपके कार्य और आपके डेटासेट के आकार पर निर्भर करती है, इसलिए किसी और के आर्म से कॉपी की गई सीमा का कोई मतलब नहीं है। जो सार्थक है वह प्रवृत्ति है। यहां वह संदर्भ रन है जिसे रेपो एक सिंगल H100 पर पांच-एपिसोड डेमो डेटासेट और 2000 चरणों के साथ दस्तावेज़ित करता है।

आकृति ही संकेत है, निरपेक्ष मान नहीं। त्रुटि लगातार कम होनी चाहिए जैसे-जैसे प्रशिक्षण चरण जमा होते हैं। केवल प्रक्षेपवक्र 0 के बजाय सभी पाँच प्रशिक्षण एपिसोड पर औसत निकालने पर, रेपो के अंतिम चेकपॉइंट ने लगभग 7.5 MSE और 1.5 MAE स्कोर किया, इसलिए संदर्भ रन भी इस बात पर निर्भर करता है कि आप किन एपिसोड का औसत निकालते हैं। अपने डेटा में कुछ भी बदलने से पहले अपरिवर्तित डेमो कमांड पर अपनी खुद की बेसलाइन रिकॉर्ड करें: यदि आप एक ज्ञात-अच्छे रन को पुन: उत्पन्न नहीं कर सकते हैं, तो आप सेटअप की गलती को डेटा समस्या से अलग नहीं कर सकते। रिपॉजिटरी सामान्य लक्षणों को कारणों से भी जोड़ती है, और उनमें से हर एक मॉडल बग के बजाय परिचालन संबंधी है।

दूसरा मार्ग: Isaac-GR00T के बजाय lerobot-train

वर्तमान LeRobot रिलीज़, 3 अगस्त 2026 से PyPI पर 0.6.1, समान आधार भार को फाइन-ट्यून करने का एक दूसरा और काफी अलग तरीका प्रदान करती है। LeRobot GR00T N1.7 को एक पॉलिसी प्रकार के रूप में उजागर करता है और इसे अपने स्वयं के lerobot-train एंट्री पॉइंट के माध्यम से प्रशिक्षित करता है। यहाँ दो बातें मायने रखती हैं। LeRobot CLI कंसोल स्क्रिप्ट का एक सेट है, इसलिए जो कुछ भी आप पढ़ते हैं जिसमें लिखा है python lerobot/scripts/train.py पुराना है और चलेगा नहीं। और LeRobot ने GR00T N1.5 समर्थन को पूरी तरह से हटा दिया, N1.5 चेकपॉइंट्स और कॉन्फ़िग्स को एक माइग्रेशन नोट के साथ अस्वीकार कर दिया, इसलिए यदि आपको LeRobot के माध्यम से N1.5 की आवश्यकता है तो आपको lerobot==0.5.1, जो इसका समर्थन करने वाली अंतिम रिलीज़ है, 7 अप्रैल 2026 को प्रकाशित हुई थी।

pip install "lerobot[groot]" "lerobot[training]"
hf auth login

lerobot-train \
  --dataset.repo_id=$HF_USER/$DATASET_NAME \
  --dataset.image_transforms.enable=true \
  --policy.type=groot \
  --policy.device=cuda \
  --policy.base_model_path=nvidia/GR00T-N1.7-3B \
  --policy.embodiment_tag=new_embodiment \
  --policy.chunk_size=16 \
  --policy.n_action_steps=16 \
  --policy.use_relative_actions=true \
  --policy.relative_exclude_joints='["gripper"]' \
  --policy.use_bf16=true \
  --seed=42 \
  --batch_size=64 \
  --steps=20000 \
  --save_freq=5000 \
  --output_dir=$OUTPUT_DIR

एक ही चेकपॉइंट प्राप्त करने के दो तरीके

चेकपॉइंट को वापस आर्म पर लाना

Isaac-GR00T ZMQ पर एक सर्वर-क्लाइंट विभाजन का उपयोग करता है। पॉलिसी GPU पर चलती है, और रोबोट मशीन पर एक पतला क्लाइंट अवलोकन भेजता है और एक्शन चंक्स प्राप्त करता है। SO-100 उदाहरण कॉपी करने के लिए पर्याप्त पूर्ण है: run_gr00t_server.py को अपने चेकपॉइंट और --embodiment-tag NEW_EMBODIMENT के साथ शुरू करें, फिर रोबोट की तरफ सीरियल पोर्ट, रोबोट आईडी, कैमरा इंडेक्स और भाषा निर्देश के साथ eval_so100.py चलाएँ। उस कमांड में कैमरा नाम आपके modality.json से अनुकूल नामों से मेल खाने चाहिए, न कि OS डिवाइस नंबरों से।

# GPU side
uv run python gr00t/eval/run_gr00t_server.py \
  --model-path /tmp/so100/checkpoint-20000 \
  --embodiment-tag NEW_EMBODIMENT \
  --device cuda:0 \
  --host 0.0.0.0 --port 5555

# robot side, from gr00t/eval/real_robot/SO100
uv run --no-sync python eval_so100.py \
  --robot.type=so101_follower \
  --robot.port=/dev/ttyACM2 \
  --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=localhost --policy_port=5555 \
  --lang_instruction="put the cube in the yellow bowl"

अब नीति कहाँ चलती है, इसके बारे में ईमानदार बात, क्योंकि प्रशिक्षण और सेवा के लिए अलग-अलग हार्डवेयर आवश्यकताएँ हैं। फाइन-ट्यूनिंग के लिए 40 GB या अधिक की आवश्यकता होती है। अनुमान के लिए नहीं: README इसे 16 GB या अधिक बताता है और RTX 4090 का स्पष्ट रूप से नाम लेता है, इसलिए आपके पास पहले से मौजूद एक कार्ड एक चेकपॉइंट को सेवा दे सकता है जिसे वह कभी उत्पन्न नहीं कर सकता था। यह तय करने वाला कि नीति कितनी प्रतिक्रियाशील महसूस होती है, VRAM नहीं है, बल्कि यह है कि सर्वर कहाँ स्थित है। AY-Robots पर GR00T N1.7 केवल क्लाउड-आधारित है, इसलिए नियंत्रण लूप प्रति एक्शन स्टेप 152 ms के ऊपर एक सार्वजनिक-इंटरनेट राउंड ट्रिप का भुगतान करता है, और केवल SmolVLA और ACT भी स्थानीय रूप से चलते हैं। धीमी पिक एंड प्लेस के लिए एक दूरस्थ पॉड सहनीय है। किसी भी प्रतिक्रियाशील चीज़ के लिए यह नहीं है: नीति इस तरह से झिझकने लगती है जो बिल्कुल प्रशिक्षण विफलता जैसी दिखती है और वह नहीं है। ACT प्रति एक्शन स्टेप 20 ms पर वह मॉडल है जो सबसे तंग लूप को सहन करता है, SmolVLA 245 ms पर रहता है, और किसी भी मात्रा में विलंबता ट्यूनिंग एक राउंड ट्रिप को वापस नहीं खरीद सकता जो पहले ही खर्च हो चुका है। अपनी पहली नीति चलाएँ सेवा पक्ष को शुरू से अंत तक बताता है।

वास्तव में क्या गलत होता है

• पहली बार चलाने पर GatedRepoError। आपको nvidia/Cosmos-Reason2-2B तक पहुंच प्रदान नहीं की गई है, या आपने प्रमाणीकरण नहीं किया है। यह GPU घड़ी के पहले ही शुरू होने के बाद होता है।
• लोड होने पर डेटासेट अस्वीकृत। लगभग हमेशा एक v3.0 डेटासेट होता है। इसे निचले संस्करण में बदलें। देखें v3 के रूप में अस्वीकृत डेटासेट।
• गलत बूलियन आयामों के बारे में IndexError। आपने delta_indices बदल दिए और आँकड़े फिर से उत्पन्न नहीं किए।
• बैच 32 पर मेमोरी से बाहर। --global-batch-size कम करें और --gradient-accumulation-steps बढ़ाएँ, या --num-shards-per-epoch कम करें, जिसकी कॉन्फ़िग स्पष्ट रूप से VRAM सीमित होने पर सलाह देती है। देखें प्रशिक्षण के दौरान मेमोरी से बाहर।
• हानि कम होती है, नीति कुछ नहीं करती। डिफ़ॉल्ट रूप से कोई सत्यापन विभाजन नहीं होता है, इसलिए एक स्वच्छ प्रशिक्षण वक्र बहुत कम साबित करता है। यह पृष्ठ निदान को कवर करता है।
• आपके सेटअप में काम करता है और कहीं नहीं। एक ही प्रकाश व्यवस्था की स्थिति में फिल्माए गए छोटे डेटासेट के साथ अपेक्षित। NVIDIA रंग जिटर ऑग्मेंटेशन के साथ-साथ विभिन्न प्रकाश व्यवस्था में 20 से 50 एपिसोड की सलाह देता है। अधिक जानकारी यहाँ।
• ग्रिपर कभी ठीक से बंद नहीं होता। जांचें कि action_configs में ग्रिपर एक्शन ABSOLUTE है और आर्म जॉइंट्स RELATIVE हैं, इसी क्रम में। ग्रिपर बंद नहीं होता अन्य कारणों को सूचीबद्ध करता है।
• रिकॉर्डिंग के बीच में एक कैमरा चुपचाप बंद हो जाता है। एपिसोड अभी भी सहेजता है और वीडियो कुंजी अभी भी मौजूद है, यही कारण है कि यह समस्या गंभीर है। कैमरा डिटेक्ट नहीं हुआ इसे कवर करता है।

विफलता मोड का पूरा सूचकांक पर रहता है। यदि आप किसी एक मॉडल को डीबग करने के बजाय मॉडलों के बीच चयन कर रहे हैं, तो और में संलग्न स्रोतों के साथ बेंचमार्क संख्याएँ हैं, और वह तुलना है जिसकी अधिकांश लोगों को वास्तव में आवश्यकता होती है, क्योंकि यह आपके डेस्क के नीचे कार्ड पर प्रशिक्षित किए जा सकने वाले मॉडल और 80 GB नोड किराए पर लेकर फाइन-ट्यून किए जाने वाले मॉडल के बीच का चुनाव है। इन मॉडलों के ऐसे व्यवहार करने के पीछे की पृष्ठभूमि के लिए, और पहले पढ़ने लायक हैं। और यदि आपके पास अभी तक कोई आर्म नहीं है, तो बिना साइनअप के एक भौतिक SO-100 स्ट्रीम करता है।