WEBVTT

00:00.390 --> 00:02.490
Hallo en welkom bij deze Python-tutorial.

00:02.850 --> 00:08.410
Dus nu is de volgende stap om die telneuronen te laten functioneren, die ons zullen geven wat we willen.

00:08.430 --> 00:13.880
Dat is dit aantal neuronen in deze enorme vector nadat de windingen zijn toegepast.

00:14.160 --> 00:16.710
Dat is de enige ontbrekende informatie die we nu nodig hebben.

00:16.920 --> 00:19.030
En we gaan het krijgen met een functie.

00:19.560 --> 00:21.290
Dus laten we deze functie maken.

00:21.750 --> 00:27.180
We gaan het heel eenvoudig het aantal onderstrepingsneuronen noemen.

00:27.610 --> 00:31.800
En wat gaat deze telling-neuronenfunctie als argumenten gebruiken?

00:32.340 --> 00:38.190
Wel, het zal het object zelf nemen, maar dan zal het iets anders nodig hebben,

00:38.340 --> 00:44.160
omdat dit aantal output-neuronen in de afvlakkende laag eigenlijk maar van één ding afhangt.

00:44.490 --> 00:50.760
Het hangt af van de afmetingen van het oorspronkelijke invoerbeeld, het beeld dat helemaal aan het begin van het neurale

00:50.760 --> 00:51.570
netwerk staat.

00:51.990 --> 00:57.270
Het enige argument dat we nu nodig hebben, zijn eigenlijk deze afmetingen, de afmetingen van de

00:57.270 --> 00:57.750
invoerbeelden.

00:58.260 --> 01:03.030
Laten we daarom een naam geven aan dit argument dat de afmetingen van de invoerafbeelding vertegenwoordigt.

01:03.330 --> 01:06.420
En we zouden het imago-dema gaan noemen.

01:07.050 --> 01:07.460
Oke.

01:07.680 --> 01:14.670
En ik kan je nu vertellen dat de werkelijke afmetingen, de invoerafbeeldingen die van jou komen, 80

01:14.670 --> 01:16.320
bij 80 zullen zijn.

01:16.680 --> 01:21.060
We gaan de grootte van de originele afbeeldingen verkleinen tot 80 bij 80.

01:21.300 --> 01:25.760
En dat wordt het formaat van de beelden die in het neurale netwerk gaan.

01:26.130 --> 01:29.670
Dus het beeld wordt eigenlijk één 188.

01:29.910 --> 01:34.470
En de ene komt overeen met het feit dat we met zwart-wit beelden werken, dat wil zeggen met maar

01:34.470 --> 01:35.070
één kanaal.

01:35.370 --> 01:39.180
Dus beeld ze zullen later gelijk zijn aan de tupel.

01:39.180 --> 01:40.260
Tachtig en tachtig.

01:41.110 --> 01:45.400
Oké, dus dat is het enige argument dat we nodig hebben en laten we nu de neuronen tellen.

01:45.730 --> 01:46.960
Dus hoe gaan we dat doen?

01:47.350 --> 01:50.960
Allereerst hebben we momenteel geen invoerafbeelding.

01:51.040 --> 01:53.890
We hebben geen dume-afbeelding die we kunnen importeren.

01:53.920 --> 01:55.000
Dat gaan we later doen.

01:55.420 --> 01:58.300
Dus het eerste dat we moeten doen, is een nep-afbeelding maken.

01:58.570 --> 02:00.760
Maar dat heeft afmetingen 80 bij 80.

02:01.090 --> 02:04.000
We gaan die nepafbeelding maken met neppixels.

02:04.180 --> 02:08.860
En dat geeft ons uiteindelijk toch het aantal dat we willen, want dat aantal hangt alleen af

02:08.860 --> 02:12.830
van de afmetingen en niet van de pixels die in de afbeeldingen zitten.

02:13.210 --> 02:17.890
Dus laten we om te beginnen een nep-afbeelding maken en dan zullen we het aantal neuronen berekenen dat we willen.

