WEBVTT

00:00.760 --> 00:05.320
Hallo en welkom terug bij de cursus en deep learning nu we neurale netwerken in actie hebben gezien, is

00:05.320 --> 00:07.990
het tijd voor ons om uit te zoeken hoe ze leren.

00:08.350 --> 00:09.580
Dus laten we er meteen op ingaan.

00:10.420 --> 00:15.910
Er zijn twee fundamenteel verschillende benaderingen om een programma te laten doen wat je wilde doen.

00:16.180 --> 00:25.030
Een daarvan is hard gecodeerde codering waarbij je de programmaspecifieke regels vertelt en welke resultaten je wilt en je gewoon de

00:25.030 --> 00:31.210
hele weg begeleidt en je rekenschap geeft van alle mogelijke opties waarmee het programma

00:31.210 --> 00:32.770
te maken heeft.

00:33.160 --> 00:37.120
Aan de andere kant heb je neurale netwerken waar je een.

00:38.680 --> 00:44.650
Faciliteit voor het programma om te kunnen begrijpen wat het uit zichzelf moet doen om dit neurale

00:44.650 --> 00:50.980
netwerk in wezen te creëren waar je input hebt geleverd, je vertelt het wat je wilt als output,

00:50.980 --> 00:55.450
en dan laat je het alles zelf uitzoeken om fundamenteel verschillende benaderingen.

00:55.840 --> 01:00.250
En dat is iets om in gedachten te houden als we door deze materialen gaan.

01:00.730 --> 01:05.920
Ons doel is om dit netwerk te creëren, dat vervolgens vanzelf leert.

01:05.920 --> 01:10.930
We gaan vermijden om te proberen de regels in te voeren.

01:10.930 --> 01:15.670
En een goed voorbeeld dat ik je nu kan geven is dat dit in de cursus nog verder komt.

01:15.670 --> 01:18.040
Maar het is maar een heel visueel voorbeeld.

01:18.040 --> 01:24.250
Hoe maak je bijvoorbeeld onderscheid tussen een hond en een kat vier aan de linkerkant op de nadering

01:24.250 --> 01:25.630
die links is afgebeeld?

01:25.630 --> 01:30.490
Je zou dingen programmeren zoals de oren van de kat zo moeten zijn.

01:30.490 --> 01:34.090
Pas op voor snorharen, pas op voor dit type neus.

01:34.090 --> 01:38.830
Pas op voor dit type gezichtsvorm en let op deze kleuren.

01:38.830 --> 01:43.570
U beschrijft zo'n beetje al deze dingen en u zou omstandigheden hebben zoals als

01:43.720 --> 01:48.820
de oren puntig zijn, dan kat als de oren naar beneden hellen, dan mogelijk hond enzovoort.

01:49.500 --> 01:54.580
Aan de andere kant, voor een neuraal netwerk, noemde je gewoon de neurale netwerken, je noemde de

01:54.820 --> 02:00.760
architectuur, en dan wijs je het neurale netwerk naar een map met al deze katten en honden met afbeeldingen van katten

02:00.760 --> 02:02.590
en honden die al gecategoriseerd zijn.

02:02.590 --> 02:04.570
En jij zegt het, oké, ik heb je.

02:04.570 --> 02:06.520
Ik heb wat afbeeldingen van katten en honden.

02:06.760 --> 02:08.800
Ga en leer wat een kat is.

02:08.800 --> 02:10.480
Ga en leer wat een hond is.

02:10.480 --> 02:16.240
En het neurale netwerk zal op zichzelf alles begrijpen wat het moet begrijpen en dan verder naar beneden, als het eenmaal is getraind,

02:16.240 --> 02:20.920
wanneer je het een nieuw beeld geeft van een kat of een hond, zal het kunnen begrijpen wat het

02:20.920 --> 02:21.370
was.

02:21.520 --> 02:22.740
Dus ze zijn er.

02:22.750 --> 02:23.110
Zij zijn.

02:23.110 --> 02:25.330
Dat zijn de twee fundamenteel verschillende benaderingen.

02:25.570 --> 02:30.730
En vandaag gaan we langzaam beginnen in te zien hoe die tweede benadering werkt.

02:30.970 --> 02:31.360
Oke.

02:31.480 --> 02:33.490
Dus laten we hier meteen naar toe gaan.

02:33.490 --> 02:37.090
We hebben een heel basaal neuraal netwerk met één laag.

02:37.090 --> 02:40.240
Wordt dit een enkellaags feedforward neuraal netwerk genoemd?

02:40.570 --> 02:42.430
En het wordt ook wel een Perceptron genoemd.

