Ciao e benvenuto in questo tutorial Python.
Tutto ok.
Ora nella prossima funzione che stiamo implementando formeremo la rete neurale profonda che si
trova all'interno della nostra intelligenza artificiale.
Quindi fondamentalmente faremo l'intero processo per la propagazione e quindi la propagazione indietro.
Quindi stiamo per ottenere il nostro risultato.
Avremo l'obiettivo.
calcolare l'ultimo errore, quindi torneremo a propagare quest'ultimo errore nella nuova rete.
Confronteremo l'output del target per
E usando la discesa del gradiente suggerita che dovrà aspettare in base a quanto ha contribuito
all'ultimo errore.
Facciamo tutto questo per quelli di voi che vengono dal profondo Corpo dei Marines.
Questa sarà roba buona ma per gli altri non ti preoccupare, lo espanderò di nuovo.
Quindi chiameremo questa nuova funzione imparare e imparare la funzione prenderà diversi argomenti.
Il primo io naturalmente che si riferirà all'oggetto della laurea in classe.
attuale, quindi il nostro batch next state quindi il nostro premio e infine l'azione Arbat.
Quindi prenderemo il nostro stato batch per lo stato
Quindi perché lo prendiamo.
Probabilmente hai riconosciuto cos'è questa serie.
Beh, questa è ovviamente una transizione una transizione del processo decisionale del mercato che è alla base.
Hai imparato.
E perché li portiamo tutti in alcuni lotti.
Beh, perché sai che ricordiamo che non consideriamo le transizioni da una serie dello stato superiore o
attuale dello stato successivo, della ricompensa attuale e dell'azione corrente.
Abbiamo creato alcuni semplici lotti qui grazie alla semplice funzione.
E così ora le nostre transizioni sono sotto forma di primo lotto per questo stato.
Un secondo lotto per la data successiva un lotto per il premio e un lotto per l'azione.
Questa è la forma della nostra transizione ora e sono tutti ben allineati rispetto al
tempo grazie a questa concatenazione che abbiamo fatto qui rispetto alla prima dimensione.
Quindi il punto è che ora abbiamo questa transizione di lotti di un lotto per ciascuno stato nei prossimi giorni in
cui lo guardiamo in azione e facciamo tutto questo perché stiamo usando questo trucco di ripetizione dell'esperienza.
Quindi questa è la nostra rete neurale profonda in grado di imparare qualcosa.
Ricorda se hai avuto solo una transizione da sola che cosa sarebbe un apprendimento istantaneo.
O se vuoi un apprendimento della memoria molto breve e quindi la talpa non imparerebbe nulla.
Quindi dobbiamo prendere questi lotti dalla memoria che diventeranno le nostre transizioni e poi alla fine otterremo i diversi
output per ciascuno degli stati degli stati di input e lo faremo per gli stati
e per gli stati successivi perché avremo bisogno di entrambi calcolare la perdita.
Ricorderò presto l'equazione dell'equilibrio che è il cuore dell'algoritmo di apprendimento.
Quindi ora entriamo nella funzione e prima otteniamo le uscite dello stato della casella.
e poi diremo naturalmente che il nostro parlare di sé non è tutto così auto-start.
Quindi chiamerò queste prime uscite vitali
No perché vogliamo ottenere i nostri output del modello degli stati di input dello stato.
E poiché il nostro modello è in realtà in attesa di una serie di stati di input.
Bene, possiamo inserire totalmente lo stato in questo momento per l'input di tutti loro.
Questo è esattamente il modo in cui abbiamo inizializzato gli stati che stanno entrando nella rete con la risposta alla
tortura con questa vaga dimensione per il batch che è perfetto.
Ora otteniamo le uscite di tutti loro.
e otterremo i risultati di tutte le azioni possibili che conosci 0 1 e 2, ma non è quello che vogliamo.
Ma poi c'è un altro trucco tecnico se vendiamo solo quello stato del modello
Siamo interessati solo alle azioni che sono state scelte.
Le azioni che sono state decise dalla rete per giocare in ogni momento e per
far sì che queste siano realmente interessate sono le azioni giocate bene, dobbiamo usare questa funzione di raccolta in
cui inseriamo una perché vogliamo solo l'azione che è stata scelta e quindi aggiungiamo quell'azione con questo.
E in quella sezione raccogliamo ogni volta la migliore azione da giocare per ciascuno degli stati di input
dello stato.
l'azione che viene eseguita l'azione che viene scelta e otteniamo questo con questo raccolgo quella azione.
Non vogliamo
Ma fai attenzione.
Lo stato qui ha questo diamanti finti e grasso nel lotto e quella sezione non ce l'ha.
Backstay ce l'ha perché non ci siamo mai abituati qui, ma non abbiamo usato nessun arm squeeze
per le azioni, quindi dobbiamo aggiungerlo qui in modo che l'azione Bache abbia esattamente la stessa dimensione dello stato.
Quindi aggiungeremo un punto e stringiamo qui la tua destra e in realtà questo non è zero ma uno perché la risposta
zero alla Fede non è lo stato e uno corrisponderà all'esame delle azioni.
E infine l'ultima cosa che dobbiamo fare qui è che dobbiamo uccidere questo gruppo falso con una stretta.
Perché abbiamo bisogno di farlo.
Perché ora siamo fuori dalla rete neurale.
Abbiamo i nostri risultati ma non li vogliamo indietro.
Li vogliamo.
E la semplice risposta è semplice vettore.
Un vettore di output dei batch solo quando lavoriamo nella rete neurale perché la rete
neurale si aspetta il formato dei sensori in un batch.
i nostri risultati e nella prossima equazione baluns del deep learning non ne avremo bisogno in un batch.
Ma ora abbiamo
Quindi sto uccidendo questo qui e uccidendo la dimensione della fede per riprendere la forma semplice delle nostre uscite.
Quindi sto solo aggiungendo qui Dot e poi spremere e poi dato che voglio uccidere la finta laminazione
corrispondente al retro dell'azione.
Bene visto che il motore dello spazio-tempo ha indice uno ne sto aggiungendo uno qui.
Tutto ok.
E ora ci siamo, abbiamo le nostre uscite.
OK.
Abbiamo un piccolo avvertimento su quale sia l'uscita della variabile locale assegnata ma mai utilizzata.
Va bene.
Lo useremo molto velocemente.
Quindi sono le nostre uscite.
E ora vogliamo ottenere i nostri prossimi outsitter Quindi ora potresti pensare perché abbiamo bisogno dei prossimi risultati.
Bene, per capire questo, dobbiamo tornare all'algoritmo di deep learning che è proprio qui
che fa parte del manuale di letak.
Quindi questo è l'intero processo di diffusione.
All'inizio stavamo inizializzando tutti i valori chiave e poi ogni volta t.
Bene, eccoci, selezioniamo l'azione con Soughed Max che è quello che abbiamo fatto con la funzione di selezione.
Quindi abbiamo aperto la transizione e quindi, come puoi vedere, otteniamo la previsione otteniamo l'obiettivo e
possiamo essere l'ultimo.
Quindi, perché abbiamo bisogno anche del prossimo output.
Questo a causa del target il target è uguale al Ghana per il prossimo output più quello che vogliamo e calcoleremo
gli obiettivi subito dopo poiché abbiamo bisogno del prossimo output del target.
Calcoliamo questo prima.
Quindi, ancora una volta per ottenere il prossimo aggiornamento molto semplice, il prossimo output sarà il risultato della
nostra rete neurale quando lo stato successivo in batch lo sta inserendo come input.
Quindi, molto semplicemente, prendiamo il nostro modello che è la nostra rete neurale e quindi questa volta l'input della
rete neurale sarà il successivo stato in batch che ha confrontato la data successiva.
Ma ora ricorda se torniamo all'algoritmo iniziale Bene, puoi vedere che l'output successivo è il massimo dei valori
q per lo stato successivo rispetto a tutte le azioni.
Quindi adesso per ottenere il prossimo output dobbiamo ottenere il massimo di questi valori q e quindi ho intenzione
di farlo qui.
Scollegate sapete come staccare tutte le uscite del modello perché abbiamo diversi stati in questo batch prossimo States che è
il batch di tutti gli stati successivi in ​​tutte le transizioni prese dal campione casuale della
nostra memoria.
Quindi li sto staccando tutti usando la funzione di scollegamento e quindi sto prendendo il massimo di tutti questi
due valori.
E dal momento che stiamo prendendo il massimo di questi due valori rispetto all'azione Bene,
dobbiamo specificare che è rispetto all'azione.
E poiché l'azione è rappresentata dall'indice.
Bene ancora una volta dobbiamo mettere il prossimo qui e quindi dobbiamo specificare che stiamo prendendo
i valori di cue come T più 1 che è lo stadio successivo e lo stato successivo è rappresentato da 0
perché lo zero dell'indice corrisponde agli stati e quindi qui dobbiamo aggiungere parentesi con indice 0.
In questo modo otteniamo il massimo dei valori chiave degli stati successivi rappresentati dallo zero successivo
in base a tutte le azioni rappresentate da uno indice e ora perfetto otteniamo i nostri output successivi.
Questi sono un nuovo set.
Ecco quando abbiamo avuto l'avvertimento.
Ma va bene.
Lo useremo adesso per calcolare l'obiettivo.
E parlando dell'obiettivo è il prossimo passo di questa nota funzione.
Quindi eccoci.
L'obiettivo è uguale.
Ora torniamo al nostro manuale AI AI.
Il target è uguale alla parola più gamma volte il prossimo output è il massimo dei valori del cubo
del giorno successivo.
Secondo le azioni che possiamo calcolare.
Quindi è uguale a se stesso che gamma e sé sono stati inizializzati con Gamma.
Qui si presenta una variabile che è la vergine Q Un oggetto auto ottiene a Times i prossimi output come
abbiamo appena detto più vogliamo che sia la migliore vuole.
Stiamo lavorando con lotti qui, quindi più lotti che vogliamo e questo è l'obiettivo.
In un campione della gamma di memoria moltiplicato per le uscite successive Più il premio.
Tutto ok.
Perfezionare.
Quindi ora abbiamo le nostre uscite.
Abbiamo anche i nostri obiettivi e quindi possiamo calcolare la perdita che rappresenta l'errore
della previsione.
Quindi chiamiamo quest'ultimo, gli ultimi due sono ovviamente per la differenza temporale.
Questo è di nuovo al centro dell'apprendimento di Q e questo noioso sarà uguale al rilascio che
migliora molto la Cunanan.
Questa è l'ultima funzione che sceglieremo per la nostra intelligenza artificiale.
Per quelli di voi che provengono dal corso di verde intenso che è davvero l'ultimo che consiglio.
Se vuoi implementare la Coonerty e quindi come lo otterremo.
Bene, di nuovo prenderemo una funzione dal modulo funzionale rappresentato da F e
quindi qui userò il nostro modulo funzionale anatre e l'Hubble us può essere ottenuto
grazie alla funzione Smoots L-1 che adora quella.
Quindi premere Invio.
E questa è davvero la migliore funzione persa che consiglio per l'apprendimento profondo.
Migliora davvero il Culin.
Ma questa è una funzione, quindi aggiungo una parentesi.
E ora non c'è niente di più semplice.
Gli argomenti che dobbiamo inserire sono le previsioni e gli obiettivi.
Quindi le previsioni ovviamente sono uscite perché questo è l'output della rete neurale.
No, l'output della rete neurale è ciò che predice la rete neurale.
Quindi questa è la previsione.
Quindi il primo argomento qui è output e quindi il secondo argomento è ovviamente l'obiettivo.
La cosa che stiamo cercando di ottenere è già calcolata perfettamente.
Possiamo inserire direttamente il target.
Perfezionare.
Ora ci hanno detto che abbiamo un po 'di tè qui.
Eccoci.
Ora l'avviso dovrebbe scomparire.
Sì.
Perfezionare.
E ora che abbiamo l'ultimo errore, possiamo riportare l'errore dei propagatori nella rete per aggiornare i pesi con
la discesa del gradiente stocastico e questo è esattamente ciò che faremo nel passaggio successivo.
dobbiamo fare è quello di ottimizzare il nostro ottimizzatore che, ancora una volta, vi introdurrà.
Quindi, ovviamente, ora quello che
E questo è un ottimizzatore atomico che in realtà è un oggetto della classe Atom ed è già
dotato dei parametri del nostro modello.
E abbiamo già scelto un tasso di apprendimento pari a 0. L'1% per perfezionare il nostro ottimizzatore è pronto, ma ora
dobbiamo giocarci sull'ultimo errore per eseguire la griglia stocastica nel senso e il peso dei dati.
Quindi, quando si lavora con i combattenti, la prima cosa che dobbiamo fare è inizializzarla di nuovo ad ogni iterazione
del ciclo.
nel ciclo di questo per ottenere la griglia nel set e inizializzarlo di nuovo.
Dobbiamo reinizializzare l'ottimizzatore da un'interazione all'altra
E ogni iterazione del ciclo.
Bene, useremo il seguente metodo che è zero.
Eccoci qui.
Zero grad reinizializzerà l'ottimizzatore ad ogni iterazione del ciclo.
Quindi non dimentichiamo la parentesi.
Perfezionare.
E ora che è reinizializzato Bene possiamo eseguire la propagazione all'indietro con il nostro ottimizzatore.
E come lo facciamo.
Bene, prendiamo le nostre leggi e torneremo a diffonderle di nuovo nella rete e di
tornare propagate nella rete.
Abbiamo bisogno di utilizzare la funzione all'indietro e all'interno di questa funzione a rovescio raccomando di inserire le
variabili del trattino basso e impostarlo su true.
Raccomando di farlo perché questo migliorerà la propagazione del dorso.
L'uso di variabili scritte è vero è quello di liberare un po 'di memoria e
abbiamo bisogno di liberare la memoria perché andremo più volte nell'ultimo modo che migliorerà sicuramente le prestazioni di allenamento.
Infine, l'ultima fase di questa funzione appresa consiste nel disporre di pesi di dati in base alla propagazione posteriore.
Questo dipende da quanto i pesi hanno contribuito all'errore.
E per fare questo riprendiamo il nostro ottimizzatore che è stato inizializzato in re-initialize e usiamo la funzione step
e semplicemente con questa riga di codice usando la funzione step.
Questo aggiornerà i pesi.
Questa è la linea di codice che aggiorna i pesi.
Questa riga di codice che propaga l'errore nella rete neurale e questa linea di codice utilizza l'ottimizzatore
per aggiornare i pesi e così via.
Abbiamo una rete neurale di apprendimento tutto bene quindi congratulazioni.
Questa era probabilmente la parte più tecnica e difficile di tutta questa disputa o domani.
So che la mia torcia può essere difficile a volte con facilità e spremere e
spremere, ma alla fine prometto che otterrete una rete neurale molto funzionale e, quindi, un modello particolare e, infine,
una grande intelligenza artificiale.
Passiamo ora al prossimo passo o all'insegnante e al modello, che sarà la funzione di aggiornamento
che ovviamente aggiornerà quando l'IA scoprirà il nuovo stato.
Quindi sai che scoprirà il nuovo stato e quindi riceverà la ricompensa.
A seconda dell'azione che viene visualizzata e questo nuovo stato si prenderà cura di questo con la
funzione di aggiornamento e lo farà nel prossimo tutorial.
Fino ad allora divertiti.
IO.