WEBVTT

00:00.530 --> 00:02.950
Ciao e benvenuto in questo tutorial Python.

00:02.990 --> 00:08.520
Quindi ora il prossimo passo è quello di far funzionare quel conteggio dei neuroni che ci darà quello che vogliamo.

00:08.540 --> 00:14.130
Questo è il numero di neuroni in questo enorme vettore dopo l'applicazione delle spire.

00:14.300 --> 00:19.640
Questa è l'unica informazione mancante di cui abbiamo bisogno in questo momento e la otterremo con la funzione.

00:19.700 --> 00:23.930
Quindi rendiamo conto di questa funzione che chiameremo.

00:24.280 --> 00:27.570
E quei neuroni centrali molto semplicemente.

00:27.830 --> 00:32.220
E come funzionano questi argomenti i neuroni del conteggio.

00:32.510 --> 00:39.450
numero di neuroni di uscita nello strato di appiattimento dipende in realtà solo da una cosa.

00:39.450 --> 00:44.540
Beh, prenderà l'oggetto in sé, ma poi prenderà qualcos'altro perché questo

00:44.660 --> 00:50.840
Dipende dalle dominazioni dell'immagine di input originale quella che si trova all'inizio della

00:50.840 --> 00:51.930
rete neurale.

00:52.160 --> 00:58.370
E quindi l'unico argomento di cui abbiamo bisogno in questo momento è in realtà il momento menziona il tempo delle immagini di input.

00:58.370 --> 01:03.410
Diamo quindi un nome a questo argomento che rappresenta il diamante e l'immagine di input.

01:03.520 --> 01:06.790
E lo chiameremo immagine.

01:07.220 --> 01:07.690
Tutto ok.

01:07.850 --> 01:14.720
dirti che le dimensioni effettive delle immagini di input provenienti da Dume saranno 80 per 80.

01:14.720 --> 01:16.850
E in questo momento posso

01:16.850 --> 01:23.330
Ridurremo le dimensioni delle immagini originali a 80 per 80 e questo sarà il formato

01:23.390 --> 01:26.270
delle immagini che entrano nella rete neurale.

01:26.270 --> 01:32.300
Quindi immaginarli sarà in realtà uno 80 80 e quello corrisponde al fatto che stiamo lavorando con immagini

01:32.300 --> 01:33.750
in bianco e nero.

01:33.830 --> 01:41.040
Questo è con un solo canale, quindi l'immagine sarà correlata al totale degli ottanta e ottanta.

01:41.280 --> 01:41.560
Tutto ok.

01:41.560 --> 01:43.590
Quindi questo è l'unico argomento di cui abbiamo bisogno.

01:43.660 --> 01:45.670
E ora esaminiamo i neuroni.

01:45.850 --> 01:47.280
Quindi, come hai intenzione di farlo.

01:47.500 --> 01:51.110
Beh, prima di tutto in realtà non abbiamo alcuna immagine di input in questo momento.

01:51.250 --> 01:54.070
Non abbiamo alcuna immagine negativa che possiamo importare.

01:54.070 --> 01:55.330
Lo faremo più tardi.

01:55.540 --> 02:01.240
Quindi la prima cosa che dobbiamo fare è creare un'immagine falsa ma che ha fatto introni 80 su 80.

02:01.240 --> 02:06.160
con pixel falsi e questo ci darà comunque il numero che vogliamo perché

02:06.160 --> 02:12.280
quel numero dipende solo dalle dimensioni e non dai pixel che si trovano all'interno delle immagini.

02:12.280 --> 02:13.320
Creeremo quell'immagine falsa

02:13.330 --> 02:15.640
Quindi questo crea solo un'immagine falsa per iniziare.

02:15.730 --> 02:18.520
E poi calcoleremo il numero di neuroni che vogliamo.

02:18.520 --> 02:23.860
Quindi il trucco per creare un'immagine falsa è bene lo chiameremo x.

02:23.890 --> 02:30.700
Prima di tutto e poi avremmo usato la torcia di Rand perché sai che metteremo dei pixel

02:30.700 --> 02:37.200
casuali in queste immagini che stiamo usando queste funzioni casuali da torche che è la funzione rand.

02:37.250 --> 02:42.740
Poi all'interno inseriremo come puoi vedere le dannate immagini.

02:42.850 --> 02:44.400
Quello è uno 80 80.

