WEBVTT

00:00.790 --> 00:03.820
Hallo en welkom terug bij de cursus over kunstmatige intelligentie.

00:04.060 --> 00:06.330
Oké, dus ik hoop dat je geniet van de tutorial.

00:06.340 --> 00:09.010
Tot nu toe zijn we bijna klaar met de intuïtionist.

00:09.010 --> 00:09.340
Zeer snel.

00:09.340 --> 00:10.470
Ga naar de praktische kant van de dingen.

00:10.480 --> 00:13.030
We hebben alleen een paar kleine dingen die we moeten verbergen.

00:13.390 --> 00:13.660
Oke.

00:13.660 --> 00:21.880
Dus eerder hadden we het over hoe we neurale netwerken toevoegen aan deze hele vergelijking van leren en nemen, leren naar de

00:21.880 --> 00:24.980
volgende stap en het omzetten in diep leren.

00:25.510 --> 00:32.890
En vandaag gaan we een extra belangrijke functie toevoegen, namelijk coderen in de praktische kant van de

00:32.890 --> 00:33.340
dingen.

00:33.340 --> 00:39.340
Dus Hadland en ik besloten dat het belangrijk voor ons is om het vaak te behandelen in de integratiekant van dingen, zodat je er beter op

00:39.340 --> 00:41.930
voorbereid bent als het gaat om de coderingskant van dingen.

00:42.310 --> 00:46.390
Dus zoals we hebben besproken, hebben we het netwerk daar.

00:46.420 --> 00:47.890
Er zijn twee delen die gebeuren.

00:47.890 --> 00:49.090
Allereerst is het het leren.

00:49.090 --> 00:55.690
Dus het netwerk leert eigenlijk bij elke nieuwe fase, het werkt langzaam zijn gewichten bij om steeds beter en

00:55.690 --> 00:58.450
beter met deze omgeving om te gaan.

00:58.720 --> 01:01.900
En dan is er het handelen binnen de staat.

01:01.930 --> 01:07.960
Dus nadat de sleutelwaarden in de staat zijn geteld, wordt er één sleutelwaarde geselecteerd.

01:08.110 --> 01:11.740
Dus vandaag gaan we het nog steeds hebben over het leergedeelte.

01:11.740 --> 01:17.380
We gaan een interessante functie bedenken die goed gaat, we gaan deze functie

01:17.380 --> 01:25.720
niet zelf bedenken, maar we zullen het hebben over een functie die erg belangrijk is voor een diep Q-leren en

01:25.900 --> 01:29.150
dat een functie heet Experience a replay.

01:29.590 --> 01:29.950
Oke.

01:29.950 --> 01:31.790
Dus hier is ons netwerk.

01:31.810 --> 01:34.510
Dus we hebben het hier maar gekopieerd.

01:34.520 --> 01:36.010
We hebben dat een verlies.

01:36.010 --> 01:38.650
Dat wil zeggen Calicut onderaan wordt terug gepropageerd via een netwerk.

01:38.950 --> 01:44.710
En laten we eens kijken naar een voorbeeld van wat er gebeurt om het probleem waar we mee te maken hebben wat beter te

01:44.710 --> 01:45.160
begrijpen.

01:45.580 --> 01:49.060
Dus hier is een voorbeeld uit deze cursus.

01:49.060 --> 01:53.000
Dit is een screenshot precies van deze cursus.

01:53.020 --> 01:54.370
Dit is wat je gaat programmeren.

01:54.760 --> 02:00.700
Dit is een zelfrijdende auto die door dit soort wegen langs deze weg rijdt.

02:00.700 --> 02:03.340
En het moet leren deze weg te bewandelen.

02:03.640 --> 02:09.220
En dus wat is zoals we eerder hebben besproken, wat is dit in deze staat?

02:09.220 --> 02:12.010
En natuurlijk wordt de staat niet alleen x1 x2.

02:12.030 --> 02:16.540
Atlan zal wat gedetailleerder beschrijven wat de staat is.

