डीएजर समझाया: व्यवहार क्लोनिंग कैसे विचलित होता है और डेटासेट एकत्रीकरण वास्तव में क्या सिद्ध करता है

एक विशेष विफलता है जिससे हर कोई जो एक हेरफेर नीति को प्रशिक्षित करता है वह जल्दी या बाद में मिलता है। नीति घन के लिए पहुंचती है, दो सेंटीमीटर के भीतर आती है, हिचकिचाती है, बग़ल में विचलित होती है, फिर कार्य से असंबंधित कुछ करती है। सत्यापन loss ठीक था। आयोजित-बाहर एपिसोड के विरुद्ध open-loop प्रजनन ठीक था। और फिर भी आर्म एक ऐसी मुद्रा में समाप्त होता है जो प्रशिक्षण डेटा में कहीं नहीं दिखाई देती है, और वहाँ से इसके पास कहने के लिए कुछ समझदारी नहीं है।

उस विफलता का एक नाम है और इसके पीछे एक स्थिर सिद्धांत है। यह डीएजर पर चार लेख में से पहला है, और यह तर्क स्वयं को कवर करता है: क्यों प्रदर्शनकारी के अपने प्रक्षेपवक्र पर एक नीति को फिट करना एक त्रुटि पैदा करता है जो एपिसोड length के वर्ग के साथ बढ़ सकती है, डेटासेट एकत्रीकरण क्या बदलता है, और कोई-पश्चाताप प्रमाण क्या नहीं वचन देता है। real hardware पर डीएजर loop चलाने को SO-100 पर एक डीएजर loop चलाना में कवर किया गया है, मानव-gated variant को एचजी-डीएजर और मानव-gated हस्तक्षेप में, और माप प्रश्न को एक डीएजर loop को मापना में।

व्यवहार क्लोनिंग चुपचाप मानती है

एक demonstration dataset एक pile है observation-action pairs की। Behavior cloning इस pile पर एक function को ordinary supervised learning के साथ फिट करता है और वहीं बंद हो जाता है। यह field में सबसे पुरानी विचार है। Pomerleau का ALVINN, 1988 में, एक three-layer back-propagation network था जो camera और laser range finder से images लेता था और direction पैदा करता था जो vehicle को travel करना चाहिए; यह simulated road images पर प्रशिक्षित किया गया था और कुछ field conditions में real roads का अनुसरण किया। Recipe ज्यादा नहीं बदली है; networks बदले हैं।

जो छोड़ा जाता है वह यह check है कि ये pairs कहाँ से आते हैं। उनमें से हर एक एक trajectory पर lie करता है जो demonstrator produced किया। Policy जो आप deploy करते हैं अपने खुद के produce करता है। जैसे ही यह deviate करता है, यह उन states के बारे में queried है जो training distribution में नहीं थे, और इसका answer इसे आगे out ले जाता है। Ross, Gordon और Bagnell डीएजर paper को बिल्कुल इससे खोलते हैं: sequential prediction i.i.d. assumption को violate करता है underlying statistical learning के, क्योंकि learner के स्वयं के predictions निर्धारित करते हैं कि inputs यह अगला कौन से देखता है।

उस paper में सबसे स्पष्ट illustration बिल्कुल robot नहीं है। Cloning एक near-optimal planner को Super Mario Bros के लिए एक policy produced की जो repeatedly एक obstacle के विरुद्ध फंस गई बजाय इसे jump करने के। Reason संपूर्ण argument है एक sentence में: expert हमेशा एक comfortable distance से jumped, तो dataset में कोई state नहीं था जिसमें Mario एक obstacle के विरुद्ध pressed up था, और इसलिए कोई label नहीं था क्या करना है एक बार वह था।

Mario को एक SO-100 arm के लिए swap करें और structure बिल्कुल समान है। आपके demonstrations एक clean approach और clean grasp दिखाते हैं, gripper closing से नहीं दो centimetres short - तो policy के पास कोई विचार नहीं है वहाँ से क्या करना है, और जो भी यह guesses इसे आगे out ले जाता है। Covariate shift एक property है डेटा संग्रह procedure का, network architecture का नहीं।

जहाँ द्विघातीय पद से आता है

