WEBVTT

00:00.520 --> 00:02.690
Ciao e benvenuto in questo tutorial Python.

00:02.860 --> 00:05.680
Va bene, quindi siamo molto eccitati per il terreno davanti a noi.

00:05.680 --> 00:10.690
Inizieremo creando l'architettura della rete neurale che creeremo la rete neurale che

00:10.690 --> 00:16.740
sarà al centro della nostra intelligenza artificiale e che restituirà l'azione a 90 anni.

00:16.930 --> 00:18.060
Quindi facciamolo.

00:18.130 --> 00:23.130
Quindi, dal momento che vogliamo che la nostra rete neurale sia oggettiva, la faremo diventare classe.

00:23.200 --> 00:25.100
E questo perché è molto più conveniente.

00:25.180 --> 00:28.370
Sai che la classe è il modello di qualcosa che vogliamo costruire.

00:28.540 --> 00:34.000
Vogliamo costruire una rete neurale e abbiamo bisogno di fare una sorta di istruzioni che saranno tutte

00:34.090 --> 00:35.080
contenute nella classe.

00:35.140 --> 00:37.910
E in questa classe faremo due funzioni.

00:37.960 --> 00:42.810
Innanzitutto la funzione init che è la funzione che emerge ogni volta che si fa lezione.

00:43.000 --> 00:47.770
E questo fondamentalmente definisce la variabile del tuo oggetto che è la rete neurale.

00:47.920 --> 00:52.600
Conoscete le variabili associate all'oggetto in contrasto con le variabili globali.

00:52.840 --> 00:57.910
funzione che definirà l'architettura della nuova rete che conosci definendo il livello di input che sarà

00:57.910 --> 01:03.460
composto da cinque neuroni di input perché abbiamo cinque dimensioni per il vettore codificato degli stati di input.

01:03.790 --> 01:05.680
E così questa è in questa

01:05.890 --> 01:08.080
Quindi definiremo alcuni livelli nascosti.

01:08.110 --> 01:12.940
Forse inizierai con uno strato nascosto e poi sarai il benvenuto a provare altre architetture

01:12.940 --> 01:13.920
della rete neurale.

01:14.200 --> 01:20.080
E poi ovviamente finiremo con il livello di output che conterrà le possibili azioni

01:20.110 --> 01:21.940
che possiamo giocare ogni volta.

01:22.180 --> 01:24.730
Questo è esattamente ciò che faremo in questa funzione.

01:24.850 --> 01:30.460
la funzione diretta e che sarà la funzione che attiverà i neuroni nella rete neurale.

01:30.460 --> 01:34.870
E poi faremo un'altra funzione ancora all'interno della classe che sarà

01:34.870 --> 01:40.570
Sapete che questo attiverà i segnali e quindi useremo una funzione di attivazione raddrizzata perché ovviamente

01:40.570 --> 01:46.920
abbiamo a che fare con un problema puramente non lineare e questa funzione rettificata rompe la linearità.

01:47.200 --> 01:53.340
Ma per lo più stiamo facendo questa funzione Ford per restituire i valori q che sono le uscite della rete.

01:53.500 --> 01:56.110
Ma abbiamo un valore chiave per ogni azione.

01:56.200 --> 02:02.710
E in seguito restituiremo l'azione finale prendendo il massimo dei valori chiave o utilizzando un

02:02.710 --> 02:03.880
metodo Max morbido.

02:04.030 --> 02:05.270
Lo vedremo dopo.

02:05.440 --> 02:10.330
Quindi in questo tutorial inizieremo implementando la funzione init e successivamente

02:10.330 --> 02:12.880
il prossimo implementerà la funzione forward.

02:12.880 --> 02:13.810
Quindi facciamolo.

02:13.810 --> 02:17.060
Per prima cosa dobbiamo presentare la nostra classe.

02:17.200 --> 02:22.930
Quindi iniziamo con la lezione e diamo un nome alla nostra classe che è dove possiamo chiamarla rete.

02:23.650 --> 02:29.980
E poi in questa classe di rete userò una tecnica di programmazione degli oggetti che è chiamata ereditarietà

02:30.310 --> 02:35.120
e che è solo per ereditare da tutti gli strumenti di una classe genitore.

02:35.200 --> 02:41.550
Quindi la nostra classe di rete che stiamo per realizzare è un test per bambini di una classe più ampia che è.

02:41.770 --> 02:44.110
E quel modulo.

