"अनुभव फिर से खेलना" क्या है और इसके लाभ क्या हैं?

मैं Google का दीपमिन्द अटारी पेपर पढ़ रहा हूँ और मैं "अनुभव फिर से खेलना" की अवधारणा को समझने की कोशिश कर रहा हूँ। अनुभव फिर से खेलना कई अन्य सुदृढीकरण सीखने के कागजात (विशेषकर, अल्फा गो पेपर) में आता है, इसलिए मैं समझना चाहता हूं कि यह कैसे काम करता है। नीचे कुछ अंश दिए गए हैं।

सबसे पहले, हमने एक जैविक रूप से प्रेरित तंत्र कहा जाता है जो अनुभव रिप्ले को डेटा पर यादृच्छिक बनाता है, जिससे अवलोकन अनुक्रम में सहसंबंधों को दूर किया जाता है और डेटा वितरण में परिवर्तन पर चौरसाई होती है।

फिर कागज इस प्रकार है:

जबकि सुदृढीकरण सीखने की सेटिंग में तंत्रिका नेटवर्क के प्रशिक्षण के लिए अन्य स्थिर तरीके मौजूद हैं, जैसे कि तंत्रिका फिट क्यू-पुनरावृत्ति, इन विधियों में पुनरावृत्तियों के नेटवर्क डे नोवो सैकड़ों पुनरावृत्तियों का प्रशिक्षण शामिल है । नतीजतन, हमारे एल्गोरिथ्म के विपरीत, ये विधियां बड़े तंत्रिका नेटवर्क के साथ सफलतापूर्वक उपयोग करने के लिए बहुत अक्षम हैं। हम अंजीर में दिखाए गए गहरे तंत्रिका नेटवर्क का उपयोग करते हुए अनुमानित मान फ़ंक्शन का करते हैं, जिसमें पर - , Q- नेटवर्क के पैरामीटर (यानी, भार) हैं । अनुभव पुनरावृत्ति करने के लिए, हम एजेंट के अनुभवों को प्रत्येक समय-चरण करते हैं $Q(s, a; \theta_i)$ $\theta_i$ $i$ $e_t = (s_t, a_t, r_t, s_{t+1})$ $t$ डेटा सेट में । सीखने के दौरान, हम अनुभव नमूनों (या मिनी-बैचों) पर क्यू-लर्निंग अपडेट लागू करते हैं, संग्रहीत नमूनों के पूल से यादृच्छिक रूप से समान रूप से खींचा जाता है। Q- अधिगम अद्यतन पुनरावृत्ति निम्नलिखित हानि फ़ंक्शन का उपयोग करता है: $D_t = \{e_1, \dots, e_t \}$ $(s, a, r, s') \sim U(D)$ $i$

${एल}_{मैं} (θ_{मैं}) = इ_{(रों, ए, आर, {रों}^{'}) ~ यू (डी)} [{(आर + γ \underset{ए^{'}}{अधिकतम} क्यू ({रों}^{'}, ए^{'}; θ_{मैं}^{-}) - क्यू (रों, ए; θ_{मैं}))}^{2}]$ $L_i(\theta_i) = \mathbb{E}_{(s, a, r, s') \sim U(D)} \left[ \left(r + \gamma \max_{a'} Q(s', a'; \theta_i^-) - Q(s, a; \theta_i)\right)^2 \right]$

अनुभव पुनरावृत्ति क्या है, और इसके फायदे, आम आदमी की शर्तों में क्या हैं?

reinforcement-learning q-learning

— रेयान ज़ोटी
स्रोत

जवाबों:

उद्धृत पाठ का मुख्य भाग है:

अनुभव पुनरावृत्ति करने के लिए हम एजेंट के अनुभवों को $e_t = (s_t,a_t,r_t,s_{t+1})$

इसका मतलब राज्य / एक्शन जोड़े पर क्यू-लर्निंग चलाने के बजाय जैसा कि वे सिमुलेशन या वास्तविक अनुभव के दौरान होते हैं, सिस्टम [राज्य, कार्रवाई, इनाम, next_state] के लिए खोजे गए डेटा को संग्रहीत करता है - आमतौर पर एक बड़ी तालिका में। ध्यान दें कि यह संबद्ध मानों को संग्रहीत नहीं करता है - यह बाद में कार्रवाई-मूल्य गणना में खिलाने के लिए कच्चा डेटा है।