2010 AISTATS paper Ross और Bagnell द्वारा, Efficient Reductions for Imitation Learning, compounding को precise बनाता है। T को task horizon बनें, task cost को unit interval में bounded बनें, और epsilon को surrogate loss बनें measured under expert's state distribution - number आपका validation set reports। फिर उस policy को T steps के लिए चलाने की extra cost, relative to expert, T squared times epsilon से bounded है। Ross, Gordon और Bagnell इसे Theorem 2.1 के रूप में डीएजर paper में restate करते हैं और sentence add करते हैं जो मायने रखता है: bound tight है। Problems exist करती हैं जहाँ एक policy जिसके पास epsilon loss है expert's distribution पर वास्तव में extra cost incur करता है जो T में quadratically बढ़ता है।

Tight मतलब typical नहीं है। Quadratic term एक worst case है over एक class of problems, नहीं एक prediction आपके pick-and-place task के लिए। What it establishes है कि more expert demonstration remove नहीं कर सकता है problem: यह केवल sharpen करता है estimate epsilon की एक distribution पर policy को tested नहीं किया जाएगा।

Escape route same paper में है, restated Theorem 2.2 के रूप में। अगर एक policy achieves loss epsilon under its own state distribution, और single wrong action costs most u में cost-to-go में under expert, extra cost bounded है u times T times epsilon द्वारा - linear in horizon। Constant u interesting quantity है: most 1 for 0-1 disagreement with expert, और O(1) जब भी expert कुछ steps में recover कर सकता है। Worst case में यह O(T) है, और linear bound फिर quadratic one से बेहतर नहीं है।

दो attempts जो आए थे डीएजर से पहले

Forward training honest लेकिन impractical answer है। Train separate policy हर timestep के लिए, in order, हर एक पर state distribution induced by policies पहले से ही fixed for earlier steps, तो हर policy देखता है exactly distribution यह face करेगा। Catch description में है: T policies, trained sequentially, no early stopping। Manipulation एपिसोड के लिए 30 frames per second पर, T hundreds में है।

SMILe, same paper से, और SEARN, Daume, Langford और Marcu के work से structured prediction पर, दूसरा route लेते हैं: एक stationary policy, लेकिन stochastic। हर iteration एक component train करता है और इसे mixture में add करता है, shifting probability mass away from expert। Result एक mixture है जिसमें कुछ components दूसरों से बदतर हैं - physical arm पर, एक controller जो bad component को mid-motion में sample कर सकता है। That stated motivation है wanting करने के लिए एक stationary deterministic policy इसके बजाय।

डीएजर: एक idea, एक box

Dataset Aggregation deterministic policy को keep करता है और fix को data collection में moves करता है। हर round: current policy को roll out करें, states record करें यह visits, expert पूछें क्या correct action होता आपके पास हर एक में, उन pairs को dataset add करें आपके पास पहले से, union पर retrain करें। Name algorithm है - आप aggregate करते हैं, आप कभी discard नहीं करते।

D            <- {}                      # the aggregate dataset
pi_hat_1     <- any policy in Pi

for i = 1 .. N:
    pi_i  = beta_i * expert  +  (1 - beta_i) * pi_hat_i
    roll out pi_i for T steps, record every visited state s
    D_i   = { (s, expert(s))  for every visited state s }
    D     = D  union  D_i               # aggregate, do not replace
    pi_hat_{i+1} = train on all of D

return the best pi_hat_i on a validation set

तीन details बहुत अधिक weight carry करते हैं वह कैसे दिखते हैं से। Labels mixed policy द्वारा visited states के लिए हैं, लेकिन actions expert से आते हैं - policy questions provide करती है, expert answers। Retraining पूरे aggregate पर है, जो हर round को Follow-The-Leader step बनाता है: round n पर आप pick करते हैं सर्वश्रेष्ठ policy hindsight में over हर trajectory so far। That framing है क्या proof hangs पर। और algorithm sequence से सर्वश्रेष्ठ policy को return करके end करता है chosen on एक validation set, क्योंकि theorems guarantee करते हैं कि some policy sequence में अच्छी है, अंतिम एक नहीं।

बीटा अनुसूची, और क्यों यह एक tuning knob नहीं है

