WEBVTT

00:00.300 --> 00:06.120
Hallo en welkom bij het super spannende deel van onze creatie, het deel waar we het slim maken.

00:06.270 --> 00:08.540
Dat is dus precies wat er gebeurt als je de lucht traint.

00:08.590 --> 00:13.200
Ik zal zijn intelligentie trainen om het doel te bereiken dat we wilden bereiken.

00:13.350 --> 00:18.870
En om dit te doen, gaan we het neurale netwerk trainen om de juiste voorspellingen uit te voeren.

00:19.110 --> 00:24.360
En dan is alles al klaar, want deze uitgangssignalen van de hersenen hebben al de juiste overdracht naar

00:24.360 --> 00:27.300
het lichaam om de laatste acties uit te voeren.

00:27.660 --> 00:32.130
Dus eigenlijk is wat we nu gaan doen iets wat we al eerder deden.

00:32.280 --> 00:37.680
We gaan gewoon wat willekeurige batches uit het geheugen halen, onze invoer uit deze monsters halen, de uitvoer

00:37.680 --> 00:42.930
krijgen, het doel krijgen, de voorspellingen krijgen, de laatste fout tussen de voorspellingen en het doel berekenen, en

00:42.930 --> 00:48.360
dan achterwaartse voortplanting uitvoeren was om de gradiëntafdaling te krijgen om de gewichten bij te werken op basis

00:48.360 --> 00:51.430
van hoeveel ze hebben bijgedragen aan deze laatste fout.

00:51.900 --> 00:53.040
Dus laten we dit allemaal doen.

00:53.040 --> 00:57.660
Je zult zien hoe het zo gemakkelijk gaat, want we hebben al alle tools om dit te

00:57.660 --> 00:58.020
implementeren.

00:58.200 --> 01:04.230
We hebben niet alleen het pad naar tools zoals de optimizer en de loss-functies, maar we hebben ook alle klassen

01:04.440 --> 01:09.600
die we eerder hebben gemaakt, zoals onze hersenen natuurlijk, die we gaan gebruiken om de voorspellingen

01:09.600 --> 01:10.290
te krijgen.

01:10.620 --> 01:17.970
Vervolgens wordt onze ervaring, herhaling van de geschiktheid van de implementatie en al deze tools gecombineerd tot de pilot,

01:17.970 --> 01:23.790
welke tools de training superprestaties zullen maken en daarom zullen we uiteindelijk een superkrachtige A

01:23.790 --> 01:26.250
krijgen. L. Dus laten we deze training waarmaken.

01:26.400 --> 01:28.110
Laten we onze ogen slim maken.

01:28.290 --> 01:33.380
En het eerste wat we nu gaan doen is de laatste functie die we tijdens de training zullen gebruiken

01:33.390 --> 01:36.200
bij het berekenen van de fout ophalen en optimaliseren.

01:36.540 --> 01:37.680
Dat is het eerste wat we gaan doen.

01:37.980 --> 01:40.590
Laten we dus een variabele maken voor de laatste functie.

01:40.590 --> 01:42.150
We gaan het verlies noemen.

01:42.810 --> 01:50.340
En dit is gelijk aan de MSE-verliesfunctie van de eindmodule.

01:50.850 --> 01:52.470
En dan die Mercilus.

01:52.740 --> 01:56.940
Dat is de laatste functie die we zullen gebruiken, omdat onze voorspellingen in feite waarden zijn.

01:56.940 --> 01:59.940
Weet je, we voorspellen de kernwaarden van de verschillende acties.

01:59.940 --> 02:05.970
En daarom, aangezien dit reële getallen zijn, doen we een soort neuraal netwerk voor regressie en daarom

02:05.970 --> 02:08.910
is de verliesfunctie het middel voor fouten.

02:09.120 --> 02:11.880
Dat is de verliesfunctie die we in het algemeen gebruiken voor regressie.

02:12.450 --> 02:12.960
Oke.

02:13.080 --> 02:18.180
Dus nu we onze laatste functie hebben, laten we onze optimizer hier zo geoptimaliseerd krijgen.

