2026లో మీరు ఏ VLA పాలసీని శిక్షణ ఇవ్వాలి?

ఈరోజు SO-100 క్లాస్ ఆర్మ్‌లో ఐదు పాలసీలను శిక్షణ ఇవ్వవచ్చు. అవి ఇన్‌ఫరెన్స్‌లో 24 రెట్లు తేడాను కలిగి ఉంటాయి లేటెన్సీ, పారామీటర్ కౌంట్‌లో 37, ఒక రన్ ఖర్చులో 12 రెట్లు తేడాను కలిగి ఉంటాయి, మరియు మీరు ఫలితాన్ని షిప్ చేయవచ్చా లేదా అనే దానిలో కూడా తేడా ఉంటుంది. ఐదు మోడల్ కార్డ్‌లు దీన్ని పరిష్కరించవు: మీకు ఉన్న ప్రశ్నకి ఏదీ సమాధానం ఇవ్వదు, నేను ముందుగా దేన్ని అమలు చేయాలి?

దిగువన ఉన్న ప్రతి సంఖ్య ఆగస్టు 2026లో పేపర్‌లు, రెపోలు మరియు కార్డ్‌ల నుండి చదవబడింది. ప్లాట్‌ఫారమ్ సంఖ్యలు నుండి వస్తాయి AY-Robots పాలసీ కేటలాగ్; ఇక్కడ రెండు విరుద్ధంగా ఉంటే, రెండూ చూపబడతాయి.

నిర్ణయ పట్టిక

ఐదుగురు అభ్యర్థులు

అన్నీ ఐదు విధానాలు: కెమెరా ఫ్రేమ్‌లు, జాయింట్ స్థానాలు మరియు, వాటిలో నాలుగుంటికి, భవిష్యత్ జాయింట్ లక్ష్యాల భాగానికి మ్యాప్ చేయబడిన భాషా సూచన. వాటిని వేరు చేసేది ఎంత మీరు రాకముందే నేర్చుకున్నారు.

GR00T N1.7

NVIDIA యొక్క ప్రస్తుత విజన్-లాంగ్వేజ్-యాక్షన్ మోడల్, సుమారు 3 బి పారామీటర్లు, సుమారు 40 మిలియన్లు శిక్షణ పొందింది ఫైన్-ట్యూనింగ్ సమయంలో. N1.6 నుండి వచ్చిన డెల్టాలను రెపో జాబితా చేస్తుంది: వెండర్డ్ ఈగిల్ మోడల్ నుండి క్వెన్3-VL లో కాస్మోస్-రీజన్2-2బికి బ్యాక్‌బోన్, డిఫ్యూజన్ లేయర్‌లు 32 నుండి 16కి, స్టేట్ మరియు యాక్షన్ డైమెన్షన్‌లు 29 నుండి 132కి, యాక్షన్ హారిజన్ 16 నుండి 40కి.

చిన్న ఆర్మ్‌పై ముఖ్యమైనది సాపేక్ష ఎండ్-ఎఫెక్టర్ యాక్షన్ స్పేస్: N1.7 డెల్టాలను అంచనా వేస్తుంది ప్రస్తుత భంగిమ నుండి, ఇది 20K గంటల ఈగోస్కేల్ మానవ వీడియోను రోబోట్ పాలసీలోకి బదిలీ చేయడానికి అనుమతిస్తుంది. స్పెసిఫికేషన్ N1.7 పేజీలో, విధానం N1.7 ఆన్ SO-100 గైడ్‌లో.

GR00T N1.5

అదే 3 B స్కేల్, ఈగిల్ 2 బ్యాక్‌బోన్, సిగ్‌లిప్2 మరియు T5, ఫ్లో-మ్యాచింగ్ డిఐటి హెడ్. ఇది మీరు ఇప్పటికే కలిగి ఉన్న ఒక ను విస్తరించడానికి ఉంది. ఇది డిఫాల్ట్‌గా ఉండటానికి రెండు కారణాలు: వెయిట్స్ NVIDIA's one-way non-commercial licence, మరియు ప్రస్తుత LeRobot విడుదలలు N1.5 మద్దతును తొలగించాయి. చూడండి .