Mixed policy beta_i times expert प्लस एक minus beta_i times learner है। Point practical है: पहले कुछ learned policies बहुत कम data पर trained हैं, make कई mistakes, और अन्यथा rollout में spend करेंगे states जो irrelevant बन जाते हैं एक बार policy improves।

Theory exactly एक condition impose करता है: running average of betas को zero जाना चाहिए। Analysis काम करता है beta_i bounded के साथ (1 - alpha) को power i-1, एक constant alpha के लिए independent of T।

Gap 2980 और 3030 के बीच एक scale पर running to roughly 4300 छोटा है, लेकिन paper की explanation यह सबसे useful practical note है section में। Parameter-free schedule के साथ, Mario same spot में early stuck हो गया और mass of near-duplicate data generate किया उस एक location से; letting expert drive fraction of time दोनों unstuck किया उसे और widened variety of states। Schedule mixing ratio के बारे में कम है की तुलना में कि क्या आपके data collection नए states produce करना रखता है या same failure।

Guarantee: एक reduction no-regret online learning को

यहाँ move है जो करता है paper को क्या है। Treat हर डीएजर round को एक example online learning problem में, जहाँ loss at round i surrogate loss है under state distribution of policy used at round i। Learner commits एक policy को before seeing उस loss, और sequence non-stationary है क्योंकि यह depend करता है policies पर produced so far।

एक algorithm no-regret है अगर its average loss over N rounds approaches कि सर्वश्रेष्ठ single policy का hindsight में। Follow-The-Leader on strongly convex losses ऐसी एक algorithm है, with average regret shrinking order of 1/N - और retraining पूरे aggregate पर precisely Follow-The-Leader है। Any other no-regret learner serve करेगा well: analysis एक reduction है, एक property नहीं एक optimiser का।

एक lemma gap को bridge करता है mixed policy के बीच जो collected data और learned policy जो will be deployed: Lemma 4.1 bounds L1 distance उनके state distributions के बीच by 2 T beta_i। यह क्यों है betas decay करने चाहिए - जब expert अभी भी appreciable control authority hold करता है, states आप collect करते हैं वह नहीं हैं states आपकी policy produce करेगी। Combine lemma को regret bound के साथ और main result follows: roughly T iterations के बाद, कुछ policy sequence में surrogate loss है under its own distribution within O(1/T) of epsilon_N। Feed उस को linear bound में और आप land करते हैं Theorem 3.2 पर।

Empirical side modest है by current standards। Super Tux Kart में supervised baseline अपनी average falls improve नहीं किया per lap as more data arrived, डीएजर reached एक policy जो कभी fell नहीं track से after fifteen iterations, और SMILe after twenty still fell roughly twice per lap। None of these एक manipulation result है।

क्या proof नहीं promise करता

Theorem statements conditional हैं, और conditions load-bearing हैं।

एक further result अक्सर quoted है एक refutation के रूप में और नहीं है एक। Rajaraman, Yang, Jiao और Ramachandran study minimax limits of imitation learning in episodic MDPs with finite state space S और horizon H, और prove suboptimality lower bound on order of |S| H squared over N जो holds even जब learner may actively query expert at visited states। That एक worst-case rate है over एक class of MDPs at fixed episode budget, और क्या rules out है idea कि interaction improves minimax rate; डीएजर का theorem एक different statement है, bounding deployed policy को relative to क्या its own policy class achieve कर सकता है।

Swamy, Choudhury, Bagnell और Wu later classified ये algorithms by कौन से moments expert's behaviour के वह match करते हैं, और introduced notion of moment recoverability जो delineates कैसे well हर family compounding error को mitigates। Surveys by Osa और by Celemin cover algorithmic landscape और human-feedback interfaces।

Bill: labelling states expert कभी नहीं produced

हर thing उपरोक्त assumes एक expert जो query किया जा सकता है anywhere। Simulation में एक planner के साथ जो nearly free है - Mario experiments used एक near-optimal planner with full access to game state। With एक human on एक robot यह dominant cost है, और peculiar एक: human को produce करना पड़ता है एक correct action में एक configuration जिसका own competence कभी नहीं बनाया है।

Kelly, Sidrane, Driggs-Campbell और Kochenderfer state objection directly HG-डीएजर paper में। Vanilla डीएजर requires expert supply करने को action labels जबकि fully in control नहीं हो रहा system का। यह reduces safety, और with human experts यह likely है degrade करने को quality of collected labels, जो वह put down करते हैं to perceived actuator lag। Label आप get back करते हैं नहीं है label algorithm assumed।