02:42.670 --> 02:46.960
Nu, voordat we verder gaan, is een ding dat we moeten aanpassen, die uitvoerwaarde.

02:47.260 --> 02:50.920
Op dit moment kun je zien dat het gewoon een manier is waarop we een Y-hoed moeten plaatsen.

02:51.040 --> 02:56.420
En de reden daarvoor is dat Y meestal staat voor de werkelijke waarde, en dat is wat we gaan gebruiken.

02:56.440 --> 03:00.610
Dus waarom zal de werkelijke waarde zijn die we in werkelijkheid zien?

03:01.120 --> 03:05.800
Uitvoerwaarde is de voorspelde waarde door het algoritme, door het neurale netwerk.

03:05.830 --> 03:06.060
Waarom?

03:06.070 --> 03:11.320
Dat is de outputwaarde, eigenlijk is dat de benaming voor de outputwaarde.

03:11.650 --> 03:19.960
En de Perceptron werd voor het eerst uitgevonden in 1957 door Frank Rosenblatt, en zijn hele idee was

03:20.050 --> 03:24.760
om iets te creëren dat zichzelf kan leren en aanpassen.

03:25.090 --> 03:27.660
En dit is waar we nu naar gaan kijken.

03:27.940 --> 03:30.160
Dus we hebben onze Perceptron.

03:30.160 --> 03:31.800
Laten we eens kijken hoe Perceptron leert.

03:31.960 --> 03:39.070
Dus laten we zeggen dat we enkele invoerwaarden hebben die aan de Perceptron en of eigenlijk aan ons neurale netwerk

03:39.070 --> 03:39.940
zijn geleverd.

03:40.240 --> 03:44.140
Vervolgens wordt de activeringsfunctie toegepast.

03:44.140 --> 03:48.970
We hebben een output en nu gaan we de output in een grafiek plotten.

03:49.120 --> 03:51.280
Dus daar is het, onze output die we hadden.

03:51.700 --> 03:57.010
Wat we nu moeten doen, is om te kunnen leren, we moeten de uitvoerwaarde vergelijken met

03:57.010 --> 04:00.730
de werkelijke waarde die we willen dat het neurale netwerk krijgt.

04:00.730 --> 04:01.060
Rechts.

04:01.460 --> 04:04.170
En dat is de wat-waarde y.

04:04.630 --> 04:07.520
Dus als we het hier plotten, zul je zien dat er een klein verschil is.

04:08.230 --> 04:13.450
Nu gaan we een functie berekenen die de kostenfunctie wordt genoemd en wordt berekend als de helft van het

04:13.450 --> 04:16.750
verschil van het gekwadrateerde verschil tussen de werkelijke waarde en de uitvoerwaarde.

04:17.110 --> 04:20.430
Nu zijn er veel manieren waarop u de kostenfunctie kunt bedenken.

04:20.440 --> 04:22.780
Er zijn veel verschillende kostenfuncties die u kunt gebruiken.

04:23.290 --> 04:30.490
Dit is waarschijnlijk de meest gebruikte kostenfunctie en waarom we juist deze functie gebruiken.

04:30.490 --> 04:34.210
We komen er verderop achter als we het hebben over een gradiëntafdaling.

04:34.210 --> 04:39.040
Maar voor nu, wie is het ermee eens dat dit de kostenfunctie is en wat

04:39.040 --> 04:43.930
de kostenfunctie ons eigenlijk vertelt, is wat de fout is die je hebt in je voorspelling?

04:44.140 --> 04:49.990
En ons doel is om de kostenfunctie te minimaliseren, want hoe lager de kostenfunctie, hoe dichter we

04:49.990 --> 04:51.320
bij Y waren.

04:52.030 --> 04:54.350
Oké, dus zolang we het daarover eens zijn, laten we doorgaan.

04:54.370 --> 05:00.730
Dus wat er vanaf hier gebeurt, is dat er een kostenfunctie is en vanaf

05:00.730 --> 05:08.660
hier wat er gebeurt, gaan we nu, als we eenmaal hebben vergeleken, deze informatie terugvoeren naar het neurale netwerk.

05:08.920 --> 05:09.640
Dus daar gaan we.

05:09.640 --> 05:14.650
Daar gaat de informatie terug naar het neurale netwerk en het gaat naar de gewichten en de gewichten

05:14.650 --> 05:15.310
worden bijgewerkt.

05:15.640 --> 05:20.680
Kortom, het enige waar we controle over hebben in dit zeer eenvoudige neurale netwerk, hoe