02:18.400 --> 02:24.400
Dus de truc om een nep-afbeelding te maken is, nou, we gaan het eerst X noemen.

02:24.760 --> 02:31.030
En dan zouden we de toorts die rand gebruiken, want, weet je, we gaan wat willekeurige pixels

02:31.030 --> 02:36.580
in deze afbeeldingen plaatsen die deze willekeurige functies van Torch gebruiken, wat de RAND-functie is.

02:37.060 --> 02:42.430
Binnen gaan we, zoals je kunt zien, de afmetingen van de afbeeldingen invoeren.

02:42.700 --> 02:44.160
Dat is een 1880.

02:44.440 --> 02:50.110
Maar aangezien we dit beeld in het neurale netwerk gaan invoeren en zoals je je herinnert, kan

02:50.110 --> 02:55.750
het neurale netwerk alleen batches van invoerstatus accepteren die hier zijn, batches invoer, afbeeldingen, we gaan

02:55.750 --> 03:00.240
die nep-dimensie creëren, die we kunnen direct doen in deze ronde functie.

03:00.520 --> 03:05.260
We hoeven eigenlijk alleen maar te beginnen met degene die overeenkomt met de batch

03:05.260 --> 03:10.680
en dan kunnen we gewoon de tuple 188 plaatsen die overeenkomt met de afmetingen van de invoerafbeelding.

03:10.930 --> 03:16.750
En zoals je begreep, zijn deze dimensies vervat in deze afbeelding dan argument, dat

03:16.750 --> 03:18.610
de tupel 188 vertegenwoordigt.

03:19.280 --> 03:22.990
Dus nu hoeven we ze alleen nog maar een afbeelding toe te voegen.

03:23.500 --> 03:28.810
Maar om de elementen van een tuple door te geven, want, weet je, nu is image dan

03:29.050 --> 03:36.120
een tuple als een lijst met argumenten van een functie die we hier moeten toevoegen voor image, dan is dat voor de tuple en

03:36.340 --> 03:42.970
start de ster zal toestaan om de elementen van de afbeelding door te geven en vervolgens tuple als een lijst met argumenten

03:42.970 --> 03:43.650
voor functie.

03:43.990 --> 03:49.150
En zoals je kunt zien, is dat precies wat hier is gespecificeerd met de ster en de afmetingen.

03:49.780 --> 03:50.140
Oke.

03:50.150 --> 03:56.400
Dus dat zal een afbeelding van neppixels creëren die niets met de afbeeldingen te maken hebben.

03:56.680 --> 03:59.770
Maar nogmaals, we zullen nog steeds in staat zijn om het uiteindelijke aantal neuronen te krijgen.

04:00.380 --> 04:07.000
En het laatste wat we moeten doen, onthoud, is om deze input-betere vector om te

04:07.000 --> 04:12.070
zetten in een fakkelvariabele, omdat dit in het neurale netwerk gaat.

04:12.880 --> 04:19.480
Oké, dus dit vertegenwoordigt nu een invoerbeeld van willekeurige pixels die zojuist is omgezet in een fakkelvariabele en die

04:19.480 --> 04:25.360
nu in het neurale netwerk zal gaan en meer specifiek, de convolutionele lagen van het neurale

04:25.360 --> 04:30.760
netwerk, want aangezien we alleen het aantal nodig hebben van neuronen nadat de windingen zijn

04:30.760 --> 04:33.830
toegepast, gaan we gewoon door tot conclusie drie.

04:34.060 --> 04:39.190
Dus direct na de derde convolutionele laag en we zullen hier niet ingaan op de twee volledige verbindingen.

04:39.670 --> 04:44.780
En dat komt omdat het aantal neuronen dat we willen tussen convolutie drie en FS1 ligt.

04:45.370 --> 04:45.700
Oke.

04:45.700 --> 04:52.540
Dus nu we één invoerafbeelding met de juiste afmetingen hebben, is het tijd om deze afbeelding in het neurale