Pi0.5

ఫిజికల్ ఇంటెలిజెన్స్ యొక్క VLA, పాలసీ రకం pi05. ఈ పత్రం పాలిగెమ్మా నుండి ప్రారంభించబడిన 2 B VLM మరియు 300 M యాక్షన్ ఎక్స్‌పర్ట్‌ను అందిస్తుంది, ఇది రోబోట్‌ను 50 Hz వద్ద నడుపుతుంది; LeRobot's pi05 config డిఫాల్ట్‌గా 50-స్టెప్ చంక్‌కు, ఆ రేటు వద్ద ఒక సెకనుకు సెట్ చేయబడింది. దీని ప్రధాన ఆకర్షణ అపరిచిత ప్రదేశాలు: నిజమైన ఇళ్లలో సుమారు 400 గంటల మొబైల్ మానిప్యులేషన్, మరియు 3, 12, 22, 53, 82 మరియు 104 ప్రదేశాలపై స్కేలింగ్ అధ్యయనం, ఇక్కడ 104-ప్రదేశాల మోడల్ టెస్ట్ ఇళ్లలోనే శిక్షణ పొందిన నియంత్రణతో సరిపోలింది.

ఒక పరిమితి, దీనిపై పేర్కొనబడింది lerobot/pi05_base కార్డ్: పోర్ట్ కేవలం ఫ్లో-మ్యాచింగ్ యాక్షన్ హెడ్‌ను మాత్రమే కలిగి ఉంటుంది. సబ్‌టాస్క్ ప్రిడిక్షన్, యాక్షన్ టోకెనైజేషన్ మరియు RL అప్‌స్ట్రీమ్‌లో విడుదల చేయబడలేదు, మరియు ఓపెన్‌పి దాని స్వంత రిపోజిటరీ గురించి కూడా అదే చెబుతుంది. Pi0.5 పేజీ మరియు SO-100 గైడ్‌పై Pi0.5 మిగిలిన వాటిని కలిగి ఉన్నాయి.

SmolVLA

450 M పారామీటర్లు, యాక్షన్ ఎక్స్‌పర్ట్‌లో సుమారు 100 M, SmolVLM-2లో VLM ఫ్రోజెన్ చేయబడి మరియు దాని మొదటి 16 లాంగ్వేజ్-మోడల్ లేయర్‌లు మాత్రమే ఉపయోగించబడ్డాయి. ప్రీట్రైనింగ్ కమ్యూనిటీ డేటా: 481 డేటాసెట్‌లు, 10.6 M ఫ్రేమ్‌లు, మీరు ఉపయోగించే అదే చౌకైన ఆర్మ్స్ నుండి. ఇక్కడ ఒక 24 GB కార్డ్‌కు సరిపోయే ఏకైక VLA, మరియు ఏకైక 30 ఎపిసోడ్ ఫ్లోర్. చూడండి SmolVLA పేజీ.

ACT

ఇది ఫౌండేషన్ మోడల్ కాదు. ALOHA నుండి వచ్చిన యాక్షన్ చంకింగ్ ట్రాన్స్‌ఫార్మర్ సుమారు 80 M పారామీటర్‌లను కలిగి ఉంటుంది, ఇది ప్రతి పనికి సున్నా నుండి, 50 Hz వద్ద 50 ప్రదర్శనలపై శిక్షణ పొందింది. ఈ పత్రం సుమారు పది నిమిషాల ప్రదర్శనల నుండి ఆరు నిజమైన బైమాన్యువల్ పనులను నివేదిస్తుంది, ప్రతి పనికి, ఇది హైలైట్ చేసే ఉదాహరణలలో 80 నుండి 90 శాతం వరకు విజయం సాధించింది. దీని ఆలోచన, యాక్షన్ చంకింగ్, ఈ పేజీలోని ప్రతి మోడల్‌లో ఉంది, మరియు దాని అబ్లేషన్ ఇప్పటికీ కొలుస్తుంది ప్రభావాన్ని ఉత్తమంగా: టెంపోరల్ ఎన్సెంబ్లింగ్ ఆఫ్ చేయబడిన రెండు సిమ్యులేటెడ్ పనులలో, k=1 వద్ద 1 శాతం నుండి k=100 వద్ద 44 శాతం వరకు. ACT పేజీ మిగిలిన వాటిని కలిగి ఉంది.

