Ciao e benvenuto alla spezia Intertoto.
Bene, in questa nuova sezione di codice implementeremo l'esperienza con il gioco.
Quindi creeremo una nuova classe che chiameremo memoria di replay e che implementerà l'esperienza per suonare
esattamente come hai visto nelle lezioni di intuizione.
Ma prima diamo un rapido promemoria su cosa è il replay dell'esperienza.
Quindi sai che tutta questa intelligenza artificiale si basa sui processi decisionali di Markov e che i
processi decisionali di Markov consistono nel guardare una serie di eventi.
Quindi gli eventi si conoscono, ad esempio, passando da uno stato a uno successivo e uno a uno.
Ma se gli eventi erano così bene dal giorno successivo è molto correlato allo stato attuale.
Bene, la rete non andrebbe molto bene.
Quindi per chi viene dal corso di deep learning è esattamente lo stesso di dove abbiamo imparato le
nostre serie temporali con un solo timestep.
Non stava imparando nulla perché un timestep non era abbastanza sufficiente per un modello per
imparare a capire le correlazioni a lungo termine.
Quindi è lo stesso qui ed è per questo che dobbiamo implementare la riproduzione dell'esperienza.
Quindi, come funziona.
Bene, è molto semplice invece di considerare solo lo stato corrente che è solo uno stato al
tempo t.
Considereremo di più in passato.
Così esattamente come per i litio e quindi la nostra serie di eventi non sarà così.
E suppongo che questo sarà per esempio i cento stati del passato.
Così come T-meno cento ottanta meno 99 fino a meno 1 e poi S-T.
in quella che chiamiamo memoria ed è per questo che abbiamo una memoria a lungo termine rispetto a una memoria
a breve termine o anche dovrei dire una memoria istantanea e questo rende l'intero processo molto più efficace.
Quindi, in altre parole, mettiamo 100 meno transizioni
E poi, una volta creato questo ricordo degli ultimi 100 eventi, sarà semplicissimo che ci vorranno alcuni
lotti casuali di queste transizioni per fare il nostro prossimo aggiornamento.
Questa è la nostra prossima mossa selezionando la sezione successiva e quindi in questa classe di memoria
di replay che implementeremo per la riproduzione dell'esperienza, faremo tre funzioni.
Prima di tutto la funzione come al solito è il caso per qualsiasi classe.
E così in questa funzione definiremo le variabili che saranno associate alle future istanze della classe
che saranno gli oggetti futuri che verranno creati da questa classe.
E quindi molto semplicemente queste variabili saranno la memoria delle 100 transizioni a 100 eventi.
E la capacità che è il numero di 100 sarà il benvenuto per provare una memoria più lunga aumentando
la capacità.
Quindi questa è la prima funzione nella sua funzione e quindi faremo due altre funzioni una funzione push
per assicurarci che la memoria non contenga mai più di 100 transizioni.
E per questo useremo la capacità semplicemente facendo una semplice condizione e poi alla fine
faremo la funzione semplice e questo sarà ovviamente per campionare alcune transizioni in questa memoria
delle ultime 100 transizioni.
Va bene, iniziamo introducendo la lezione.
Quindi, come sapete, iniziamo con la classe e poi li assegniamo alla classe che chiamiamo replay memory
e quindi tra parentesi inseriamo l'oggetto poi Cullin e poi andiamo iniziamo con la prima funzione.
La fine è la funzione.
Quindi è esattamente lo stesso di prima che iniziamo con la morte.
Quindi due trattini di sottolineatura in esso due sottolineano nuovamente e quindi le variabili.
future istanze della classe degli oggetti futuri e quindi avremo un'altra variabile in modo che tu
possa provare qualche altra esperienza con alcuni dei ricordi e che sta per essere la capacità.
Quindi, naturalmente, c'è il sé che è la variabile associata alle
Quindi questa capacità sarà semplicemente il numero cento perché faremo esperienza
per giocare con le cento meno transizioni.
Va bene e poi Collon Ed eccoci qui.
Entriamo nella funzione e definiamo le variabili del nostro oggetto replay memory.
Quindi il primo sarà la capacità di autodidatta e, come probabilmente avete capito, questa sarà la capacità che è il numero
massimo di transizioni che vogliamo avere nella nostra memoria degli eventi.
quando si crea un oggetto della classe di memoria di replay e quindi questa è la capacità.
E questo sarà uguale agli argomenti che verranno inseriti
Questo è l'argomento della funzione di init.
Quindi capacità.
Quindi, ancora una volta, non essere confuso da sé che la capacità è il nome della variabile che è
collegata all'oggetto e la capacità qui è l'argomento che introdurrà quando creerà un oggetto della classe di memoria di replay.
Tutto ok.
E poi abbiamo un secondo voivode.
Questo è, naturalmente, il ricordo.
Così autodidatta Nemec.
Tutto ok.
E quindi a cosa servirà questo Voivode della memoria.
Bene, questa memoria dovrebbe contenere gli ultimi 100 eventi e quindi questo dovrebbe essere un semplice test.
Conoscete una lista che conterrà gli ultimi 100 eventi delle ultime 100 transizioni e per inizializzare la
lista.
Non c'è niente di più semplice, aggiungiamo solo alcune parentesi come quella.
E qui andiamo.
La nostra memoria è inizializzata così ovviamente all'inizio dell'esperimento o più precisamente all'inizio
dell'esplorazione la memoria sarà una lista vuota e quindi metteremo le transizioni.
Ogni volta che raggiungiamo uno stato futuro.
E parlando di questo è esattamente ciò che faremo con la funzione successiva che
chiameremo la funzione push.
Faremo questa funzione push per mettere in fila gli eventi in questa lista di memoria e poi useremo
la capacità per assicurarci che questa lista di memoria contenga sempre 100 eventi e mai più.
Va bene, facciamolo anche nel prossimo.
E fino ad allora I.