तुमच्या स्वतःच्या 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 पर्यंतच्या Isaac-GR00T मुख्य शाखेच्या (n1.7-release लाइन) आणि 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: भाग स्वतः

खालील सर्व गोष्टी गृहीत धरतात की तुम्ही आधीच भाग (episodes) रेकॉर्ड केले आहेत. जर तुम्ही केले नसतील, तर ती खरी पहिली पायरी आहे आणि तीच ठरवते की परिणाम किती चांगला असू शकतो, कारण अनुकरण शिक्षण डेटा मध्ये नसलेली माहिती परत मिळवू शकत नाही. प्रथम दोन्ही हात कॅलिब्रेट करा, नंतर फॉलोअरला लीडर आर्म वापरून 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 भाग असावेत, कॅमेरे स्थिर ठेवावेत आणि पकडण्याची (grasping) वर्तणूक सुसंगत ठेवावी. विविधता नंतर जोडा, सुरुवातीला नाही. लक्षात ठेवण्यासारखा एक नियम: जर तुम्ही केवळ कॅमेरा इमेजेसवरून स्वतः कार्य करू शकला नसता, तर पॉलिसी देखील करू शकत नाही. आर्म-विशिष्ट सेटअपसाठी, 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 ची मागणी करतो आणि lerobot ला एका गिट कमिटवर पिन करतो, तर 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/, MP4 फाइल्स खाली videos/chunk-000/observation.images./, आणि एक अतिरिक्त फाइल जी मानक 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 ऐवजी पायथन फाइल आहे, कारण ते प्रत्येक ॲक्शन ग्रुपचे प्रतिनिधित्व कसे केले जाते हे देखील ठरवते. 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. जुना 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/ मधील 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 उदाहरणामध्ये वगळले आहेत. हे संक्षिप्त अर्थाने आहे: भाषा बॅकबोन आणि व्हिज्युअल एन्कोडर गोठलेले राहतात, आणि जे प्रशिक्षित होते ते प्रोजेक्टर आणि डिफ्यूजन ॲक्शन हेड आहे.

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 आहे आणि त्या डेटाक्लासमध्ये 'seed' फील्ड नाही. README मध्ये स्वतंत्रपणे नमूद केले आहे की नॉन-डिटरमिनिस्टिक इमेज ऑगमेंटेशनमुळे रनमध्ये 5 ते 6 टक्के फरक येऊ शकतो. सारख्याच फ्लॅगसह दोन रन केल्यास सारखे चेकपॉइंट्स तयार होणार नाहीत, जे हायपरपॅरामीटर बदलामुळे मदत झाली की फक्त नशीब चांगले होते हे ठरवताना खूप महत्त्वाचे आहे. तुलनेसाठी, lerobot चा स्वतःचा ट्रेनर डीफॉल्टनुसार seed 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 data collection हे आर्म-विशिष्ट आहे.

पायरी 6: तुम्ही आर्मला स्पर्श करण्यापूर्वी ओपन-लूप मूल्यांकन

नवीन चेकपॉईंट प्रत्यक्ष आर्मवर (physical arm) वापरू नका हे पाहण्यासाठी की प्रशिक्षण (training) यशस्वी झाले की नाही. प्रथम ओपन-लूप मूल्यांकन (open-loop evaluation) चालवा. हे रेकॉर्ड केलेला एपिसोड पुन्हा प्ले करते, प्रत्येक टप्प्यावर मॉडेलला कृतींसाठी विचारते आणि MSE आणि MAE सह ग्राउंड ट्रुथच्या विरुद्ध भविष्यवाणी (prediction) प्लॉट करते. याला काहीही खर्च येत नाही आणि ते पायऱ्या 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

रिपॉझिटरी (repository) हेतुपुरस्सर कस्टम डेटासाठी (custom data) लक्ष्य MSE प्रकाशित करण्यास नकार देते, आणि हा योग्य निर्णय आहे: ही संख्या तुमच्या ॲक्शन युनिट्स (action units), तुमच्या कार्यावर (task) आणि तुमच्या डेटासेटच्या आकारावर (dataset size) अवलंबून असते, त्यामुळे दुसऱ्याच्या आर्ममधून कॉपी केलेली मर्यादा (threshold) निरर्थक आहे. महत्त्वाचा आहे तो ट्रेंड (trend). येथे संदर्भ रन (reference run) आहे जो रिपो (repo) एका H100 वर पाच-एपिसोड डेमो डेटासेट (five-episode demo dataset) आणि 2000 स्टेप्ससह (steps) डॉक्युमेंट करतो.

आकार हे सिग्नल आहे, निरपेक्ष मूल्ये नाहीत. त्रुटी हळूहळू कमी झाली पाहिजे जसे की जमा होतात. केवळ ट्रॅजेक्टरी 0 ऐवजी सर्व पाच प्रशिक्षण एपिसोड्सवर सरासरी काढल्यास, रेपोसच्या अंतिम चेकपॉईंटने अंदाजे 7.5 MSE आणि 1.5 MAE गुण मिळवले, त्यामुळे तुम्ही कोणत्या एपिसोड्सची सरासरी काढता यावर अवलंबून संदर्भ रन देखील वेगळा दिसतो. तुमच्या स्वतःच्या डेटामध्ये काहीही बदल करण्यापूर्वी, न बदललेल्या डेमो कमांडवर तुमची स्वतःची बेसलाइन रेकॉर्ड करा: जर तुम्ही ज्ञात-चांगली रन पुन्हा तयार करू शकत नसाल, तर तुम्ही सेटअपमधील चूक आणि डेटा समस्या यातील फरक ओळखू शकत नाही. रेपॉजिटरी सामान्य लक्षणांना कारणांशी देखील जोडते, आणि त्यापैकी प्रत्येक मॉडेलमधील बगऐवजी कार्यात्मक आहे.

दुसरा मार्ग: lerobot-train ऐवजी Isaac-GR00T

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 स्थानिक पातळीवर देखील चालतात. हळू पिक अँड प्लेससाठी रिमोट पॉड टिकू शकते. कोणत्याही प्रतिक्रियाशील गोष्टीसाठी ते शक्य नाही: धोरण अशा प्रकारे संकोच करते जे प्रशिक्षण अपयशासारखे दिसते पण ते नसते. प्रति ॲक्शन स्टेप 20 ms वर ACT हे सर्वात घट्ट लूप सहन करणारे मॉडेल आहे, 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 स्ट्रीम करतो.