మీ స్వంత SO-100 డేటాసెట్‌పై GR00T N1.7కి ఎలా శిక్షణ ఇవ్వాలి

NVIDIA మీరు బహుశా కలిగి ఉన్న ఆర్మ్ కోసం ఖచ్చితమైన ఫైన్-ట్యూనింగ్ ఉదాహరణను అందిస్తుంది. లోపల ఐజాక్-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 ఆరు-డిగ్రీ-ఆఫ్-ఫ్రీడమ్ హాబీ ఆర్మ్ కోసం మోడల్‌ను వ్రాసిన వ్యక్తులచే నిర్వహించబడుతుంది. ఇది స్కేల్ డౌన్ చేయబడిన హ్యూమనాయిడ్ డెమో కాదు, ఇది అదే ఆర్మ్.

చెడు వార్త ఏమిటంటే, మధ్య దూరం నేను 60 ఎపిసోడ్‌లను రికార్డ్ చేసాను మరియు ఆర్మ్ పనిని చేస్తుంది. ఈ పైప్‌లైన్ బిగ్గరగా కాకుండా నిశ్శబ్దంగా విఫలమయ్యే ఆరు ప్రదేశాలు ఉన్నాయి, మరియు వాటిలో నాలుగు చాలా మంది ఎప్పుడూ తెరవని ఫైల్‌లలో ఉంటాయి: meta/modality.json, పైథాన్ డేటా కాన్ఫిగరేషన్, meta/relative_stats.json, మరియు డేటాసెట్ యొక్క స్వంత వెర్షన్ స్ట్రింగ్. ఈ గైడ్ నిజమైన ఆదేశాలతో మాన్యువల్ మార్గాన్ని ఎండ్-టు-ఎండ్ నడుపుతుంది, ఆపై అదే పనిని ఫారమ్‌గా చూపిస్తుంది AY-Robots. కింద ఉన్నవన్నీ 20 ఆగస్టు 2026 నాటికి (n1.7-రిలీజ్ లైన్) ఐజాక్-GR00T మెయిన్ బ్రాంచ్ మరియు 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లో టెన్సార్‌ఆర్‌టి ఇంజిన్. అదే కార్డ్‌లో ప్లెయిన్ పైటార్చ్ 85.8 ms, మరియు మోడల్ కార్డ్ అంతరాన్ని 3.08x వద్ద ఉంచుతుంది. ఈ సంఖ్యలలో సర్వింగ్ లేయర్, రెండవ కెమెరా లేదా నెట్‌వర్క్ హాప్ ఏదీ చేర్చబడలేదు. AY-రోబోట్స్ దాని అందించిన 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 యొక్క సలహా ఏమిటంటే, ప్రతి వస్తువు స్థానానికి సుమారు 10 చొప్పున కనీసం 50 ఎపిసోడ్‌లను రికార్డ్ చేయాలి, కెమెరాలను స్థిరంగా ఉంచాలి మరియు పట్టుకునే ప్రవర్తనను స్థిరంగా ఉంచాలి. ప్రారంభంలో కాకుండా తర్వాత వైవిధ్యాన్ని జోడించండి. గుర్తుంచుకోవలసిన సాధారణ నియమం: మీరు కెమెరా చిత్రాల నుండి మాత్రమే పనిని చేయలేకపోతే, పాలసీ కూడా చేయలేదు. ఆర్మ్-నిర్దిష్ట సెటప్ కోసం, 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 దాని స్వంత పైప్రాజెక్ట్‌ను కలిగి ఉంది, ఇది పైథాన్ 3.10 లేదా 3.11ని అడుగుతుంది మరియు లెరోబోట్‌ను ఒక గిట్ కమిట్‌కు పిన్ చేస్తుంది, అయితే ఐజాక్-GR00Tకి పైథాన్ 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 రిపోజిటరీని దీనికి తరలించింది మరియు పైథాన్ 3.12కి. పాత కాండా ప్లస్ pip install -e . మార్గం READMEలోని కుదించబడిన విభాగంలో ఇప్పటికీ ఉంది, అయితే ఫ్లాష్-అటెన్షన్ మరియు టెన్సర్‌ఆర్‌టితో సహా GPU డిపెండెన్సీలకు మాన్యువల్ ఇన్‌స్టాలేషన్ అవసరం కావచ్చని ఇది హెచ్చరిస్తుంది. మీకు ప్రత్యేక కారణం లేకపోతే uvని ఉపయోగించండి. ఫ్లాష్-అటెన్షన్ విషయంలో, ఒక వివరాలు గందరగోళాన్ని నివారిస్తాయి: మీరు చూస్తారు 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 డిపెండెన్సీలను లాగుతుంది. కొత్త 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
   హగ్గింగ్ ఫేస్‌కు వ్యతిరేకంగా ప్రామాణీకరించండి

   మొదటి శిక్షణ ప్రారంభానికి ముందు దీన్ని చేయండి, ఎనిమిది నిమిషాల తర్వాత అది విఫలమైన తర్వాత కాదు.

   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, మరియు ఆ డేటాక్లాస్‌లో సీడ్ ఫీల్డ్ లేదు. నాన్-డిటర్మినిస్టిక్ ఇమేజ్ ఆగ్మెంటేషన్ కారణంగా రన్‌ల మధ్య 5 నుండి 6 శాతం వ్యత్యాసం ఉంటుందని README విడిగా పేర్కొంది. ఒకే ఫ్లాగ్‌లతో కూడిన రెండు రన్‌లు ఒకే చెక్‌పాయింట్‌లను ఉత్పత్తి చేయవు, ఇది హైపర్‌పారామీటర్ మార్పు సహాయపడిందా లేదా మీరు అదృష్టవంతులయ్యారా అని నిర్ణయించడానికి ప్రయత్నిస్తున్నప్పుడు చాలా ముఖ్యం. పోలిక కోసం, 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లో గంటకు 0.30 నుండి 0.60 USD మరియు రన్‌కు 1 నుండి 3 USD చొప్పున 24 GB కార్డ్‌లో జరుగుతుంది. అదే నిజమైన ట్రేడ్-ఆఫ్: GR00T ప్రతి ప్రయత్నానికి సుమారు నాలుగు రెట్లు ఎక్కువ ఖర్చవుతుంది, మరియు మీరు దానిని మీ డెస్క్ కింద ఉన్న 4090లో అమలు చేయలేరు.