02:16.540 --> 02:24.880
Het zullen een aantal parameters zijn die betrekking hebben op de hoek van de auto en enkele relatieve parameters, wat de

02:24.880 --> 02:26.410
sensoren lezen enzovoort.

02:26.420 --> 02:29.770
Er zullen dus meer parameters zijn om de staat te beschrijven.

02:29.770 --> 02:33.790
Maar desalniettemin wordt het een vector van waarden, gaat het door een neuraal netwerk

02:33.790 --> 02:36.400
en dan krijg je aan de uitgang wat AQ-waarden.

02:36.400 --> 02:42.400
Nogmaals, er zal een ander zijn, afhankelijk van de omgeving, er kan een ander aantal acties zijn, mogelijke acties, maar dat

02:42.670 --> 02:47.530
zal, omwille van de eenvoud, het op vier laten, alleen voor ons om een beetje beter

02:47.530 --> 02:50.440
te begrijpen wat er is hier aan de hand.

02:50.710 --> 02:55.600
Dus in dit geval, wat is de vraag tot nu toe, wat is dit?

02:55.600 --> 02:58.480
Dit komt in dit neurale netwerk?

02:58.480 --> 03:03.370
Of meer specifiek, hoe vaak activeren we dit neurale net?

03:03.460 --> 03:05.050
Hoe vaak gaat dit neurale netwerk door?

03:05.080 --> 03:10.510
Welnu, elke keer dat de auto in een nieuwe staat terechtkomt, dus de auto een beweging maakt, komt hij in een nieuwe

03:10.690 --> 03:12.490
staat terecht, en dan gaat alles.

03:12.580 --> 03:16.000
Al die data, al die informatie van over de staat gaat via het netwerk.

03:16.180 --> 03:22.210
Kivel is een berekende fout, maar deze fout wordt berekend op basis van wat we in eerdere tutorials hebben besproken.

03:22.900 --> 03:26.050
Deze fout wordt terug gepropageerd via een netwerk dat wordt bijgewerkt.

03:26.080 --> 03:28.480
Vervolgens selecteert de auto welke actie er moet worden ondernomen.

03:28.510 --> 03:31.420
Die verhuizing komt in een nieuwe staat terecht.

03:31.600 --> 03:33.860
In de nieuwe staat begint alles opnieuw.

03:34.270 --> 03:37.480
En dus gebeurt dit eigenlijk elke keer als de auto er is.

03:37.480 --> 03:39.810
En dan zeg je, kijk eens naar dit voorbeeld.

03:39.820 --> 03:46.180
Ik heb specifiek deze screenshot gemaakt omdat het eruit ziet dat het heel goed het probleem illustreert dat wordt aangepakt

03:46.180 --> 03:48.970
door middel van ervaring, opnieuw afspelen en ervaren.

03:48.970 --> 03:52.480
Replay is niet alleen iets dat we in deze cursus of in dit specifieke probleem gebruiken.

03:52.660 --> 04:00.340
Het is iets dat je overal zult zien, zoals steeds weer en steeds weer in

04:00.340 --> 04:05.040
kunstmatige-intelligentiealgoritmen, omdat het zo krachtig en zo belangrijk is.

04:05.050 --> 04:10.840
Dus kijk naar deze auto, deze auto in dit probleem of in deze omgeving, de gaullisten komen van hier

04:10.840 --> 04:12.340
naar hier en terug.

04:12.340 --> 04:17.230
Het doel is om hierheen te navigeren, zonder deze muren, die van zand zijn gemaakt, te overschrijden.

04:17.620 --> 04:25.030
En dus begon de auto hier, hij ging naar beneden en zoals zijn beloning is gebaseerd op hoe dicht hij bij stereo is.

04:25.040 --> 04:26.920
Dus de auto ging vanaf hier.

04:26.920 --> 04:28.510
Het ging naar beneden en ging zo door.

04:28.510 --> 04:29.440
Zo, zo, zo, zo.

04:29.450 --> 04:30.400
Langs deze muur.

04:30.400 --> 04:31.210
Langs deze muur.

