WEBVTT

00:00.420 --> 00:04.730
Ciao e benvenuto all'ultimo passaggio di questo primo capitolo.

00:04.860 --> 00:10.500
Ora l'unica cosa che dobbiamo fare è rendere questa funzione Ford che propagherà il

00:10.500 --> 00:16.650
segnale fin dall'inizio, quando il cervello arriverà alla fine dell'immagine quando inserirò l'azione, così faremo

00:16.650 --> 00:22.260
questo tutta la funzione e questo sarà il nostro ultimo passo prima di passare

00:22.260 --> 00:26.710
alla formazione della nostra IA con un profondo kulang convoluzionale.

00:26.890 --> 00:28.080
Quindi facciamolo.

00:28.080 --> 00:34.470
Prenderemo la chiamata alla funzione che in realtà è simile alla funzione init che è una funzione

00:34.470 --> 00:38.760
esistente, ma questa volta la usiamo per chiamare alcune altre funzioni.

00:38.790 --> 00:43.170
Quelli che abbiamo fatto prima, perché sai che useremo la funzione in avanti dal

00:43.290 --> 00:45.490
cervello e la funzione portuale dal corpo.

00:45.630 --> 00:50.270
E così ora stiamo usando questa funzione per chiamare fondamentalmente queste funzioni.

00:50.550 --> 00:53.160
Quindi la chiamata sta per prendere due argomenti.

00:53.160 --> 00:54.330
Il primo è sé.

00:54.330 --> 01:00.220
Certamente l'oggetto e il secondo argomento che secondo te cosa sarà.

01:00.360 --> 01:02.910
Bene, stiamo facendo l'intera propagazione questa volta.

01:02.910 --> 01:08.460
naturalmente, le immagini di input perché ovviamente questo è il punto di partenza quando l'IA sta giocando.

01:08.460 --> 01:10.860
Quindi, quello che vogliamo prendere come input è,

01:10.860 --> 01:16.080
Prima visualizza le immagini del gioco, quindi diffonde i segnali nel cervello e

01:16.080 --> 01:17.180
poi riproduce l'azione.

01:17.190 --> 01:20.130
Quindi il secondo argomento sarà input.

01:20.610 --> 01:24.740
E ora siamo pronti a fare tutta questa propagazione.

01:24.810 --> 01:26.220
Quindi facciamolo di nuovo.

01:26.220 --> 01:31.900
Quindi il primo passo in cui è il primo passo è ricevere le immagini di input dal gioco.

01:32.190 --> 01:38.010
immaginare che dobbiamo formattarle in una struttura speciale e la struttura è ovviamente una struttura torcia.

01:38.010 --> 01:42.840
E dal momento che queste immagini stanno per entrare nella rete neurale Bene, puoi

01:42.840 --> 01:48.420
Quindi, la prima cosa che accadrà è che convertiremo queste immagini in un array di arpioni,

01:48.420 --> 01:55.320
poi lo convertiremo in un tensore della torcia e infine metteremo il tensore della torcia all'interno di una variabile della

01:55.500 --> 01:58.260
torcia che conterrà sia il tensore che un gradiente.

01:58.350 --> 02:03.780
Questo è per i nostri grafici dinamici per calcolare in modo molto efficiente i gradienti in seguito più veloci di Kattie,

02:03.780 --> 02:04.460
nel senso giusto.

02:04.620 --> 02:06.200
Quindi questo è il nostro primo passo.

02:06.270 --> 02:12.130
in grado di entrare nella rete neurale e quindi è lì che faremo tutta la propagazione dei segnali.

02:12.360 --> 02:16.320
E poi, una volta ottenuto il corretto formato delle nostre immagini, esse saranno

02:16.380 --> 02:20.340
Quindi, facciamo prima questo per convertire l'immagine nel formato giusto.

02:20.430 --> 02:23.050
Quindi le nostre immagini sono così per gli input.

02:23.220 --> 02:26.780
Ora creeremo una nuova variabile che sto chiamando input.

02:26.820 --> 02:30.470
Questo è il vero input della rete neurale e questo input.

02:30.510 --> 02:31.760
Dove sarà.

02:31.920 --> 02:34.490
Per prima cosa dobbiamo prendere i nostri input.

