SO-100 पर VLA नीति के साथ DAgger लूप चलाना

आपकी नीति चलती है। यह घन तक पहुंचती है, ग्रिपर को एक सेंटीमीटर बहुत जल्दी बंद कर देती है, और ऐसे चलती है मानो इसके पास यह हो। कोई त्रुटि नहीं होती है, और प्रशिक्षण हानि को देखने की कितनी भी कोशिश इसे समझा नहीं सकती। समाधान समान प्रदर्शनों पर 20,000 और gradient steps नहीं है। यह है आपके हाथ को आर्म पर ठीक उसी जगह वापस रखना जहां यह गलत हो जाता है, रिकॉर्ड करना कि आपने इसके बजाय क्या किया, और अगली चेकपॉइंट को पुराने डेटा के साथ प्लस उस सुधार पर प्रशिक्षित करना। यह एक DAgger राउंड है, और यह है कि एक SO-100 पर vision-language-action नीति के साथ कैसे चलता है।

सिद्धांत कहीं और है: डेटासेट एकत्रीकरण बिल्कुल क्यों काम करता है और मानव gating इसके बारे में क्या बदलता है। यह operating manual है, और यह एक प्रशिक्षित चेकपॉइंट, एक कार्यशील कैमरा सेट, और एक आर्म मानता है जो चलता है। नीचे दिए गए छह चरण लूप हैं जैसे कि implemented इस प्लेटफॉर्म के DAgger पृष्ठ पर, लेकिन अनुक्रम आपकी अपनी scripts से समान है।

दूसरा राउंड सिर्फ अधिक डेटा क्यों नहीं है

Behavior cloning उन states पर प्रशिक्षित करता है जो एक मानव ने दौरा किया। परीक्षण time पर नीति वह states दौरा करती है जो यह causes करता है, और छोटी action errors compounds हो जाती हैं states में कि कोई demonstration covered नहीं किया। Ross, Gordon और Bagnell ने उस failure को AISTATS 2011 के लिए formalized किया और एक iterative algorithm के साथ इसका उत्तर दिया जो एक stationary deterministic policy को प्रशिक्षित करता है और, उनके reduction के तहत, state distribution के तहत अच्छी तरह perform करना है जो यह induces: current policy चलाएं, expert को states को label करने दें जो यह actually reached करता है, उन्हें dataset में add करें, retrain करें, repeat करें। Kelly et al. ने query को HG-DAgger के साथ practical बनाया, जहां मानव decide करता है कि कब control लें instead of states को बिना controls held किए label करने के; वे simulated और real autonomous driving task पर DAgger और behavior cloning दोनों पर improved performance रिपोर्ट करते हैं। Human gating वह है जो एक desk arm पर loop को tolerable बनाता है - आप अपने हाथों को केवल तब move करते हैं जब कुछ गलत हो रहा हो।

दो परिणाम सिद्धांत की तुलना में व्यावहारिक में अधिक matter करते हैं। Corrections ordinary demonstrations नहीं हैं: वे Mandlekar et al. द्वारा describe किए गए bottleneck regions पर concentrate होते हैं, जहां एक छोटा deviation policy को states में drop कर देता है कि demonstrations कभी covered नहीं किए। और एक dataset जो केवल उन hard parts से बना हो एक badly shaped dataset है - Belkhale, Cui और Sadigh argue करते हैं data side से कि state diversity हमेशा beneficial नहीं है, और कि action divergence और transition diversity together dataset quality decide करते हैं। Mixed dataset एक compromise नहीं है, यह वह point है।

Round one से पहले ये freeze करें

एक DAgger राउंड एक नीति की एक दूसरे के साथ समय के साथ तुलना करता है। कुछ भी जो आप rounds के बीच change करते हैं जो dataset नहीं है वह तुलना को meaningless बनाता है।

• कैमरा positions और mounts, wrist camera included। एक clamp loosen करें और आपने observation distribution change किया है, नीति नहीं।
• Exposure और white balance, यदि आपका capture stack उन्हें pin करने देता है। Auto-exposure drifting rounds के बीच एक slow, invisible domain shift है।
• Arm calibration और servo zero positions। यदि आपको recalibrate करना चाहिए, तो इसे recorded करने से पहले सब कुछ एक separate dataset के रूप में treat करें।
• Task text। हर VLA यहां इसे condition करता है; rewording करना mid-loop एक different task है।
• Lighting, table surface, object set। एक new object एक new experiment है, अगली round नहीं।
• Recording frame rate। Comparing करना intervention rates को दो sampling rasters के अंतर्गत उन differences को produce करता है जो raster से आते हैं।