04:31.390 --> 04:34.850
En wat het daarna gaat doen, zal blijven doorgaan.

04:34.870 --> 04:37.240
Wat we wilden doen, is hier doorgaan.

04:37.600 --> 04:39.150
Maar laten we er even over nadenken.

04:39.430 --> 04:44.170
Eenmaal bij deze muur, gaat het elke keer dat het vooruit gaat, vooruit.

04:44.170 --> 04:44.950
Het gaat vooruit.

04:44.950 --> 04:45.640
Het gaat vooruit.

04:45.640 --> 04:46.240
Het gaat vooruit.

04:46.240 --> 04:46.750
Het gaat vooruit.

04:46.750 --> 04:47.680
Het gaat vooruit en zo verder.

04:47.680 --> 04:48.310
Het gaat vooruit.

04:48.460 --> 04:53.140
Dus er kan zijn, afhankelijk van de structuuromgeving, het zou kunnen zijn als 100 honderd zetten hier

04:53.140 --> 04:54.370
of 50 zetten hier.

04:54.880 --> 04:57.400
Dat blijft maar vooruit, vooruit, vooruit, vooruit, vooruit ervoor gaan.

04:57.640 --> 04:58.810
En er verandert niets.

04:58.990 --> 04:59.440
Niks.

04:59.620 --> 05:03.870
Verandert echt, ja, het gaat verder weg van dit begon dichter bij dit doel, dat is heerlijk.

05:04.080 --> 05:08.370
Maar qua omgeving verandert er niet veel.

05:08.370 --> 05:09.780
Het is nog steeds diezelfde muur.

05:09.930 --> 05:15.420
Als je in de auto zit, heb je waarschijnlijk de situatie gezien wanneer je in de

05:15.420 --> 05:21.150
auto rijdt, het is alsof de omgeving zo eentonig is dat je gewoon ongeveer hetzelfde voorbij ziet

05:21.150 --> 05:21.770
komen.

05:21.780 --> 05:26.100
Maar stel je voor dat je door een woestijn rijdt en je ziet precies hetzelfde.

05:26.100 --> 05:27.030
Het is hetzelfde teken.

05:27.030 --> 05:27.660
Het is dezelfde kant.

05:27.660 --> 05:31.320
Er gebeurt niets, er verandert niets en zo basaal.

05:31.320 --> 05:38.340
Maar elke keer dat we die staat, die nieuwe staat hier plaatsen, ja, natuurlijk kan er iets

05:38.340 --> 05:38.900
veranderen.

05:38.910 --> 05:43.240
U bestuurt bijvoorbeeld de auto en uw GPS geeft aan dat u dichter bij uw bestemming bent.

05:43.410 --> 05:45.900
Een van deze ingangen is dus gewijzigd.

05:45.900 --> 05:51.810
Maar veel van deze andere inputs, bijvoorbeeld de sensoren die op de auto zitten, veranderen niet.

05:51.810 --> 05:56.520
En daarom, terwijl je aan het rijden bent, dus in deze staat, voer je de invoer in

05:56.530 --> 06:01.530
en je bent de hele tijd een beetje hier, hier, hier, hier, hier, hier, hier en hier en hier.

06:01.530 --> 06:02.920
De ingangen zijn vrijwel hetzelfde.

06:03.120 --> 06:10.410
Dus als je dezelfde invoer, dezelfde waarden, dezelfde vector of zeer vergelijkbare vectoren in je netwerk blijft

06:10.410 --> 06:16.320
invoeren, omdat er geen variatie is, zal de auto heel goed leren.

06:16.740 --> 06:21.300
Eén ding leer je heel goed hoe je langs deze muur moet rijden, die zich rechts ervan bevindt.

06:21.550 --> 06:26.760
En zo zal het netwerk zich updaten en je wordt beloond, langzaamaan beloond voor

06:26.760 --> 06:27.570
het rijden.

06:27.570 --> 06:30.930
Nou, het zal zijn als, oké, dus vanaf hier zal ik zo eenzaam zijn.

06:30.930 --> 06:32.160
Oh het gaat zo goed met me.