బెంచ్‌మార్క్‌లు వాస్తవానికి ఏమి చెబుతున్నాయి

LIBERO అనేది ఈ ఐదుంటిలో మూడు నివేదించే ఒక బెంచ్‌మార్క్: సిమ్యులేటెడ్ ఫ్రాంకా పాండాపై భాషా-నియంత్రిత పనులు, ప్రతి పది పనులతో క్రింద ఉన్న నాలుగు సూట్‌లుగా విభజించబడ్డాయి. NVIDIA ప్రతి సూట్‌కు 200 ట్రయల్స్ నిర్వహించింది.

SimplerEnv విస్తరణను చూపుతుంది, LIBERO చూపదు. NVIDIA N1.7ని N1.6తో పోలుస్తుంది, ఇది "తరాల డెల్టా"కి దగ్గరగా ఉన్న పబ్లిక్ విషయం.

బ్రిడ్జ్ వరుస ఉపయోగకరమైనది: సగటున 5.7 పాయింట్లు సాధించింది, అయితే put_eggplant_in_basket 36 కోల్పోయింది మరియు put_eggplant_in_sink 33 నుండి 2కి పడిపోయింది. ఒక కొత్త తరం పంపిణీని పైకి లేపడం కంటే కదిలిస్తుంది, కాబట్టి మీ పని N1.7 వెనుకబడిన చోట ఉంటే, సగటు ఏమీ చెప్పదు.

ఐదింటిలో, SmolVLA పేపర్ మాత్రమే SO-100 క్లాస్ ఆర్మ్ గురించి నివేదిస్తుంది: మూడు పనులలో SmolVLAకి 78.3 శాతం మరియు Pi0కి 61.7 శాతం, రెండూ మల్టీ-టాస్క్, ACT శిక్షణ పొందిన సింగిల్-టాస్క్‌కు 48.3 శాతంతో పోలిస్తే, ఇది సరిపోలడం లేదు. స్పష్టమైన జత SO-101 పిక్-అండ్-ప్లేస్‌లో రెండూ సింగిల్-టాస్క్: పంపిణీలో 70కి 90, దాని వెలుపల 40కి 50. పోల్చండి ACT వర్సెస్ SmolVLA మరియు Pi0.5 వర్సెస్ SmolVLA, లేదా బ్రౌజ్ చేయండి అరేనా.

లేటెన్సీ మరియు ఖర్చు విస్తరణను నిర్ణయిస్తాయి

ఇన్‌ఫరెన్స్ లేటెన్సీ అనేది ప్రజలు చివరిగా కనుగొనే మరియు మొదట చింతించే పరిమితి. బెంచ్‌మార్క్‌లో ఐదు పాయింట్లు మెరుగైన పాలసీ, కానీ ప్రతి చర్యకు అర సెకను ఎక్కువ సమయం తీసుకుంటే మీ డెస్క్‌పై అది అధ్వాన్నంగా కనిపిస్తుంది: కాంటాక్ట్ డైనమిక్స్ వేచి ఉండవు.

ఒక హెచ్చరిక: GR00T ఫిగర్ NVIDIA కార్డ్‌తో విభేదిస్తుంది, ఇది 4 డెనాయిసింగ్ దశలను మరియు ఒక కెమెరాను H100లో ఈగర్ మోడ్‌లో 85.8 ms, torch.compileతో 48.6 ms, పూర్తి TensorRT ద్వారా 27.9 ms వద్ద సమయం చేస్తుంది. ఇక్కడ 152 ms అనేది సర్వింగ్ ఓవర్‌హెడ్ మరియు ఒకటి కంటే ఎక్కువ కెమెరాలతో కూడిన మొత్తం-స్టాక్ ఫిగర్, ఫార్వర్డ్ పాస్ కాదు.