Round, end to end

1. 1
   Inference चलाएं और इसे record करें

   Checkpoint के विरुद्ध run शुरू करें जिसे आप improve करना चाहते हैं, फिर recording को inference root में शुरू करें। इस तरीके से Recorded इसे run का अपना task text inherit करते हैं, जो कि नीति को trained किया गया था, instead default teleoperation label के बजाय। Recording के बिना आप failure को watch कर सकते हैं लेकिन इसे train नहीं कर सकते।

   bash

   # two calls, not one: the run, then its recording
   POST /inference/start      # model_id, and hf_repo_id = the checkpoint to drive
   POST /recording/start      # root=inference
   # root=inference also makes the recording inherit the run's task text

2. 2
   जब यह गलत हो तो अधिग्रहण करें

   Take over दबाएं और input mode choose करें: leader arm, keyboard या sliders। Runner pause करता है, आप correct करते हैं, आप hand back करते हैं। Frames जो recorded होती हैं जब आप driving कर रहे थे automatic रूप से interventions के रूप में flagged होती हैं।

   bash

   POST /inference/takeover/start   # input = leader | keyboard | sliders
   POST /inference/takeover/nudge   # keyboard, relative delta per call
   POST /inference/takeover/set     # sliders, absolute target
   POST /inference/takeover/stop    # back to the policy

3. 3
   Episodes को triage करें

   Decide करें प्रति episode: file करें correction के रूप में, evaluation के रूप में रखें, या discard करें। एक run जो policy ने बिना help के complete किया evaluation data है।

4. 4
   Correction dataset को sync करें

   Corrections collect होते हैं एक local dataset में प्रति policy और automatic sync के through cloud storage को। कुछ भी mixed नहीं है जो आपने वहां नहीं रखा।

5. 5
   Mixed dataset को compose करें

   Original dataset को corrections के साथ combine करें, explicitly choosing episodes प्रति source। Result एक ordinary dataset है उस point से आगे।

   bash

   POST /training/datasets/compose
     sources  = [ original_dataset, korrekturen_<policy> ]
     episodes = explicit selection per source

6. 6
   Checkpoint से प्रशिक्षण जारी रखें

   Mix को previous checkpoint से rather base model के बजाय train करें। Note करें कि कौन सी checkpoint और कौन सा mix; उस pair के बिना round reproducible नहीं है।

   bash

   # field on the training job
   base_checkpoint = s3://ay-robots/checkpoints/<run>/<checkpoint>
   # the platform passes it to the training pod as BASE_CKPT_S3

Step 2 विस्तार में: अधिग्रहण के दो तरीके

एक लीडर आर्म के साथ

में leader-follower mode takeover एक handover है दो arms के बीच जो एक ही pose में नहीं हैं। Take over को press करना runner को pause करता है और leader को follower के current pose पर drive करता है, तो कुछ नहीं jump होता जब torque transfer करता है। यदि वह alignment drive timeout करता है, तो आप leader को hand से align करते हैं और केवल release करते हैं एक बार दोनों five degrees के within होते हैं। उस point से आप normally teleoperate करते हैं और action column जो आपने command किया record करता है।

इस path के बारे में honest रहें: alignment drive और torque handover loop का least tested part हैं real hardware पर। Handover को test करें एक slow, harmless pose पर before आप इस पर rely करते हैं run में जो आप care करते हैं। एक leader arm तीनों modes में smoothest corrections produce करता है, और भी सबसे अधिक है जो mechanically गलत हो सकता है।

एक लीडर आर्म के बिना: कीबोर्ड और स्लाइडर

अधिकतर लोग जो यह पढ़ते हैं एक arm own करते हैं। यह enough है। Keyboard या slider input choose करें जब आप Take over को press करते हैं, और takeover immediate और manual है - दूसरा arm align करने के लिए नहीं है, तो कोई alignment step नहीं है। Follower अपने pose को hold करता है और input के लिए wait करता है।