02:44.560 --> 02:50.500
Ma dal momento che metteremo questa immagine nella rete neurale e ricordando che la rete neurale può accettare

02:50.500 --> 02:55.170
solo lotti di stati di input che sono qui lotti di immagini di input.

02:55.370 --> 03:00.600
Creeremo quei diamanti falsi in cui possiamo eseguire direttamente questa funzione di esecuzione.

03:00.670 --> 03:05.720
In realtà, iniziamo solo con quello che corrisponderà al batch e quindi

03:05.730 --> 03:11.070
possiamo semplicemente metterlo su tutti i 188 corrispondenti ai domini dell'immagine di input.

03:11.110 --> 03:16.980
E come hai capito queste nomination sono contenute in questa immagine, argomento che rappresenta

03:16.980 --> 03:19.330
quella tabella 1 80 80.

03:19.420 --> 03:23.290
Quindi, abbiamo solo bisogno di aggiungere loro un'immagine.

03:23.620 --> 03:29.410
Ma per passare gli elementi del tavolo perché lo sai ora Image è un doppio come

03:29.410 --> 03:31.940
una lista di argomenti di una funzione.

03:32.020 --> 03:39.460
Abbiamo bisogno di aggiungere qui prima di immaginarli prima che il negozio di Apple consenta di passare gli elementi del

03:39.550 --> 03:44.100
file di Apple a lui come elenco di argomenti per la funzione.

03:44.170 --> 03:49.600
E come puoi vedere è esattamente ciò che viene specificato qui con il negozio e il diamante.

03:49.930 --> 03:56.640
Va bene, così creerai un'immagine di pixel falsi che non avrà nulla a che fare con le immagini.

03:56.800 --> 04:01.720
ancora in grado di ottenere il numero finale di neuroni e

04:01.720 --> 04:11.080
ora l'ultima cosa che dobbiamo ricordare è convertire questo vettore di input in una variabile torcia perché questo entrerà nella rete neurale.

04:11.380 --> 04:13.060
Ma di nuovo saremo

04:13.060 --> 04:13.380
Tutto ok.

04:13.390 --> 04:20.650
Quindi questo rappresenta ora un'immagine di input di pixel casuali che è stata appena convertita in una valida e che

04:20.650 --> 04:22.440
ora entrerà nella rete neurale.

04:22.570 --> 04:28.330
E più precisamente gli strati convoluzionali della rete neurale perché poiché abbiamo solo bisogno del

04:28.330 --> 04:34.100
numero di neuroni dopo che le circonvoluzioni sono state applicate, andremo semplicemente alle convoluzioni 3.

04:34.210 --> 04:36.440
Quindi fino al terzo strato convoluzionale.

04:36.580 --> 04:39.630
E non entreremo nei due collegamenti completi qui.

04:39.850 --> 04:45.490
E questo perché il numero di neuroni che vogliamo è tra la convoluzione 3 e la f. c 1.

04:45.520 --> 04:52.120
Va bene ora che abbiamo una immagine di input con le giuste menzioni Beh, è ​​tempo di propagare

04:52.180 --> 04:58.330
questa immagine nella rete neurale per raggiungere lo strato appiattito, quindi otterremo i neuroni nello strato appiattito

04:58.330 --> 05:03.850
e otterremo solo il informazione che vogliamo che sia il numero di neuroni in questo

05:03.850 --> 05:04.750
livello di appiattimento.

05:04.990 --> 05:08.950
Quindi ora dobbiamo fare esattamente quello che facciamo in una funzione avanzata.

05:08.950 --> 05:14.560
Abbiamo bisogno di propagare i segnali nella rete neurale ma solo negli strati convoluzionali fino a

05:14.560 --> 05:16.120
raggiungere lo strato di inondazione.

05:16.330 --> 05:17.360
Quindi facciamolo.

05:17.360 --> 05:25.660
Stiamo aggiornando x ora x è l'immagine di input e con la seconda X qui X diventerà il

05:25.660 --> 05:27.050
primo strato convoluzionale.

05:27.310 --> 05:32.930
E ora quello che dobbiamo fare è che i tre passaggi procedono nel primo passo applicando la deconvoluzione alle

05:32.950 --> 05:33.790
immagini di input.

05:33.850 --> 05:40.960
Poi il secondo passo applichiamo la potatura alle immagini e agli inserti convoluti che attiviamo i

