WEBVTT

00:00.270 --> 00:06.230
Ciao e benvenuti a questa pipe ea Torro ora dobbiamo definire le cinque variabili di questa funzione

00:06.240 --> 00:09.560
che sono le tre convoluzioni e le connessioni temporali.

00:09.810 --> 00:11.100
Quindi iniziamo con il primo.

00:11.250 --> 00:18.690
Convolutional applica convoluzione alle immagini di input, quindi quelle sono le immagini originali e ora vedrai

00:18.690 --> 00:22.710
come tutto diventerà così semplice da creare questa convoluzione.

00:22.770 --> 00:29.070
Bene, quello che dobbiamo fare è in realtà creare un argomento di una classe specifica

00:29.070 --> 00:38.800
e questa classe è presa da e poi le classi arrivano al perché stiamo lavorando con immagini 2D e ora come puoi vedere

00:38.800 --> 00:40.930
dobbiamo mettere diversi argomenti.

00:40.930 --> 00:43.140
Il primo è nei canali.

00:43.190 --> 00:45.910
Mettiamolo nei canali.

00:45.970 --> 00:49.210
Il secondo è fuori dai canali.

00:49.330 --> 00:57.070
Il terzo è la dimensione di Kerno e il resto di loro è il passo che riempie i gruppi di dilatazione e il pregiudizio.

00:57.130 --> 00:59.120
E abbiamo valori diversi per tutti questi.

00:59.260 --> 01:02.290
Quindi non lo faremo, ma continueremo a mantenere i valori predefiniti.

01:02.470 --> 01:08.500
Ma ciò che è importante sono questi tre argomenti nei canali e canali e la dimensione del kernel e così

01:08.500 --> 01:09.740
indovino a cosa corrispondono.

01:09.880 --> 01:15.730
Molto semplicemente, in generale, corrisponde all'input della convoluzione e tutti i canali

01:15.730 --> 01:17.900
corrispondono all'output della conclusione.

01:17.920 --> 01:19.940
Quindi cosa sarà.

01:20.110 --> 01:24.460
Molto semplicemente questo sarà il numero di canali nelle nostre immagini.

01:24.610 --> 01:30.460
In realtà lavoreremo con le immagini in bianco e nero perché fondamentalmente non riconosciamo i colori per

01:30.460 --> 01:31.360
riconoscere i mostri.

01:31.450 --> 01:35.310
L'intelligenza artificiale è totalmente in grado di riconoscere i mostri in bianco e nero.

01:35.440 --> 01:39.200
Quindi non vediamo affatto i colori solo riconoscerli per la loro forma.

01:39.250 --> 01:44.380
Quindi useremo un canale in modo tale che un canale sia quando si hanno immagini in bianco e

01:44.380 --> 01:46.820
nero e tre canali quando si chiamano le immagini.

01:46.930 --> 01:51.320
E quindi dal momento che stiamo lavorando con le immagini in bianco

01:51.340 --> 01:59.730
e nero nei canali sarà uguale a uno dei nostri canali, quindi i nostri canali saranno uguali alle immagini che vorrete avere nel

01:59.730 --> 02:02.970
luogo convoluzionale che è l'output di questa costituzione uno.

02:02.970 --> 02:08.820
Quindi, in pratica, questo è uguale al numero di funzioni che desideri inserire nel testo delle tue

02:09.240 --> 02:15.040
immagini originali, perché chi creerà un'immagine per funzione che vogliamo rilevare, perché in pratica sai come funziona.

02:15.120 --> 02:21.390
di input e quindi il numero di immagini di output qui è il numero di funzionalità che vogliamo rilevare.

02:21.390 --> 02:26.450
Abbiamo applicato un rilevatore di caratteristiche all'immagine di input per rilevare una caratteristica specifica nell'immagine

02:26.460 --> 02:30.110
Quindi ora la domanda è quante funzionalità vogliamo rilevare.

02:30.240 --> 02:38.730
Beh, una pratica comune è iniziare con 32 rivelatori di caratteristiche e in modo da portarci al 32% di immagini

02:38.820 --> 02:46.170
in questo primo strato convoluzionale in modo che l'input sia un'immagine in bianco e nero un'immagine reale