06:32.160 --> 06:32.970
Het gaat nog beter met me.

06:32.970 --> 06:33.630
Ik doe het beter.

06:33.870 --> 06:40.740
Hij zal deze valse perceptie hebben dat hij het eigenlijk heel goed doet, ook al leert hij alleen hoe

06:40.740 --> 06:43.140
hij langs deze muur moet rijden.

06:43.440 --> 06:47.490
En zo zal het neurale netwerk zeer aangepast worden om langs deze muur te rijden.

06:47.490 --> 06:52.950
En dan is er ineens die bocht en weet de auto niet wat hij moet doen en past

06:52.950 --> 06:55.080
hij totaal niet in dit neurale netwerk.

06:55.290 --> 07:01.500
En zelfs als het zich op de een of andere manier aanpast, laten we hypothetisch zeggen dat het deze plek passeert en dan eindigt

07:01.500 --> 07:05.040
het op deze muur, hetzelfde gaat gebeuren, gaat van hier, hier, hier rijden.

07:05.190 --> 07:10.440
Oké, nu herstructureert het neurale netwerk zichzelf om zich aan deze muur aan te passen en dan, bam, gebeurt

07:10.440 --> 07:10.830
dit.

07:10.830 --> 07:16.200
En zelfs als het daar op de een of andere manier voorbij komt, zal het langs dit ding rijden en dan hetzelfde langs deze lijnen.

07:16.210 --> 07:23.400
Dus eigenlijk is dit een heel levendig voorbeeld van het probleem dat we zijn wat we hebben, is dat omdat de manier waarop

07:23.400 --> 07:29.550
we het neurale netwerk gebruiken, het elke staat bijwerken, als we eenmaal veel opeenvolgende dingen hebben, ze niet eens

07:29.550 --> 07:30.810
hetzelfde moeten zijn.

07:30.810 --> 07:39.690
Maar in omgevingen is het normaal dat opeenvolgende toestanden op de een of andere manier gecorreleerd zijn of op de een of andere manier onderling

07:39.690 --> 07:40.620
afhankelijk zijn.

07:40.830 --> 07:45.510
En we willen niet dat die onderlinge afhankelijkheid ons netwerk vertekent.

07:45.510 --> 07:52.530
We willen niet dat de auto gewoon leert rijden als een rechte lijn of langs een gebogen lijn

07:54.020 --> 08:01.710
of zoals iets dat je denkt dat ze kunnen bedenken in een leven waarin een agent zou navigeren in een

08:01.710 --> 08:09.540
omgeving waar we kunnen denken aan gecorreleerde of onderling afhankelijke toestanden die op elkaar volgen, die je neurale netwerk echt

08:10.140 --> 08:15.060
in de war kunnen brengen als je de agent daarvan laat leren.

08:15.270 --> 08:17.580
En dat is waar experience replay om de hoek komt kijken.

08:17.580 --> 08:21.810
Wat er gebeurt bij het opnieuw afspelen van ervaringen, zijn deze ervaringen.

08:21.810 --> 08:27.780
Dus deze staten dat het in, een, twee, drie is, hoeveel vijftig staten hier op een rij ook zijn, ze

08:28.170 --> 08:30.600
worden niet meteen door het netwerk gestuurd.

08:31.410 --> 08:34.800
Ze zijn eigenlijk opgeslagen in het geheugen van de agent.

08:36.030 --> 08:40.980
En dus, bijvoorbeeld, het slaat al deze op en bewaart al deze en sommigen zullen je op een bepaald moment, zodra het een bepaalde

08:40.980 --> 08:44.580
drempel bereikt, die je tijdens de lunch kunt coderen, laten zien hoe je dat moet doen.

08:45.000 --> 08:51.210
Zodra het een bepaalde drempel bereikt, beslist de agent zelf, OK, het is tijd om te leren.

08:51.210 --> 08:56.500
Ik heb deze batch ervaringen die ik heb en nu ga ik van die batch leren.

