WEBVTT

00:00.360 --> 00:06.030
Ciao e benvenuto nella prima parte di questa implementazione di IA parte prima costruendo l'intelligenza artificiale.

00:06.120 --> 00:12.570
E come puoi vedere ho già aggiunto delle dimensioni nella struttura di questa rientranza con queste tre sezioni che

00:12.660 --> 00:16.620
compongono la Parte 1 che mostrano chiaramente come costruiremo questa IA.

00:16.620 --> 00:18.750
Per prima cosa creeremo il cervello.

00:18.840 --> 00:23.760
Non c'è nient'altro che la rete neurale, quindi faremo il corpo che definirà come

00:23.760 --> 00:25.400
le azioni verranno giocate.

00:25.590 --> 00:31.620
E poi, una volta che avremo il cervello e il corpo, li assembleremo per creare l'IA che sarà

00:31.620 --> 00:33.840
nell'ultima sezione di questa prima parte.

00:33.840 --> 00:37.890
Quindi ora puoi già avere una buona visione della struttura di questa implementazione.

00:37.890 --> 00:42.760
Per prima cosa creiamo il cervello, poi creiamo il corpo e poi assembliamo i due per creare l'intelligenza artificiale.

00:43.050 --> 00:48.520
E poi questo è tutto ciò che inizieremo con la prima sezione che riguarda la creazione del cervello.

00:48.810 --> 00:51.330
E questo ci porterà per esercitazioni.

00:51.360 --> 00:54.810
Puoi immaginare che creare un cervello non è come fare una torta.

00:54.900 --> 00:57.100
Quindi questo richiederà più di un tutorial.

00:57.270 --> 01:03.690
al solito, rappresenteremo quel cervello con una classe perché avremo bisogno di diverse funzioni e

01:03.690 --> 01:10.200
per avere una struttura di diverse funzioni che saranno organizzate in una sorta di istruzioni.

01:10.200 --> 01:11.160
Ovviamente, come

01:11.310 --> 01:16.010
Beh, certo, abbiamo bisogno di una lezione e questo è Berkeley perché una volta abbiamo fatto quella lezione.

01:16.080 --> 01:22.080
Bene, saremo in grado di creare il maggior numero di cervelli che vogliamo semplicemente creando alcuni oggetti di questa classe.

01:22.080 --> 01:28.050
Quindi ancora una volta le classi in Python e in generale i linguaggi di programmazione orientati agli oggetti sono molto pratici perché

01:28.200 --> 01:33.510
si crea un modello di qualcosa che si vuole costruire e quindi si è in grado di creare il

01:33.510 --> 01:37.820
numero di oggetti che si desidera e avranno tutte le funzionalità che si definire nella classe.

01:38.010 --> 01:40.470
E per il nostro cervello le caratteristiche saranno ovviamente.

01:40.500 --> 01:45.930
neuroni di input ai neuroni di output che sarà ovviamente la funzione Ford che realizzerà.

01:45.930 --> 01:51.780
Beh, prima di tutto l'architettura della rete neurale che ricordo sarà della CNN e naturalmente due

01:51.780 --> 01:55.520
funzioni diverse come ad esempio il passaggio dei segnali dai

01:55.920 --> 01:58.940
Facciamo così, iniziamo a fare il cervello.

01:58.950 --> 02:00.600
Sarà molto eccitante.

02:00.650 --> 02:02.380
È una delle mie parti preferite.

02:02.520 --> 02:04.860
E quindi entriamo subito.

02:04.890 --> 02:10.880
Quindi inizieremo con l'introduzione della classe, ovviamente, e chiameremo questa classe.

02:10.950 --> 02:18.570
cervello ma siamo più diretti e chiamiamolo CNN perché in realtà il cervello è una rete della CNN.

02:18.570 --> 02:20.570
Beh, ho esitato a chiamarlo

02:20.580 --> 02:22.510
Rete neurale involutiva.

02:22.530 --> 02:27.440
Quindi mentre guardi puoi chiamare il cervello se vuoi, ma almeno ora sappiamo cosa stiamo costruendo.

02:28.710 --> 02:35.040
E la CNN per quanto riguarda la rete della macchina auto-guida erediterà dalla fine di Mudgal.

02:35.220 --> 02:42.870
Quindi ricorda che la fine del modulo è ciò che mettiamo qui e vogliamo essere in grado di utilizzare tutti

02:42.870 --> 02:49.050
gli strumenti di questo e di un modulo e quindi vogliamo usare questa tecnica nella programmazione

02:49.050 --> 02:55.870
orientata agli oggetti che è ereditaria e che ci consente di sapere bene usa tutti gli strumenti di

02:55.900 --> 02:59.970
una classe genitore e questa stessa classe sarà su quel modulo.

02:59.970 --> 03:00.830
Eccoci.

03:00.930 --> 03:05.510
E ora possiamo usare tutti gli strumenti e gli oggetti alla fine di quel modulo.