02:46.170 --> 02:53.010
e l'output nel primo convoluzionale ci siano 32 immagini elaborate e per elaborazione intendo naturalmente che

02:53.380 --> 02:59.750
la conclusione è stata applicata all'immagine di input per ottenere 32 nuove immagini con caratteristiche rilevate.

03:00.240 --> 03:06.990
E quindi dobbiamo specificare una dimensione del kernel che non è altro che le dimensioni del

03:07.080 --> 03:09.450
quadrato che passerà attraverso l'immagine originale.

03:09.600 --> 03:15.350
E nella pratica comune usiamo entrambi per comprare due o tre larghe tre o cinque per cinque.

03:15.660 --> 03:22.170
E per il primo utilizzeremo un rilevatore di caratteristiche cinque per cinque che è un rilevatore di funzionalità

03:22.170 --> 03:24.580
che avrà cinque cinque cinque motori.

03:24.810 --> 03:29.290
E poi ridurremo la dimensione di questo kernel per i successivi strati convoluzionali.

03:29.340 --> 03:32.320
E parlando di questo è esattamente quello che faremo ora.

03:32.390 --> 03:40.860
Lo copiamo per definire la seconda convoluzione e quindi mi baso sul fatto che qui e ora è molto divertente e

03:40.890 --> 03:43.370
molto semplice è come un domino.

03:43.500 --> 03:49.260
canale di ingresso del secondo strato convoluzionale è il canale di uscita del primo convoluzionale.

03:49.260 --> 03:49.810
Il

03:49.950 --> 03:55.300
Quindi questo numero di uscite 32 Qui c'è lo stesso numero di ingressi 32 qui.

03:55.420 --> 04:01.290
E questo perché abbiamo 32 immagini nello strato convoluzionale di input della seconda convoluzione.

04:01.440 --> 04:09.830
E così la seconda convoluzione viene applicata a questo secondo strato convoluzionale per restituire un terzo strato

04:09.830 --> 04:10.340
convoluzionale.

04:10.530 --> 04:13.280
E quindi ora la domanda è quante nuove immagini vogliamo.

04:13.410 --> 04:19.820
Beh, lo stesso che crea 32 nuove immagini 32 è in realtà un numero molto comune nelle reti neurali convoluzionali se

04:19.830 --> 04:23.710
si osservano le architetture che si trovano 32 in molte di esse.

04:24.030 --> 04:29.910
E poi per le dimensioni del kernel Bene, abbiamo bisogno di ridurre la dimensione del kernel che è la dimensione del nostro

04:29.910 --> 04:30.610
rilevatore di funzionalità.

04:30.780 --> 04:37.680
E così ora andremo da cinque a quattro o anche tre e poi andremo ancora più piccoli.

04:37.920 --> 04:40.790
Va bene, la nostra seconda convoluzione è pronta.

04:40.830 --> 04:43.830
Prende come input 32 immagini di processo.

04:43.890 --> 04:51.130
Ognuno in una prima caratteristica dell'immagine di input originale e crea 32 nuove immagini.

04:51.270 --> 04:54.990
Grazie a queste dimensioni ridotte del rilevatore di caratteristiche.

04:55.120 --> 04:57.250
E così ora spingiamo ancora di più questo.

04:57.300 --> 05:05.450
Quindi sto copiando questo e incollando qui per creare una terza convoluzione per rilevare alcune funzionalità.

05:05.470 --> 05:08.010
E così ora è lo stesso i canali di input.

05:08.010 --> 05:13.800
Ecco il numero di immagini di input a sinistra della connessione di deconvoluzione e questo è il numero di

05:13.800 --> 05:17.740
immagini di precessione che sono andate a destra delle connessioni di convoluzione precedenti.

05:17.740 --> 05:18.710
Questo è 32.

05:18.750 --> 05:20.030
Pertanto ci dispiace per ascoltare.

05:20.030 --> 05:20.990
È perfetto.

05:21.220 --> 05:25.220
E ora la domanda è di nuovo quante nuove immagini vogliamo rilevare.

05:25.310 --> 05:31.130
Ora prenderemo 64 e quindi 64 immagini di precessione in uscita.