02:18.180 --> 02:21.240
Dat is de variabele die we voor it-optimizer maken.

02:21.270 --> 02:23.940
En we gaan zoals gewoonlijk.

02:23.940 --> 02:30.750
Wat betreft de zelfrijdende auto, de atom optimizer, dat is een zeer krachtige optimizer die wonderen zal doen voor

02:30.930 --> 02:31.710
de training.

02:32.130 --> 02:35.820
Dus laten we deze naar dat atoom brengen.

02:36.810 --> 02:42.720
En onthoud, dat is precies wat de zelfrijdende auto moet hebben om twee essentiële argumenten in te voeren.

02:43.080 --> 02:49.200
De eerste is degene die de verbinding zal maken tussen de optimizer en de parameters van ons neurale netwerk, dat

02:49.200 --> 02:52.650
wil zeggen de gewichten van de neuronen van onze hersenen.

02:53.040 --> 02:56.640
En om dit te doen, nemen we onze hersenen, die we CNN noemden.

02:57.030 --> 02:59.040
Dat is het object dat we voor onze hersenen hebben gemaakt.

02:59.280 --> 03:05.860
En dus CNN die parameters onthoudt die we gaan en wat haakjes.

03:06.270 --> 03:11.970
Dus dat maakt de verbinding tussen de optimizer en de gewichten van de neuronen in de

03:11.970 --> 03:18.630
hersenen van onze A. L. En dan is het tweede argument een leertempo, en dat wordt gegeven door l. R.

03:18.990 --> 03:24.510
En dus moeten we hier een kleinere leersnelheid nemen omdat we niet te snel willen convergeren en we willen wat verkenning hebben

03:24.510 --> 03:29.370
en daarom een goede manier van leren waarvan we kunnen zeggen dat hier een kleine is die vier

03:29.370 --> 03:33.150
punten is of een die is 0. 01 procent.

03:33.390 --> 03:36.270
Ik denk dat dat dezelfde is die we gebruikten voor de zelfrijdende auto.

03:37.320 --> 03:43.410
Oké, dus nu hebben we een verloren functie-optimizer, dus we zijn bijna klaar om de volledige lus te starten.

03:43.470 --> 03:45.890
Nou, eigenlijk beginnen we nu met de volledige lus.

03:46.140 --> 03:52.100
Maar net voordat we het doen, gaan we de grootte bepalen van het aantal tijdperken waarin

03:52.100 --> 03:58.170
we zullen veranderen en daarom creëren we hier een nieuwe variabele die zal reageren op dit aantal tijdperken.

03:59.320 --> 04:02.140
En laten we het gelijk stellen aan honderd.

04:02.530 --> 04:08.350
Dat is goed genoeg om de lucht te trainen en ik wed zelfs dat de lucht de beste

04:08.500 --> 04:11.140
weg zal bereiken voor honderd, twintig of dertig.

04:11.500 --> 04:12.000
Laten we eens kijken.

04:12.010 --> 04:13.750
Maar laten we er nu honderd nemen.

04:13.990 --> 04:15.940
En als we het nodig hebben, vergroten we het.

04:16.090 --> 04:17.710
Maar ik denk niet dat dat nodig zal zijn.

04:18.370 --> 04:22.660
Oké, dus nu we ons aantal luchthavens hebben, kunnen we beginnen met het maken van de volledige lus,

04:22.840 --> 04:26.680
je weet wel, deze volledige hoofdlus van de training wanneer we over de luchthavens trainen.

04:27.010 --> 04:31.530
Dus voorlopig gaat het hele volleybal aan het werk.

04:31.540 --> 04:34.240
Daar kiezen we voor terug in.

04:34.990 --> 04:42.310
Nu gaan we natuurlijk de bereikfunctie gebruiken om te zeggen dat we van de eerste naar het aantal

04:42.670 --> 04:44.500
van ongeveer willen gaan.

04:47.120 --> 04:52.730
Plus één, want onthoud dat de bovengrens van een bereik niet is inbegrepen, en daarom, als