03:05.510 --> 03:12.100
Bene, ora che abbiamo la nostra eredità, possiamo andare in classe per fare la nostra prima funzione.

03:12.150 --> 03:18.360
E come probabilmente intuisci la prima funzione è la funzione finale che definirà tutte le variabili

03:18.720 --> 03:20.330
dei futuri oggetti cerebrali.

03:20.370 --> 03:23.440
Conosci il futuro e gli oggetti che verranno creati.

03:23.700 --> 03:24.890
Va bene, facciamolo

03:24.900 --> 03:29.800
Def quindi due underscore in esso per i punteggi di nuovo.

03:29.910 --> 03:31.910
E ora abbiamo bisogno di mettere alcune variabili.

03:32.100 --> 03:37.460
Quindi, prima di tutto, stavo per essere io che ovviamente si riferisce all'oggetto.

03:37.490 --> 03:42.380
Ora credo che tu sia abbastanza a tuo agio con questo, quindi aggiungeremo un'altra variabile

03:42.380 --> 03:45.310
che sarà il numero di azioni nell'ambiente di Dumah.

03:45.500 --> 03:48.900
Quindi chiameremo quelle azioni numeriche.

03:49.010 --> 03:50.380
Numero di azioni

03:50.570 --> 03:54.390
E in realtà questa variabile non è obbligatoria per la funzione.

03:54.500 --> 03:59.360
È solo che se vuoi mettere alla prova l'idea che costruiremo su altri ambienti.

03:59.540 --> 04:06.100
Beh, questo sarà molto pratico perché importeremo questo numero di azioni orribili dal doom e

04:06.120 --> 04:12.290
dai wrapper di Varman con due discreti e quando lo faremo sapremo inserire il

04:12.510 --> 04:13.980
nome dell'ambiente da zero.

04:14.180 --> 04:21.050
Quindi, se vuoi farti sperimentare con questo su altri ambienti e giocare bene con altri giochi, non avrai

04:21.050 --> 04:26.300
nulla da fare perché questo numero di azioni otterrà direttamente il numero di azioni

04:26.300 --> 04:27.470
nell'ambiente di Dumor.

04:27.470 --> 04:28.650
Ti divertirai.

04:29.110 --> 04:32.710
OK, questo è tutto per i due argomenti di questa funzione.

04:32.780 --> 04:36.500
Quindi ora possiamo entrare e ora ricordare cosa dobbiamo fare.

04:36.530 --> 04:41.560
La prima cosa che dobbiamo fare è attivare l'ereditarietà con la superfunzione.

04:41.570 --> 04:43.840
Quindi è esattamente come per l'auto che guida.

04:43.970 --> 04:50.940
Prendiamo la superfunzione, quindi iniziamo inserendo la classe che definirà la rete neurale e

04:51.470 --> 04:53.330
che è la CNN.

04:53.690 --> 04:56.950
Quindi dobbiamo inserire self per riferirsi all'oggetto.

04:57.190 --> 05:05.230
Ma ricorda che non è tutto quello che dobbiamo aggiungere qui al DOT e poi la funzione init con alcune parentesi.

05:05.270 --> 05:07.880
E facendo ciò attiviamo l'eredità.

05:07.950 --> 05:11.470
E ora possiamo usare tutti gli strumenti dalla fine e dal modulo.

05:11.510 --> 05:17.070
Va bene, ora penso che sia tempo di costruire l'architettura della rete neurale.

05:17.270 --> 05:23.330
E così come ricorderai, costruiremo una rete neuronale convoluzionale della CNN semplicemente perché

05:23.330 --> 05:30.290
questa volta l'IA avrà occhi e gli occhi saranno gli strati convoluzionali di questa rete

05:30.290 --> 05:31.220
neurale convoluzionale.

05:31.520 --> 05:38.240
E poi, dopo che i ai visualizzano le immagini con gli strati convoluzionali, passeranno i segnali in

05:38.330 --> 05:41.040
un classico della nostra rete neurale visiva.

05:41.180 --> 05:44.510
Questo è quello che avevamo prima con i livelli completamente connessi.

05:44.660 --> 05:50.730
Ed è qui che proverà a prevedere i valori del cubo per ogni azione possibile che possiamo giocare.

05:51.290 --> 05:56.930
Quindi hai in mente l'architettura, prima avremo alcuni strati convoluzionali e poi alcuni strati

05:56.930 --> 06:01.270
completamente connessi e questo sarà il cervello della nostra intelligenza artificiale.

06:01.550 --> 06:07.530
Quindi, cosa faremo per essere in grado di fare un passo indietro a ciò che stiamo facendo.

06:07.670 --> 06:11.840
Bene, facciamo questa architettura con le variabili che vogliamo creare.

06:11.840 --> 06:18.890
Quindi, parlando di questa architettura, costruiremo una CNN con tre strati convoluzionali.

06:18.920 --> 06:24.530
E poi dopo quello strato nascosto significa che avremo bisogno di tre connessioni convoluzionali

06:24.530 --> 06:26.020
e due connessioni complete.