05:20.680 --> 05:28.660
dan ook, het is één W2 helemaal naar W en ons doel is om de kostenfunctie te minimaliseren, zodat we alleen het gewicht kunnen

05:28.660 --> 05:29.080
bijwerken.

05:29.410 --> 05:36.160
Dus we werken de gewichten bij en tweaken ze een beetje en hoe we precies zullen ontdekken voor de Don.

05:36.160 --> 05:37.810
Maar voor nu zijn we het erover eens dat we hebben.

05:38.010 --> 05:40.020
De gewichten en dan gaan we verder.

05:40.050 --> 05:48.210
Maar hier heb ik deze schermafbeelding van de gegevens geplaatst om één punt heel duidelijk te maken, dat op dit moment, tijdens dit

05:48.210 --> 05:52.960
hele experiment, alles wat we nu doen, we te maken hebben met slechts die

05:52.960 --> 05:53.930
ene rol.

05:53.940 --> 05:59.760
We hebben dus te maken met een dataset van één rol waarbij we bijvoorbeeld te maken hebben

06:00.000 --> 06:01.900
met hoe lang je studeert.

06:01.950 --> 06:08.040
Net als de variabele die ze voorspelden, is wat voor resultaten je op een examen zult krijgen.

06:08.310 --> 06:12.420
En de afhankelijke, onafhankelijke variabelen die we hebben is voor hoeveel uur heb je gestudeerd?

06:12.600 --> 06:16.730
Hoeveel uur heb je geslapen en wat heb je halverwege het semester op de quiz gekregen?

06:16.740 --> 06:18.870
Dus halverwege het semester is er een quiz.

06:18.880 --> 06:19.810
Hoeveel procent heb je daar gehaald?

06:19.830 --> 06:25.500
Dus op basis van die variabelen proberen we te voorspellen welke score je krijgt voor het examen en examen, de

06:25.920 --> 06:27.940
93 procent, dat is de werkelijke waarde.

06:27.960 --> 06:28.710
Dus dat is waarom.

06:29.490 --> 06:35.220
Dus voeren we deze drie waarden nu voor de tweede keer weer in ons neurale netwerk.

06:36.030 --> 06:38.740
En dan gaan we de resultaten vergelijken met waarom.

06:39.030 --> 06:40.020
Dus laten we eens kijken hoe dit werkt.

06:40.680 --> 06:42.690
We voeren deze waarden in het neurale netwerk.

06:43.710 --> 06:46.620
Alles wordt aangepast en gewichten worden aangepast.

06:46.620 --> 06:50.490
Dus zoals je kunt zien, dit is, nogmaals, we gaan de waarden opnieuw voeden.

06:50.490 --> 06:53.130
Het punt hier is dat we dezelfde waarden invoeren.

06:53.130 --> 06:54.420
We hebben dus maar één rol.

06:54.420 --> 06:56.330
We proberen om op één rij te trainen.

06:56.340 --> 06:59.250
Dit komt omdat dit slechts een heel eenvoudig, eenvoudig voorbeeld is.

06:59.490 --> 07:01.130
Dan zien we wel wat er gebeurt als er meer is.

07:01.710 --> 07:06.120
Dus nogmaals, we voeden deze rollen in onze kostenfunctie, worden aangepast.

07:06.120 --> 07:10.460
Zoals je kunt zien, gebeurt alles weer in die richting.

07:10.470 --> 07:16.140
Dus zoals je kunt zien, verandert Alinejad elke keer dat ons hart verandert omdat we de gewichten hebben aangepast.

07:16.380 --> 07:17.520
Onze kostenfunctie verandert.

07:17.550 --> 07:18.300
Laten we nog eens kijken.

07:18.300 --> 07:19.890
Die voeren we dus in.

07:20.430 --> 07:21.630
We hadden een wijziging in de kosten.

07:21.630 --> 07:22.530
Functie verandert.

07:22.800 --> 07:26.970
We krijgen informatie terug, koppelen terug naar de gewichten zodat de gewichten weer aangepast worden.

07:26.970 --> 07:32.400
We voeren elke keer dezelfde waarden in als alles wordt aangepast, gaat terug naar de

07:32.400 --> 07:36.600
gewichten en nog een keer feed-in, OK, en nog een keer.

07:36.600 --> 07:39.540
Dus we hebben het gewicht aangepast, de gewichten aangepast die we in de informatie invoeren.

07:40.080 --> 07:40.540
Aha.

07:40.680 --> 07:41.290
En daar gaan we.

07:41.310 --> 07:45.660
Dus dit keer is het gewicht gelijk aan waarom functioneel nul.