04:52.730 --> 04:58.730
je tot 100 wilt gaan, nou, we moeten specificeren en een plus één zijn om tot 100 te gaan.

04:59.390 --> 04:59.840
Oke.

04:59.840 --> 05:00.800
Dus, Colin.

05:00.980 --> 05:02.800
En laten we nu in de lus gaan.

05:03.620 --> 05:03.980
Oke.

05:03.980 --> 05:08.300
Dus het eerste wat we gaan doen is 200 runs van tien stappen doen.

05:08.660 --> 05:13.630
Dus elke époque zal 200 runs zijn, de een na de ander van 10 stappen.

05:13.940 --> 05:19.550
En om dit te doen, hebben we deze eenstaps-functie uit onze ervaringsklasse en daarom gebruiken we

05:19.550 --> 05:24.770
deze functie, wat eigenlijk een methode is omdat we het uit ons geheugenobject halen,

05:24.770 --> 05:30.080
wat een object uit de vervangingsklasse is om deze twee runs te genereren van tien stappen.

05:30.320 --> 05:36.020
We moeten ons geheugenobject nemen dat ik je eraan herinner dat we hier hebben gemaakt.

05:36.170 --> 05:40.400
Geheugen is een doel om geheugenklasse opnieuw af te spelen met Insteps.

05:40.400 --> 05:43.300
Dat is 10 treden en een capaciteit van tienduizend.

05:43.910 --> 05:52.370
We hebben dit object gemaakt en van dit object nemen we goed, deze Rundstedt-functie voert stappen uit en we

05:52.370 --> 06:00.430
specificeren tweehonderd opeenvolgende ronden van tien stappen, zodat we gewoon bij elk in principe 200 stappen uitvoeren.

06:00.860 --> 06:08.060
En nu we deze 200 stappen bij elke apoc hebben lopen, is het tijd om enkele batches van deze runs

06:08.060 --> 06:10.630
te bemonsteren en deze batches te bemonsteren.

06:10.640 --> 06:16.700
We hebben nog een andere functie uit ons geheugen, dat is een monsterbatch, en die zal precies enkele

06:16.700 --> 06:18.910
batches van deze 200 runs genereren.

06:19.400 --> 06:26.720
Maar onthoud, deze batches zijn deze keer batches van een reeks overgangen die een reeks van tien stappen zijn, in tegenstelling

06:27.020 --> 06:31.630
tot voorheen, waar de batches hier slechts enkele batches van enkele overgangen waren.

06:31.640 --> 06:37.040
Deze keer worden het batches van tien stappen, tien overgangen, en daarom is het nu tijd

06:37.040 --> 06:41.870
om deze willekeurige batches uit ons geheugen te halen en ze op te halen.

06:41.870 --> 06:48.320
We gebruikten de eenvoudige batchfunctie waarop we de batchgrootte moeten toepassen en voor de batchgrootte

06:48.320 --> 06:53.480
waar we tweeëndertig of zelfs vierenzestig of zelfs honderdachtentwintig kunnen nemen.

06:54.080 --> 06:57.830
Denk eraan, voor die maat is het gebruikelijk om tweeëndertig te gebruiken.

06:58.070 --> 07:03.470
Dat is wat je in het algemeen zult zien in de neurale netwerkarchitecturen wanneer je wat batch-learning doet.

07:03.740 --> 07:05.470
Maar deze keer is het heel anders.

07:05.660 --> 07:11.530
Wij, we nemen slechts enkele batches van 10 stappen, dus het is beter om batches met grotere maten te nemen.

07:11.690 --> 07:14.710
Dus daar kunnen we vierenzestig, honderdachtentwintig nemen.

07:15.170 --> 07:16.940
Dus we gaan honderdachtentwintig nemen.

07:17.150 --> 07:25.130
En eigenlijk zal dit binnen de lus zijn omdat we verschillende batches willen nemen en we nemen ze op

07:25.130 --> 07:28.870
in wat wordt geretourneerd door deze eenvoudige batchfunctie.

07:29.420 --> 07:36.020
Dus deze volledige lus voor batch in geheugen monster batch, honderd achtentwintig betekent dat elke honderd