02:44.470 --> 02:50.790
Quindi è solo per ereditare da tutti gli strumenti di questa classe di moduli che ovviamente sono gli strumenti per

02:50.790 --> 02:51.940
implementare una rete neurale.

02:51.940 --> 02:57.880
Quindi questo è un trucco molto potente ed evolutivo nella programmazione orientata agli oggetti che sta andando in eredità.

02:57.910 --> 03:02.670
E proprio ora stiamo ereditando da questa classe genitore del modulo.

03:02.800 --> 03:06.000
Va bene e ora siamo pronti per entrare nella classe.

03:06.130 --> 03:12.910
Quindi premo invio due volte perché creeremo due funzioni e inizieremo con la

03:13.140 --> 03:14.280
funzione finale.

03:14.350 --> 03:20.470
Quindi la funzione init dobbiamo nominarla in questo modo con due in questo corso e poi dentro.

03:20.650 --> 03:25.750
E poi di nuovo per sottolineare che è solo la sintassi di Python che è proprio come dobbiamo farlo.

03:25.930 --> 03:28.460
E poi dobbiamo mettere gli argomenti.

03:28.720 --> 03:30.340
Quindi abbiamo tre argomenti.

03:30.340 --> 03:35.800
Il primo è un argomento obbligatorio che è in realtà sé e sé.

03:35.800 --> 03:42.250
Non c'è alcun mistero a riguardo che si riferisca all'oggetto che verrà creato da questa classe che stiamo

03:42.250 --> 03:42.810
per realizzare.

03:42.820 --> 03:44.400
Sai che stiamo facendo questa lezione.

03:44.470 --> 03:48.980
È come un'istruzione del modello di questa rete neurale che vogliamo costruire.

03:49.180 --> 03:53.620
E poi, una volta che la classe è pronta, possiamo fare il maggior numero di reti che vogliamo.

03:53.620 --> 04:00.130
E ognuna di queste nuove reti sarà oggetto di questa classe e dato che useremo l'oggetto

04:00.400 --> 04:07.630
per altri scopi di cui abbiamo bisogno, ma quali sono le variabili dell'oggetto e di Spudis, stiamo

04:07.630 --> 04:11.900
usando questo sé per specificare che noi Mi riferisco all'oggetto.

04:12.100 --> 04:18.430
Quindi ogni volta che voglio usare disponibile dal mio oggetto userò self prima della variabile per

04:18.430 --> 04:21.340
specificare che questa è una variabile dell'oggetto.

04:21.340 --> 04:25.680
ovviamente il numero di neuroni di input e il numero di neuroni di output.

04:25.680 --> 04:30.240
Va bene, questo è il primo argomento e quindi abbiamo altri due argomenti che sono

04:30.550 --> 04:38.220
Quindi il numero di neuroni di input lo chiameremo dimensione di input e questo è in realtà

04:38.310 --> 04:45.890
cinque perché i nostri vettori di input hanno cinque dimensioni su tre segnali più orientamento più meno

04:45.900 --> 04:51.020
che sono vettori di valori codificati che descrivono uno stato dell'ambiente.

04:51.210 --> 04:54.960
Questi cinque valori sono sufficienti per descrivere uno stato dell'ambiente.

04:54.960 --> 05:00.600
Avremmo potuto pensare a meno valori o più valori, ma è quello che ho provato e in realtà ha senso perché

05:00.600 --> 05:05.520
in realtà abbiamo bisogno di un segnale da sinistra uno di fronte a noi e uno a destra.

05:05.520 --> 05:10.860
abbiamo questo orientamento e l'orientamento negativo a te sapere tenere traccia dell'obiettivo che stavi cercando di raggiungere.

05:10.860 --> 05:17.370
Sai che quando guidiamo un'auto, potremmo partire per un segnale a 360 ° che conosciamo come i segnali nella parte superiore

05:17.400 --> 05:22.200
delle auto di Google, che possiamo guidare totalmente da soli con tre sensori e quindi

05:22.530 --> 05:29.160
E poi abbiamo ovviamente i neuroni di uscita della nostra rete che corrispondono alle azioni e abbiamo tre azioni

05:29.160 --> 05:32.840
possibili che vanno a sinistra andando dritte o andando a destra.

05:32.880 --> 05:38.520
E quindi lo chiamerò e l'azione e ce ne saranno tre.

05:38.520 --> 05:39.030
Tutto ok.

05:39.120 --> 05:44.850
Finora dobbiamo solo dare nomi agli input e poi useremo queste pallavolo per fare le condizioni all'interno