08:56.520 --> 09:03.240
En dus selecteert het willekeurig een uniform verdeelde en uniforme sleutel is hier belangrijk, want daar zullen we het

09:03.240 --> 09:05.670
op de volgende dia over hebben.

09:06.720 --> 09:11.460
Zal kijken, zal dat vermelden, maar er is een uniform verdeelde steekproef voor nodig.

09:12.360 --> 09:15.540
Dus in principe worden alle ervaringen als gelijk beschouwd.

09:15.540 --> 09:23.280
Het neemt een uniform verdeelde steekproef van die reeks ervaringen die het heeft, en dan gaat het er doorheen en

09:23.280 --> 09:24.660
leert het ervan.

09:24.660 --> 09:26.730
Dus het hoeft niet alle extremen te nemen.

09:26.730 --> 09:28.320
Het duurt gewoon een uniform verdeelde monsters.

09:28.320 --> 09:31.020
Het kan een paar van hier vergen, een paar van hier, een paar van hier.

09:31.320 --> 09:34.860
En het en elke ervaring wordt gekenmerkt door de staat.

09:34.860 --> 09:43.200
Het zat in de actie die het ondernam, de staat waarin het belandde en de beloning die het behaalde door die actie

09:43.200 --> 09:44.730
in die specifieke staat.

09:44.730 --> 09:49.560
Dus vier elementen in elke ervaring geven één actie aan, toestand twee en beloning.

09:50.040 --> 09:54.600
En dus duurt het al die ervaringen en dan geeft het ze door het netwerk en het leert.

09:54.600 --> 09:59.130
En op die manier doorbreekt het het patroon daarvan.

09:59.230 --> 10:06.330
Bias, die voortkomt uit de sequentiële aard van de ervaring, alsof je ze een voor een door het

10:06.330 --> 10:07.780
netwerk zou sturen.

10:08.220 --> 10:11.820
Dus dat is de belangrijkste focus van het opnieuw afspelen van ervaringen.

10:11.830 --> 10:17.670
Dat is het probleem dat wordt aangepakt en een ander voordeel van het opnieuw afspelen van ervaringen is

10:17.670 --> 10:22.060
dat je in een omgeving als deze soms zeer waardevolle, zeldzame ervaringen hebt.

10:22.290 --> 10:25.860
Dus bijvoorbeeld, ik weet het niet, laten we eens kijken naar dit kwartaal.

10:26.010 --> 10:26.280
Rechts.

10:26.290 --> 10:28.050
Dit is een rechterhoek.

10:28.290 --> 10:28.620
Rechts.

10:28.650 --> 10:29.700
En een hele scherpe.

10:29.700 --> 10:30.810
Hoeveel is scherp?

10:30.810 --> 10:34.830
Dus het zal van hier komen, ervan uitgaande dat het deze hoek omhelst.

10:35.550 --> 10:40.890
Dus hoeveel scherpe rechterhoeken hebben we hierin in dit geheel en we hebben maar één rechterhoek hier en

10:40.890 --> 10:42.060
één rechterhoek hier.

10:43.530 --> 10:43.800
Rechts.

10:43.880 --> 10:45.990
Dus als het deze kant op komt, is dat de juiste hoek.

10:46.240 --> 10:48.540
En als het dan teruggaat, is het hier een scherpe rechterhoek.

10:48.550 --> 10:50.080
Dus en deze is niet scherp, deze scherp.

10:50.130 --> 10:56.280
Er is dus maar één kans in de hele omgeving om te leren vanuit een scherpe rechterhoek.

10:56.820 --> 11:02.760
En dat is een heel belangrijke ervaring, want het kan heel goed worden in het rijden langs rechte lijnen,

11:02.760 --> 11:06.390
heel goed in het doen van zulke zachte bochten, zoals dat.

11:06.390 --> 11:13.860
Maar en dan zal het deze scherpe rechterhoek blijven verknoeien, simpelweg omdat het simpelweg niet zoveel gelegenheid heeft om

11:13.860 --> 11:15.480
ervan te leren.

11:15.480 --> 11:17.880
En daarom zal het al het andere vrij snel leren.