07:36.020 --> 07:41.720
achtentwintig stappen, ons geheugen ons een batch van grootte zal geven, honderd achtentwintig, die

07:41.720 --> 07:47.210
eigenlijk de laatste zal bevatten honderdachtentwintig stappen die we zojuist hebben uitgevoerd.

07:47.960 --> 07:53.060
We krijgen gewoon een paar batches van zes, honderdachtentwintig en het leren gaat gebeuren op

07:53.210 --> 07:54.080
deze batches.

07:54.320 --> 07:58.910
En behalve in deze batches, zullen we in aanmerking komende trays draaien, weet je, om elke 10 stappen

07:58.910 --> 07:59.480
te leren.

08:00.230 --> 08:00.620
Oke.

08:00.620 --> 08:06.950
Dus nu binnen deze lus, die nog steeds in één tijdperk plaatsvindt, maar nu zitten we in een specifieke

08:06.950 --> 08:07.360
batch.

08:07.790 --> 08:14.060
Het eerste wat we nu gaan doen, is dat we onze input en ons doel afzonderlijk gaan krijgen.

08:14.570 --> 08:16.610
En dat, zoals ik je al zei, heel gemakkelijk is.

08:16.610 --> 08:21.290
We kunnen het doen met een van de tools die we hebben geïmplementeerd, namelijk het traceren van geschiktheid.

08:21.620 --> 08:27.950
Zoals u hier kunt zien, neemt deze functie voor het traceren van geschiktheid de invoer als invoer en nu hebben we

08:28.310 --> 08:32.060
de batch en retouren als uitvoer, de invoer en de doelen.

08:32.420 --> 08:37.490
Dus wat we nu eenvoudig kunnen doen, is twee nieuwe variabelen maken, die de invoer en het doel

08:37.490 --> 08:38.300
zullen zijn.

08:38.690 --> 08:48.080
En of deze invoer op doelen komt, is precies hetzelfde als wat deze traceerfunctie voor geschiktheid van toepassing is op een

08:48.080 --> 08:48.610
batch.

08:49.010 --> 08:51.950
Dus we zullen deze functie toepassen op de batch van onze lus.

08:52.280 --> 08:55.160
En dus wat we zullen doen, is gewoon in aanmerking komen.

08:56.460 --> 09:00.110
Trace toegepast op de partij van onze hoop.

09:00.660 --> 09:07.110
Oké, dus dat geeft ons de input en de doelen, maar in strakke wads is er altijd iets meer dat we

09:07.110 --> 09:07.850
moeten doen.

09:08.100 --> 09:13.530
En dit is natuurlijk om de invoer van het neurale netwerk en ook het doelwit om te zetten in enkele

09:13.530 --> 09:14.030
tahj-variabelen.

09:14.340 --> 09:16.170
Maar er is ook niets nieuws.

09:16.200 --> 09:17.310
Wij weten hoe het moet.

09:17.490 --> 09:18.450
We kunnen het op deze manier doen.

09:18.460 --> 09:24.930
We nemen onze input, dan onze doelen en nou ja, ze zullen gelijk zijn aan verbaal.

09:25.820 --> 09:26.510
Ingangen.

09:27.750 --> 09:30.210
Dat is voor de input en verbaal.

09:31.150 --> 09:33.580
Doelen, en dat is voor de doelen.

09:34.090 --> 09:42.250
Oké, dus de input van de hersenen wordt omgezet in enkele tahj-variabelen en de doelen worden ook omgezet

09:42.250 --> 09:43.900
in enkele tahj-variabelen.

09:44.320 --> 09:48.320
Dus nu kunnen we de input in het neurale netwerk krijgen.

09:48.640 --> 09:50.530
En waarom moeten we dit doen?

09:50.530 --> 09:55.270
Omdat de volgende stap is om de voorspellingen te krijgen, hebben we de input die we moeten targeten.

09:55.540 --> 09:59.980
Nu hebben we natuurlijk onze voorspellingen nodig, want wat er dan gebeurt, is dat we het verlies tussen