మోడల్‌ను మార్చకుండా సమయాన్ని ఆదా చేయడానికి ఒక మార్గం: SmolVLA పేపర్ సింక్రోనస్ ఎగ్జిక్యూషన్‌ను కొలుస్తుంది, ఇక్కడ పాలసీ తదుపరిదాన్ని అంచనా వేయడానికి ముందు ఒక భాగాన్ని పూర్తి చేస్తుంది, అసమకాలికంగా, ఇక్కడ అంచనా ఎగ్జిక్యూషన్‌తో అతివ్యాప్తి చెందుతుంది. విజయం సమానంగా ఉంటుంది, 78.3కి వ్యతిరేకంగా 73.3, కానీ అదే పికప్-అండ్-ప్లేస్ 13.75 బదులుగా 9.7 సెకన్లు పడుతుంది, మరియు ఒక నిర్ణీత విండోలో రోబోట్ 9 బదులుగా 19 సైకిళ్లను నిర్వహిస్తుంది.

లైసెన్స్‌లు, ఎందుకంటే ఎవరూ వాటిని తనిఖీ చేయరు

Pi0.5 వరుసకు శ్రద్ధ అవసరం. LeRobot pi05 డాక్యుమెంటేషన్ openpiకి అనుగుణంగా Apache 2.0 అని పేర్కొంటుంది, అయితే హబ్ కార్డ్ lerobot/pi05_base కలిగి ఉంది license: gemma. రెండూ సజీవంగా ఉన్నాయి. GR00T N1.7కి తేలికపాటి వెర్షన్ ఉంది: Isaac-GR00T README N1.7 Apache 2.0 కింద పూర్తిగా వాణిజ్యపరంగా లైసెన్స్ చేయదగినదని ప్రస్తావించింది, అయితే దాని స్వంత లైసెన్స్ విభాగం మరియు మోడల్ కార్డ్ కోడ్‌ను మాత్రమే Apache 2.0 కింద మరియు వెయిట్స్‌ను NVIDIA కింద ఉంచాయి Open Model License.

మీరు వాస్తవంగా అమలు చేసే డిఫాల్ట్‌లు

ప్రతి ట్రైనర్ ఫారమ్ ఒక డిఫాల్ట్‌తో వస్తుంది, మరియు అవి ఏకపక్షమైనవి కావు. ACTలు LeRobot యొక్క సొంతం: బ్యాచ్ 8, lr 1e-5, 100000 శిక్షణ దశలు, చంక్ సైజు 100, ACTConfig అప్‌స్ట్రీమ్‌కు సరిపోలుతుంది మరియు k=100 from the ACT paper. క్రింద ఉన్న ఒక కాలమ్ ఒక ఉచ్చు.

మోడల్ ఎంపిక కంటే ముఖ్యమైన నాబ్

ఇది యాక్షన్ చంక్. పొడవైన చంక్‌లు సున్నితమైన కదలికను మరియు తక్కువ సమ్మేళన లోపాలను అందిస్తాయి, కానీ బ్లాక్ అమలులో ఉన్నప్పుడు పాలసీ కట్టుబడి ఉంటుంది, కాబట్టి కదిలే దేనికైనా ఆలస్యంగా స్పందిస్తుంది: స్థిరమైన క్యూబ్‌పై నమ్మకంగా ఉంటుంది, కదిలే దానిపై నిస్సహాయంగా ఉంటుంది. అది అతిగా వెళితే, అమలు చేయబడిన భాగాన్ని తగ్గించడం తిరిగి శిక్షణ ఇవ్వడం కంటే మెరుగు మరియు ఉచితం. మధ్యలో ఆగిపోయే జాయింట్ ఒక విభిన్న సమస్య; చూడండి .