05:40.960 --> 05:48.160
neuroni in queste immagini contorte e la x diventerà questo primo convoluzionale. Sono composti da tutti

05:48.160 --> 05:50.590
questi gruppi di Energis contorti.

05:51.010 --> 05:56.840
Facciamo quindi questo primo passo applicando la prima convoluzione alle immagini di input.

05:57.040 --> 06:07.540
Quindi quello che facciamo è prendere la nostra convoluzione in un solo io che convoca Lucian che andiamo applichiamo alle nostre immagini

06:07.550 --> 06:11.360
di input che finora sono rappresentate da x.

06:11.500 --> 06:14.290
Quindi questo è il primo che è stato fatto per primo.

06:14.320 --> 06:22.630
Secondo passo applicheremo lo spooling alle nostre immagini convolute restituite dalla convoluzione quando X e due climax

06:22.640 --> 06:26.880
che tirano Bene, prenderemo una funzione dal modulo funzionale.

06:26.920 --> 06:34.610
Quindi prendiamo la scorciatoia e poi useremo la funzione Max pool a D.

06:34.810 --> 06:42.340
una X tra parentesi del tiro massimo verso il perché suoniamo il prossimo tiro nelle immagini contorte.

06:42.360 --> 06:45.220
È quello che mettiamo in auto-convoluzione

06:45.750 --> 06:53.140
Ma questa funzione successiva richiede argomenti addizionali che sono prima la dimensione del kernel.

06:53.190 --> 06:59.190
Quindi di nuovo questa è la dimensione della finestra che scorre attraverso le immagini e che prenderà il massimo

06:59.190 --> 07:00.710
dei pixel in ogni diapositiva.

07:00.830 --> 07:06.750
In questo modo verranno comunque rilevate le funzionalità poiché le funzionalità sono associate a un valore elevato del

07:06.840 --> 07:07.750
pixel negli array.

07:07.890 --> 07:09.580
Come dici tu lezioni di intuizione.

07:09.780 --> 07:14.020
Quindi questa prima necessità umana documentata di input è questa dimensione del kernel.

07:14.100 --> 07:15.560
E ne prenderemo tre.

07:15.660 --> 07:17.650
Questa è una scelta comune per le dimensioni del kernel.

07:17.940 --> 07:25.200
E poi abbiamo bisogno di mettere il passo che sai per quanti pixel scivolerà nelle immagini.

07:25.200 --> 07:27.560
E faremo un passo indietro di due.

07:27.610 --> 07:29.400
Ancora una volta è una scelta comune.

07:29.820 --> 07:30.670
Quindi eccoci.

07:30.690 --> 07:32.530
Ora il secondo passo è fatto.

07:32.620 --> 07:38.910
passiamo al terzo passo che è quello di attivare tutti i neuroni in questo pool e le immagini contorte.

07:38.910 --> 07:39.580
E ora

07:39.610 --> 07:46.090
E questo primo strato di convoluzione e per fare questo ancora applicheremo una funzione a tutto questo.

07:46.170 --> 07:51.960
E così qui e riprenderò perché prenderemo un'altra funzione che, come avresti potuto immaginare,

07:52.050 --> 07:55.170
sarà una funzione di attivazione, ma quale.

07:55.230 --> 08:01.410
Come al solito verrà ripristinata la funzione di attivazione e forse ti ricordi il nome per quello

08:01.620 --> 08:02.330
è davvero.

08:02.790 --> 08:03.410
Eccoci.

08:03.450 --> 08:04.290
È lui.

08:04.290 --> 08:12.540
E così applichiamo davvero alle nostre immagini complesse raggruppate che è tutto questo.

08:12.540 --> 08:12.940
Tutto ok.

08:12.990 --> 08:14.270
E questo è tutto.

08:14.370 --> 08:15.320
Tre passi fatti.

08:15.330 --> 08:16.370
E 'stato molto veloce

08:16.500 --> 08:23.460
Quindi ricordate il modo in cui dobbiamo guardare questo è il primo che applichiamo la convoluzione alle nostre

08:23.460 --> 08:28.830
immagini di input, quindi applichiamo Max alle nostre immagini contorte ottenute con una convoluzione.

08:28.950 --> 08:35.730
strato convoluzionale su cui si è tirato un climax e in cui i neuroni sono ora attivati.

08:35.730 --> 08:43.960
E poi attiviamo i neuroni in tutto questo strato convoluzionale dello stagno con la funzione di attivazione del raddrizzatore così perfetta