05:44.940 --> 05:46.140
della rete neurale.

05:47.090 --> 05:55.010
Va bene allora e si inizia usando un altro trucco con la torcia questo trucco è una

05:55.010 --> 05:59.310
superfunzione che è una funzione che eredita effettivamente dal modulo.

05:59.390 --> 06:02.730
Ecco perché abbiamo dovuto usare l'ereditarietà per ereditare anche il modulo.

06:02.750 --> 06:04.440
Questo è il primo da usare.

06:04.520 --> 06:11.120
E quindi fondamentalmente stiamo usando questa superfunzione super trucco per poter usare gli strumenti del modulo che

06:11.580 --> 06:13.320
è molto più efficiente.

06:13.670 --> 06:18.620
E all'interno della superfunzione ho solo bisogno di specificare prima la rete.

06:18.650 --> 06:25.100
classe di rete chul, perché questa è ereditata dal modulo genitore di classe e quindi dal nostro oggetto.

06:25.550 --> 06:27.360
Quindi questa è la nostra

06:27.380 --> 06:35.220
E poi aggiungo solo questo e sono in una funzione come questa esattamente come l'abbiamo chiamata.

06:35.570 --> 06:39.350
Va bene, questo è solo un trucco che serve solo per usare tutti gli strumenti che ho.

06:39.360 --> 06:46.270
E in quel modulo possiamo passare al prossimo passo che è quello di specificare il livello di input.

06:46.550 --> 06:53.300
Quindi, in pratica, quello che devo fare è introdurre una nuova variabile che sarà collegata all'oggetto e

06:53.300 --> 06:57.120
questa variabile conterrà il numero di neuroni di input.

06:57.170 --> 07:05.140
Quindi, per non essere confuso con la dimensione dell'ingresso, la dimensione dell'ingresso è l'argomento della funzione finale.

07:05.180 --> 07:09.710
non è la variabile che è collegata all'oggetto, ma la variabile che è collegata all'oggetto.

07:09.710 --> 07:10.360
Ma quella

07:10.520 --> 07:16.520
Come ho appena detto, è necessario specificare che è invece collegato all'oggetto, quindi usiamo un

07:17.230 --> 07:22.130
autodidatta e ora diamo un nome a questa prima variabile associata all'oggetto.

07:22.190 --> 07:24.870
E quindi possiamo semplicemente dare lo stesso nome dell'input.

07:24.920 --> 07:33.650
Possiamo chiamarlo dimensione di input e diremo che è uguale agli argomenti una funzione che è la dimensione di input.

07:33.680 --> 07:34.080
Tutto ok.

07:34.130 --> 07:39.900
Ogni volta che sto creando un oggetto dalla classe di rete e sto specificando la dimensione dell'input come ad

07:39.900 --> 07:41.170
esempio sto mettendo 5.

07:41.180 --> 07:47.330
Ci sarà di 5 qui e quindi la variabile di input size del nostro oggetto avrà il valore di

07:47.690 --> 07:54.110
5 perché questa dimensione di input sarà 5 e quindi la nostra nuova rete avrà 5 neuroni di input

07:54.110 --> 07:55.470
nel layer di input.

07:55.490 --> 07:55.790
Tutto ok.

07:55.790 --> 08:02.180
E poi è lo stesso per l'altra variabile che vogliamo collegare agli oggetti.

08:02.210 --> 08:08.100
E come avrai intuito, questa sarà una variabile per il numero di neuroni di uscita.

08:08.330 --> 08:15.030
E dire che prendiamo il nostro oggetto di sé e poi diamo un nome a questa

08:15.040 --> 08:17.740
seconda variabile dell'oggetto che chiameremo e all'azione.

08:18.170 --> 08:23.600
E questo sarà uguale a questo argomento qui dato il numero di azioni che è il numero di neuroni

08:23.600 --> 08:24.250
di uscita.

08:24.530 --> 08:30.850
E quindi lo impostiamo in modo uguale all'azione e l'azione sarà uguale a tre.

08:30.890 --> 08:37.930
Pertanto la variabile e l'azione associata al nostro oggetto in una rete otterranno il valore di tre.

08:38.240 --> 08:41.680
In realtà possiamo vedere un avvertimento qui dice un nome indefinito.

08:41.720 --> 08:44.180
E poi bene, perché qui usiamo il.

08:44.230 --> 08:46.030
E poi la scorciatoia.

08:46.350 --> 08:48.530
E dobbiamo usare una scorciatoia qui.