06:26.180 --> 06:31.340
E parlando di connessioni che è esattamente quello che stiamo per definire saranno le variabili per la classe

06:31.370 --> 06:35.030
CNN e quindi in questo momento ho intenzione di definire cinque variabili.

06:35.150 --> 06:39.100
Tre per le connessioni convoluzionali e due connessioni politiche.

06:39.350 --> 06:40.100
Quindi facciamolo.

06:40.100 --> 06:42.570
Cominceremo con le connessioni di convoluzione.

06:42.770 --> 06:47.250
Quindi li chiamerò convoluzione autodidatta.

06:47.540 --> 06:53.620
Uno andando a copiare quello e basato sul basso.

06:54.020 --> 07:01.640
convoluzionale lì e quindi questo convoluzionale otterrà alcune nuove immagini ognuna di esse rilevando una caratteristica specifica.

07:01.640 --> 07:08.450
E poi passiamo all'autoconcessione e all'autocompattazione tre che sono le connessioni di convoluzione a questa

07:08.460 --> 07:15.860
prima conclusione, qui applicheremo qualche convoluzione alle immagini di input per ottenere un primo strato convoluzionale,

07:15.860 --> 07:21.180
quindi il secondo contributo a qui prenderà il primo convoluzionale strato come

07:21.180 --> 07:25.920
input e applicando di nuovo una convoluzione creerà un secondo

07:26.030 --> 07:32.840
Quindi otterremo queste nuove immagini in modo convoluzionale, quindi applicheremo questa convoluzione qui per connettere queste

07:32.870 --> 07:39.740
nuove immagini da questo primo strato convoluzionale ad alcune nuove immagini di un secondo strato di

07:39.740 --> 07:40.300
convoluzione.

07:40.430 --> 07:46.120
E queste nuove immagini rileveranno ancora alcune caratteristiche nelle immagini del primo convoluzionale lì.

07:46.220 --> 07:52.100
Quindi è solo per rafforzare il rilevamento futuro e quindi per l'emergere del secondo convoluzionale

07:52.100 --> 07:52.650
lì.

07:52.790 --> 07:57.000
Abbiamo applicato il terzo convoluzionale qui per ottenerlo per ciascuno di essi.

07:57.050 --> 08:01.900
Altre immagini che rilevano ancora più funzioni all'interno delle immagini di input.

08:02.050 --> 08:07.300
E così più lo facciamo e più applichiamo alcune convoluzioni ai diversi livelli di immagini.

08:07.520 --> 08:13.580
Bene, più siamo in grado di rilevare alcune caratteristiche ed è così che rilevando le caratteristiche l'occhio

08:13.580 --> 08:18.360
capirà dove sono i mostri dove deve sparare per ucciderli e dove dovrebbe andare.

08:18.500 --> 08:21.290
Rileverà anche i muri gli ostacoli.

08:21.440 --> 08:28.100
Beh, letteralmente dove deve andare e questo è grazie a ciò che tutti questi strati convoluzionali

08:28.130 --> 08:29.680
rilevano nelle immagini originali.

08:30.450 --> 08:34.980
Va bene così è per la parte convoluzione della CNN.

08:35.100 --> 08:42.720
Ma poi ricorda che dopo gli strati convoluzionali dobbiamo appiattire tutti i pixel ottenuti dalle diverse serie di

08:42.720 --> 08:48.660
convoluzioni che sono state applicate e appiattendo tutti gli array di pixel otteniamo questo

08:48.810 --> 08:53.260
enorme vettore che diventerà l'input di una rete neurale artificiale classica.

08:53.490 --> 08:58.600
Ed è qui che riceviamo le nostre lettere completamente collegate e quindi le nostre connessioni.

08:58.710 --> 09:04.560
qua e là e il livello di uscita composto dai neuroni di uscita che sono i valori chiave.

09:04.810 --> 09:09.330
E così ora quello che dobbiamo fare è creare due nuove variabili perché ne

09:09.330 --> 09:16.260
avremo una qua e là in questa classica rete neurale artificiale che verrà dopo e quindi abbiamo bisogno di una connessione completa

09:16.260 --> 09:21.620
da questo enorme vettore Flaten a questo qui e lì e una seconda connessione completa tra questo

09:21.960 --> 09:27.090
Quindi facciamo queste prime due connessioni e poi definiremo tutte queste connessioni.

09:27.240 --> 09:36.200
Quindi chiedi la colonna sonora nel codice che chiameremo sé stesso e poi anche l'autodidatta.

09:36.240 --> 09:41.010
Va bene così ora abbiamo tutti i nostri oggetti di valore e per sapere cosa dobbiamo

09:41.250 --> 09:44.300
fare è definito chiaramente con le classi del modulo motore.

09:44.310 --> 09:49.110
pratica creeremo l'architettura della rete neurale e questo è ciò che faremo nel prossimo domani.

09:49.190 --> 09:50.340
Ciò significa che in

09:50.490 --> 09:51.920
Fino ad allora I.