07:45.870 --> 07:48.360
Meestal krijgt u geen kostenfunctie die gelijk is aan nul.

07:48.360 --> 07:49.970
Maar dit is een heel eenvoudig voorbeeld.

07:50.730 --> 07:57.180
Dus hopelijk was dat allemaal logisch elke keer dat we precies dezelfde rol spelen, want in dit

07:57.180 --> 08:04.290
geval hebben we alleen te maken met die ene rij in ons neurale netwerk waar de gewichten de waarden

08:04.290 --> 08:04.890
vermenigvuldigen.

08:04.890 --> 08:06.930
Is de activeringsfunctie trouwens zoals toegepast?

08:06.930 --> 08:09.630
We snappen waarom we dit hadden in vergelijking met waarom?

08:10.200 --> 08:12.090
Dan zien we hoe de kostenfunctie is veranderd.

08:12.270 --> 08:16.830
Feedback op de feed die informatie terug in het neurale netwerk en de gewichten gewoon weer aanpassen

08:17.730 --> 08:21.120
en dan herhalen we hetzelfde proces opnieuw met dezelfde exacte rol.

08:21.480 --> 08:23.020
We proberen die kostenfunctie te minimaliseren.

08:23.400 --> 08:26.570
Dus tot nu toe hadden we te maken met slechts die ene rol.

08:26.940 --> 08:29.400
Laten we eens kijken wat er gebeurt als je meerdere rollen hebt.

08:29.400 --> 08:31.260
Dus hier is de volledige dataset.

08:31.260 --> 08:38.790
We hebben acht rijen met hoeveel uur je hebt geslapen of misschien zijn dit verschillende studenten die hetzelfde examen afleggen, hoeveel andere

08:38.790 --> 08:43.920
uren er is bestudeerd, hoeveel uur ze slapen voor het examen, wat te krijgen op

08:43.920 --> 08:47.070
de quiz en hun eindresultaat op de test .

08:47.400 --> 08:51.840
En zoals je hier aan de linkerkant kunt zien, heb ik acht van deze waarnemingen.

08:51.840 --> 08:54.120
Eigenlijk zijn ze allemaal hetzelfde.

08:54.120 --> 08:54.690
Perceptron.

08:54.690 --> 08:55.600
Dit is dus ook belangrijk.

08:55.600 --> 08:55.930
Ik begrijp.

08:55.950 --> 09:04.230
Ik heb het gewoon vermenigvuldigd of acht keer gedupliceerd, zodat we dat kunnen conceptualiseren.

09:04.230 --> 09:06.720
Maar het belangrijkste hier is hetzelfde neurale netwerk.

09:06.720 --> 09:10.320
We gaan deze invoeren in hetzelfde neurale netwerk.

09:10.320 --> 09:10.920
Dus laten we gaan.

09:10.920 --> 09:11.560
Laten we beginnen.

09:11.580 --> 09:20.520
Dus één tijdperk, zoals je Hadland zult horen zeggen, één tijdperk is wanneer we onze hele dataset doornemen

09:20.520 --> 09:26.240
en we ons neurale netwerk trainen op al deze rollen.

09:26.250 --> 09:26.780
Dus laten we gaan.

09:26.790 --> 09:27.360
Laten we beginnen.

09:27.390 --> 09:31.220
Dus daar is onze eerste rij en daar hadden we voor de eerste rij.

09:32.480 --> 09:35.160
Er is een tweede rij, er is er een die ik had voor de tweede rij.

09:35.180 --> 09:39.260
Dus nogmaals, het is elke keer in hetzelfde neurale netwerk ingevoerd.

09:39.340 --> 09:43.800
Ik heb ze zojuist meerdere keren gekopieerd, zodat we visueel kunnen zien hoe dit gebeurt.

09:44.970 --> 09:47.450
Dan gebeurt het weer.

09:47.780 --> 09:48.770
Dat is de derde rij.

09:48.860 --> 09:49.820
Vierde rij.

09:50.570 --> 09:52.970
Er is onze weg vooruit voor de vierde rij, enzovoort.

09:52.970 --> 09:56.540
Kortom, dan krijgen we dezelfde waarden voor de resterende vier uur.

09:56.540 --> 10:02.430
Dus elke keer dat we ons op een rij voelen in ons neurale netwerk, krijgen we een waarde.

10:03.740 --> 10:06.860
Dan vergelijken we met de werkelijke waarde.

10:06.900 --> 10:08.250
Er zijn dus de werkelijke waarden.

10:08.660 --> 10:11.080
Dus voor elke rij hebben we een werkelijke waarde.