08:48.590 --> 08:52.780
E per le nostre torche partono e in Mudgal e poi scomparirà.

08:52.880 --> 08:53.670
Eccoci qui.

08:53.690 --> 08:54.580
Perfezionare.

08:54.590 --> 09:00.800
Al momento abbiamo nuovi avvisi tutti gli avvertimenti qui sono solo per specificare che ciò che importiamo non è

09:00.800 --> 09:01.520
ancora utilizzato.

09:01.580 --> 09:04.660
Va bene li useremo in seguito.

09:04.670 --> 09:10.010
Bene, allora abbiamo altre due variabili che vogliamo definire per oggetto.

09:10.190 --> 09:15.820
la piena connessione delle connessioni complete tra i diversi strati della nostra rete neurale.

09:15.830 --> 09:16.810
E questa sarà

09:16.820 --> 09:21.800
Quindi visto che adesso vogliamo creare una rete neurale composta da una sola testa nel loro mondo

09:21.800 --> 09:23.440
ci saranno due connessioni complete.

09:23.570 --> 09:27.740
Ci sarà una prima connessione completa tra il livello di input e il livello nascosto.

09:27.980 --> 09:32.450
E un secondo collegamento completo tra la collina e lo strato di uscita.

09:32.480 --> 09:34.770
Quindi iniziamo con la prima connessione completa.

09:34.890 --> 09:43.310
Lo chiameremo SE1 E di nuovo uso qui per specificare che FC uno è una variabile del mio oggetto

09:43.780 --> 09:44.530
per risolverlo.

09:44.530 --> 09:47.490
FC quello che sarà uguale a.

09:47.630 --> 09:55.160
E ora usiamo il modulo N in e useremo una funzione chiamata R lineare e questo è esattamente

09:55.160 --> 10:02.080
per rendere questa connessione completa tra i neuroni e il livello di input ai neuroni del nascosto.

10:02.180 --> 10:04.090
E cosa intendo per connessione completa.

10:04.160 --> 10:09.190
Ciò significa che tutti i neuroni dello strato di input saranno tutti collegati a tutti i neuroni del

10:09.190 --> 10:09.920
Qui in là.

10:10.190 --> 10:16.140
E così per fare questa connessione usiamo questa funzione lineare a cui dobbiamo mettere alcuni argomenti.

10:16.190 --> 10:19.880
E come puoi vedere questi argomenti sono nelle caratteristiche.

10:19.880 --> 10:25.370
Quindi questo è il numero di neuroni della prima legge che vuoi collegare loro caratteristiche che sono il

10:25.370 --> 10:30.110
numero di neuroni del secondo strato che vuoi collegare, cioè il livello a destra che è

10:30.110 --> 10:32.360
lo strato nascosto e la bicicletta è vera.

10:32.420 --> 10:38.850
Quindi, la bicicletta è vera manterremo il valore predefinito che è per avere un pregiudizio e non solo un po

10:38.900 --> 10:43.350
'di peso collegato alla corsa che dovremo aspettare e un pregiudizio per ogni livello.

10:43.610 --> 10:46.140
E così bene vediamo cosa dobbiamo inserire.

10:46.280 --> 10:51.850
Quindi il primo argomento nelle caratteristiche è il numero di neuroni di input nel livello di input.

10:52.000 --> 10:52.930
E quindi dov'è.

10:53.030 --> 10:55.080
Beh, questo è in realtà impreciso.

10:55.100 --> 11:01.930
Questo è l'argomento della nostra funzione di init che più avanti saremo in grado di combattere l'orientamento dei tre

11:02.200 --> 11:04.150
segnali e l'orientamento di Mannus.

11:04.160 --> 11:05.020
Quindi eccoci qui.

11:05.190 --> 11:14.300
Quando i primi argomenti e le dimensioni put e quindi il secondo argomento sono le feature, questo è il numero di

11:14.300 --> 11:17.090
neuroni che vogliamo avere nel secondo livello.

11:17.180 --> 11:20.450
Il secondo livello che sarà completamente connesso al primo strato.

11:20.450 --> 11:24.960
E così ora la domanda è quanti neuroni vogliamo in questo strato nascosto.

11:25.220 --> 11:27.420
Bene, ho fatto un sacco di addestramento sui parametri.

11:27.440 --> 11:29.110
Ho fatto molti esperimenti.

11:29.210 --> 11:31.940
Questo è ciò che facciamo o è ciò che facciamo più in profondità.

