आफ्नै SO-100 डेटासेटमा GR00T N1.7 लाई कसरी तालिम दिने

NVIDIA ले तपाईंसँग भएको पाखुराको लागि ठीक फाइन-ट्यूनिङ उदाहरण पठाउँछ। भित्र Isaac-GR00T भण्डार एउटा फोल्डर छ जसलाई भनिन्छ demo_data/cube_to_bowl_5: पाँच एपिसोड, 30 fps मा 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 (n1.7-release लाइन) सम्मको Isaac-GR00T मुख्य शाखा र 3 अगस्त 2026 मा PyPI मा प्रकाशित lerobot 0.6.1 विरुद्ध जाँच गरिएको थियो। अपस्ट्रिम छिटो चल्छ, र जहाँ एउटा फ्ल्यागको नाम परिवर्तन गरिएको थियो यो लेखले त्यसो भन्छ।

GR00T N1.7 वास्तवमा के हो

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

दोस्रो आधा पनि परिवर्तन भयो, जुन तपाईंको सञ्चालनका लागि महत्त्वपूर्ण छ। एक्शन हेड 32 डिफ्युजन लेयरबाट 16 मा झर्यो, अनुमानित एक्शन चङ्क 16 स्टेपबाट 40 मा बढ्यो, र अधिकतम स्टेट र एक्शन चौडाइ 29 बाट 132 मा गयो। यी तीन संख्याहरू रिपोजिटरी README मा रहेको चेन्जलगबाट आएका हुन्; NVIDIA को आफ्नै लन्च पोस्टले अझै पनि System 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 ले तिनीहरूलाई सँगै राख्छ।

तपाईंले केही टाइप गर्नु अघि रनलाई के चाहिन्छ

चरण ०: एपिसोडहरू आफैं

तलका सबै कुराले तपाईंले पहिले नै एपिसोडहरू रेकर्ड गरिसक्नुभएको छ भनी मान्दछ। यदि तपाईंले गर्नुभएको छैन भने, त्यो नै वास्तविक पहिलो चरण हो र यसले परिणाम कति राम्रो हुन सक्छ भन्ने निर्धारण गर्दछ, किनभने अनुकरण सिकाइ डेटामा नभएको जानकारी पुन: प्राप्त गर्न सक्दैन। पहिले दुवै हात क्यालिब्रेट गर्नुहोस्, त्यसपछि अनुयायीलाई नेता हात प्रयोग गरेर चलाउनुहोस् जब 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 ले आफ्नै pyproject बोक्छ जसले Python 3.10 वा 3.11 माग्छ र lerobot लाई एउटा git कमिटमा पिन गर्छ, जबकि 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, parquet फाइलहरू अन्तर्गत data/chunk-000/, MP4 फाइलहरू अन्तर्गत videos/chunk-000/observation.images./, र एउटा अतिरिक्त फाइल जुन मानक LeRobot मा छैन। त्यो अतिरिक्त फाइलमा बाँकी अधिकांश त्रुटिहरू छन्।

चरण २: 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 मा छन् र parquet फाइलमा कुन इन्डेक्स कुन हो भनी केही भनिएको छैन। 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 को सट्टा पाइथन फाइल हो, किनभने यसले प्रत्येक कार्य समूहलाई कसरी प्रतिनिधित्व गरिन्छ भन्ने पनि निर्णय गर्छ। यो N1.7 कार्यप्रवाहको त्यो भाग हो जुन N1.5 मा उही रूपमा अवस्थित थिएन, र यो दुई पटक पढ्न लायकको भाग हो। पठाइएको SO-100 कन्फिगले पाँचवटा आर्म जोइन्टहरूलाई RELATIVE हालको अवस्थाबाट डेल्टाको रूपमा र ग्रिपरलाई ABSOLUTE लक्ष्य स्थितिको रूपमा भविष्यवाणी गर्छ, किनभने बाइनरी खुला-वा-बन्द संकेत डेल्टाको सट्टा लक्ष्यको रूपमा राम्रो व्यवहार गर्छ।

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 ले ट्याग पहिले नै दर्ता नभएको दाबी गर्छ, त्यसैले एउटै पाइथन प्रक्रियामा दोस्रो NEW_EMBODIMENT कन्फिग Embodiment tag ... already registered सँग समाप्त हुन्छ। तपाईंले यी मध्ये दुईलाई एउटै स्क्रिप्टमा आयात गर्न सक्नुहुन्न। तेस्रो नियम पछि, डिप्लोयमेन्टमा लागू हुन्छ: कार्य delta_indices शून्यबाट सुरु हुने निरन्तर दायरा हुनुपर्छ। [0, 4, 8] जस्तो विरल विन्डो अस्वीकृत हुन्छ, किनभने डाउनस्ट्रीममा सबै कुराले अनुमानित खण्डलाई रैखिक रूपमा अनुक्रमणिका गर्छ र अन्यथा गलत पङ्क्तिहरू कार्यान्वयन गर्दछ।

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