• ACT: ACTConfig defaults to chunk_size 100 and n_action_steps 100. Temporal ensembling is off and requires n_action_steps 1.
• GR00T N1.7: internal horizon went 16 to 40, yet LeRobot's SO-101 example still runs --policy.chunk_size=16 --policy.n_action_steps=16. The rollout flag was renamed to --execution-horizon.
• Pi0.5: a 50-step chunk, of which LeRobot's LIBERO recipe executes 10 via --policy.n_action_steps=10; with --policy.pretrained_path it falls back to 50 if you omit the flag.
• SmolVLA: 50-action chunks, both knobs exposed.

ఒక మధ్యాహ్నంలో ఐదుంటినీ ఎలా స్క్రీన్ చేయాలి

చౌకైన సమాధానం ఎక్కువ చదవడం కాదు. సుమారు 15 USD ఖర్చు చేసి, చేయి మీకు చెప్పనివ్వండి: ఒకసారి రికార్డ్ చేయండి, ముందుగా చౌకైన మోడల్‌కు శిక్షణ ఇవ్వండి, డేటా సరైనదని నిరూపించబడిన తర్వాత పెంచండి. నిర్మాణం పరిమాణం కంటే మెరుగు, మరియు .

1. 1
   ఒకసారి 50 ఎపిసోడ్‌లను రికార్డ్ చేయండి

   GR00T, Pi0.5 మరియు ACT, అలాగే SmolVLA యొక్క 30 కోసం యాభై అంతస్తును క్లియర్ చేస్తుంది. ప్రతి వైవిధ్యాన్ని విస్తరించకుండా పునరావృతం చేయండి: 5 క్యూబ్ స్థానాల్లో 50 ఎపిసోడ్‌లు శిక్షణ పొందాయి, 25 శిక్షణ పొందలేదు. మీ మొదటి డేటాసెట్‌ను రికార్డ్ చేయండి చూడండి.

   bash

   lerobot-record \
     --robot.type=so100_follower \
     --robot.port=/dev/ttyACM1 \
     --robot.id=my_follower_arm \
     --teleop.type=so100_leader \
     --teleop.port=/dev/ttyACM0 \
     --teleop.id=my_leader_arm \
     --dataset.repo_id=${HF_USER}/pick-place-50 \
     --dataset.num_episodes=50 \
     --dataset.single_task="Put the lego brick into the box"

2. 2
   ముందుగా ACTకి శిక్షణ ఇవ్వండి, ఎందుకంటే అది మీకు అబద్ధం చెప్పదు

   ముందుగా శిక్షణ పొందిన వెయిట్‌లు లేవు, కాబట్టి ఇది పనిని చేస్తే, మీ డేటాసెట్ ఆ పనిని కలిగి ఉంటుంది. ACT ఫ్లాట్‌లైన్ అయితే, డేటాను సరిచేయండి. 24 GB కార్డ్‌లో 1 నుండి 3 USD, 2 నుండి 5 గంటలు.

   bash

   lerobot-train \
     --dataset.repo_id=${HF_USER}/pick-place-50 \
     --policy.type=act \
     --policy.device=cuda \
     --batch_size=8 \
     --steps=100000 \
     --seed=1000 \
     --output_dir=outputs/train/act_pickplace \
     --job_name=act_pickplace

3. 3
   అదే డేటాసెట్‌లో SmolVLAని మార్చకుండా అమలు చేయండి

   అదే డేటా, అదే ఆర్మ్, 80 M పారామీటర్లకు బదులుగా 450 M పారామీటర్లు, అదనంగా భాషా కండిషనింగ్. LeRobot ఒక A100లో సుమారు 4 గంటల పాటు 20K స్టెప్ రన్‌ను అమలు చేస్తుంది. ప్రీట్రైనింగ్ ఏదైనా ప్రయోజనం చేకూరుస్తుందో లేదో ఇది మీకు తెలియజేస్తుంది.

   bash

   lerobot-train \
     --policy.path=lerobot/smolvla_base \
     --dataset.repo_id=${HF_USER}/pick-place-50 \
     --batch_size=64 \
     --steps=20000 \
     --policy.device=cuda \
     --output_dir=outputs/train/smolvla_pickplace \
     --job_name=smolvla_pickplace

