Ciao e benvenuto in questo modello è orrore.
Bene, abbiamo appena aggiornato la memoria dopo aver raggiunto il nuovo stato.
E ora prendiamoci cura del giorno dopo.
Secondo te ora quale sarà il prossimo aggiornamento.
Beh, in pratica abbiamo finito con una transizione che abbiamo datato l'ultimo elemento della transizione che è il
nuovo stato.
Quindi ora è come se stessimo ricominciando da capo.
E quando stavamo ricominciando tutto da capo.
È come se sapessimo che siamo in questo nuovo stato dell'ambiente e quindi cosa dobbiamo fare ora in modo naturale.
Beh, certo, è un'azione da svolgere perché abbiamo già avuto l'osservazione degli Stati di notizie.
Ora la cosa che dobbiamo fare è giocare un'azione e quindi quello che dobbiamo fare ora
è ovviamente usare la funzione azione selezionata per giocare l'azione.
Facciamo così, creiamo una nuova azione Voivode e giochiamo l'azione con l'azione selezionata,
quindi prendo.
Bene prima di tutto per specificare che la funzione di azione di selezione è un metodo dell'oggetto della classe
che verrà creato.
Quindi un sé che seleziona l'azione.
Eccoci qui.
Quindi questa è la prossima azione.
E poi, naturalmente, poiché la funzione di azione di selezione prende lo stato come input perché ovviamente la
funzione di azione di selezione restituirà l'uscita della rete neurale quando lo stato di ingresso corrente è entrato nella
rete neurale.
dato che sono gli stati che abbiamo appena raggiunto nell'ambiente in questo momento in cui lo stato di input è
ovviamente lo stato perché questo stato che abbiamo appena raggiunto al momento in cui ci troviamo ora è Newstead.
Quindi dobbiamo inserire lo stadio di input qui e
Quindi in questa funzione di selezione prescelta, intendo mettere nuovi bastoncini.
Va bene così con questa linea di codice semplicemente giochiamo la nuova azione dopo aver raggiunto il nuovo stato.
OK e ora che abbiamo giocato un'azione Bene otteniamo la ricompensa e quindi otteniamo un riscontro con la ricompensa.
E quindi se abbiamo più di 100 elementi nella memoria Beh, sarebbe tempo di imparare.
E quindi quello che dobbiamo fare ora è ciò che logicamente viene dopo aver selezionato un'azione che è
naturalmente quella di abbassare l'IA necessario per iniziare l'apprendimento.
Se sta facendo le cose nel modo giusto.
E ora, dato che ha appena giocato bene l'azione, faremo imparare l'IA dalle sue azioni negli
ultimi 100 eventi.
Ma prima di applicare questa funzione appresa dobbiamo fare questa condizione per assicurarci di aver già raggiunto
più di 100 eventi perché sai che stiamo imparando dai campioni casuali della memoria.
Sai che abbiamo questo enorme ricordo di 10000 elementi.
Stiamo prendendo alcuni campioni casuali della memoria di 100 elementi e l'IA sta imparando dalle informazioni
contenute in questo campione di 100 transizioni casuali.
della tua classe di memoria di replay, ma poi la classe di memoria di replay ha un attributo che è memoria.
Quindi, facciamo solo questa condizione, per accertarci che il numero di elementi della memoria di
quella memoria e quindi fare attenzione solo un piccolo trucco qui la memoria autodidatta sia l'oggetto
Quindi, in effetti, abbiamo bisogno di prendere un po 'della memoria che la memoria è la prima memoria
della classe replay e la seconda memoria è l'attributo che la memoria.
Quindi se il numero di elementi nella memoria è buono, vogliamo che sia più grande di 100, quindi Cullin e poi
cosa succede.
Bene, possiamo imparare, ma per l'apprendimento abbiamo bisogno di ottenere questo campione casuale di 100 transizioni e questo
possiamo ottenere con la semplice funzione.
E poiché la funzione semplice restituisce i diversi lotti agli stati al tempo t questi dati 20 più uno le
azioni del tempo t e noi eravamo a 20.
Bene, quello che dobbiamo fare ora è creare delle nuove revisioni che saranno il lotto
degli stati al momento t il lotto delle prossime date il lotto delle parole e
il lotto delle azioni e possiamo semplicemente dare gli stessi nomi come abbiamo dato per gli argomenti qui e sono qui.
E queste variabili saranno uguali a ciò che restituisce la funzione semplice perché restituisce esattamente questi lotti e le
successive azioni dello stato sono parole e azioni.
oggetto di memoria e quindi da questo oggetto di memoria useremo il metodo semplice che prenderà come input.
Quindi quello che dobbiamo semplicemente fare ora è ottenere prima il nostro
Bene, il numero di transizioni che vogliamo che la nostra IA apprenda da questo è 100.
Ecco perché abbiamo fatto in modo che avessimo più di cento transizioni.
Quindi imparerà da 100 transizioni della memoria.
Quindi l'apprendimento sarà molto meglio.
E così ora facciamo in modo che questo accada davvero.
Bene visto che il metodo di apprendimento è un metodo della nostra classe.
oggetti futuri che verranno creati da una classe diversa e quindi ciò che dobbiamo prendere è self.
Bene, dobbiamo accedere a questo metodo Learn dagli
Il sé si riferisce a quell'obiettivo da fare durante le lezioni e poi impara come questo metodo appreso metodo
appreso a cui, quando messo Ovviamente questi ragazzi qui, il cattivo stato, lo stato belga, il mondo naturale
e l'azione Bachche.
Questi sono i nostri lotti campionati dalla nostra memoria e ne riceviamo 100 perché abbiamo 100 transizioni
da queste 100 transizioni prendiamo 100 stati 100 stati successivi 100 ricompensa e 100 azioni affrontiamo il
qui e il là andiamo ora l'apprendimento avverrà.
Succederà da tutti questi lotti casuali.
Perfezionare.
E ora quello che dobbiamo fare sono gli ultimi aggiornamenti dopo aver saputo raggiungere un nuovo stato e giocare
in azione.
Beh, abbiamo davvero giocato, ma non abbiamo ancora avuto questa reazione.
Questo è il nostro sé che ultimo voivoda azione.
Quindi assicuriamoci di non dimenticarlo.
Facciamolo adesso.
che l'ultima azione sia uguale e, naturalmente, eseguiamo l'azione che restiamo qui con questa funzione di azione selezionata.
Aggiorneremo l'ultima azione in modo
A questo punto l'ultima sezione viene aggiornata quindi.
Lo stesso vale per il nuovo stato.
Abbiamo raggiunto il nuovo stato ma non abbiamo ancora aggiornato l'ultima data perché, naturalmente, l'ultimo era prima dello
stato all'ora t.
Ma da adesso abbiamo raggiunto il nuovo surplus di stato quando è il momento di superarne uno.
Bene, l'ultimo diventa questo che hai detto qui.
Quindi abbiamo bisogno anche di aggiornamenti.
Sé che l'ultimo stato è uguale al nostro nuovo stato.
Eccoci.
E ora cosa dobbiamo datare.
Bene, c'è solo una cosa rimasta.
Questa è ovviamente la parola e la parola è esattamente la parola che otteniamo nella realtà.
Quindi questo sarà l'argomento di questa funzione che se avessimo stabilito la connessione con la nostra mappa sarebbe
stata l'ultima parola.
Questa è la parola che otteniamo subito dopo aver giocato l'azione in questo ha raggiunto nuovi stati.
Quindi se andiamo ad un suono questa ultima parola sarà quella meno se andiamo più lontano avremo
una parola leggermente cattiva meno 0. 2 se ci avviciniamo all'obiettivo.
Otterremo un premio leggermente buono 0. 1.
E se ci avviciniamo troppo a un bordo della mappa, questo riguarderà la punizione.
Otterremo meno uno per ciascuno.
Quindi questa è l'ultima parola che otteniamo.
In realtà è quando ciò accade per davvero sulla mappa.
E questo sarà l'argomento della funzione.
L'ultima parola qui.
Questo è esattamente questo.
E siccome questo è l'argomento della funzione di aggiornamento che corrisponde a
questo non eravamo qui e quindi il nostro sé che l'ultima variabile di parola inizializzata all'inizio in questa funzione diventa
la nuova parola che otteniamo nella realtà che è la parola o che è la stessa ultima parola.
Tutto ok.
Ora abbiamo aggiornato la nostra ultima parola.
E ora da quando abbiamo appena avuto la nostra ultima parola.
Bene, ora possiamo uscire con il mondo.
Ricordi la guerra quando inizializzammo qui come una delle variabili dell'oggetto della nostra classe.
Questa è la finestra che terrà traccia di come questo treno sta andando prendendo la
media degli ultimi 100 premi.
Quindi sai che sarà come una finestra scorrevole che ci mostra come si sta evolvendo la media del mondo.
E così da quando abbiamo appena avuto la nostra ultima parola.
Bene, possiamo aggiornare la finestra su come aggiornarla.
il mio sé della finestra di guerra che diciamo quando sentono questo e userò la funzione append.
Beh, abbiamo semplicemente bisogno di aggiungere questa ultima parola alla finestra e quindi quello che ho intenzione di fare è prendere
E all'interno della funzione aperta abbiamo bisogno di inserire l'elemento che vogliamo aggiungere al momento
in cui lo facevamo, ovviamente lo vogliamo.
Va bene perfetto.
E poi, dal momento che questa finestra di guerra avrà una dimensione fissa, sai che non sarà una finestra
in crescita, sarà una finestra di dimensioni fisse che scorre col tempo per mostrare l'evoluzione del mondo.
E così ora dobbiamo decidere per una taglia di questo inverno.
Ed è semplicemente il numero di mezzi del premio che avremo in questa finestra.
E così, per esempio, ti facciamo conoscere gli ultimi 1000 mezzi delle ultime 100 parole.
E quindi, per assicurarcene, aggiungeremo se poi pianifichiamo la nostra finestra di lavoro e aggiungiamo semplicemente
qui se il numero di elementi nella finestra è maggiore di 1000.
Bene, quello che vogliamo fare è eliminare il primo elemento di questo che la nostra finestra e il
primo elemento di questa era finestra deve indicizzare zero.
Tutto ok.
Ora ci assicuriamo che questa finestra di guerra non ottenga mai più di 1000 elementi.
è perfetto questa sarà una finestra di dimensioni fisse in modo che possiamo vedere se la media della parola è in aumento.
C'è un migliaio di mezzi delle ultime 100 parole che
E quindi se la formazione sta andando bene e di conseguenza la corte fa quello che vogliamo.
Perfezionare.
E ora una piccola piccola cosa da lasciare a te secondo che cosa sarà.
Ricorda che questa funzione di aggiornamento non solo aggiorna i diversi elementi della transizione nella finestra
di guerra, ma restituisce anche l'azione che è stata giocata quando si raggiunge questo nuovo stato.
Ecco perché abbiamo e poi quell'azione equivale a portare quella data che siamo meno segnale e quindi si suppone
che restituisca qualcosa e il qualcosa che si suppone debba tornare è, naturalmente, l'azione.
Quindi l'ultima cosa che dobbiamo fare qui è solo restituire l'azione che è stata appena giocata quando si raggiunge
il nuovo stadio.
E questa è la nostra funzione di aggiornamento è pronta.
Farà tutti gli aggiornamenti richiesti e cambierà azione quando raggiungerà la nuova fase.
È perfetto.
Quella fu l'ultima azione difficile da fare per tutto questo un processo.
Ora il resto sarà roba buona.
Creeremo solo una funzione di base per restituire i mezzi che vogliamo nella finestra.
Quindi faremo una funzione sicura per salvare il cervello dell'auto ogni volta che vuoi uscire dall'applicazione
e tornare ad esso.
E naturalmente dal momento che vuoi essere in grado di caricare il cervello della tua auto quando
torni a tornare all'applicazione.
Bene finiremo per creare una funzione di caricamento che caricherà il modello dopo aver salvato il modello
con la stessa funzione.
Quindi tre funzioni per farlo, ma sarà semplice.
la sezione più eccitante di questo primo modulo che è la demo che vedremo se l'aria funziona.
E poi avremo
Vedremo se la macchina raggiungerà gli obiettivi e vedremo come possiamo migliorarla e poi alla
fine dovrai costruire la tua prima IA.
Quindi non vedo l'ora di iniziare la demo.
Facciamo prima queste tre funzioni e fino a quel momento I.