Clamps को server-side से enforce किया जाता है, interface में नहीं, क्योंकि एक mistyped delta एक bus-servo arm पर एक collision है। Keyboard corrections stepwise और slightly coarse आते हैं; slider corrections smoother हैं, क्योंकि server target की ओर walk करता है जबकि interface stream करता रहता है। Either way action column complete commanded pose vector को receive करता है और intervention marking leader path के identical है, तो keyboard corrections dataset में land करते हैं बिना एक format difference के।

Q / A   joint 1      R / F   joint 4
W / S   joint 2      T / G   joint 5
E / D   joint 3      Z / X   gripper

जब button को press करें

जल्दी rather late। एक correction जो शुरू होता है gripper के बाद बंद हो जाता है nothing पर failure से recover सिखाता है कि नीति को नहीं enter करना चाहिए था, और recovery data उस avoidance data से far less worth है। Interrupt करें पहले moment पर जब आप confident होते हैं trajectory गलत है, correct करें difficult part के through, hand back करें जैसे ही state एक है कि नीति ने before handle किया। ThriftyDAgger उस decision को automate करता है novelty गेटिंग interventions को और estimated risk को fixed human budget के तहत, लेकिन एक single arm पर एक human already watching के साथ, human gate cheaper है और better calibrated है कि कुछ भी आप tune करेंगे।

Step 3 विस्तार में: triage quality decide करता है

Run के बाद आपके पास एक recording है कुछ frames marked के साथ interventions के रूप में। तीन destinations exist करते हैं, और गलत एक quietly अगली round को poison करता है।

• File करें correction के रूप में जब intervention एक genuine fix था: policy कहीं गलत था जा रहा था और आपकी input दिखाया सही चीज़ को एक state से कि policy itself produce किया।
• Keep करें evaluation के लिए clean autonomous runs के लिए और runs के लिए जो आप caution से out take करते हैं। Evaluation episodes कैसे आप measure करते हैं next checkpoint, और वे कभी नहीं trained होने चाहिए।
• Discard करें runs ruined कुछ unrelated से - एक dropped camera frame, एक stalled servo, एक object जो आपने knocked over किया। एक messy correction कोई correction से worse है।

Step 5 विस्तार में: mix को compose करना

Composition original dataset लेता है plus correction dataset और produce करता है एक new, ordinary LeRobot dataset जो किसी अन्य की तरह train करता है। Important property यह है कि episode selection explicit है per source - कुछ नहीं blended automatically है। यह minor सुनता है जब तक first time एक policy strangely behave नहीं करता और आपको reconstruct करना होता क्या यह trained था।

Open question ratio है, और कोई भी संख्या नहीं है जो transfer करता है। साहित्य जो agree करता है वह यह है कि corrections करना चाहिए count के लिए more than their frame share। Mandlekar et al. iteratively retrain करते हैं data पर कि उनका intervention system collect करता है, तो policy learns traverse bottlenecks को, और report करते हैं कि agents trained उस तरीके outperform agents trained non-interventional demonstrators से equivalent number of samples पर। Sirius further जाता है और re-weights करता है training samples approximated human trust द्वारा, reporting एक 8 percent gain simulation में और 27 percent real hardware पर policy success rate में methods के विरुद्ध यह compare करता है, converged speed के दो गुना पर। कोई भी training entry points यहां expose नहीं करते एक sample-weighting knob को, तो crude substitute है हर correction episode को keep करना जबकि subsample करना original demonstrations - और write करना down क्या आपने किया।

Step 6 विस्तार में: क्या continuing from a checkpoint really means करता है

Training mix base model से करना काम करता है लेकिन throws away previous round और cost करता है एक full run। Continuing previous से checkpoint faster है और usually better। यह भी अधिक है limited than phrase suggest करता है।

Latency compounds अंदर एक DAgger loop में तरीके यह does नहीं during एक demo: roughly 485 ms प्रति action step पर आप take over करते हैं क्योंकि arm hesitated, नहीं क्योंकि यह गलत था, और hesitation corrections useful नहीं हैं training data। यदि आप iterating हैं data पर rather chasing एक final success rate, iterate करें एक fast model पर। Shukor et al. describe करते हैं SmolVLA को designed करते हुए train करने के लिए एक single GPU पर और deploy करने के लिए consumer GPUs या CPUs पर, एक asynchronous inference stack के साथ जो action prediction को execution से decouple करता है allow करने के लिए higher control rates - property जो एक takeover loop को responsive रखता है।