11:17.880 --> 11:19.680
Maar het zal lang duren om dit te leren.

11:19.680 --> 11:19.860
Rechts.

11:19.860 --> 11:24.090
Omdat het een zeer vereenvoudigd voorbeeld is, is een zeer vereenvoudigde uitleg.

11:24.090 --> 11:29.850
Maar het illustreert het concept dat er soms zeldzame ervaringen zijn die waardevol kunnen zijn.

11:30.090 --> 11:35.820
En als je gewoon een eenvoudig neuraal netwerk aan het maken bent waar je je waarden hier invoert en je weet

11:35.820 --> 11:40.860
dat ze doorgaan en, weet je, zelfs als we dat probleem vergeten van de sequentiële aard van ervaringen

11:40.860 --> 11:45.750
en hoe ze kunnen onderling afhankelijk zijn en allemaal gecorreleerd zijn, vergeet dat zelfs voor een

11:45.750 --> 11:46.110
seconde.

11:46.740 --> 11:52.020
Wat er gebeurt, is dat als je eenmaal een ervaring erin stopt, het wat gegevens doorloopt, en dan vergeet je het

11:52.020 --> 11:53.310
meteen, vergeet je die ervaring.

11:53.310 --> 11:54.270
Je gaat door naar de volgende.

11:54.330 --> 11:57.240
Dat is gewoon hoe de neurale netwerken dan ga je naar de volgende dag.

11:57.250 --> 12:00.930
De volgende dag, de volgende dag, de volgende ervaring, volgende ervaring, ervaring enzovoort.

12:01.080 --> 12:05.700
Dus dit rechter kwadrant, zodra het door een netwerk gaat, is het weg en heb je geen enkele

12:05.700 --> 12:07.260
herinnering aan die waardevolle ervaring.

12:07.440 --> 12:14.160
Terwijl we herhaling hebben ervaren omdat je deze ervaringen in batches stopt, kun je je batch organiseren als

12:14.160 --> 12:15.600
een rollend venster.

12:15.600 --> 12:18.150
U kunt dus bijvoorbeeld 100 batches hebben.

12:18.150 --> 12:20.280
Dus 100 ervaringen in je batch.

12:20.280 --> 12:26.730
Dus als het van hier terugkomt, is het zodra het deze ervaring in zijn batch heeft vastgelegd, en dan,

12:27.270 --> 12:34.020
zoals op een bepaald moment, het een uniforme distributie van zijn batch ervaringen nodig heeft en dan is er een

12:34.020 --> 12:35.010
rollend venster.

12:35.010 --> 12:37.920
Dus het vergeet deze ervaringen, maar dan behoudt het deze ervaringen.

12:37.920 --> 12:43.680
En aan de andere kant, het leert van als het eenmaal hier is, het leert van deze batch en als het eenmaal hier

12:43.680 --> 12:47.940
is, als het helemaal tot hier komt, maar dan heeft het een batch van dergelijke ervaringen.

12:47.940 --> 12:50.370
Dus daarom leert een notitie van deze ervaringen.

12:50.610 --> 12:58.650
En op die manier krijg je dat deze rechterhoek meerdere keren naar voren kan komen in zijn leerproces, omdat het

12:58.650 --> 13:03.000
in die batch was toen de batch daar zo was.

13:03.000 --> 13:05.100
Toen zat het in de batch hier in de batch hier.

13:05.100 --> 13:11.340
Dus het kwam in verschillende batches naar voren omdat een batch mogelijk wordt bijgewerkt als een rollend venster van ervaring.

13:11.400 --> 13:14.550
Dus de oudere ervaringen worden eruit gegooid, de nieuwere ervaringen worden toegevoegd.

13:14.550 --> 13:16.150
En dan nog, oudere ervaring, Victor.

13:16.320 --> 13:23.010
Een ervaring blijft dus geruime tijd in de batch en de auto of agent kan meerdere keren van die

13:23.010 --> 13:23.940
ervaring leren.

13:24.090 --> 13:27.210
Dus dat is nog een voordeel van ervaring, replay.