10:00.190 --> 10:02.120
de voorspellingen en de doelen gaan berekenen.

10:02.890 --> 10:06.350
Dus laten we deze voorspellingen krijgen om ze te krijgen.

10:06.640 --> 10:07.930
Nou, nogmaals, dit is zo eenvoudig.

10:07.930 --> 10:14.650
Nu hoeven we alleen ons brein, dat is CNN, ons convolutionele neurale netwerk, te nemen en het toe

10:14.830 --> 10:16.730
te passen op onze input.

10:17.320 --> 10:17.950
Daar gaan we.

10:18.320 --> 10:23.320
De invoer gaat naar het neurale netwerk en het neurale netwerk zal de voorspellingen uitvoeren.

10:24.170 --> 10:29.270
Perfect, dus nu hebben we de voorspellingen, we hebben de doelen zodat we de wetten kunnen krijgen en dat

10:29.270 --> 10:34.640
is de volgende stap, we gaan een nieuwe meer introduceren omdat we nu de laatste fout krijgen, die anders is

10:34.790 --> 10:39.660
dan de laatste functie, omdat we het gebruiken als een functie om de laatste fout te krijgen.

10:40.100 --> 10:50.570
Dus minder fouten hier en dat we het zullen krijgen met de minder functie die wordt toegepast op onze voorspellingen en de doelen

10:50.570 --> 10:54.860
die we gaan bekijken hoe alles nu soepel verloopt.

10:55.070 --> 10:56.170
Alles is logisch.

10:56.180 --> 11:00.590
We krijgen eerst de input, de doelen, en dankzij de input krijgen we de voorspellingen.

11:00.590 --> 11:03.800
En dan dankzij de voorspellingen en de doelen die we krijgen, hoe minder fouten.

11:05.070 --> 11:08.850
Heel logisch en vlot dus, en wat is nu de volgende stap?

11:09.150 --> 11:14.940
Welnu, hetzelfde logische pad nu we het laatste hebben, we kunnen deze minder fout terug propageren in het nieuwe netwerk

11:14.940 --> 11:16.890
om de gewichten bij te werken.

11:17.190 --> 11:21.540
En dat doen we met stochastische gradiëntafdaling en om stochastische gradiëntafdaling uit te voeren.

11:21.540 --> 11:24.010
We hebben onze optimizer nodig, maar die hebben we al.

11:24.030 --> 11:26.040
Hier zijn Adam Optimizer.

11:26.430 --> 11:29.010
Maar onthoud nu op dit punt wat we moeten doen.

11:29.370 --> 11:32.380
We moeten het initialiseren en initialiseren.

11:32.400 --> 11:40.620
Onthoud dat we ons optimalisatieobject nemen en vervolgens de nulgradenmethode toepassen.

11:41.440 --> 11:48.220
Daar gaan we, we vergeten de haakjes die het initialiseren niet, en nu is de volgende stap om

11:48.220 --> 11:55.630
de laatste fout terug te propageren in het nieuwe netwerk en dit te doen waar we onze laatste fout nemen

11:55.630 --> 11:58.950
en we passen erop de achterwaartse methode toe.

11:58.960 --> 12:01.800
Dus dat is precies om achterwaartse voortplanting toe te passen.

12:02.110 --> 12:06.380
En dan tot slot, nu de laatste fout terug is, propageer deze naar het nieuwe netwerk.

12:06.610 --> 12:09.610
Welnu, we kunnen de gewichten bijwerken met de Cassi-gradiëntafdaling.

12:10.300 --> 12:16.950
En om dit te doen, onthoud dat we onze optimizer nemen en vervolgens de stapmethode toepassen.

12:17.500 --> 12:18.210
Daar gaan we.

12:18.400 --> 12:19.900
De gewichten zijn nu bijgewerkt.

12:20.200 --> 12:25.500
Zoals ik je al zei, we hebben het niet alleen al gedaan, maar nu lijkt het zo eenvoudig en zo natuurlijk.

12:26.200 --> 12:28.440
Dus nu gaan we iets leuks doen.