4. 4
   GR00Tని ఉపయోగించే ముందు v2.1కి మార్చండి

   GR00T LeRobot v2 ఫార్మాట్ యొక్క ఒక రకాన్ని, అదనంగా meta/modality.json అనే అదనపు ఫైల్‌ను చదువుతుంది, ఇది కనెక్ట్ చేయబడిన స్టేట్ మరియు యాక్షన్ శ్రేణులు పేరున్న ఫీల్డ్‌లుగా ఎలా విభజించబడతాయో మ్యాప్ చేస్తుంది. v3.0 డేటాసెట్ ఆ లోడర్‌ను క్రాష్ చేస్తుంది, ఎందుకంటే v3.0 అనేక ఎపిసోడ్‌లను భాగస్వామ్య ఫైల్‌లలో ప్యాక్ చేస్తుంది, అయితే v2 ప్రతి ఎపిసోడ్‌కు ఒకదాన్ని వ్రాసింది. Isaac-GR00T డౌన్‌గ్రేడ్ హెల్పర్‌ను scripts/lerobot_conversion/convert_v3_to_v2.pyగా అందిస్తుంది; v3 తిరస్కరణ పేజీ వేగవంతమైన మార్గం.

   text

   # GR00T expects this layout, not the v3.0 file-based one
   my_dataset/
     meta/
       info.json
       episodes.jsonl      # episode index and lengths
       tasks.jsonl         # language task descriptions
       modality.json       # GR00T-specific: state/action/video key mapping
     data/chunk-000/       # parquet, state and action per timestep
     videos/chunk-000/     # one mp4 per episode

5. 5
   మొదటి రెండు ఏదైనా మిగిల్చి ఉంటే మాత్రమే GR00T N1.7కి వెళ్ళండి

   ఇక్కడ చూపిన NVIDIA యొక్క CLI ద్వారా, లేదా LeRobot యొక్క groot పాలసీ రకం ద్వారా. NVIDIA ఫైన్-ట్యూనింగ్ కోసం 40 GB లేదా అంతకంటే ఎక్కువ VRAMని, ఇన్ఫరెన్స్ కోసం 16 GBని సిఫార్సు చేస్తుంది. OOM విషయంలో, OOM పేజీని చూడండి.

   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

ఆ స్క్రీనింగ్ పాస్‌ను అమలు చేయడానికి రెండు మార్గాలు

# 1. LeRobot: ACT, SmolVLA, Pi0.5 and GR00T N1.7 via --policy.type=groot
pip install "lerobot[smolvla]"
pip install "lerobot[pi]"
pip install "lerobot[groot]"

# 2. GR00T reference implementation and benchmark examples
git clone https://github.com/NVIDIA/Isaac-GR00T

# 3. Physical Intelligence reference implementation
git clone --recurse-submodules https://github.com/Physical-Intelligence/openpi

ఫౌండేషన్ మోడల్ లేదా మొదటి నుండి

ఏ 3B మోడల్‌ను ఎంచుకోవాలనేది అసలు సమస్య కాదు. అసలు ప్రీట్రైన్డ్ VLAని ఉపయోగించాలా వద్దా అనేది అసలు సమస్య, ఎందుకంటే ACT ఆరు నిజమైన బైమాన్యువల్ పనులను ఒక్కొక్కటి సుమారు పది నిమిషాల డెమాన్‌స్ట్రేషన్‌ల నుండి నేర్చుకుంది, 80 M పారామీటర్‌లతో మరియు ఏదీ ప్రీట్రైన్ చేయబడలేదు.

పాత రన్‌ను పునరుత్పత్తి చేసే సందర్భం