13:27.460 --> 13:29.760
En natuurlijk is het laatste voordeel ervaring.

13:29.760 --> 13:35.520
Replay geeft je de mogelijkheid om van meer ervaringen te leren dan wanneer je slechts één voor één zou

13:35.520 --> 13:40.020
leren, omdat je die batch hebt en daarom en het een rollend venster is.

13:40.110 --> 13:47.130
En daarom, zelfs als uw omgeving beperkt is tot ervaring, kan uw benadering van het opnieuw afspelen van ervaringen

13:47.130 --> 13:49.020
u helpen sneller te leren.

13:49.230 --> 13:54.840
En in plaats van alleen maar opnieuw te doen, zijn er vele, vele, vele keren dat u sneller kunt leren omdat u het niet opnieuw

13:54.840 --> 13:55.650
hoeft te doen.

13:55.650 --> 13:57.050
Je hebt die ervaringen opgeslagen.

13:57.720 --> 13:59.520
Dat zijn dus de belangrijkste voordelen van ervaring.

13:59.520 --> 14:00.450
Replay, dat is opnieuw koppelen.

14:00.450 --> 14:03.720
Dan hebben we dat we dat patroon van onafhankelijkheid doorbreken en.

14:04.750 --> 14:10.930
Correlatie van opeenvolgende ervaringen, we bewaren zeldzame ervaringen die belangrijk kunnen zijn, en

14:10.930 --> 14:18.310
daarom kunnen we er vaker van leren en we kunnen leren in omgevingen, we kunnen snellere

14:18.310 --> 14:26.470
omgevingen leren die ervaring zijn, die een tekort aan ervaringen hebben, die geen zoveel ervaringen die de agent

14:26.470 --> 14:27.240
doormaakt.

14:27.250 --> 14:28.930
En toch kunnen we het leren.

14:29.290 --> 14:31.540
Dus dat is waar ervaring om draait.

14:32.320 --> 14:34.400
Als je wat meer wilt lezen dan dit.

14:34.480 --> 14:38.870
Er is een interessant artikel gepubliceerd door Deep Mind in 2016.

14:38.920 --> 14:46.630
Het heet Prioritized Experience Replay en het vertelt waarom we een uniforme distributie gebruiken om

14:46.630 --> 14:50.430
onze ervaringen uit de ervaringsbatch te selecteren?

14:50.440 --> 14:55.480
Waarom zoeken we geen betere manier om onze ervaringen te selecteren en prioriteit te geven aan enkele van de ervaringen die

14:55.480 --> 14:56.470
we belangrijk vinden.

14:57.040 --> 14:58.100
Het is dus best een interessant iets.

14:58.120 --> 15:07.660
Dus in dit geval kunt u niet alleen uw kennis over het opnieuw afspelen van ervaringen versterken, maar

15:07.660 --> 15:12.580
u kunt ook echt meegaan met de allernieuwste technologie.

15:12.610 --> 15:15.010
Dit is dus 2016 en gepubliceerd door Deep Mines.

15:15.010 --> 15:17.490
Het is dus een zeer recent, zeer krachtig artikel.

15:17.500 --> 15:23.530
U kunt dus daadwerkelijk de grenzen verkennen of dit algoritme nog verder verkennen en naar een hoger

15:23.530 --> 15:24.240
niveau tillen.

15:24.430 --> 15:30.820
Dus ik laat het aan jou over om uit te zoeken waarom en hoe we de uniforme verdeling kunnen veranderen in een andere benadering

15:30.820 --> 15:33.490
van ervaringsrapportage uit dit artikel, als je dat wilt.

15:33.790 --> 15:35.590
En ik hoop dat je er vandaag van geniet, Statoil.

15:35.590 --> 15:40.990
En nu weten we wat ervaring werkelijk is en kunnen we het vol vertrouwen in onze praktische termen gebruiken.

15:41.320 --> 15:42.790
En ik kijk ernaar uit om je de volgende keer te zien.

15:42.820 --> 15:44.500
Tot die tijd, geniet van I.