12:28.600 --> 12:31.650
We gaan de gemiddelde beloning elke apoc afdrukken.

12:31.840 --> 12:35.830
Dus, weet je, we kunnen bijhouden hoe de A. L. gaat, hoe de opleiding gaat.

12:36.190 --> 12:40.420
We willen de gemiddelde beloning zien toenemen over de stappen, over de doos.

12:40.630 --> 12:44.070
En eerst is er natuurlijk deze verkenningsfase.

12:44.080 --> 12:49.690
Dus de gemiddelde beloning zal in het begin misschien niet toenemen, maar als het eenmaal de exploitatiefase bereikt,

12:49.690 --> 12:56.050
zullen we zien dat de gemiddelde beloning zeker toeneemt en het zal toenemen tot een bepaald niveau, dat is wanneer

12:56.290 --> 12:58.740
het het westen zo snel als mogelijk.

12:59.380 --> 13:01.210
Dus laten we beginnen met de afdruk.

13:02.200 --> 13:07.660
Weet je, we doen dit in één keer, dus we moeten terug naar de meer lusvormige

13:07.660 --> 13:12.610
afdruk en dan gaan we goed afdrukken, eerst ongeveer een kolom, dan procent.

13:12.610 --> 13:18.850
S, want we gaan alles converteren naar een string die beter is en dan gaan

13:18.850 --> 13:21.100
we de gemiddelde beloning toevoegen.

13:22.490 --> 13:27.620
En dan tellen we ook nog eens procent op, dan gaan we de quote sluiten.

13:28.890 --> 13:35.220
En dan voegen we een percentage toe en aan de andere kant, weet je, voeren we de variabelen in die de

13:35.220 --> 13:41.430
eerste persoon zullen zijn, want dat is hier het epos en de tweede variabele die overeenkomt met de gemiddelde beloning, die

13:41.610 --> 13:42.840
nu wordt berekend.

13:43.020 --> 13:45.560
De gemiddelde beloningsvariabele bestaat dus nog niet.

13:45.780 --> 13:47.600
We gaan het nu maken.

13:48.120 --> 13:51.930
Dus we gaan ETR op het werk gebruiken.

13:52.470 --> 13:55.440
Zelfs als Époque het getal is, zetten we dat om in een string.

13:55.440 --> 13:57.090
Dat is beter en.

13:58.110 --> 14:03.150
We gaan eraan toevoegen, Estie, dat dit de gemiddelde beloning zal zijn en dus gaan

14:03.150 --> 14:09.810
we een variabele maken die we een grote beloning gaan noemen en nu gaan we deze variabele maken en berekenen ?

14:10.560 --> 14:12.430
Oké, laten we dit doen.

14:12.450 --> 14:13.980
Dat is het enige wat we nog moeten doen.

14:13.980 --> 14:15.900
Dus Époque hebben we al.

14:16.170 --> 14:20.040
Laten we nu de gemiddelde wereld berekenen en we moeten het hier berekenen.

14:20.130 --> 14:27.090
Nog steeds in de lus, maar uit de lus, want nu hebben we onze batch gesampled en hebben we onze training in

14:27.090 --> 14:28.050
de batch.

14:28.350 --> 14:31.940
Maar nu wordt de voorwaartse voortplanting plus de achterwaartse voortplanting in de batch gedaan.

14:32.190 --> 14:39.900
Dus we komen weer in de lus en we kunnen nu de cumulatieve beloningen berekenen die we kunnen doen met

14:39.900 --> 14:41.100
ons wreefobject.

14:41.430 --> 14:47.910
Omdat ons insteps-object deze functie bevat, zouden we stappen uitvoeren waarmee we de cumulatieve beloningen in de

14:47.910 --> 14:51.250
stappen kunnen krijgen, weet je, tijdens de instep-run.

14:51.660 --> 14:57.330
Dus we gaan het nu gebruiken om de nieuwe beloningen van de stappen bij te werken.

14:57.660 --> 15:05.640
En dan zullen we het voortschrijdend gemiddelde object bijwerken door de cumulatieve beloningen toe te voegen aan het bewegende alledaagse object en vervolgens