02:34.530 --> 02:36.650
Queste sono le nostre immagini originali.

02:36.870 --> 02:42.190
Quindi, come abbiamo detto, vogliamo convertire queste immagini in array di Nampa.

02:42.330 --> 02:49.260
Quindi per fare questo possiamo semplicemente prendere nessuno con cui ha una scorciatoia e poi la matrice di funzioni.

02:49.500 --> 02:52.850
Quindi inseriamo le parentesi della serie di funzioni.

02:52.890 --> 02:53.340
Eccoci.

02:53.340 --> 02:55.940
Ora è convertito in qualcosa e dagli array.

02:56.190 --> 03:02.790
Ma dato che le celle degli array di tastierino numerico conterranno i pixel, in realtà è più sicuro

03:02.790 --> 03:04.230
specificare il tipo float.

03:04.310 --> 03:11.040
È meglio assicurarci di avere alcuni float al momento per assicurarci di poter usare quel float.

03:11.090 --> 03:12.690
Mi dispiace di sentire.

03:12.720 --> 03:15.390
Va bene così ora abbiamo ancora un arbitro.

03:15.540 --> 03:17.330
Ma con il tablet.

03:17.720 --> 03:24.150
Va bene e questo è anche un altro motivo per cui i tensori sono per definizione array di un singolo tipo.

03:24.270 --> 03:28.060
E così scegliamo il singolo tipo come float float 32.

03:28.060 --> 03:28.350
Tutto ok.

03:28.350 --> 03:34.440
Ora che abbiamo il nostro non-bio, il passo successivo è quello di convertirlo in un sensore di

03:34.440 --> 03:37.990
tartaruga e per farlo possiamo usare ad esempio la torcia.

03:38.070 --> 03:45.380
E poi dalla funzione di sottolineatura non-pilota che la convertirà in un sensore di torcia.

03:45.420 --> 03:46.200
Eccoci.

03:46.210 --> 03:52.320
E ora l'ultimo passo è mettere questi sensori di torcia in una variabile torcia contenente sia il

03:52.320 --> 03:53.230
tensore che l'accordo.

03:53.400 --> 04:02.010
E sai come farlo ovviamente prendiamo la nostra classe variabile perché in realtà tutto ciò che è dentro questa

04:02.010 --> 04:05.530
variabile è in realtà l'input della classe variabile.

04:05.760 --> 04:11.400
Ma volevo mostrartelo in questo modo perché sai che iniziamo con le nostre immagini di input,

04:11.400 --> 04:15.890
quindi le convertiamo in array numerati, poi torchiamo i tensori e poi domani.

04:16.170 --> 04:17.220
E ora stiamo bene.

04:17.220 --> 04:23.370
Sono autorizzati ad entrare nella rete neurale che è prima gli occhi degli occhi e quindi i

04:23.370 --> 04:25.770
livelli completamente collegati a condurre alle previsioni.

04:26.220 --> 04:30.340
Quindi, parlando degli occhi degli occhi, è esattamente quello che faremo ora.

04:30.480 --> 04:37.280
Ora propagheremo queste immagini permesse negli occhi degli occhi attraverso i tre

04:37.290 --> 04:38.720
strati convoluzionali.

04:38.850 --> 04:41.620
E per fare questo vedrai ora come è così semplice.

04:41.640 --> 04:46.290
Questo perché abbiamo già il nostro cervello nel nostro corpo dalla funzione di init.

04:46.320 --> 04:56.190
Abbiamo semplicemente bisogno di prendere il cervello del nostro cervello e applicare questo cervello alle immagini di input e questo diffonderà le

04:56.190 --> 04:59.830
cose alla funzione di cibo qui dal cervello.

05:00.430 --> 05:06.190
Questo propagherà i segnali all'interno del cervello e poiché la funzione diretta del cervello restituisce

05:06.520 --> 05:13.600
i segnali di uscita che i neuroni dello strato di uscita contengono i valori Q Bene questo l'input del

05:13.610 --> 05:19.030
cervello qui restituirà questo segnale in uscita e quindi stiamo per mettere qui se

