WEBVTT

00:00.210 --> 00:05.730
Hallo en welkom bij het eerste deel van deze implementatie, deel één, het oog bouwen.

00:05.910 --> 00:11.760
En zoals je kunt zien, heb ik al een dimensie toegevoegd aan de structuur van deze implementatie met de drie

00:11.760 --> 00:16.310
secties die er een vormen die duidelijk laten zien hoe we dit oog gaan bouwen.

00:16.500 --> 00:20.580
Eerst gaan we de hersenen maken die niets anders zijn dan het neurale netwerk.

00:20.830 --> 00:25.140
Dan gaan we het lichaam maken, dat zal bepalen hoe de acties zullen worden gespeeld.

00:25.410 --> 00:31.260
En als we eenmaal de hersenen en het lichaam hebben, zullen we ze samenvoegen om de A te maken. L. , die in het laatste deel

00:31.260 --> 00:33.210
van dit eerste deel zal staan.

00:33.690 --> 00:37.510
U kunt nu dus al een goed beeld hebben van de opbouw van deze implementatie.

00:37.740 --> 00:42.440
Eerst maken we de hersenen, dan maken we het lichaam, en dan assembleren we de twee om de lucht te maken.

00:42.870 --> 00:48.220
En dan gaan we zo beginnen met het eerste deel dat gaat over het maken van de hersenen.

00:48.660 --> 00:51.240
En dit gaat ons voor tutorials brengen.

00:51.240 --> 00:54.730
Je kunt je voorstellen dat het maken van een brein niet hetzelfde is als het maken van een cake.

00:54.750 --> 00:56.840
Dit vereist dus meer dan één tutorial.

00:57.120 --> 01:03.630
En natuurlijk, zoals gewoonlijk, gaan we dat brein vertegenwoordigen met een klas omdat we verschillende functies nodig

01:03.630 --> 01:04.230
hebben.

01:04.530 --> 01:10.950
En om een structuur te hebben van verschillende functies die in een soort instructies zullen worden georganiseerd.

01:11.190 --> 01:12.780
Natuurlijk hebben we een klas nodig.

01:13.050 --> 01:18.660
En dat is perfect, want als we die klasse eenmaal goed hebben gemaakt, kunnen we zoveel hersens creëren als we

01:18.660 --> 01:21.570
willen door slechts enkele objecten van deze klasse te maken.

01:21.930 --> 01:27.930
Dus nogmaals, klassen in Python en in het algemeen en objectgeoriënteerde programmeertalen zijn erg praktisch omdat je je model

01:28.050 --> 01:33.450
maakt van iets dat je wilt bouwen en dan kun je zoveel objecten maken als je wilt

01:33.450 --> 01:37.560
en ze zullen alle functies hebben die u in de klas definieert.

01:37.830 --> 01:40.360
En voor onze hersenen zullen de kenmerken dat natuurlijk zijn.

01:40.380 --> 01:45.600
Allereerst de architectuur van het neurale netwerk, waarvan ik veronderstel dat het op CNN zal zijn

01:45.600 --> 01:50.790
en natuurlijk de verschillende functies, zoals bijvoorbeeld het doorgeven van de signalen van de inputneuronen

01:51.030 --> 01:52.100
naar de outputneuronen.

01:52.260 --> 01:55.020
Dus dat wordt natuurlijk de vierde functie die we gaan maken.

01:55.770 --> 01:56.790
Dus laten we dit doen.

01:56.790 --> 01:58.620
Laten we beginnen met het maken van de hersenen.

01:58.800 --> 02:00.300
Dit gaat best spannend worden.

02:00.500 --> 02:04.440
Het is een van mijn favoriete onderdelen en daarom gaan we er meteen op in.

02:04.770 --> 02:10.770
Dus we beginnen natuurlijk met het introduceren van een klas, en we gaan deze klas noemen.

02:10.800 --> 02:18.060
Ik aarzelde om het hersenen te noemen, maar laten we directer zijn en het CNN noemen, want eigenlijk