15:05.640 --> 15:07.770
het gemiddelde opnieuw te berekenen.

15:07.780 --> 15:09.910
En zo gaan we de gemiddelde beloning krijgen.

15:10.590 --> 15:11.510
Dus laten we dit doen.

15:11.520 --> 15:14.640
Het eerste dat we nodig hebben, zijn de DARABA-gegevens voor beloningen.

15:14.970 --> 15:16.950
Dus laten we ze beloningen noemen.

15:18.100 --> 15:27.700
Stappen en dan, zoals we zeiden, nemen we ons eindstappen-object, dat, ik herinner me, hier een object van de

15:27.700 --> 15:33.310
instant-progress-klasse was vanuit onze ervaring dat we zo'n gevoelig onderwerp bevuilen.

15:34.000 --> 15:39.410
Vervolgens voegen we beloningen, stappen en vervolgens enkele haakjes toe.

15:39.760 --> 15:40.150
Oke.

15:40.180 --> 15:43.690
Dat zal ons de nieuwe cumulatieve beloningen van de stappen opleveren.

15:43.990 --> 15:44.500
Oke.

15:45.310 --> 15:50.800
Maar dan moeten we deze nieuwe cumulatieve beloningen toevoegen aan onze voortschrijdend gemiddelde objecten.

15:50.980 --> 15:57.760
En om dit te doen, hebben we deze keer een methode in de klasse voortschrijdend gemiddelde, namelijk deze advertentiemethode die heel eenvoudig

15:57.760 --> 15:58.210
is.

15:58.220 --> 16:03.190
We nemen ons voortschrijdend gemiddelde object, dat we hier in honderd stappen hebben gemaakt.

16:03.790 --> 16:11.710
Dan gaan we onze ADD-methode gebruiken en dan voeren we in de atmosfeer onze beloningsstappen in en dit zal de beloningen

16:11.710 --> 16:15.130
van de stappen toevoegen aan het voortschrijdend gemiddelde.

16:15.970 --> 16:16.360
Oke.

16:16.360 --> 16:21.670
En tot slot kunnen we de gemiddelde beloning berekenen en dat is goed, weet je, dat is dezelfde variabele

16:21.670 --> 16:21.960
hier.

16:22.690 --> 16:26.440
Dus dat is wat gelijk zal zijn aan de gemiddelde beloning.

16:26.860 --> 16:33.250
En om het te krijgen, hoeven we deze keer alleen de gemiddelde methode te gebruiken van ons voortschrijdend gemiddelde object.

16:33.700 --> 16:41.470
En dat doen we en een puntgemiddelde zomaar, omdat ons voortschrijdend gemiddelde al was bijgewerkt met de nieuwe beloningsstappen

16:41.710 --> 16:45.520
die we zojuist hebben toegevoegd aan de ADD-methode.

16:46.430 --> 16:46.890
Geweldig.

16:46.960 --> 16:52.990
Dus nu hebben we onze gemiddelde prijs, dus dat is erg populair hier en dit wordt elk jaar gedrukt.

16:53.420 --> 16:54.990
Oké, dus we zijn klaar.

16:55.030 --> 16:57.170
Dus ik ben zo benieuwd naar de resultaten.

16:57.170 --> 17:01.670
En eigenlijk heb ik een verrassing voor je in de volgende tutorial terwijl ik naar de resultaten kijk.

17:01.700 --> 17:03.380
Het wordt dus best spannend.

17:03.650 --> 17:06.740
En nu denk ik dat het tijd is om met de lucht te spelen en plezier te hebben.

17:07.610 --> 17:08.060
Oke.

17:08.060 --> 17:11.240
Dus bereid jezelf een goede koffie of een goede thee.

17:11.480 --> 17:17.410
Nu is het tijd om comfortabel in onze stoel te gaan zitten en een aantal zeer coole video's van ons vliegtuig te bekijken om te laten zien,

17:17.430 --> 17:18.760
dat is in de volgende tutorial.

17:18.770 --> 17:20.160
En tot die tijd, geniet ervan.