05:31.260 --> 05:36.800
E ovviamente ora prendiamo una dimensione del kernel più piccola e ne prenderemo due.

05:36.800 --> 05:42.660
E quindi questa è un'architettura molto classica di un convoluzionale ed è molto efficiente avere un

05:42.660 --> 05:45.840
alto livello di rilevamento delle caratteristiche all'interno delle immagini.

05:46.200 --> 05:53.010
Va bene e così ora che abbiamo i nostri tre convoluzionali ci sono le nostre tre connessioni di convoluzione

05:53.010 --> 05:53.510
qui.

05:53.640 --> 05:59.970
le 64 volte 32 volte 32 di nuovo immagini che abbiamo ottenuto da tutte queste convoluzioni, così abbiamo

05:59.970 --> 06:07.710
appiattito tutti i pixel di queste immagini e possiamo un unico vettore che diventerà l'input di una nuova rete neurale pienamente connessa.

06:08.160 --> 06:13.920
Bene, ora è il momento di ottenere le nostre connessioni dentate che ricordo che prenderemo questo enorme

06:14.190 --> 06:16.590
vettore che otteniamo dopo aver appiattito tutte

06:16.860 --> 06:22.230
E così è quando dobbiamo fare queste connessioni tra prima questo enorme vettore e uno strato nascosto

06:22.470 --> 06:27.710
e poi una seconda connessione completa tra il livello nascosto e l'output che sono composti dai neuroni

06:27.730 --> 06:28.270
di output.

06:28.320 --> 06:31.940
Ognuno corrisponde a un valore cubo delle azioni possibili.

06:31.980 --> 06:33.960
Quindi facciamo queste due connessioni.

06:33.960 --> 06:35.220
Sai come farlo.

06:35.220 --> 06:37.550
Questo è esattamente ciò che abbiamo fatto per l'auto che guida.

06:37.560 --> 06:38.800
Quindi facciamolo di nuovo.

06:39.000 --> 06:46.890
Bene, prima prendiamo il Maggio e prendiamo la classe di Lynnie perché, ancora una volta, la connessione che creiamo è

06:46.920 --> 06:49.060
un oggetto della classe dominante.

06:49.260 --> 06:50.550
E poi tra parentesi.

06:50.670 --> 06:58.620
Bene, è lo stesso per mettere le caratteristiche di input che sono il numero di esse e le caratteristiche di output.

06:58.850 --> 07:03.110
E così le funzionalità di input per la prima connessione completa che cosa sarà.

07:03.340 --> 07:10.300
in questo enorme cambiamento di vettore dopo aver appiattito tutte le immagini di processo dopo le tre convoluzioni.

07:10.480 --> 07:13.830
Bene, sarà uguale al numero di pixel presenti

07:13.830 --> 07:15.110
E quindi cosa fa questo numero.

07:15.220 --> 07:17.350
Beh, in realtà c'è un trucco qui.

07:17.380 --> 07:19.620
Questo numero è davvero difficile da ottenere.

07:19.660 --> 07:22.770
In realtà abbiamo bisogno di fare una funzione per calcolare quel numero.

07:22.960 --> 07:25.570
Non abbiamo una variabile che ci porterà questo numero.

07:25.570 --> 07:29.040
Dobbiamo calcolarlo e quindi cosa faremo ora.

07:29.150 --> 07:34.780
perché la prima volta potresti dire hey non lo faccio avere questo numero di neuroni nel vettore Flaten.

07:35.200 --> 07:40.930
E ora è molto importante capire la mentalità della programmazione che dobbiamo avere e provare a portarti la

07:41.110 --> 07:45.690
mentalità che è quello che devi pensare in questo momento per superare questo ostacolo

07:45.730 --> 07:46.650
Cosa dovrei fare.

07:46.660 --> 07:47.600
Sono bloccato qui.

07:47.800 --> 07:55.720
Beh, in realtà no, perché quello che puoi fare ora è semplicemente inserire qualsiasi nome qui che rappresenterà il numero di

07:55.720 --> 08:01.690
neuroni così rari che il numero di neuroni numero di neuroni e poi faremo semplicemente una

08:01.690 --> 08:05.130
funzione che ritornerà e questo numero di neuroni variabile.