02:18.300 --> 02:22.140
is het brein een CNN-netwerk, een convolutioneel neuraal netwerk.

02:22.390 --> 02:24.180
Dus dat is wat je hersenen kunt noemen als je wilt.

02:24.480 --> 02:27.240
Maar nu weten we tenminste wat we aan het bouwen zijn.

02:28.520 --> 02:34.790
En CNN, wat betreft het netwerk van de zelfrijdende auto, gaat erven van de Annand-module.

02:35.060 --> 02:42.590
Dus onthoud, de motormodule is wat we hier hebben geïmporteerd, en we willen alle tools van deze motormodule

02:42.590 --> 02:43.760
kunnen gebruiken.

02:43.940 --> 02:49.670
En daarom willen we deze techniek gebruiken in objectgeoriënteerd programmeren, wat overerving is, en waarmee

02:49.880 --> 02:54.950
we, je weet wel, alle tools van een bovenliggende klasse kunnen gebruiken.

02:55.190 --> 02:59.030
En deze klas zal in die module zitten.

02:59.810 --> 03:00.550
Daar gaan we.

03:00.740 --> 03:04.850
En nu kunnen we alle gereedschappen en objecten van de engine, die module, gebruiken.

03:05.330 --> 03:05.860
Oke.

03:06.140 --> 03:11.800
Dus nu we onze erfenis hebben, kunnen we naar de klas gaan om onze eerste functie te maken.

03:11.960 --> 03:18.260
En zoals je waarschijnlijk al vermoedt, is de eerste functie de init-functie die alle variabelen van de toekomstige

03:18.530 --> 03:20.970
hersenobjecten in de toekomst zal definiëren.

03:20.990 --> 03:23.120
CNN-objecten die worden gemaakt.

03:23.540 --> 03:31.190
Oké, dus laten we dit def doen, dan twee op deze cursus erin naar de weer en nu moeten we wat variabelen

03:31.190 --> 03:31.660
plaatsen.

03:31.940 --> 03:34.400
Dus eerst en vooral zou ik mezelf zijn.

03:35.180 --> 03:37.120
Dat is natuurlijk om naar het object te verwijzen.

03:37.340 --> 03:39.290
Nu denk ik dat je je hier redelijk comfortabel bij voelt.

03:39.740 --> 03:45.050
Vervolgens gaan we nog een variabele toevoegen, namelijk het aantal acties in de omgeving.

03:45.350 --> 03:49.790
Dus we gaan het aantal acties noemen, aantal acties.

03:50.390 --> 03:54.050
En eigenlijk is deze variabele niet verplicht voor de init-functie.

03:54.300 --> 03:59.120
Het is alleen zo dat als je het idee wilt testen dat we op

03:59.390 --> 04:05.780
andere Dhume-omgevingen gaan bouwen, dit heel praktisch zal zijn omdat we dit aantal acties zullen invoeren, variabel vanuit

04:05.780 --> 04:08.090
de doom-omgeving, rappers met twee discrete.

04:08.360 --> 04:13.660
En als we dat doen, zullen we, je weet wel, de naam van de omgeving invoeren, V0 doen.

04:13.970 --> 04:19.940
En dus als je wilt, weet je, hiermee experimenteren in andere DUME-omgevingen en andere games spelen, nou,

04:19.940 --> 04:25.670
dan heb je niets te doen omdat dit aantal acties direct het aantal acties in de

04:25.670 --> 04:28.250
omgeving krijgt die je' mee zal spelen.

04:28.940 --> 04:32.460
OK, dus dat is het voor de twee argumenten van deze init-functie.

04:32.600 --> 04:36.080
Dus nu kunnen we naar binnen gaan en ons herinneren wat we moeten doen.

04:36.410 --> 04:41.050
Het eerste dat we moeten doen, is de overerving activeren met de superfunctie.

04:41.480 --> 04:43.610
Dus dat is precies hetzelfde als voor de zelfrijdende auto.

04:43.820 --> 04:50.450
We nemen de superfunctie, dan beginnen we met het invoeren van de klasse die het neurale netwerk