Laskey और colleagues attack problem को other side से with DART, और उनकी framing blunt है: on-policy techniques tedious हैं human supervisors के लिए, add computational burden, और may visit dangerous states during training। उनके alternative injects calibrated noise into supervisor के own demonstrations, तो recovery gets demonstrated without robot कभी running एक untrusted policy। MuJoCo Humanoid पर वह report करते हैं DART decreasing supervisor का cumulative reward by 5 percent during training, जबकि डीएजर executes policies with 80 percent less cumulative reward than supervisor; grasping in clutter में एक Toyota HSR के साथ, average 62 percent increase over behavior cloning।

Zhang और Cho के SafeDAgger treats queries को reference policy को as scarce resource: एक separate safety policy predicts, without querying, क्या primary policy about है to deviate from reference beyond threshold, और only उन states handed over हैं। सभी तीन react करते हैं same fact को - डीएजर analysis charges कुछ नहीं expert labels के लिए, और reality charges बहुत।

क्या यह मतलब है एक SO-100 के लिए आपकी desk पर

Translate horizon को अपने own units में। एक twenty-second episode at 30 frames per second है 600 decision steps, और T हर bound में above है कि number। At T = 600, difference एक term scaling के बीच T और एक scaling with T squared है difference एक policy के बीच जो recover करता है एक bad approach से और एक जो नहीं करता।

यह part है क्यों action chunking helps: जब एक policy emits एक short sequence actions per inference step का, number decision points drops, और तो does number chances to compound। Zhao, Kumar, Levine और Finn name compounding error as motivation for Action Chunking with Transformers, और report 80 से 90 percent success on six difficult real-world tasks, on low-cost bimanual hardware, from ten minutes worth of demonstrations। Chunking remove नहीं करता covariate shift - states still हैं policy's own - लेकिन shortens effective horizon। देखें action chunking और SO-100 अनुकरण सीखने guide।

दूसरा translation है progress metric। आप measure नहीं कर सकते epsilon under policy's own distribution directly - जो needs है ground-truth expert actions हर visited state के लिए, thing आप हैं trying करने करना avoid producing। क्या एक human-gated loop आपको देता है instead है intervention rate: fraction frames में एक run के दौरान जिसमें human had taken over। यह proxy है, और यह moves for reasons unrelated to policy - एक patient operator intervenes कम। Used consistently, यह one number है जो says क्या एक round था worth afternoon।

एक तीसरा translation है एक data-quality warning analysis cover नहीं करता। Mandlekar और colleagues studied छह offline learning algorithms on पाँच simulated and तीन real-world multi-stage manipulation tasks, और report sensitivity to algorithmic design choices, dependence on quality of demonstrations, और variability caused by stopping criterion। Belkhale, Cui और Sadigh argue कि dataset quality should be formalized through action divergence और transition diversity, और note कि state diversity हमेशा beneficial नहीं है। एक डीएजर round adds states nobody chose deliberately: कुछ हैं recovery data आपको need, कुछ हैं robot flailing जबकि आप fumble करते हैं takeover control के लिए।

Mechanically एक round है छह steps: run inference with recording on, take over जब policy misbehaves, review run और file हर episode, sync corrections, compose mixed dataset से originals plus corrections with episode selection made explicitly per source, और continue training से previous checkpoint राथर base model से। ay-robots पर those steps exist as buttons, जो removes plumbing लेकिन नहीं judgement। दो caveats: continuing from checkpoint initializes weights और नहीं है एक optimizer resume, और leader-arm alignment move still है lightly tested on hardware। देखें training और datasets।

Family tree, एक table में

अक्सर पूछे जाने वाले प्रश्न

यहाँ कहाँ जाएँ से

अगर आपने train नहीं किया एक policy अभी, यह theory है premature: record एक dataset पहले, शुरुआत से अपनी first policy training करना और desktop client। अगर आप weighing हैं एक और सौ clean demonstrations के विरुद्ध शुरुआत करना corrections: clean demonstrations नहीं करते fix distribution problem। Mechanics के लिए, continue करें human-gated variant और फिर SO-100 walkthrough।