08:05.180 --> 08:07.100
Questo numero di pixel che stiamo cercando.

08:07.330 --> 08:12.760
Quindi possiamo assolutamente fare in modo che possiamo mettere tutto questo molto vocale, ovviamente avremo un

08:12.760 --> 08:17.090
avvertimento perché non esiste ancora, ma lo creeremo in seguito con una funzione.

08:17.350 --> 08:21.140
E ci è totalmente permesso farlo anche se la funzione viene dopo.

08:21.170 --> 08:25.970
Questo è un tipico pensiero di programmazione che devi avere quando ottieni questo tipo di ostacolo.

08:26.020 --> 08:29.710
Bene, puoi fare una funzione per ottenere ciò che ti manca.

08:29.740 --> 08:32.640
Va bene e poi le nostre funzionalità e il nostro futuro.

08:32.650 --> 08:37.830
Questo è il numero di neuroni in un livello nascosto e questa volta dipende da te.

08:37.870 --> 08:41.230
Dipende dall'architettura della nuova rete che vuoi creare.

08:41.230 --> 08:44.230
E quindi un buon numero non sarebbe un numero piccolo.

08:44.230 --> 08:46.960
Quindi per esempio 40 neuroni potrebbero andare bene.

08:46.960 --> 08:48.660
Possiamo provare ad aumentarlo.

08:48.790 --> 08:51.280
Se l'allenamento non è troppo lento, puoi provare ad aumentarlo.

08:51.340 --> 08:56.750
Forse questo migliorerà le previsioni, ma iniziamo con 40 forse lo aumenteremo in seguito.

08:57.130 --> 09:04.690
Bene, questo è tutto per la prima connessione completa, quindi copieremo questa copia qui per la seconda connessione completa che

09:04.710 --> 09:09.300
è la connessione tra il livello nascosto e il livello di output.

09:09.370 --> 09:15.720
E così le caratteristiche qui diventano le caratteristiche del livello precedente e cioè 40.

09:15.790 --> 09:18.020
Quindi qui possiamo mettere 40.

09:18.190 --> 09:20.500
Questo è ovviamente il numero di neuroni in un livello.

09:20.860 --> 09:27.280
E il nostro futuro sarà uguale al numero di neuroni di uscita non dovrebbe esserci alcuna rete neurale.

09:27.340 --> 09:33.360
E dal momento che ogni neurone di uscita corrisponde a un nuovo valore e un Cuvee e la

09:33.370 --> 09:38.440
risposta a un'azione mentre il numero di neuroni di uscita qui è ovviamente il numero

09:38.740 --> 09:47.320
di azioni e abbiamo una variabile per questo che è il numero di azioni e quindi qui le azioni del numero di input e ci andiamo congratulazioni.

09:47.390 --> 09:53.850
Abbiamo trovato l'architettura della nostra rete neurale la nostra rete neurale è composta da tre strati

09:53.850 --> 09:55.960
convoluzionali e uno strato nascosto.

09:56.130 --> 10:03.020
Tutto questo in una grande CNN e questa CNN rileverà funzionalità nel gioco in modo che l'IA saprà dove

10:03.020 --> 10:06.550
deve andare dove deve andare e dove deve sparare.

10:06.900 --> 10:08.240
Quindi andiamo per questo passo.

10:08.340 --> 10:10.720
Questo è un primo passo molto importante fatto.

10:10.720 --> 10:16.020
Ora passeremo al prossimo passo che è ovviamente quello di ottenere questo numero di neuroni

10:16.020 --> 10:17.010
che ancora manca.

10:17.010 --> 10:21.930
Questo è in realtà il motivo per cui abbiamo l'avvertimento qui e il numero di telefono dei neuroni, ma non ci sono preoccupazioni.

10:21.960 --> 10:26.970
questo enorme vettore e metteremo quel numero in una variabile che chiamerà un numero di neuroni.

10:26.970 --> 10:30.210
Ora faremo una funzione che restituirà il numero di neuroni in

10:30.270 --> 10:32.070
Quindi facciamolo nel prossimo tutorial.

10:32.070 --> 10:33.130
Questo è il nostro prossimo passo.

10:33.180 --> 10:34.790
E fino ad allora goditi l'intelligenza artificiale.