2025 చెక్‌పాయింట్‌ను వెంబడించడం మీకు మోడల్ ఎంపికను చేస్తుంది మరియు సమస్యను వెర్షన్ పిన్నింగ్‌గా మారుస్తుంది: ప్రస్తుత LeRobot N1.5ని తిరస్కరిస్తుంది, కాబట్టి మీరు పిన్ చేయండి lerobot==0.5.1. సీడ్ ఫీల్డ్ లేకుండా మరియు రన్‌ల మధ్య 5 నుండి 6 శాతం వ్యత్యాసంతో, పునరుత్పత్తి నిర్మాణం ద్వారా సుమారుగా ఉంటుంది. మరియు ప్లాట్‌ఫారమ్ వైపు ఉన్నాయి.

రెండుకు చేరిందా? ACT వర్సెస్ GR00T N1.7 మరియు GR00T N1.7 వర్సెస్ SmolVLA. ముడి వరుసలు అరేనా ఎంట్రీలలో ఉన్నాయి: GR00T N1.7, Pi0.5, SmolVLA మరియు ACT.

ఈ ప్లాట్‌ఫారమ్ మీకు ఎక్కడ సహాయం చేయదు

• ఇది రిమోట్ ఇన్‌ఫరెన్స్‌ను వేగవంతం చేయదు. 20 నుండి 485 ms లూప్ మోడల్‌కు చెందినది; ఇంటర్నెట్ రౌండ్ ట్రిప్‌లు దీనికి అదనంగా ఉంటాయి.
• ఇది మీ స్వంత హార్డ్‌వేర్‌లో GR00T లేదా Pi0.5ని ఫైన్-ట్యూన్ చేయదు. ఇక్కడ రెండూ క్లౌడ్-మాత్రమే; SmolVLA మరియు ACT మాత్రమే స్థానికంగా నడుస్తాయి.
• ఇది డేటాసెట్‌ను పరిష్కరించదు. నష్టం తగ్గుతుంది కానీ పాలసీ ఏమీ చేయదు అనేది డేటా సమస్య, ఒక సెటప్‌లో మాత్రమే పనిచేసే పాలసీ అనేది కవరేజ్ సమస్య.
• ఇది GR00T రన్‌లను పునరుత్పత్తి చేయదు: అప్‌స్ట్రీమ్ కాన్ఫిగ్‌లో సీడ్ ఫీల్డ్ లేదు.

ఒకదాన్ని ఎంచుకుని ముందుకు సాగడం

ఒక డిఫాల్ట్: 50 ఎపిసోడ్‌లను రికార్డ్ చేయండి, డేటాసెట్‌ను నిరూపించడానికి ACTని 1 నుండి 3 USDకి శిక్షణ ఇవ్వండి, ఆపై SmolVLAని అదే డేటాపై ఉపయోగించండి. మొత్తం 6 USD కంటే తక్కువ, మరియు అవి ముఖ్యమైన ప్రశ్నకు సమాధానం ఇస్తాయి: ఇక్కడ ప్రీట్రైనింగ్ సహాయపడుతుందా, లేదా బాటిల్‌నెక్ డేటానేనా. కాంటాక్ట్-రిచ్ మల్టీ-స్టెప్ టాస్క్‌ల కోసం GR00T N1.7కి, సీన్ మారినప్పుడు Pi0.5కి పెంచండి.

ప్లాట్‌ఫారమ్ వాక్‌త్రూ: మీ మొదటి పాలసీకి శిక్షణ ఇవ్వండి, ఆపై మీ మొదటి పాలసీని అమలు చేయండి. శిక్షణ డాక్యుమెంట్లు మరియు డేటాసెట్ డాక్యుమెంట్లు ఫారం మరియు ఫార్మాట్‌ను కవర్ చేస్తాయి; SO-100 పేజీ మరియు పూర్తి SO-100 గైడ్ బిల్డ్ మరియు కాలిబ్రేషన్‌ను కవర్ చేస్తాయి. నేపథ్యం: VLA అవలోకనం మరియు Pi0 ఫ్లో-మ్యాచింగ్ ఆర్టికల్. మీ విజయ రేటును పెంచేది డేటా నాణ్యత గైడ్.