50-ఎపిసోడ్ కనీసం ఒక ఫ్లోర్, లక్ష్యం కాదు. NVIDIA యొక్క FAQ మరింత డిమాండ్ చేస్తుంది: సాధారణ స్థిర-స్థాన పిక్ అండ్ ప్లేస్ కోసం సుమారు 100 ట్రాజెక్టరీలు, సంక్లిష్ట లేదా బహుళ-దశల దృశ్యాల కోసం 500 లేదా అంతకంటే ఎక్కువ, మరియు సూక్ష్మ మానిప్యులేషన్ కోసం 100 నుండి 500. మీరు 20 ఎపిసోడ్‌ల వద్ద ఉంటే, సాయంత్రం ట్యూనింగ్ చేయడానికి బదులు మధ్యాహ్నం రికార్డింగ్ చేయండి. డేటా సేకరణ గైడ్ ఉపయోగకరమైన ఎపిసోడ్‌ను వృధా అయిన దాని నుండి వేరు చేసే వాటిని వివరిస్తుంది, మీ మొదటి డేటాసెట్‌ను రికార్డ్ చేయండి అనేది చిన్న వెర్షన్, మరియు SO-100 డేటా సేకరణ అనేది ఆర్మ్-నిర్దిష్టమైనది.

Step 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ని ప్రచురించడానికి ఉద్దేశ్యపూర్వకంగా నిరాకరిస్తుంది, మరియు అది సరైన నిర్ణయం: ఈ సంఖ్య మీ యాక్షన్ యూనిట్లు, మీ పని మరియు మీ డేటాసెట్ పరిమాణంపై ఆధారపడి ఉంటుంది, కాబట్టి మరొకరి చేయి నుండి కాపీ చేయబడిన థ్రెషోల్డ్ అర్థరహితం. ముఖ్యమైనది ట్రెండ్. ఐదు-ఎపిసోడ్ డెమో డేటాసెట్ మరియు 2000 దశలతో ఒకే H100లో రిపోజిటరీ డాక్యుమెంట్ చేసిన రిఫరెన్స్ రన్ ఇక్కడ ఉంది.

ఆకారం సంకేతం, సంపూర్ణ విలువలు కాదు. లోపం స్థిరంగా తగ్గాలి, పేరుకుపోతున్న కొద్దీ. ట్రాజెక్టరీ 0 మాత్రమే కాకుండా, ఐదు శిక్షణ ఎపిసోడ్‌లన్నింటిలో సగటున, రెపో యొక్క చివరి చెక్‌పాయింట్ సుమారుగా 7.5 MSE మరియు 1.5 MAE స్కోర్ చేసింది, కాబట్టి మీరు ఏ ఎపిసోడ్‌లను సగటున తీసుకుంటారనే దానిపై ఆధారపడి రిఫరెన్స్ రన్ కూడా భిన్నంగా ఉంటుంది. మీ స్వంత డేటా గురించి ఏదైనా మార్చడానికి ముందు సవరించని డెమో కమాండ్‌లో మీ స్వంత బేస్‌లైన్‌ను రికార్డ్ చేయండి: మీకు తెలిసిన-మంచి రన్‌ను పునరుత్పత్తి చేయలేకపోతే, మీరు సెటప్ పొరపాటును డేటా సమస్య నుండి వేరు చేయలేరు. రిపోజిటరీ సాధారణ లక్షణాలను కారణాలకు కూడా మ్యాప్ చేస్తుంది, మరియు వాటిలో ప్రతి ఒక్కటి మోడల్ బగ్ కాకుండా కార్యాచరణకు సంబంధించినది.

మరొక మార్గం: Isaac-GR00T బదులుగా lerobot-train

ప్రస్తుత LeRobot విడుదల, 2026 ఆగస్టు 3 నుండి 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ని పిన్ చేయాలి, ఇది దానికి మద్దతు ఇచ్చే చివరి విడుదల, 2026 ఏప్రిల్ 7న ప్రచురించబడింది.

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ని ప్రసారం చేస్తుంది.