N1.7 ले भण्डारलाई युभी र Python 3.12 मा सार्यो। पुरानो कोन्डा प्लस 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/ मा भएका parquet फाइलहरू पोइन्टर स्टबको रूपमा आउँछन्, र फाइल सूचीमा उपस्थित देखिने डेटासेटमा डेमो रन असफल हुन्छ।

   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 स्थापना गर्नुहोस् र वातावरण सिंक गर्नुहोस्

   पूर्वनिर्धारित स्थापनाले flash-attn र TensorRT सहित GPU निर्भरताहरू तान्छ। नयाँ 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 उदाहरणले छोडेका वृद्धि (augmentation) र चेकपोइन्टिङ फ्ल्यागहरू पनि समावेश छन्। यो संकीर्ण अर्थमा हो: भाषा ब्याकबोन र भिजुअल एन्कोडर स्थिर रहन्छन्, र जुन तालिम हुन्छ त्यो प्रोजेक्टर र डिफ्युजन एक्शन हेड हो।

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 एउटा डेटाक्लासबाट उत्पन्न भएको टायरो CLI हो, र त्यो डेटाक्लासमा कुनै सीड फिल्ड छैन। README ले गैर-निर्धारित छवि वृद्धि (non-deterministic image augmentation) को कारणले गर्दा रनहरू बीच ५ देखि ६ प्रतिशत भिन्नता रहेको छुट्टै उल्लेख गर्दछ। समान फ्ल्यागहरू भएका दुई रनहरूले समान चेकपोइन्टहरू उत्पादन गर्दैनन्, जुन हाइपरप्यारामिटर परिवर्तनले मद्दत गर्यो वा तपाईं भाग्यमानी हुनुभयो भनेर निर्णय गर्ने प्रयास गर्दा धेरै महत्त्वपूर्ण हुन्छ। तुलनाका लागि, lerobot को आफ्नै ट्रेनरले सीड 1000 मा पूर्वनिर्धारित गर्दछ, र LeRobot GR00T रेसिपीले --seed=42 स्पष्ट रूपमा पास गर्दछ।

२००००-चरणको रनको लागत कति हुन्छ

GR00T N1.7 लाई ८० GB कार्ड चाहिन्छ, त्यसैले लागतको प्रश्नको सीमित उत्तर छ। AY-Robots मा groot1.7 ट्रेनर A100 80 GB वा H100 80 GB टियरमा चल्छ, जहाँ एक रनलाई स्पट बजारमा प्रति घण्टा 1.20 देखि 2.00 USD मा ३ देखि ६ घण्टा लाग्छ। पूर्वनिर्धारित २००००-चरणको कामको लागि त्यो लगभग 4 देखि 12 USD हो। मा समान कार्य SmolVLA वा ACT प्रति घण्टा 0.30 देखि 0.60 USD र प्रति रन 1 देखि 3 USD मा २४ GB कार्डमा हुन्छ। त्यो वास्तविक ट्रेड-अफ हो: GR00T प्रति प्रयास लगभग चार गुणा बढी महँगो छ, र तपाईं यसलाई आफ्नो डेस्क मुनिको 4090 मा चलाउन सक्नुहुन्न।

५०-एपिसोड न्यूनतम एउटा आधार हो, लक्ष्य होइन। NVIDIA को आफ्नै FAQ अझ बढी माग गर्दछ: साधारण निश्चित-स्थान पिक र प्लेसका लागि लगभग १०० ट्र्याजेक्टोरीहरू, जटिल वा बहु-चरण दृश्यहरूका लागि ५०० वा सोभन्दा बढी, र सूक्ष्म हेरफेरका लागि १०० देखि ५००। यदि तपाईंसँग २० एपिसोडहरू छन् भने, साँझ ट्युन गर्नुको सट्टा दिउँसो रेकर्डिङमा खर्च गर्नुहोस्। डाटा सङ्कलन गाइडले उपयोगी एपिसोडलाई खेर गएको एपिसोडबाट के कुराले अलग गर्छ भन्ने कुरा समेट्छ, आफ्नो पहिलो डेटासेट रेकर्ड गर्नुहोस्छोटो संस्करण हो, र SO-100 डाटा सङ्कलनहात-विशेष संस्करण हो।

चरण 6: तपाईंले पाखुरा छुनु अघि ओपन-लूप मूल्याङ्कन

ताजा चेकपोइन्टलाई तालिमले काम गर्यो कि गरेन भनेर पत्ता लगाउन भौतिक हातमा नराख्नुहोस्। पहिले ओपन-लूप मूल्याङ्कन चलाउनुहोस्। यसले रेकर्ड गरिएको एपिसोडलाई पुन: प्ले गर्छ, प्रत्येक चरणमा कार्यहरूको लागि मोडेललाई सोध्छ, र MSE र MAE सँग ग्राउन्ड ट्रुथ विरुद्ध भविष्यवाणी प्लट गर्छ। यसको कुनै लागत लाग्दैन र यसले चरण २ र ३ बाट म्यापिङ त्रुटिहरू पत्ता लगाउँछ।

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 चरणहरूको साथ रिपो कागजातहरूमा सन्दर्भ रन छ।

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

अर्को मार्ग: Isaac-GR00T को सट्टा lerobot-train

LeRobot को हालको संस्करण, 0.6.1 PyPI मा 3 अगस्त 2026 देखि उपलब्ध छ, यसले समान आधारभूत वजनहरूलाई फाइन-ट्यून गर्ने दोस्रो र एकदम फरक तरिका प्रदान गर्दछ। 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 स्ट्रिम गर्छ।