Ho letto DeepMind Atari di Google paper e sto provando per comprendere il concetto di “replay dellesperienza”. Il replay dellesperienza compare in molti altri documenti di apprendimento per rinforzo (in particolare, il documento AlphaGo), quindi voglio capire come funziona. Di seguito sono riportati alcuni estratti.
In primo luogo, abbiamo utilizzato un meccanismo di ispirazione biologica denominato riproduzione dellesperienza che randomizza sui dati, rimuovendo così le correlazioni nella sequenza di osservazione e attenuando i cambiamenti nella distribuzione dei dati.
Il documento elabora quindi come segue:
Mentre esistono altri metodi stabili per laddestramento delle reti neurali nel contesto dellapprendimento per rinforzo, come literazione Q neurale adattata, questi metodi comportano laddestramento ripetuto di reti de novo centinaia di iterazioni. Di conseguenza, questi metodi, a differenza del nostro algoritmo, sono troppo inefficiente per essere utilizzato con successo con grandi reti neurali. Parametrizziamo una funzione di valore approssimativo $ Q (s, a; \ theta_i) $ utilizzando la rete neurale convoluzionale profonda mostrata in Fig. 1, in cui $ \ theta_i $ sono i parametri (cioè i pesi) della rete Q alliterazione $ i $ . Per eseguire la riproduzione dellesperienza, archiviamo le esperienze dellagente $ e_t = (s_t, a_t, r_t, s_ {t + 1}) $ in ogni fase temporale $ t $ in un set di dati $ D_t = \ {e_1, \ dots, e_t \} $ . Durante learning, applichiamo gli aggiornamenti Q-learning, su esempi (o mini-batch) di esperienza $ (s, a, r, s “) \ sim U (D) $ , estratto in modo uniforme e casuale dal pool di campioni immagazzinati. Laggiornamento Q-learning alliterazione $ i $ utilizza la seguente funzione di perdita:
$$ 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] $$
Cosè la riproduzione dellesperienza e quali sono i suoi vantaggi, in parole povere?
Risposta
La parte fondamentale del il testo citato è:
Per eseguire la riproduzione dellesperienza memorizziamo le esperienze dellagente $ e_t = (s_t, a_t, r_t, s_ {t + 1} ) $
Ciò significa che invece di eseguire Q-learning sulle coppie stato / azione mentre si verificano durante la simulazione o lesperienza reale, il sistema memorizza i dati rilevati per [stato, azione, ricompensa, prossimo_stato] – in genere in una tabella di grandi dimensioni. Nota che questo non memorizza i valori associati: questi sono i dati grezzi da inserire in seguito nei calcoli del valore dellazione.
La fase di apprendimento è quindi logicamente separata dallacquisizione di esperienza e si basa sul prelievo di campioni casuali da questa tabella. Vuoi ancora intercalare i due processi – recitazione e apprendimento – perché il miglioramento della politica porterà a comportamenti diversi che dovrebbero esplorare azioni più vicine a quelle ottimali, e vuoi imparare da quelle. Tuttavia, puoi dividerlo come preferisci, ad es. fai un passo, impara da tre passaggi precedenti casuali, ecc. Gli obiettivi Q-Learning quando si utilizza la riproduzione dellesperienza utilizzano gli stessi obiettivi della versione online, quindi non esiste una nuova formula per questo. La formula di perdita fornita è anche quella che useresti per DQN senza replay dellesperienza. La differenza è solo quale s, a, r, s “, a” ci dai.
In DQN, il team di DeepMind ha anche mantenuto due reti e ha cambiato quale era apprendimento e quale alimenta le attuali stime del valore dellazione come “bootstraps”. Ciò ha contribuito alla stabilità dellalgoritmo quando si utilizza un approssimatore di funzione non lineare. Questo è ciò che rappresenta la barra in $ {\ theta} ^ {\ overline {\ space}} _ i $ – indica la versione congelata alternativa dei pesi.
Vantaggi della riproduzione dellesperienza:
-
Uso più efficiente dellesperienza precedente, imparando con essa più volte. Questa è la chiave quando acquisire esperienza nel mondo reale è costoso, puoi sfruttare appieno Gli aggiornamenti del Q-learning sono incrementali e non convergono rapidamente, quindi più passaggi con gli stessi dati sono vantaggiosi, specialmente quando cè una bassa varianza nei risultati immediati (ricompensa, stato successivo) dato lo stesso stato, coppia di azioni.
-
Migliore comportamento di convergenza durante laddestramento di un approssimatore di funzione. In parte ciò è dovuto al fatto che i dati sono più simili ai dati iid assunti in la maggior parte delle prove di convergenza dellapprendimento supervisionato.
Svantaggio della riproduzione dellesperienza:
- È più difficile utilizzare algoritmi di apprendimento in più fasi, come Q ($ \ lambda $) , che può essere regolato per fornire migliori curve di apprendimento bilanciando tra bias (dovuto al bootstrap) e varianza (a causa di ritardi e casualità nei risultati a lungo termine). DQN in più passaggi con experience-replay DQN è una delle estensioni esplorate nel documento Rainbow: Combining Improvement in Deep Reinforcement Learning .
Lapproccio utilizzato in DQN è brevemente delineato da David Silver in alcune parti di questa lezione video (intorno all01: 17: 00, ma vale la pena vedere le sezioni prima). Consiglio di guardare lintera serie, che è un corso di laurea sullapprendimento per rinforzo, se hai tempo.
Commenti
- Lascia ‘ s dice durante la formazione che siamo in uno stato e intraprendiamo unazione secondo la politica epsilon-greedy e tu finisci in un altro stato. Quindi ottieni ricompense e il prossimo stato. Qui la ricompensa può essere il punteggio del gioco e gli stati possono essere i modelli di pixel sullo schermo. E poi prendiamo nuovamente lerrore tra il nostro approssimatore di funzione e il valore che abbiamo ottenuto dalla politica avida usando di nuovo lapprossimatore di funzione già congelato. Ma con la riproduzione dellesperienza quando si ottimizza lapprossimatore prendiamo alcuni set di dati di azioni di stato casuale. Ho ragione?
- @ShamaneSiriwardhana: Sì, penso che tu abbia ragione. Sono esattamente gli stessi dati dalla traiettoria reale, ma invece di imparare solo dal passaggio più recente, li salvi in una grande tabella e provi da quella tabella (di solito più campioni, con un archivio di migliaia di passaggi precedenti tra cui scegliere ). Se hai bisogno di ulteriori chiarimenti, magari fai una domanda sul sito.
- Sì, ho esaminato di nuovo il giornale. Dice anche che questo metodo può migliorare anche lapprendimento fuori dalle politiche. Perché in Q lapprendimento agisce secondo la politica epsilon-greedy ma aggiorna i valori funziona secondo la politica avida. Quindi, quando ogni passo temporale i nostri parametri della rete neurale vengono aggiornati da statistiche mini batch, cosa ancora più importante non correlata alle statistiche del passo temporale esatto, ma ciò che è accaduto prima di questo aiuta anche a non correlare i dati.
- @Neil Slater, I ‘ ho esaminato il documento Rainbow e ‘ non ho visto commenti speciali sullutilizzo di uno speciale trucco per combinare la riproduzione dellesperienza e metodo passo. Inoltre ‘ ho sentito che il metodo a più passaggi è originariamente impossibile da combinare con la riproduzione dellesperienza, ma perché non scegliere casualmente n-esperienze consecutive invece di 1 dalla riproduzione dellesperienza ma dalla riproduzione, quindi che tra ogni n-esperienze non sono state trovate correlazioni? ‘ t questa esperienza in più passaggi è riprodotta?
- @NeilSlater Perché è ” più difficile da usare algoritmi di apprendimento graduale “? Cosa intendevi?
Risposta
Lalgoritmo (o almeno una sua versione, come implementato in il Coursera RL capstone project ) è il seguente:
-
Crea un “Buffer” di replay che memorizza lultimo
#buffer_sizeSARS (Stato, Azione, Ricompensa, Nuovo Stato). -
Esegui il tuo agente e lascia che accumuli esperienze nel replay-buffer finché (il buffer) non ha almeno
#batch_sizeesperienze .- Puoi selezionare azioni in base a una certa politica (ad es. soft-max per spazio di azione discreto, gaussiano per continuo, ecc.) tramite il tuo $ \ hat {Q} (s, a; \ theta) $ stimatore di funzioni.
-
Una volta raggiunto
#batch_sizeo altro:-
crea una copia dello stimatore della funzione ( $ \ hat {Q} (s, a; \ theta) $ ) al momento attuale, ovvero una copia dei pesi $ \ theta $ – che “congeli” e non “aggiorni, e utilizza per calcolare gli stati “true” $ \ hat {Q} (s “, a”; \ theta) $ . Esegui per
num_replayaggiornamenti:-
sample
#batch_sizeesperienze dal buffer di riproduzione. -
Usa le esperienze campionate per pr e forma un aggiornamento in batch per lo stimatore della funzione (ad es. in Q-Learning dove $ \ hat {Q} (s, a) = $ Rete neurale – aggiorna i pesi della rete). Utilizza i pesi congelati come funzione dei valori di azione “veri”, ma continua a migliorare la funzione non congelata.
-
-
fallo finché non raggiungere uno stato terminale.
-
non dimenticare di aggiungere costantemente le nuove esperienze al Replay Buffer
-
-
Corri per tutti gli episodi di cui hai bisogno.
Cosa intendo per “vero”: ogni esperienza può essere considerata come un duo di apprendimento “supervisionato”, in cui hai una funzione di valore reale $ Q (s, a) $ e uno stimatore di funzioni $ \ hat {Q} (s, a) $ . Il tuo obiettivo è ridurre il valore-errore, ad es. $ \ sum (Q (s, a) – \ hat {Q} (s, a)) ^ 2 $ . Dato che probabilmente non hai accesso ai valori di azione true , utilizzi invece una versione migliorata con bootstrap dellultimo estimatore , tenendo conto della nuova esperienza e della ricompensa fornita. In Q-learning, il valore “true” dellazione è $ Q (s, a) = R_ {t + 1} + \ gamma \ max_ {a “} \ hat {Q} (s”, a “; \ theta) $ dove $ R $ è la ricompensa e $ \ gamma $ è il fattore di sconto.
Ecco un estratto del codice:
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