सीखने का चरण तब तार्किक रूप से अनुभव प्राप्त करने से अलग होता है, और इस तालिका से यादृच्छिक नमूने लेने के आधार पर। आप अभी भी दो प्रक्रियाओं - अभिनय और सीखने को बीच में लाना चाहते हैं - क्योंकि नीति में सुधार करने से विभिन्न व्यवहारों को बढ़ावा मिलेगा जो कि इष्टतम लोगों के करीब आने वाली क्रियाओं का पता लगाने चाहिए, और आप उन लोगों से सीखना चाहते हैं। हालाँकि, आप इसे इस तरह से विभाजित कर सकते हैं कि आप कैसे पसंद करते हैं - जैसे एक कदम उठाएं, तीन यादृच्छिक पूर्व चरणों से सीखें। अनुभव रिप्ले का उपयोग करते समय क्यू-लर्निंग लक्ष्य ऑनलाइन संस्करण के समान लक्ष्यों का उपयोग करते हैं, इसलिए इसके लिए कोई नया सूत्र नहीं है। जो नुकसान का फॉर्मूला दिया गया है, वह भी है जिसे आप डीपीएन के लिए बिना रीप्ले के इस्तेमाल करेंगे। अंतर केवल इतना है कि एस, ए, आर, एस ', एक' आप इसमें फ़ीड करते हैं।

DQN में, डीपमाइंड टीम ने भी दो नेटवर्क बनाए रखे और स्विच किया जो एक सीख रहा था और जो मौजूदा एक्शन-वैल्यू अनुमानों में "बूटस्ट्रैप" के रूप में खिला था। गैर-रेखीय फ़ंक्शन सन्निकटन का उपयोग करते समय एल्गोरिथ्म की स्थिरता के साथ यह मदद करता है। यही वह बार है जो - यह वज़न के वैकल्पिक जमे हुए संस्करण को दर्शाता है । ${\theta}^{\overline{\space}}_i$

अनुभव फिर से खेलना के लाभ:

कई बार इसके साथ सीखकर, पिछले अनुभव का अधिक कुशल उपयोग। यह महत्वपूर्ण है जब वास्तविक दुनिया का अनुभव प्राप्त करना महंगा है, तो आप इसका पूरा उपयोग कर सकते हैं। क्यू-लर्निंग अपडेट वृद्धिशील हैं और जल्दी से अभिसरण नहीं करते हैं, इसलिए एक ही डेटा के साथ कई पास फायदेमंद होते हैं, खासकर जब तत्काल परिणाम में कम विचरण होता है (इनाम, अगले राज्य) एक ही राज्य, कार्रवाई जोड़ी दी जाती है।
फंक्शन सन्निकटन का प्रशिक्षण देते समय बेहतर अभिसरण व्यवहार। आंशिक रूप से ऐसा इसलिए है क्योंकि डेटा अधिक है जैसे कि आईआईडी डेटा को सबसे अधिक पर्यवेक्षित शिक्षण अभिसरण प्रमाण में ग्रहण किया जाता है।

अनुभव पुनरावृत्ति का नुकसान:

मल्टी-स्टेप लर्निंग एल्गोरिदम, जैसे क्यू ( ) का उपयोग करना कठिन होता है , जिसे पूर्वाग्रह (बूटस्ट्रैपिंग के कारण) और विचरण (लंबे समय के परिणामों में देरी और यादृच्छिकता के कारण) के बीच संतुलन बनाकर बेहतर शिक्षण वक्र देने के लिए तैयार किया जा सकता है। )। एक्सपीरिएंस-रिप्ले DQN के साथ मल्टी-स्टेप DQN पेपर रेनबो में एक्सप्लोर किए गए एक्सटेंशन में से एक है : डीप रिनफोर्समेंट लर्निंग में कॉम्बिनेशन इम्प्रूवमेंट । $\lambda$

DQN में प्रयुक्त दृष्टिकोण को संक्षेप में डेविड सिल्वर द्वारा इस वीडियो लेक्चर के कुछ हिस्सों (लगभग 01:17:00 बजे, लेकिन इससे पहले के खंडों को देखने के लायक है) द्वारा रेखांकित किया गया है । मैं पूरी श्रृंखला देखने की सलाह देता हूं, जो सुदृढीकरण सीखने पर स्नातक स्तर का पाठ्यक्रम है, यदि आपके पास समय है।

— नील स्लेटर
स्रोत

मान लीजिए कि प्रशिक्षण के दौरान हम एक राज्य में हैं और हम एप्सिलॉन-लालची नीति के अनुसार कार्रवाई करते हैं और आप दूसरे राज्य में समाप्त होते हैं। तो आपको पुरस्कार मिलता है, और अगली अवस्था। यहां इनाम खेल का स्कोर हो सकता है और राज्य स्क्रीन में पिक्सेल पैटर्न हो सकते हैं। और फिर हम अपने फ़ंक्शन aproximator और उस मान के बीच त्रुटि लेते हैं जो हमें पहले से जमे हुए फ़ंक्शन सन्निकट का उपयोग करके लालची नीति से मिला है। लेकिन अनुभव पुनरावृत्ति के साथ जब सन्निकटन का अनुकूलन हम कुछ यादृच्छिक राज्य कार्रवाई डेटा सेट लेते हैं। क्या मैं सही हू ?