04:52.720 --> 04:55.740
netwerk te verspreiden om de afvlakkingslaag te bereiken.

04:55.990 --> 05:01.180
En dan krijgen we de neuronen in de afvlakkingslaag en krijgen we gewoon de informatie die we

05:01.180 --> 05:01.660
willen.

05:01.670 --> 05:04.480
Dat is het aantal neuronen in deze afvlakkende laag.

05:04.870 --> 05:08.560
Dus wat we nu moeten doen, is precies wat we doen in de voorwaartse functie.

05:08.800 --> 05:14.500
We moeten de signalen in het neurale netwerk verspreiden, maar alleen in de convolutionele lagen totdat we

05:14.500 --> 05:15.790
de afvlakkingslaag bereiken.

05:16.180 --> 05:17.010
Dus laten we dit doen.

05:17.170 --> 05:20.200
We gaan X nu updaten.

05:20.200 --> 05:26.600
X is het invoerbeeld en met de tweede X hier, wordt X, nou ja, de eerste convolutionele laag.

05:27.130 --> 05:29.860
Wat we nu moeten doen, is een proces in drie stappen.

05:30.010 --> 05:30.910
Eerste stap.

05:30.910 --> 05:33.420
We passen de convolutie toe op de invoerbeelden.

05:33.700 --> 05:40.900
Dan de tweede stap, passen we toe op de verkregen ingewikkelde afbeeldingen en dan de derde stap, we activeren

05:40.900 --> 05:44.080
de neuronen in deze samengevoegde, ingewikkelde afbeeldingen.

05:44.260 --> 05:50.160
En zo wordt X deze eerste convolutionele laag die bestaat uit al deze poelen, gecompliceerde beelden.

05:50.890 --> 05:56.550
Dus laten we deze eerste stap doen, de eerste convolutie convolutie één toepassen op de invoerafbeeldingen.

05:56.890 --> 06:00.910
Dus wat we doen is onze convolutie zelf nemen.

06:01.360 --> 06:04.180
Die convolutie.

06:04.420 --> 06:05.020
Daar gaan we.

06:05.410 --> 06:10.900
We passen het toe op onze invoerafbeeldingen, die tot nu toe worden weergegeven door X.

06:11.350 --> 06:12.400
Dus dat is de eerste stap.

06:12.520 --> 06:13.360
Eerste stap gedaan.

06:13.690 --> 06:15.130
Nu, tweede stap.

06:15.130 --> 06:22.990
We gaan Max pooling toepassen op onze ingewikkelde afbeeldingen die zijn geretourneerd door bijdrage één X en Max Pwning

06:22.990 --> 06:23.560
toepassen.

06:23.560 --> 06:26.590
Welnu, we nemen een functie van de functionele module.

06:26.770 --> 06:34.330
Dus we nemen f de snelkoppeling, dan punt en dan gaan we de functie max pool naar G gebruiken.

06:34.660 --> 06:40.780
Dat is degene die we zelfconvolutie één X tussen haakjes plaatsen van de max pool van de functie.

06:41.620 --> 06:48.850
Omdat we aan het spelen zijn, poolen in de ingewikkelde beelden, maar deze maximale pooling-functie vereist

06:48.850 --> 06:53.050
extra argumenten die voorop staan, zegt de kolonel.

06:53.080 --> 06:59.050
Dus nogmaals, dat is de grootte van het venster dat door je afbeeldingen schuift en dat zal het maximum van de pixels

06:59.050 --> 07:00.430
in elk licht nodig hebben.

07:00.700 --> 07:06.670
Die zal de features nog detecteren omdat de features gekoppeld zijn aan een hogere waarde van de pixel in de

07:06.670 --> 07:09.310
arrays, zoals je bij de intuïtieve docent zag.

07:09.670 --> 07:15.300
Dus dit eerste argument dat we hier moeten invoeren, is deze kernelgrootte en we gaan er drie nemen.