11:31.940 --> 11:38.270
In generale facciamo molti esperimenti per vedere quale sarebbe la migliore rete neurale per il nostro

11:38.270 --> 11:39.170
problema specifico.

11:39.170 --> 11:45.950
E così ho provato molti valori e alla fine ho scelto 30 30 run in un livello nascosto e vedrai che

11:45.950 --> 11:50.750
con questo numero otterremo dei risultati piuttosto buoni, ma poi sentirai libero di cambiare l'architettura

11:50.750 --> 11:51.580
della rete neurale.

11:51.580 --> 11:53.120
Sentiti libero di giocarci.

11:53.180 --> 11:58.730
Puoi non solo cambiare il numero di neuroni nel qui e là, ma anche aggiungere altri strati in

11:59.150 --> 12:05.000
modo che tu possa ottenere un'auto ancora migliore, ma 30 neuroni hinna ci procureranno una buona rete neurale e

12:05.000 --> 12:06.000
una buona causa.

12:06.020 --> 12:07.390
Quindi questo è quello che vogliamo.

12:07.520 --> 12:08.410
E noi andiamo.

12:08.420 --> 12:13.500
Abbiamo la nostra prima connessione completa davvero con questa funzione lineare.

12:13.520 --> 12:16.910
Creiamo la connessione tra il livello di input e la gamba nascosta.

12:17.360 --> 12:23.270
E ora è il momento di fare la seconda connessione completa che è la connessione completa tra il livello nascosto

12:23.600 --> 12:25.180
e il livello di output.

12:25.490 --> 12:26.750
Quindi eccoci.

12:26.750 --> 12:31.380
Chiameremo questa seconda connessione completa in C2.

12:31.490 --> 12:32.280
Eccoci.

12:32.360 --> 12:36.400
Eppure questo è disponibile per più oggetti usando Saphir.

12:36.650 --> 12:38.330
E poi usiamo di nuovo.

12:38.450 --> 12:45.310
Beh, in realtà possiamo copiare questo perché useremo il modulo N nel modulo e poi la funzione lineare.

12:45.530 --> 12:49.250
Ma poi dobbiamo prima cambiare gli argomenti, naturalmente.

12:49.280 --> 12:55.050
Questo è lo stesso primo è il numero di neuroni che avremo nel primo strato della connessione.

12:55.190 --> 12:56.510
Quindi questo è il nascosto lì.

12:56.720 --> 13:03.810
E quindi questo è 30 e quindi il secondo argomento è il numero di neuroni nel secondo strato

13:04.010 --> 13:08.810
della connessione e che corrisponde al livello di output e all'output che c'è.

13:08.980 --> 13:15.020
E i neuroni reali che in seguito saranno tre perché abbiamo tre possibili azioni ma finora dobbiamo

13:15.020 --> 13:16.930
usare i nomi che abbiamo definito.

13:17.050 --> 13:23.990
il nome dell'argomento della funzione init e quindi inseriamo qui e l'azione e così via.

13:23.990 --> 13:24.950
Questo è

13:24.950 --> 13:27.760
Prima di tutto le nostre connessioni tuple ri.

13:27.920 --> 13:30.980
E in secondo luogo, qualsiasi funzione è Israele.

13:31.400 --> 13:36.940
Questo è ciò che inizializzeremo il nostro oggetto ogni volta che creiamo un oggetto dalla classe di rete.

13:37.130 --> 13:44.300
E così, non appena creiamo un oggetto, tutte queste variabili per variabili qui immettono dimensione e reazione.

13:44.380 --> 13:46.980
Tu e due saranno definiti.

13:47.180 --> 13:52.060
Ed è così che otterremo l'architettura della nostra rete di animali per ogni oggetto che creiamo.

13:52.160 --> 13:59.450
corrisponderà a una rete neurale di cinque neuroni di input 30 neuroni nascosti e tre neuroni di uscita.

13:59.450 --> 14:00.440
Ogni oggetto

14:00.470 --> 14:01.430
Quindi eccoci.

14:01.430 --> 14:06.980
Abbiamo finito con questa prima funzione e ora possiamo passare alla seconda funzione che è la

14:06.980 --> 14:13.100
funzione in avanti e che verrà utilizzata per attivare i neuroni nella rete neurale usando la funzione di

14:13.100 --> 14:19.500
attivazione del raddrizzatore e soprattutto per tornare ai valori del cubo che sono le uscite di una sola rete.

14:19.580 --> 14:23.420
Quindi non vedo l'ora di farlo nel prossimo tutorial e fino a quel momento.