— शामे सिरिवर्धना

@ शमनसेरीवर्धन: हां मुझे लगता है कि आप सही हैं। यह वास्तविक प्रक्षेपवक्र से सटीक डेटा है, लेकिन केवल सबसे हालिया चरण से सीखने के बजाय, आप इसे एक बड़ी तालिका में सहेजते हैं और उस तालिका से नमूना (आमतौर पर कई नमूने, पिछले चरणों की एक दुकान के साथ चुनने के लिए) )। यदि आपको अधिक स्पष्टीकरण की आवश्यकता है, तो शायद साइट पर एक प्रश्न पूछें।

— नील स्लेटर

हाँ, मैं फिर से कागज के माध्यम से चला गया। यह भी कहता है कि इस पद्धति से ऑफ पॉलिसी लर्निंग में भी सुधार हो सकता है। क्योंकि क्यू में एप्सिलॉन-लालची नीति के अनुसार कार्य करना सीखना लेकिन लालची नीति के अनुसार मूल्यों को अद्यतन करना। इसलिए जब हर बार हमारे तंत्रिका शुद्ध मापदंडों को मिनी बैच आँकड़ों द्वारा अद्यतन किया जाता है जो कि अधिक महत्वपूर्ण रूप से सटीक समय कदम आँकड़ों से संबंधित नहीं होता है, लेकिन इससे पहले जो हुआ वह डेटा को असम्बद्ध करने में भी मदद करता है।

— शामे सिरीवर्धन

@ नील स्लेटर, मैं रेनबो पेपर के माध्यम से गया हूं और मैंने अनुभव रिप्ले और मल्टी-स्टेप विधि के संयोजन के लिए एक विशेष ट्रिक का उपयोग करने पर कोई विशेष टिप्पणी नहीं देखी है। यह भी मैंने सुना है कि मल्टी-स्टेप विधि मूल रूप से अनुभव रिप्ले के साथ संयोजन करना असंभव है लेकिन क्यों न केवल बेतरतीब ढंग से अनुभव रिप्ले से 1 के बजाय n-लगातार अनुभव लें, बल्कि रिप्ले से फिर से ताकि प्रत्येक एन-अनुभव के बीच कोई सहसंबंध न मिले? क्या यह मल्टी-स्टेप अनुभव रिप्ले नहीं है?

— एसटीएल

@NeilSlater "मल्टी-स्टेप लर्निंग एल्गोरिदम का उपयोग करना कठिन" क्यों है? आप क्या मतलब था?

— गुलजार

एल्गोरिथ्म (या कम से कम इसका एक संस्करण, जैसा कि कौरसेरा आरएल कैपस्टोन परियोजना में लागू किया गया है ) निम्नानुसार है:

अंतिम #buffer_sizeSARS (राज्य, कार्य, पुरस्कार, नया राज्य) अनुभवों को संग्रहित करने वाला रिप्ले "बफर" बनाएँ ।
अपने एजेंट को चलाएं, और इसे रिप्ले-बफर में अनुभवों को जमा करने दें जब तक कि यह (बफर) कम से कम #batch_sizeअनुभव न हो।
- $\hat{Q}(s,a ; \theta)$
एक बार जब यह पहुँच जाता है #batch_size, या अधिक:
- $\hat{Q}(s,a; \theta)$ $\theta$ $\hat{Q}(s', a'; \theta)$ num_replay
  1. #batch_sizeरिप्ले बफर से नमूना अनुभव।
  2. $\hat{Q}(s,a) =$
- ऐसा तब तक करें जब तक आप टर्मिनल स्थिति तक नहीं पहुंच जाते।
- रीप्ले बफर के लिए नए अनुभवों को लगातार जोड़ना न भूलें
जितनी जरूरत हो उतने एपिसोड चलाएं।

$Q(s,a)$ $\hat{Q}(s,a)$ $\sum(Q(s,a) - \hat{Q}(s,a))^2$ सच है $Q(s,a) = R_{t+1} + \gamma \max_{a'}\hat{Q}(s', a'; \theta)$ $R$ $\gamma$

यहाँ कोड का एक अंश है:

def agent_step(self, reward, state):
    action = self.policy(state)
    terminal = 0
    self.replay_buffer.append(self.last_state, self.last_action, reward, terminal, state)
    if self.replay_buffer.size() > self.replay_buffer.minibatch_size:
        current_q = deepcopy(self.network)
        for _ in range(self.num_replay):
            experiences = self.replay_buffer.sample()
            optimize_network(experiences, self.discount, self.optimizer, self.network, current_q, self.tau)
    self.last_state = state
    self.last_action = action        
    return action

— डेविड रेफेली
स्रोत