07:15.490 --> 07:17.380
Dat is een gebruikelijke keuze voor de kernelgrootte.

07:17.740 --> 07:24.700
En dan moeten we de stappen invoeren, weet je, met hoeveel pixels het in de afbeeldingen gaat schuiven.

07:25.030 --> 07:26.920
En we zouden een staking van twee nemen.

07:27.280 --> 07:28.930
Nogmaals, dat is een veelvoorkomende keuze.

07:29.680 --> 07:30.360
Dus daar gaan we.

07:30.550 --> 07:32.220
Nu is de tweede stap gedaan.

07:32.380 --> 07:38.830
En laten we nu verder gaan met de derde stap, namelijk het activeren van alle neuronen in deze poel en ingewikkelde

07:38.830 --> 07:40.960
beelden in deze eerste convolutionele laag.

07:41.380 --> 07:45.730
En om dit opnieuw te doen, gaan we een functie op dit alles toepassen.

07:45.980 --> 07:51.400
En dus doe ik hem hier weer uit, want we gaan een andere functie nemen, die, zoals je

07:51.400 --> 07:53.980
misschien al geraden had, een activeringsfunctie zal zijn.

07:54.160 --> 07:55.050
Maar welke?

07:55.060 --> 07:58.210
Zoals gewoonlijk wordt het een activeringsfunctie van de gelijkrichter.

07:58.690 --> 08:04.090
En misschien herinner je je de naam daarvoor is dat we gaan, dat is het.

08:04.120 --> 08:10.200
En dus passen we echt toe op onze samengevoegde, ingewikkelde afbeeldingen.

08:10.210 --> 08:11.400
Dat is dit alles.

08:12.370 --> 08:12.870
Oke.

08:12.880 --> 08:14.020
En dat is het.

08:14.230 --> 08:15.190
Drie stappen gedaan.

08:15.220 --> 08:16.150
Dat was heel snel.

08:16.360 --> 08:22.600
Dus onthoud, de manier waarop we hier naar moeten kijken, is dat we eerst de convolutie toepassen op onze invoerafbeeldingen.

08:23.020 --> 08:28.390
Dan passen we, Max, volledig toe op onze ingewikkelde afbeeldingen die met de convolutie zijn verkregen.

08:28.780 --> 08:36.070
En dan activeren we de neuronen in deze gepoolde convolutionele laag met de gelijkrichteractiveringsfunctie.

08:37.090 --> 08:44.080
Zo perfect, we krijgen onze eerste convolutionele laag waarop max pooling is aangebracht en waarin de neuronen

08:44.080 --> 08:45.750
nu worden geactiveerd.

08:46.090 --> 08:51.580
Wat het eigenlijk doet, is dat het de signalen van de eerste convolutionele laag naar de volgende

08:51.580 --> 08:52.240
propageert.

08:52.450 --> 08:56.130
En over de volgende gesproken, dat is precies waar we nu voor gaan zorgen.

08:56.380 --> 09:01.630
We gaan hetzelfde doen als op de eerste convolutionele laag naar de tweede convolutionele laag

09:01.630 --> 09:08.080
om de signalen opnieuw verder in het neurale netwerk te verspreiden door de neuronen van de tweede convolutionele

09:08.080 --> 09:09.370
laag te activeren.

09:09.690 --> 09:12.630
Maar voordat we dit doen, moeten we deze convolutionele laag krijgen.

09:12.940 --> 09:16.330
En dus gaan we convolutie toepassen op X.

09:16.330 --> 09:21.610
Dat is nu de eerste convolutionele laag waarop we convolutie gaan toepassen op X om

09:21.610 --> 09:27.170
de tweede convolutionele laag te verkrijgen, waarna we eraan trekken en dan uiteindelijk zijn Terrans activeren.

09:27.820 --> 09:28.740
Dus laten we dit doen.

09:28.960 --> 09:30.010
Het is eigenlijk heel gemakkelijk.