08:44.050 --> 08:46.200
che otteniamo il nostro primo

08:46.260 --> 08:51.640
E così fondamentalmente ciò che fa è che si propaga i segnali dal primo strato convoluzionale

08:51.640 --> 08:52.500
a quello successivo.

08:52.630 --> 08:56.580
E a proposito di quello successivo è esattamente ciò di cui ci occuperemo adesso.

08:56.570 --> 09:01.660
Faremo la stessa cosa che abbiamo appena fatto sul primo convoluzionale al

09:01.660 --> 09:08.170
secondo strato convoluzionale per propagare nuovamente i segnali ulteriormente nella rete neurale attivando i neuroni

09:08.170 --> 09:09.660
del secondo strato convoluzionale.

09:09.850 --> 09:12.910
Ma prima di fare questo dobbiamo ottenere questo strato convoluzionale.

09:13.120 --> 09:18.330
E quindi applicheremo la convoluzione a X che ora è il primo strato convoluzionale.

09:18.460 --> 09:24.070
Bene applicheremo la convoluzione a 2 x per ottenere il secondo strato convoluzionale dopo il quale

09:24.070 --> 09:25.120
Max lo tirerà.

09:25.240 --> 09:27.860
E poi finalmente attivando Sirat.

09:27.970 --> 09:29.070
Quindi facciamolo.

09:29.170 --> 09:35.350
In realtà è molto facile solo copiarlo e incollarlo sotto.

09:35.350 --> 09:39.240
Ovviamente, dobbiamo sostituire anche la convoluzione per convoluzione.

09:39.520 --> 09:40.460
E noi andiamo.

09:40.480 --> 09:43.650
In realtà è pronto, vedi molto facile.

09:43.900 --> 09:50.200
E ora con questa linea propagiamo i segnali dal secondo convoluzionale al successivo che

09:50.260 --> 09:52.580
sarà il terzo convoluzionale lì.

09:52.720 --> 09:57.220
E per ottenere questo terzo convincente dovrà applicarlo di nuovo.

09:57.220 --> 10:04.630
Quindi sto copiando questo incollaggio qui sotto e sostituendo la convoluzione anche con la convoluzione 3 e ciò è fatto

10:04.870 --> 10:06.340
non è così pratico.

10:06.340 --> 10:11.490
Propaghiamo i segnali nelle tre lettere convoluzionali in una torcia elettrica.

10:11.500 --> 10:13.100
Grazie a questa fantastica struttura.

10:14.020 --> 10:15.340
Va bene così perfetto.

10:15.340 --> 10:21.250
Ora abbiamo i nostri segnali propagati fino al terzo strato convoluzionale e dopo.

10:21.360 --> 10:24.780
E a proposito di questo ci porta a ciò che stiamo cercando.

10:24.820 --> 10:28.510
Quello che ci interessa è l'appiattimento lì.

10:28.510 --> 10:33.620
Va bene ora che abbiamo il nostro terzo convoluzionale là che è l'ultima X qui.

10:33.790 --> 10:36.120
È tempo di fare il nostro appiattimento.

10:36.490 --> 10:37.990
E così è esattamente quello che faremo.

10:37.990 --> 10:44.200
Ora andremo ad appiattire tutti i pixel di questo terzo strato convoluzionale che stiamo per prendere

10:44.290 --> 10:48.430
tutti i pixel di tutti i canali del terzo strato convoluzionale.

10:48.640 --> 10:51.920
Li metteremo uno dopo l'altro in un enorme vettore.

10:52.150 --> 10:56.920
E ovviamente questo enorme vettore non sarà altro che lo strato appiattito e allo

10:56.920 --> 11:02.000
stesso tempo useremo un trucco per ottenere il numero di neuroni in questo appiattimento.

11:02.070 --> 11:03.790
Questo è quello che stiamo cercando.

11:03.790 --> 11:09.370
di neuroni che ci manca e quindi restituiamo direttamente ciò che vogliamo e in questo ritorno andremo ad appiattire

11:09.370 --> 11:15.130
il terzo strato convoluzionale e raggiungere lo stesso numero e il numero di neuroni in questo livello di appiattimento.

11:15.130 --> 11:16.330
Questo è il numero

11:16.630 --> 11:20.150
Quindi prenderemo X. che è il nostro terzo convoluzionale là.

