Ciao e benvenuto all'ultimo passaggio di questo primo capitolo.
Ora l'unica cosa che dobbiamo fare è rendere questa funzione Ford che propagherà il
segnale fin dall'inizio, quando il cervello arriverà alla fine dell'immagine quando inserirò l'azione, così faremo
questo tutta la funzione e questo sarà il nostro ultimo passo prima di passare
alla formazione della nostra IA con un profondo kulang convoluzionale.
Quindi facciamolo.
Prenderemo la chiamata alla funzione che in realtà è simile alla funzione init che è una funzione
esistente, ma questa volta la usiamo per chiamare alcune altre funzioni.
Quelli che abbiamo fatto prima, perché sai che useremo la funzione in avanti dal
cervello e la funzione portuale dal corpo.
E così ora stiamo usando questa funzione per chiamare fondamentalmente queste funzioni.
Quindi la chiamata sta per prendere due argomenti.
Il primo è sé.
Certamente l'oggetto e il secondo argomento che secondo te cosa sarà.
Bene, stiamo facendo l'intera propagazione questa volta.
naturalmente, le immagini di input perché ovviamente questo è il punto di partenza quando l'IA sta giocando.
Quindi, quello che vogliamo prendere come input è,
Prima visualizza le immagini del gioco, quindi diffonde i segnali nel cervello e
poi riproduce l'azione.
Quindi il secondo argomento sarà input.
E ora siamo pronti a fare tutta questa propagazione.
Quindi facciamolo di nuovo.
Quindi il primo passo in cui è il primo passo è ricevere le immagini di input dal gioco.
immaginare che dobbiamo formattarle in una struttura speciale e la struttura è ovviamente una struttura torcia.
E dal momento che queste immagini stanno per entrare nella rete neurale Bene, puoi
Quindi, la prima cosa che accadrà è che convertiremo queste immagini in un array di arpioni,
poi lo convertiremo in un tensore della torcia e infine metteremo il tensore della torcia all'interno di una variabile della
torcia che conterrà sia il tensore che un gradiente.
Questo è per i nostri grafici dinamici per calcolare in modo molto efficiente i gradienti in seguito più veloci di Kattie,
nel senso giusto.
Quindi questo è il nostro primo passo.
in grado di entrare nella rete neurale e quindi è lì che faremo tutta la propagazione dei segnali.
E poi, una volta ottenuto il corretto formato delle nostre immagini, esse saranno
Quindi, facciamo prima questo per convertire l'immagine nel formato giusto.
Quindi le nostre immagini sono così per gli input.
Ora creeremo una nuova variabile che sto chiamando input.
Questo è il vero input della rete neurale e questo input.
Dove sarà.
Per prima cosa dobbiamo prendere i nostri input.
Queste sono le nostre immagini originali.
Quindi, come abbiamo detto, vogliamo convertire queste immagini in array di Nampa.
Quindi per fare questo possiamo semplicemente prendere nessuno con cui ha una scorciatoia e poi la matrice di funzioni.
Quindi inseriamo le parentesi della serie di funzioni.
Eccoci.
Ora è convertito in qualcosa e dagli array.
Ma dato che le celle degli array di tastierino numerico conterranno i pixel, in realtà è più sicuro
specificare il tipo float.
È meglio assicurarci di avere alcuni float al momento per assicurarci di poter usare quel float.
Mi dispiace di sentire.
Va bene così ora abbiamo ancora un arbitro.
Ma con il tablet.
Va bene e questo è anche un altro motivo per cui i tensori sono per definizione array di un singolo tipo.
E così scegliamo il singolo tipo come float float 32.
Tutto ok.
Ora che abbiamo il nostro non-bio, il passo successivo è quello di convertirlo in un sensore di
tartaruga e per farlo possiamo usare ad esempio la torcia.
E poi dalla funzione di sottolineatura non-pilota che la convertirà in un sensore di torcia.
Eccoci.
E ora l'ultimo passo è mettere questi sensori di torcia in una variabile torcia contenente sia il
tensore che l'accordo.
E sai come farlo ovviamente prendiamo la nostra classe variabile perché in realtà tutto ciò che è dentro questa
variabile è in realtà l'input della classe variabile.
Ma volevo mostrartelo in questo modo perché sai che iniziamo con le nostre immagini di input,
quindi le convertiamo in array numerati, poi torchiamo i tensori e poi domani.
E ora stiamo bene.
Sono autorizzati ad entrare nella rete neurale che è prima gli occhi degli occhi e quindi i
livelli completamente collegati a condurre alle previsioni.
Quindi, parlando degli occhi degli occhi, è esattamente quello che faremo ora.
Ora propagheremo queste immagini permesse negli occhi degli occhi attraverso i tre
strati convoluzionali.
E per fare questo vedrai ora come è così semplice.
Questo perché abbiamo già il nostro cervello nel nostro corpo dalla funzione di init.
Abbiamo semplicemente bisogno di prendere il cervello del nostro cervello e applicare questo cervello alle immagini di input e questo diffonderà le
cose alla funzione di cibo qui dal cervello.
Questo propagherà i segnali all'interno del cervello e poiché la funzione diretta del cervello restituisce
i segnali di uscita che i neuroni dello strato di uscita contengono i valori Q Bene questo l'input del
cervello qui restituirà questo segnale in uscita e quindi stiamo per mettere qui se
si trasforma in una variabile e la chiameremo semplicemente in astuzia questa uscita è il segnale di uscita
del cervello.
e per fare questo useremo la seconda funzione in avanti dal corpo e per farlo.
E ora che abbiamo il segnale di uscita del cervello Bene, dobbiamo propagare questo segnale in uscita al corpo
Abbiamo semplicemente bisogno di prendere il nostro corpo e applicarlo naturalmente all'output perché la funzione Ford del corpo
assume come input i segnali di uscita del cervello.
Questo è esattamente l'output in questo momento e restituisce le azioni.
E quindi dal momento che restituisce le azioni.
Bene, qui aggiungeremo delle azioni per causare a se stesso quell'output.
cervello e poi dal cervello fin dall'inizio utilizzando la funzione della forma dal cervello che ci
prende e inserisce le immagini di input e poi le diffonde nel cervello per mantenere i valori chiave.
Bene, ora puoi vedere che molto semplicemente abbiamo propagato i segnali all'interno del
E poi propaghiamo questo segnale in uscita nel corpo in cui la funzione in avanti del nostro corpo fa in
modo che l'azione venga riprodotta.
E così ora resta l'unica cosa che dobbiamo fare e questa è l'ultima riga di codice
di questa parte che costruisce il.
Dobbiamo restituire l'azione da giocare e cioè le azioni.
azioni devono incanalare il formato e abbiamo bisogno di convertirle nuovamente in diritto e per
fare questo prenderemo la struttura dei dati di queste azioni e quindi aggiungeremo la funzione non-pilota e poi andremo.
Tuttavia in questo momento le
Ora abbiamo le azioni che abbiamo trasformato nel formato giusto.
Quindi congratulazioni.
Ora abbiamo finito con questa prima parte 1.
Costruiamo l'intelligenza artificiale in tre fasi.
Per prima cosa abbiamo creato il cervello dopo aver creato il corpo.
E in terzo luogo assembliamo il cervello nel corpo e abbiamo propagato l'intero segnale dagli occhi al
momento in cui giochiamo all'azione.
Quindi questo è un primo passo.
È stato un grande passo ma ora, come hai capito, abbiamo costruito un'IA AI, ma è ancora stupido.
Dobbiamo addestrarlo per essere intelligenti.
Quindi abbiamo bisogno di addestrarlo a fare ciò che volevamo fare e per farlo useremo la
parola dobbiamo fare gli ambienti che conoscete perché sta imparando dal mondo rafforzandosi quando ottiene una
buona ricompensa.
E venendo punito o indebolito quando sta ricevendo una parolaccia, è lì che entrerà in gioco
l'apprendimento delle cue.
E questo è esattamente ciò che faremo in questa parte per allenarci negli occhi con un profondo apprendimento Q convoluzionale.
Non vedo l'ora di iniziare e fino a quel momento.