09:30.020 --> 09:34.930
We hoeven dat alleen maar te kopiëren en hieronder te plakken.

09:35.170 --> 09:38.890
Nu moeten we natuurlijk ook convolutie één door convolutie vervangen.

09:39.310 --> 09:40.330
En daar gaan we.

09:40.330 --> 09:43.180
Dat is eigenlijk klaar c heel gemakkelijk.

09:43.720 --> 09:50.140
En nu met deze lijn, propageren we de signalen van de tweede convolutionele laag naar de volgende, die

09:50.140 --> 09:52.300
de derde convolutionele laag zal zijn.

09:52.510 --> 09:56.610
En om de derde convolutionele laag te krijgen, moeten we die opnieuw toepassen.

09:57.070 --> 10:03.240
Dus ik kopieer dit, plak dat hieronder en vervang convolutie door convolutie drie.

10:03.760 --> 10:04.540
En dat is gedaan.

10:04.690 --> 10:11.770
Is het niet zo praktisch dat we de signalen in de drie convolutionele lagen en een zaklamp verspreiden dankzij

10:11.770 --> 10:12.910
deze geweldige structuur.

10:13.840 --> 10:15.220
Oké, zo perfect.

10:15.250 --> 10:22.240
Nu hebben we onze signalen gepropageerd naar de derde convolutionele laag en daarna en sprekend van daarna, dat leidt ons

10:22.240 --> 10:25.720
naar wat we zoeken, waar we in geïnteresseerd zijn.

10:26.020 --> 10:27.670
Dat is de afvlakking daar.

10:28.330 --> 10:28.720
Oke.

10:28.720 --> 10:35.880
Dus nu we onze derde convolutie daar hebben, dat is de laatste X hier, is het tijd om onze Flatman-laag te krijgen.

10:36.310 --> 10:38.250
En dat is dus precies wat we nu gaan doen.

10:38.260 --> 10:42.790
We gaan alle pixels van deze derde convolutionele laag afvlakken.

10:43.090 --> 10:48.070
Dat wil zeggen dat we alle pixels van alle kanalen van de derde convolutionele laag gaan nemen.

10:48.490 --> 10:51.690
We gaan ze een voor een in een enorme vector plaatsen.

10:51.940 --> 10:55.740
En natuurlijk zal deze enorme vector niets anders zijn dan de afvlakkingslaag.

10:56.080 --> 11:01.720
En tegelijkertijd zullen we een truc gebruiken om het aantal neuronen in deze afvlakkende laag te krijgen.

11:01.930 --> 11:03.420
Dat is precies wat we zoeken.

11:03.610 --> 11:05.410
Dat is het aantal neuronen dat we missen.

11:05.560 --> 11:08.320
En laten we daarom direct teruggeven wat we willen.

11:08.680 --> 11:14.260
En in deze terugkeer gaan we de derde convolutionele laag afvlakken en tegelijkertijd het aantal neuronen in

11:14.260 --> 11:15.990
deze afgeplatte laag krijgen.

11:16.480 --> 11:19.690
Dus we gaan X nemen, wat onze derde convolutie daar is.

11:20.170 --> 11:23.440
We nemen alle kanalen van de derde convolutie daar.

11:23.680 --> 11:29.350
En we gaan een functie gebruiken die de groottefunctie is om alle pixels van al deze kanalen in

11:29.350 --> 11:31.620
éénzelfde enorme vector af te vlakken.

11:32.020 --> 11:35.630
En dus de truc, je kunt het vinden in de Python-tutorial.

11:35.980 --> 11:40.560
Welnu, we nemen eerst de gegevens van X omdat X een speciale structuur is.

11:40.750 --> 11:42.100
Weet je, het is een fakkelvariabele.

11:42.100 --> 11:44.000
Het heeft dus een vrij complexe structuur.

11:44.140 --> 11:47.170
Maar eerst moeten we hier toegang krijgen met gegevens.

11:48.040 --> 11:51.660
Dan moeten we kijken wat erin zit.