04:50.450 --> 04:52.790
zal definiëren en dat is CNN.

04:53.540 --> 04:56.720
Dan moeten we zelf invoeren om naar het object te verwijzen.

04:57.080 --> 05:02.090
Maar onthoud, dat is niet alles wat we hier bij DOT moeten toevoegen en dan de init-functie.

05:03.680 --> 05:09.500
Met wat haakjes, en door dat te doen, activeren we de overerving en nu kunnen we alle tools van

05:09.500 --> 05:10.700
die module gebruiken.

05:11.360 --> 05:11.810
Oke.

05:11.810 --> 05:16.800
Dus nu denk ik dat het tijd is om de architectuur van het neurale netwerk te bouwen.

05:17.090 --> 05:23.300
En dus, zoals je je herinnert, gaan we een CNN convolutief neuraal netwerk bouwen, simpelweg omdat de

05:23.300 --> 05:30.230
AI deze keer ogen zal hebben en de ogen van de AI de convolutionele lagen van dit convolutionele neurale

05:30.230 --> 05:30.910
netwerk.

05:31.340 --> 05:38.150
En dan na de A. L. visualiseert de beelden met de convolutionele lagen, het

05:38.180 --> 05:40.790
zal de signalen doorgeven aan een klassiek kunstmatig neuraal netwerk.

05:41.060 --> 05:44.230
Dus dat is degene die we eerder hadden met volledig verbonden lagen.

05:44.480 --> 05:50.060
En dat is waar het zal proberen de kernwaarden te voorspellen voor elke mogelijke actie die we kunnen spelen.

05:51.140 --> 05:53.330
Dus je hebt de architectuur in gedachten.

05:53.600 --> 05:58.700
Eerst zullen we enkele convolutionele lagen hebben en dan enkele volledig verbonden lagen, en dit

05:58.700 --> 06:06.740
zal het brein zijn van onze A. L. Dus waar we gaan doen om een stap terug te

06:06.740 --> 06:11.240
kunnen doen waar we goed in zijn, laten we deze architectuur maken met de variabelen die we willen creëren.

06:11.690 --> 06:18.740
Dus eigenlijk, over deze architectuur gesproken, we gaan een CNN bouwen met drie convolutionele lagen.

06:18.750 --> 06:24.200
En dan na die ene verborgen laag, dat betekent dat we drie convolutionele verbindingen en twee

06:24.200 --> 06:25.780
volledige verbindingen nodig hebben.

06:26.030 --> 06:29.480
En over verbindingen gesproken, dat is precies wat we gaan definiëren.

06:29.480 --> 06:32.330
Dat zijn de variabelen van onze CNN-klasse.

06:32.330 --> 06:37.160
En daarom ga ik nu vijf variabelen definiëren, drie voor de convolutionele verbindingen en twee

06:37.280 --> 06:38.890
voor de volledige verbindingen.

06:39.200 --> 06:40.040
Dus laten we dit doen.

06:40.050 --> 06:42.350
We beginnen met de convolutieverbindingen.

06:42.650 --> 06:47.840
Dus ik ga ze zelf die convolutie noemen.

06:48.380 --> 06:50.510
Ik ga dat kopiëren en.

06:52.370 --> 07:00.410
Neem ze hieronder en daar gaan we, zelfcontradictie twee en zelfconvolutie drie die convolutieverbindingen zijn met deze eerste

07:00.410 --> 07:07.280
convolutie, één hier zal enige convolutie toepassen op de invoerafbeeldingen om de eerste convolutionele laag

07:07.280 --> 07:08.740
te krijgen.

07:09.170 --> 07:14.840
Dan zal de tweede conclusie tot hier de eerste convolutionele laag als invoer nemen.

07:15.020 --> 07:19.340
En door opnieuw wat convolutie toe te passen, zal het een tweede convolutionele laag creëren.

07:19.670 --> 07:25.620
En in deze convolutionele daar zullen we een aantal nieuwe afbeeldingen krijgen, die elk een specifiek kenmerk detecteren.