10:11.510 --> 10:18.260
En nu gebaseerd op al deze verschillen tussen witte hoeden en waarom we de kostenfunctie

10:18.260 --> 10:26.600
kunnen berekenen, wat de som is van al die kwadratische verschillen tussen witte hoeden en wit, en dat alles wordt

10:26.600 --> 10:27.110
gehalveerd.

10:28.100 --> 10:29.570
En daar is onze kostenfunctie.

10:30.200 --> 10:36.680
En wat we eigenlijk doen nadat we de volledige kostenfunctie hebben, we gaan terug en we werken de gewichten bij,

10:37.070 --> 10:39.430
we werken een, twee, drie bij.

10:39.440 --> 10:45.740
En het belangrijkste om te onthouden is dat al deze Perceptron, al deze neurale netwerken eigenlijk één

10:45.740 --> 10:47.270
neuraal netwerk zijn.

10:47.280 --> 10:48.290
Het zijn er dus geen acht.

10:48.290 --> 10:49.040
Er is er maar één.

10:49.530 --> 10:54.410
En als we de gewichten bijwerken, gaan we de gewichten in dat ene neurale netwerk bijwerken.

10:54.440 --> 10:57.490
Dus in principe zullen de gewichten hetzelfde zijn voor alle rijen.

10:57.830 --> 11:00.440
Het is dus niet zo dat elke rij zijn eigen gewichten heeft?

11:00.440 --> 11:02.510
Nee, alle rijen delen de gewichten.

11:02.750 --> 11:09.950
Daarom hebben we gekeken naar de kostenfunctie, de som van de kwadratische verschillen.

11:10.220 --> 11:11.870
En toen hebben we de gewichten bijgewerkt.

11:11.870 --> 11:15.140
En nu vanaf hier was dat slechts één iteratie.

11:15.200 --> 11:18.950
Vervolgens gaan we dit hele ding opnieuw uitvoeren.

11:18.950 --> 11:25.400
We gaan elke rij in het neurale netwerk invoeren, onze kostenfunctie uitzoeken en dit hele proces

11:25.400 --> 11:26.300
opnieuw doen.

11:26.310 --> 11:32.030
Dus net zoals we eerder zagen waar we maar één rij hadden en we alles opnieuw en opnieuw deden, opnieuw,

11:32.040 --> 11:32.540
opnieuw.

11:32.780 --> 11:33.530
Hetzelfde hier.

11:33.530 --> 11:38.720
Maar nu gaan we het doen Phaedrus of 800 honderd- of achtduizend rijen, hoeveel rijen je ook

11:38.720 --> 11:43.370
in je dataset hebt, je doet dit proces en dan bereken je de kostenfunctie.

11:44.090 --> 11:51.200
En het doel hier is om de kostenfunctie te minimaliseren en om zodra je het minimum van de kostenfunctie

11:51.200 --> 11:54.290
hebt gevonden, dat is je uiteindelijke neurale netwerk.

11:54.290 --> 12:05.630
Dat betekent dat uw gewichten zijn aangepast en dat u de optimale gewichten hebt gevonden voor deze dataset waarop u uw training uitvoert en dat u klaar bent

12:05.630 --> 12:10.520
om door te gaan naar de testfase of naar de toepassingsfase.

12:11.380 --> 12:18.010
En dit hele proces wordt terugpropagatie genoemd, dus wat extra lezing die je misschien wilt doen

12:18.010 --> 12:24.780
voor de kostenfunctie, en ik weet dat we het er net over hadden en er zijn veel verschillende.

12:24.790 --> 12:28.210
Een goed artikel staat op Cross Validated.

12:28.690 --> 12:32.650
Het wordt een lijst met kostenfuncties genoemd die naast toepassingen in neurale netwerken worden gebruikt.

12:32.980 --> 12:34.090
Dus de URL's daar.

12:34.090 --> 12:40.720
Maar je kunt gewoon Googlen voor die exacte zoekterm of een zoekterm en je zult zien dat deze de eerste

12:40.720 --> 12:41.820
is die opduikt.

12:42.010 --> 12:48.320
Het heeft eigenlijk een aantal goede voorbeelden en toepassings- of use-cases voor verschillende kostenfuncties.

12:48.350 --> 12:51.340
Dus als je meer wilt weten over kostenfuncties, bekijk dan dit artikel.

12:51.820 --> 12:54.260
En wat dat betreft, ik hoop dat je genoten hebt van de kleermakerij van vandaag.

12:54.310 --> 12:55.930
Ik kijk ernaar uit om je de volgende keer te zien.

12:55.960 --> 12:57.970
Geniet tot die tijd van deep learning.