Dataset formats interchangeable नहीं हैं either। GR00T लेता है LeRobot v2.0 या v2.1, और Isaac-GR00T repository describe करता है इसकी input को एक flavour के रूप में LeRobot v2 format की एक added modality description file के साथ; newer trainers expect करते हैं v3.0। एक mix composed wrong version में fail करता है load time rather producing एक bad policy पर - better failure mode, still एक wasted queue slot। dataset documentation lists करता है कौन सा format each trainer लेता है।

Round को waste करने के चार तरीके

1. Corrections अकेले पर प्रशिक्षण

सबसे common failure और सबसे tempting shortcut। एक correction-only dataset लगभग पूरी तरह से task का difficult middle है, approach और retreat missing के साथ; policy better हो जाती है hard part पर और forget करती है कैसे वहां arrive करें। Aggregation एक implementation detail नहीं है method का, यह mechanism है: old data जो है hold करता है बाकी behavior को जगह पर जबकि corrections move करते हैं एक हिस्सा।

2. राउंड के बीच कैमरा को moving

एक कैमरा जो shift करता है दो centimetres rounds के बीच produce करता है एक policy worse करता है जो आपने शुरू किया, और एक diagnosis जो cost करता है एक day। हर VLA यहां condition करता है images पर; joint state अकेले disambiguate नहीं करता है object कहां है। Photograph करें setup को first round से पहले और check करें वह photograph को हर बाद वाले से।

3. Handover artefacts को training में letting

ऊपर से covered, और list पर क्योंकि यह invisible है। Symptom एक policy है जो stall करती है एक fraction second के previous round के जहां operator take over किया। यह hesitation जैसा दिखता है; यह imitation है।

4. Warm start को एक resume कह रहा है

यदि आप believe करते हैं optimizer state carried over, initial loss spike read होता है एक bug के रूप में और आप hunt करते हैं corrupted data के लिए। यदि आप जानते हैं optimizer fresh started, spike expected है और आप look करते हैं यह क्या आता है after। Same numbers, opposite conclusions।

Round को measure करना

Metric एक human-gated loop के लिए intervention rate है: frames recorded जब आप control में थे, divided total frames के द्वारा run का। यह है takeover status में, और यह केवल संख्या है जो answer करती है question कि round ने पूछा। Training loss fall करती है whether या नहीं नीति improved; success rate binary है और noisy sample sizes पर एक desk arm produce करता है। Intervention rate continuous है, measured on states जो policy itself caused करता है, और drop करता है नीति जैसे जैसे आपको कम need करती है।

Compare करें यह केवल across runs recorded identical conditions के तहत। Full argument, और कैसे build करें एक evaluation set जो survive करता है दो से अधिक rounds, है article on measuring a DAgger loop में। Round one realistically एक feasibility test है: आप checking हैं कि takeover काम करता है आपके hardware पर, कि corrections land करते हैं उनके flags के साथ, और कि continued run load किया checkpoint जो आपने named किया। Rounds दो और तीन जहां rate should शुरू move करना है। यदि यह नहीं move किया है round चार तक, problem upstream है DAgger का।

यदि आपके पास अभी तक एक checkpoint नहीं है

Loop के पास कोई entry point नहीं है बिना एक के। Record करें एक first dataset, train एक first policy, run करें - recording, training और policy चलाना उस path को cover करते हैं। Recording client है on download page, GPU tiers और hourly rates पर pricing page, और एक usable episode क्या दिखता है SO-100 data collection guide में। Get करें demonstrations को right करें corrections से पहले: DAgger एक repair mechanism है, और यह काम करता है far better एक ऐसा कुछ जो nearly right पहले से था।

कोई भी यह solved problem नहीं है और कोई भी एक click नहीं है। Interactive imitation learning एक active research area है precisely क्योंकि इसके questions - कब intervene करें, कैसे weight करें जो मानव ने किया, कितना old data रखें - कोई settled answers नहीं हैं; survey Celemin et al. द्वारा maps करता है क्या still open है। जो loop करता है उसके पास measurable convergence है जब यह run किया जाता है carefully, hardware पर जो cost करता है कुछ सौ euros। Freeze करें setup को, intervene करें early, triage करें honestly, mix करें deliberately, और record करें intervention rate हर बार।