07:25.880 --> 07:28.640
Dus we zullen deze nieuwe afbeeldingen daar in een convolutie krijgen.

07:29.030 --> 07:36.500
Vervolgens passen we deze convolutie hier toe om deze nieuwe afbeeldingen van deze eerste convolutionele laag te verbinden met

07:36.500 --> 07:40.060
enkele nieuwe afbeeldingen van een tweede convolutionele laag.

07:40.220 --> 07:45.890
En deze nieuwe afbeeldingen zullen opnieuw enkele kenmerken detecteren in de afbeeldingen van de eerste convolutionele laag.

07:46.070 --> 07:52.010
Dus het is alleen om de functiedetectie te versterken en dan naar de afbeeldingen van de tweede convolutie.

07:52.010 --> 07:59.360
Daar passen we de derde convolutie hier toe om voor elk van hen wat meer afbeeldingen te krijgen die nog meer

07:59.360 --> 08:01.550
functies in de invoerafbeeldingen detecteren.

08:01.880 --> 08:06.970
Dus hoe meer we dit doen, hoe meer we enkele windingen toepassen op de verschillende lagen van afbeeldingen.

08:07.370 --> 08:10.010
Welnu, hoe meer we in staat zijn om sommige functies te detecteren.

08:10.310 --> 08:15.470
En dat is hoe het oog door de kenmerken te detecteren, zal begrijpen waar de monsters zijn, waar het moet

08:15.470 --> 08:18.190
schieten om ze te doden en waar het naartoe moet.

08:18.320 --> 08:24.560
Het zal ook de muren detecteren, de obstakels, nou ja, letterlijk waar het heen moet, en dat is

08:24.710 --> 08:29.450
te danken aan wat al deze convolutionele lagen detecteren in de originele invoerbeelden.

08:30.290 --> 08:30.650
Oke.

08:30.650 --> 08:34.750
Dus dat is voor het convolutiegedeelte van de CNN.

08:34.910 --> 08:42.350
Maar onthoud dan dat we na de convolutionele lagen alle pixels moeten afvlakken die zijn verkregen door de verschillende

08:42.350 --> 08:44.600
reeksen convoluties die zijn toegepast.

08:44.690 --> 08:51.320
En door alle arrays van pixels af te vlakken, krijgen we deze enorme vector die de invoer wordt van een

08:51.320 --> 08:53.060
klassiek kunstmatig neuraal netwerk.

08:53.300 --> 08:58.020
En daar krijgen we onze volledig verbonden spelers en dus onze volledige verbindingen.

08:58.520 --> 09:04.910
Wat we nu moeten doen, is twee nieuwe variabelen creëren, want we krijgen één Hillaire in dit klassieke

09:04.910 --> 09:07.250
kunstmatige neurale netwerk dat hierna komt.

09:07.370 --> 09:13.160
En daarom hebben we één volledige verbinding nodig van deze enorme afgeplatte vector naar deze hier en

09:13.370 --> 09:19.220
daar, en een tweede volledige verbinding tussen deze hier en daar en de outputlaag die bestaat uit de

09:19.220 --> 09:21.220
outputneuronen die de kernwaarden zijn.

09:21.800 --> 09:26.620
Dus laten we deze twee eerste verbindingen maken en dan zullen we al deze verbindingen definiëren.

09:27.110 --> 09:35.300
Dus wat betreft de zelfrijdende auto, we gaan ze zelf die ene noemen en dan zelf die F. C. naar.

09:36.050 --> 09:36.560
Oke.

09:36.570 --> 09:38.290
Dus nu hebben we al onze variabelen.

09:38.300 --> 09:43.600
En dus moeten we ze nu natuurlijk definiëren met de klassen van de motormodule.

09:44.150 --> 09:48.860
Dus dat betekent dat we in feite de architectuur van het neurale netwerk zullen creëren en dat zullen we

09:48.860 --> 09:51.050
tot die tijd in de volgende tutorial doen.

09:51.050 --> 09:51.850
En ik.