05:19.090 --> 05:26.120
si trasforma in una variabile e la chiameremo semplicemente in astuzia questa uscita è il segnale di uscita

05:26.120 --> 05:26.690
del cervello.

05:26.930 --> 05:31.970
e per fare questo useremo la seconda funzione in avanti dal corpo e per farlo.

05:31.970 --> 05:37.990
E ora che abbiamo il segnale di uscita del cervello Bene, dobbiamo propagare questo segnale in uscita al corpo

05:38.030 --> 05:46.370
Abbiamo semplicemente bisogno di prendere il nostro corpo e applicarlo naturalmente all'output perché la funzione Ford del corpo

05:46.370 --> 05:50.600
assume come input i segnali di uscita del cervello.

05:50.660 --> 05:55.880
Questo è esattamente l'output in questo momento e restituisce le azioni.

05:56.000 --> 05:58.080
E quindi dal momento che restituisce le azioni.

05:58.380 --> 06:03.530
Bene, qui aggiungeremo delle azioni per causare a se stesso quell'output.

06:03.920 --> 06:09.380
cervello e poi dal cervello fin dall'inizio utilizzando la funzione della forma dal cervello che ci

06:09.380 --> 06:15.410
prende e inserisce le immagini di input e poi le diffonde nel cervello per mantenere i valori chiave.

06:15.410 --> 06:19.830
Bene, ora puoi vedere che molto semplicemente abbiamo propagato i segnali all'interno del

06:20.240 --> 06:25.400
E poi propaghiamo questo segnale in uscita nel corpo in cui la funzione in avanti del nostro corpo fa in

06:25.520 --> 06:26.900
modo che l'azione venga riprodotta.

06:26.900 --> 06:32.300
E così ora resta l'unica cosa che dobbiamo fare e questa è l'ultima riga di codice

06:32.300 --> 06:34.510
di questa parte che costruisce il.

06:34.760 --> 06:39.370
Dobbiamo restituire l'azione da giocare e cioè le azioni.

06:39.530 --> 06:45.020
azioni devono incanalare il formato e abbiamo bisogno di convertirle nuovamente in diritto e per

06:45.260 --> 06:51.660
fare questo prenderemo la struttura dei dati di queste azioni e quindi aggiungeremo la funzione non-pilota e poi andremo.

06:51.890 --> 06:53.840
Tuttavia in questo momento le

06:53.840 --> 06:56.780
Ora abbiamo le azioni che abbiamo trasformato nel formato giusto.

06:56.780 --> 06:58.040
Quindi congratulazioni.

06:58.040 --> 07:00.660
Ora abbiamo finito con questa prima parte 1.

07:00.770 --> 07:03.410
Costruiamo l'intelligenza artificiale in tre fasi.

07:03.410 --> 07:06.860
Per prima cosa abbiamo creato il cervello dopo aver creato il corpo.

07:06.860 --> 07:13.430
E in terzo luogo assembliamo il cervello nel corpo e abbiamo propagato l'intero segnale dagli occhi al

07:13.430 --> 07:15.130
momento in cui giochiamo all'azione.

07:15.560 --> 07:17.100
Quindi questo è un primo passo.

07:17.120 --> 07:22.200
È stato un grande passo ma ora, come hai capito, abbiamo costruito un'IA AI, ma è ancora stupido.

07:22.220 --> 07:24.110
Dobbiamo addestrarlo per essere intelligenti.

07:24.170 --> 07:29.030
Quindi abbiamo bisogno di addestrarlo a fare ciò che volevamo fare e per farlo useremo la

07:29.030 --> 07:34.100
parola dobbiamo fare gli ambienti che conoscete perché sta imparando dal mondo rafforzandosi quando ottiene una

07:34.100 --> 07:34.690
buona ricompensa.

07:34.760 --> 07:40.610
E venendo punito o indebolito quando sta ricevendo una parolaccia, è lì che entrerà in gioco

07:40.610 --> 07:41.670
l'apprendimento delle cue.

07:41.690 --> 07:47.510
E questo è esattamente ciò che faremo in questa parte per allenarci negli occhi con un profondo apprendimento Q convoluzionale.

07:47.510 --> 07:50.270
Non vedo l'ora di iniziare e fino a quel momento.