11:51.940 --> 11:56.590
Dus we gebruiken deze weergavefunctie en nu moeten we toegang krijgen tot wat we zoeken.

11:56.680 --> 12:01.560
En dat wordt gegeven met de argumenten één en min één.

12:02.050 --> 12:06.610
Je hoeft niet te begrijpen wat er in de structuur zit, maar je kunt gewoon begrijpen dat dit is

12:06.610 --> 12:08.530
hoe we dit aantal neuronen gaan krijgen.

12:08.920 --> 12:15.130
En om te eindigen, moeten we de grootte tussen haakjes toevoegen en binnenin voeren we er een in.

12:15.760 --> 12:21.550
Dus wat we hier doen, is dat we alle pixels van alle kanalen nemen en ze een voor een

12:21.550 --> 12:26.420
in deze enorme vector plaatsen, die de invoer zal zijn van het volledig verbonden netwerk.

12:27.040 --> 12:29.020
Dat is eigenlijk wat deze maat doet.

12:29.200 --> 12:33.250
En hiermee kunnen we het aantal neuronen krijgen waarnaar we op zoek zijn.

12:33.880 --> 12:34.270
Oke.

12:34.270 --> 12:36.290
Dus nu krijgen we wat we willen.

12:36.310 --> 12:43.690
En ten slotte kunnen we hier een aantal neuronen vervangen door wat deze functie teruggeeft wanneer deze wordt

12:43.690 --> 12:47.030
toegepast op het formaat van de afbeeldingen.

12:47.260 --> 12:49.730
Dat is één bij acht bij acht.

12:50.050 --> 12:56.920
Dus wat we nu moeten doen is geen neuronen vervangen, maar we nemen het aantal neuronen.

12:57.800 --> 13:05.600
Functie, die we toepassen op het formaat van de afbeeldingen, die de tupel zal zijn.

13:06.760 --> 13:14.860
Tachtig en tachtig en daar gaan we en natuurlijk vergeten we het zelf niet, want Counts Neuron is eigenlijk een methode van

13:15.040 --> 13:18.280
de CNN-klasse, dus we moeten het zelf toevoegen.

13:18.490 --> 13:20.490
En nu zou de waarschuwing moeten verdwijnen.

13:21.010 --> 13:21.800
En daar gaan we.

13:22.390 --> 13:23.610
Nu is alles goed.

13:23.800 --> 13:27.730
We krijgen de architectuur van het neurale netwerk zonder dat er iets ontbreekt.

13:28.000 --> 13:33.010
En we hebben de functie van aftellen voor het geval je een aantal andere architecturen wilt proberen

13:33.160 --> 13:35.950
en dit aantal neuronen niet handmatig wilt tellen.

13:36.160 --> 13:37.450
Deze functie gebruik je gewoon.

13:37.450 --> 13:39.760
Je past het toe op het formaat van je afbeeldingen.

13:40.000 --> 13:42.000
En hiermee krijgt u direct wat u wilt.

13:42.010 --> 13:47.520
Dat is het aantal neuronen in de overstromende laag zonder iets te hoeven doen en wat de architectuur ook is.

13:48.230 --> 13:49.350
Dus dat is best gaaf.

13:49.360 --> 13:55.750
En nu zijn we klaar met de eerste grote, belangrijke stap van dit brein die we maken.

13:56.020 --> 13:57.610
En we hebben nog een laatste stap.

13:57.610 --> 14:02.130
Dat is een functie minder om te maken, wat de belangrijkste voorwaartse functie zal zijn.

14:02.440 --> 14:06.040
Dus we gaan de signalen vanaf het begin van de hersenen verspreiden.

14:06.190 --> 14:11.880
Dat is van de ogen van het oog tot aan de uitgangslaag die na de tweede doorverbinding is.

14:12.310 --> 14:14.110
Dus dat doen we in de volgende tutorial.

14:14.110 --> 14:15.790
En tot dan en ik.