11:20.320 --> 11:25.150
Prenderemo tutti i canali del terzo convoluzionale e useremo una funzione che è

11:25.150 --> 11:32.160
la funzione delle dimensioni per appiattire tutti i pixel di tutti questi canali in uno stesso enorme vettore.

11:32.230 --> 11:35.930
E quindi il trucco lo puoi trovare nel pito a guardare la fatica.

11:36.130 --> 11:42.400
Bene prima prendiamo i dati di X perché X è una struttura speciale, sai che è una torcia Voivode

11:42.400 --> 11:44.250
Quindi ha una struttura piuttosto complessa.

11:44.320 --> 11:51.920
Ma prima dobbiamo accedervi con i dati qui, quindi dobbiamo vedere cosa c'è dentro.

11:52.090 --> 11:57.700
Quindi usiamo questa funzione di visualizzazione e ora abbiamo bisogno di accedere a ciò che stiamo

11:57.700 --> 12:01.980
cercando e che è anche con gli argomenti 1 e meno 1.

12:02.230 --> 12:04.390
Devi capire cosa c'è dentro la struttura.

12:04.510 --> 12:10.060
Ma puoi capire che questo è il modo in cui otterremo questo numero di

12:10.150 --> 12:15.560
neuroni e quindi per finire dobbiamo aggiungere dimensioni tra parentesi e input interni 1.

12:15.880 --> 12:21.610
Quindi, in pratica, ciò che facciamo qui è che prendiamo tutti i pixel di tutti i canali

12:21.610 --> 12:27.180
e li mettiamo uno dopo l'altro in questo enorme vettore che sarà l'input della rete completamente connessa.

12:27.190 --> 12:29.250
Questo è fondamentalmente ciò che fa la dimensione.

12:29.410 --> 12:34.060
E con questo possiamo ottenere questo numero di nuovi che stiamo cercando.

12:34.060 --> 12:36.460
Va bene così ora otteniamo ciò che vogliamo.

12:36.490 --> 12:44.350
E così finalmente possiamo sostituire qui i neuroni del numero con ciò che viene restituito da questa funzione

12:44.530 --> 12:47.400
quando viene applicata al formato delle immagini.

12:47.440 --> 12:50.140
Quello è uno per 80 per 80.

12:50.170 --> 13:00.040
Quindi quello che dobbiamo fare ora è sostituire i neuroni del numero con la funzione dei neuroni

13:00.250 --> 13:09.040
di conteggio che applichiamo al formato delle immagini che sarà il totale 80 e 80.

13:09.460 --> 13:10.400
E noi andiamo.

13:10.510 --> 13:17.140
E naturalmente non dimentichiamo noi stessi perché il conteggio dei neuroni è in realtà un metodo del test della CNN.

13:17.170 --> 13:18.490
Quindi abbiamo bisogno di aggiungere il.

13:18.700 --> 13:21.190
E ora l'avviso dovrebbe scomparire.

13:21.190 --> 13:22.540
E noi andiamo.

13:22.540 --> 13:23.890
Ora tutto è buono.

13:23.980 --> 13:29.930
Otteniamo l'architettura della rete neurale senza nulla e abbiamo questa funzione di contrappesi nel caso in

13:30.140 --> 13:35.290
cui tu sappia che vuoi provare altre architetture e non vuoi contare manualmente il

13:35.290 --> 13:36.210
numero di neuroni.

13:36.340 --> 13:39.940
Basta usare questa funzione per riprodurla nel formato delle tue immagini.

13:40.180 --> 13:42.130
E questo ti porterà direttamente ciò che desideri.

13:42.130 --> 13:45.810
Questo è il numero di neuroni nello strato di inondazione senza dover fare nulla.

13:45.820 --> 13:49.450
E ovunque l'architettura è critica.

13:49.480 --> 13:57.040
E ora abbiamo finito con il primo grande passo importante di questo cervello che stiamo facendo e abbiamo un

13:57.040 --> 13:57.720
ultimo passo.

13:57.790 --> 14:02.500
Questa è l'ultima funzione per stabilire quale sarà la principale funzione di avanzamento.

14:02.590 --> 14:07.730
occhi dell'occhio allo strato di output che è dopo la seconda connessione.

14:07.730 --> 14:12.160
Quindi propagheremo i segnali dall'inizio del cervello che proviene dagli

14:12.460 --> 14:15.850
Quindi lo faremo nei prossimi due toile e fino ad allora la nostra IA.
