WEBVTT

00:00.150 --> 00:05.760
Hallo en welkom bij deze Python-tutorial in deze tutorial, we gaan de eerste stap zetten in het

00:05.760 --> 00:07.800
implementeren van het deep learning-model.

00:08.130 --> 00:13.340
Dus eigenlijk staan we op het punt om het hele proces van het algoritme te implementeren.

00:13.650 --> 00:16.530
En dus gaan we gebruiken wat we eerder hebben gemaakt.

00:16.530 --> 00:22.350
Dat is de architectuur van het nieuwe netwerk om geheugen te vervangen, om dit te integreren in het hele

00:22.470 --> 00:23.310
deep learning-proces.

00:23.970 --> 00:28.150
En dit hele algoritme voor het leren uit de wachtrij gaat in één klas passen.

00:28.170 --> 00:31.880
Dus dat is de laatste taak die we maken om kunstmatige intelligentie te implementeren.

00:32.160 --> 00:35.550
En deze klasse zal gewoon verschillende functies bevatten.

00:35.580 --> 00:41.580
We zullen dus de energiefuncties hebben die alle variabelen die aan onze toekomst zijn gekoppeld, zullen creëren en

00:41.580 --> 00:42.210
initialiseren.

00:42.210 --> 00:46.110
Deep learning-objecten, die zelf een deep learning-model vertegenwoordigen.

00:46.440 --> 00:48.180
En dan hebben we nog wat andere functies.

00:48.330 --> 00:52.360
Een daarvan zal natuurlijk zijn om op elk moment de juiste actie te selecteren.

00:52.800 --> 00:58.830
We zullen ook een update-functie hebben als kernfunctie om deze kern te krijgen en een idee te hebben van hoe het

00:58.830 --> 00:59.730
leren gaat.

00:59.730 --> 01:05.670
Als het goed gaat, als de verkenning goed gaat, en als het kan overgaan tot exploitatie, en dan hebben we

01:05.670 --> 01:10.650
dezelfde functie om het model te redden, namelijk het brein van de auto redden en uiteindelijk

01:10.650 --> 01:11.890
een laadfunctie .

01:12.360 --> 01:14.250
We moeten dus een aantal functies maken.

01:14.490 --> 01:17.230
We gaan één functie maken voor elke Statoil.

01:17.340 --> 01:22.520
En vandaag gaan we zoals gewoonlijk beginnen met de init-functie als we een klas maken.

01:22.890 --> 01:26.730
Maar laten we eerst niet vergeten de klas voor te stellen.

01:26.740 --> 01:29.510
Dus we gaan het diep noemen.

01:30.060 --> 01:34.550
V En voor een diep netwerk, dan een paar haakjes.

01:35.100 --> 01:38.460
Kullen en daar gaan we met onze eerste functie.

01:39.360 --> 01:44.430
Dus laten we deze def doen, dan verdubbelen en scoren.

01:44.430 --> 01:47.560
Het onderstreept niet opnieuw en haakjes.

01:48.030 --> 01:52.740
Dus zoals je in deze init-functie hebt begrepen, gaan we de variabelen introduceren die aan ons object

01:52.740 --> 01:53.420
zijn gekoppeld.

01:53.430 --> 01:59.190
We zullen dus een aantal regels hebben die helemaal vanzelf beginnen en we zullen in principe alle variabelen

01:59.190 --> 02:03.040
creëren en initialiseren die nodig zijn om een diep Q-netwerk te implementeren.

02:03.360 --> 02:09.680
We gaan dus bijvoorbeeld een object of netwerk maken omdat we natuurlijk ons diepe neurale netwerk nodig hebben.

02:10.140 --> 02:11.990
Dan hebben we ons geheugen nodig.

02:12.150 --> 02:14.310
We zullen een andere variabele voor het geheugen maken.

02:14.610 --> 02:17.430
Dus we zullen een andere variabele zelf hebben, dat geheugen.

02:17.700 --> 02:20.040
Maar dan is dat niet alles wat we ook zullen moeten creëren.

02:20.340 --> 02:24.410
Enkele variabelen voor de laatste datum, de laatste actie en de laatste beloning.

02:24.780 --> 02:29.940
Dat zijn natuurlijk de variabelen die je ziet in het deep learning-algoritme.

02:30.720 --> 02:31.580
En wat dan nog?

02:31.770 --> 02:37.440
We hebben ook een optimalisatieprogramma nodig om een stochastische gradiëntafdaling uit te voeren om de gewichten

02:37.470 --> 02:43.950
bij te werken op basis van hoeveel ze zullen bijdragen aan de fout wanneer de AIA een fout maakt.

02:44.310 --> 02:49.950
En dan denk ik dat dat dus eigenlijk de variabelen zijn die we nu moeten maken en initialiseren.

02:50.400 --> 02:54.030
Maar in deze eindfunctie zullen we een aantal argumenten invoeren.

02:54.330 --> 02:59.670
Eerst, zoals gewoonlijk, zelf, dat zijn de argumenten die verwijzen naar ons object.

03:00.060 --> 03:04.940
Sindsdien, weet je, gaan we een object van de netwerkklasse maken.

03:05.250 --> 03:12.360
Welnu, aangezien de netwerkklasse zijn argument opneemt in de invoergrootte van de functie init en de actie, is dat

03:12.360 --> 03:13.320
hier hetzelfde.

03:13.680 --> 03:18.420
Wanneer we een object van de netwerkklasse maken, moeten we een argument voor de invoergrootte kiezen en

03:18.420 --> 03:19.590
het actieargument beëindigen.

03:20.040 --> 03:22.080
Daarom kunnen we ze gewoon kopiëren.

03:23.660 --> 03:24.170
En.

03:25.670 --> 03:27.290
Ze hier en daar gaan we.

03:27.560 --> 03:34.880
Dus deze argumenten worden nu ook enkele argumenten van de klas wanneer we toekomstige objecten van de andere klas

03:34.880 --> 03:38.890
maken, dat wil zeggen enkele toekomstige modellen voor diep leren.

03:39.290 --> 03:44.810
Welnu, we zullen de invoergrootte moeten specificeren, waarvan ik eraan herinner dat het een aantal dimensies is

03:44.810 --> 03:51.020
en de vectoren die uw staat, uw invoerstatussen en een aantal acties omvatten, wat een aantal mogelijke acties is die

03:51.020 --> 03:52.650
de auto kan uitvoeren.

03:53.030 --> 03:57.380
Dus ik herinner eraan dat deze ofwel links, rechtdoor of rechtsaf zijn.

03:58.040 --> 03:58.910
Oke perfect.

03:59.090 --> 04:04.580
Dan, weet je, zullen we een object van de replay-geheugenklasse maken om het geheugenobject te

04:04.580 --> 04:10.370
maken om ons geheugen van de overgangen te krijgen en in de eindfunctie hebben we het capaciteitsargument.

04:10.700 --> 04:15.700
Maar aangezien we het maar één keer zullen gebruiken, eigenlijk wanneer we een geheugen maken

04:15.860 --> 04:19.640
en niet ergens daarna, hoeven we geen capaciteitsargument op te geven.

04:19.880 --> 04:25.160
We zouden dit kunnen doen, maar we zullen direct het aantal overgangen invoeren dat we willen dat ons geheugen heeft.

04:26.040 --> 04:31.980
Maar dan hebben we nog een laatste argument nodig, namelijk de GEMAP-parameter in het diepe Cutrone-model.

04:32.310 --> 04:35.910
Onthoud dat deze gammaparameter de vertragingscoëfficiënt is.

04:36.270 --> 04:38.030
Dat is een barometer van de vergelijking.

04:38.040 --> 04:42.610
En daarom zullen we het hier plaatsen omdat we het daarna meerdere keren zullen gebruiken.

04:43.020 --> 04:44.510
Dus laten we het hier plaatsen.

04:44.910 --> 04:46.590
We gaan het Gamma noemen.

04:47.040 --> 04:48.990
Dus daarvoor is alleen de naam van het argument.

04:49.410 --> 04:53.360
En dan gaan we dat alle argumenten nodig zijn voor deze init-functie.

04:53.610 --> 05:00.240
Dus dat betekent dat wanneer we ons diepe KRY-model maken, dat is wanneer we een object van de

05:00.690 --> 05:06.990
klasse maken, we als argumenten de invoergrootte, het aantal acties en de gamma-parameter moeten specificeren en

05:06.990 --> 05:09.870
de echte waarden zullen opnemen voor hen.

05:11.010 --> 05:11.400
Oke.

05:11.400 --> 05:13.620
Laten we nu naar de Init-functie gaan.

05:14.040 --> 05:16.300
OK, dus nu wordt dit in principe gemakkelijk.

05:16.350 --> 05:20.730
We staan op het punt om alle variabelen te maken en te initialiseren die we nodig hebben.

05:21.000 --> 05:22.550
En laten we beginnen met de eerste.

05:22.740 --> 05:24.310
Laten we beginnen met Gamma.

05:24.330 --> 05:25.790
Eigenlijk de vertragingscoëfficiënt.

05:26.190 --> 05:30.190
Dus omdat dit een variabele is, willen we aan ons object worden gehecht.

05:30.240 --> 05:31.510
We beginnen bij onszelf.

05:31.740 --> 05:35.610
Dus Gamma wordt een variabele van ons DeQuan-model.

05:35.970 --> 05:42.540
Dus zelf dat gamma is gelijk aan de argumenten die worden ingevoerd bij het maken van een object van de klasse.

05:42.810 --> 05:44.090
Gamma dus.

05:44.340 --> 05:50.250
En dan gaan we met het tweede argument naar het tweede argument, het beloningsvenster.

05:50.700 --> 05:52.050
Dus wat betekent dit beloningsvenster?

05:52.350 --> 05:57.480
Nou, dat wordt het glijdende venster van het gemiddelde van de laatste honderd beloningen, dat alleen zal worden

05:57.480 --> 06:03.300
gebruikt om de evolutie van de prestatie te evalueren, weet je, het gemiddelde van de beloning in dit beloningsvenster dat

06:03.300 --> 06:06.030
in de loop van de tijd zal verschuiven .

06:06.240 --> 06:11.370
En wat we willen observeren is een gemiddelde van de laatste honderd beloningen die met de tijd toenemen.

06:11.760 --> 06:17.890
Dus laten we het initialiseren met zelf, dat beloningsonderstrepingsvenster.

06:18.510 --> 06:24.390
En aangezien dit een schuifvenster wordt van de evoluerende betekenis van de laatste honderd beloningen, gaan we het initialiseren

06:24.690 --> 06:30.870
als een lege lijst en dan zullen we het gemiddelde van de beloningen in de loop van de tijd

06:30.870 --> 06:31.500
bekijken.

06:32.710 --> 06:37.240
Oké, spannender, laten we ons neurale netwerk maken.

06:37.450 --> 06:43.600
We gaan het dus een autodidactisch model noemen, want dat is in feite het hart van het model.

06:43.600 --> 06:44.770
Dus ik noem het model.

06:45.740 --> 06:52.520
En dit model zal niets anders zijn dan een object van de netwerkklasse en om zo'n object te

06:52.520 --> 06:52.980
maken.

06:53.120 --> 07:01.370
We nemen ons klassennetwerk, dan haakjes, en hier voeren we alleen de argumenten van de netwerkklasse in.

07:01.760 --> 07:07.850
Maar we plaatsen deze argumenten in de argumenten van de init-functie en daarom hoeven we ze alleen

07:07.850 --> 07:12.170
maar hier te kopiëren en ze in de netwerkklasse te plaatsen.

07:13.010 --> 07:15.080
En dan gaan we met deze regel code.

07:15.200 --> 07:19.100
We creëren één neuraal netwerk voor een grappig model.

07:20.000 --> 07:22.410
Perfect, laten we dan een herinnering maken.

07:22.760 --> 07:28.660
Dus nogmaals, we gaan een nieuw logo maken dat we zelf dat geheugen noemen.

07:29.750 --> 07:33.980
En nogmaals, dit wordt een object van de replaying memory-klasse.

07:34.100 --> 07:36.290
Dus laten we gewoon de naam van onze klas nemen.

07:36.530 --> 07:37.510
Laten we het kopiëren.

07:38.060 --> 07:40.010
Laten we dat hier onder ogen zien.

07:40.220 --> 07:46.700
En tussen sommige haakjes moeten we de capaciteit invoeren omdat de capaciteit een argument is van de

07:46.700 --> 07:47.140
Init-functie.

07:47.330 --> 07:49.470
En dat is het enige argument dat we hier hoeven in te voeren.

07:50.090 --> 07:51.940
Dus welke capaciteit gaan we kiezen?

07:51.950 --> 07:57.290
Onthoud dat dit overeenkomt met het aantal overgangen, het aantal gebeurtenissen, de laatste acht nieuwe staat, de

07:57.440 --> 07:59.090
laatste actie en minder beloning.

07:59.660 --> 08:07.490
En dus, zoals vermeld in een van de vorige, gaan we honderdduizendhonderdduizend overgangen in het geheugen nemen en

08:07.490 --> 08:13.970
dan zullen we uit dit geheugen monsters nemen om een klein aantal willekeurige overgangen

08:13.970 --> 08:15.050
te krijgen.

08:15.050 --> 08:17.180
En daar zal het model van leren.

08:18.050 --> 08:20.800
OK, dus nu hebben we ons geheugen perfect.

08:21.060 --> 08:22.900
Laten we er nu voor gaan.

08:23.300 --> 08:28.490
Dus nogmaals, zelf, we creëren een nieuwe variabele die we optimizer noemen.

08:29.540 --> 08:35.870
Dus optimizer is een andere variabele van onze toekomst, een object uit de wachtrij halen, dus zelf

08:35.960 --> 08:43.640
die optimizer, en als we nu teruggaan, kun je zien dat we geïmporteerd hebben naar die AP'TIN, een module van torch

08:43.640 --> 08:46.980
die alle tools bevat om stochastische gradiëntafdaling uitvoeren.

08:47.000 --> 08:51.290
Dus het bevat natuurlijk enkele optimizers en we hebben het de snelkoppeling gegeven.

08:51.560 --> 08:58.900
Upton en daarom gaan we hier de uptime van het model nemen, die zo optimaal is.

08:59.030 --> 09:02.840
En uit deze module gaan we een van de optimizers nemen.

09:03.030 --> 09:05.300
Dus zoals je kunt zien, worden ze hier allemaal vermeld.

09:05.720 --> 09:07.130
Velen van hen zijn uitstekend.

09:07.340 --> 09:13.340
Armis Prop is bijvoorbeeld een uitstekende optimizer die bijvoorbeeld sterk wordt aanbevolen voor reguliere neurale netwerken

09:13.430 --> 09:15.650
of afhankelijk is van onbewaakt.

09:16.100 --> 09:21.880
Maar de andere die uitstekend is en die we zullen kiezen, is de atom-optimizer.

09:22.370 --> 09:23.750
Dat is degene waarmee je dat zult zien.

09:23.750 --> 09:26.140
Deze krijgt een goede zelfrijdende auto.

09:26.450 --> 09:29.120
Maar nogmaals, je bent van harte welkom om andere te proberen.

09:29.120 --> 09:32.500
Je kunt de armsteun proberen, maar als model zullen we Adam kiezen.

09:32.660 --> 09:33.800
Dus ik druk op enter.

09:34.370 --> 09:37.040
En in feite merk je dat er hier een AI met een hoofdletter is.

09:37.130 --> 09:40.340
Dat komt omdat we een object van de atoomklasse maken.

09:40.350 --> 09:44.540
Dit is een klasse, maar het object zal zelf een atom-optimizer zijn.

09:44.930 --> 09:47.630
Maar aangezien dit een klasse is, moeten we enkele argumenten invoeren.

09:48.020 --> 09:54.350
De argumenten van de atoomklasse en de argumenten of alle parameters die uw atoomoptimalisatieprogramma kunnen

09:54.350 --> 09:54.990
aanpassen.

09:55.220 --> 10:00.020
Dat is bijvoorbeeld typisch de leersnelheid, het verval of andere parameters.

10:00.350 --> 10:05.280
En naast het nemen van alle parameters van ons model, zullen we een leersnelheid specificeren.

10:05.840 --> 10:12.400
Dus als we het hebben over de parameters van ons model, we kunnen ze krijgen met onszelf, dat model.

10:12.710 --> 10:14.840
Dus dat is het model dat we hier hebben gemaakt.

10:14.840 --> 10:17.120
Autodidactisch model uit onze netwerkklas.

10:17.430 --> 10:18.620
Een soort model dus.

10:18.830 --> 10:26.450
En om vervolgens de parameters van het model te accepteren, voegen we heel eenvoudig nog een punt toe en vervolgens parameters tussen

10:26.840 --> 10:27.560
haakjes.

10:28.040 --> 10:35.800
Dus dat is alleen om de Atom Optimizer te verbinden met ons neurale netwerk, degene die we hier opnieuw hebben gemaakt.

10:35.810 --> 10:43.280
Zoals we net zeiden, gaan we een leersnelheid toevoegen en het argument hiervoor is een R en we zullen

10:43.280 --> 10:48.890
deze gelijk stellen aan een waarde zodat het leren niet te snel gebeurt.

10:49.220 --> 10:53.390
Als we een leertempo te groot krijgen, dan leert de A1 goed.

10:53.750 --> 10:58.580
We willen onze A. L. wat tijd om te verkennen, te leren van zijn fouten.

10:58.730 --> 11:04.100
Weet je, als we het straffen, als het een paar fouten maakt, zoals op de een of andere manier naar de zin gaan of te dicht

11:04.100 --> 11:05.160
bij een muur komen.

11:05.630 --> 11:08.570
Nou, we willen de A. L. wat tijd om te leren.

11:08.720 --> 11:11.690
We willen wachten tot het neurale netwerk correct werkt.

11:12.000 --> 11:20.270
En dus een goede waarde voor het leertempo dat ik kreeg nadat ik er een aantal had geprobeerd, is een punt of één.

11:21.020 --> 11:21.440
Oke.

11:21.440 --> 11:24.310
En dat is alles wat we nodig hebben om een optimizer te maken.

11:24.560 --> 11:27.920
Dus eigenlijk creëren we een object van de atoomklasse.

11:28.400 --> 11:28.910
Geweldig.

11:28.910 --> 11:36.620
En dan zijn de laatste drie variabelen die we nodig hebben de variabelen die onze overgangsgebeurtenissen samenstellen, zodat de laatste datum,

11:36.650 --> 11:39.710
de laatste actie en de laatste beloning.

11:39.980 --> 11:44.490
En dat is dus eigenlijk wat we nu gaan maken en we hoeven ze alleen maar te initialiseren.

11:45.170 --> 11:52.820
Dus laten we beginnen met de laatste datum, de laatste datum die we zichzelf die laatste onderstrepingsstatus gaan noemen.

11:53.300 --> 11:55.670
En hoe gaan we het dan initialiseren?

11:56.030 --> 12:03.440
Onthoud dat de laatste datum een vector van vijf dimensies is, een vector die codeert voor één toestand van

12:03.440 --> 12:04.460
de omgeving.

12:04.760 --> 12:10.760
En ter herinnering, deze vijf dimensies zijn de drie signalen van de drie sensoren

12:10.760 --> 12:14.310
links en rechts en oriëntatie en minus oriëntatie.

12:15.080 --> 12:20.810
Dit is dus een vector in intuïtieve zin, maar voor achteruit moet het meer zijn dan een vector.

12:21.020 --> 12:23.410
Het moet eigenlijk een toortssensor zijn.

12:23.690 --> 12:29.900
Maar het moet niet alleen een toortssensor zijn, maar het moet ook nog een dimensie hebben die ik

12:29.900 --> 12:33.080
graag een nep-dimensie noem die overeenkomt met de batch.

12:33.440 --> 12:38.030
En dat komt omdat de laatste datum de invoer van het neurale netwerk zal zijn.

12:38.360 --> 12:43.970
Maar als je werkt met neurale netwerken in het algemeen, of het nu gaat om verzorgers met een hogere dichtheid

12:44.300 --> 12:47.810
of Bythewood, dan kunnen de invoervectoren op zichzelf geen eenvoudige vector zijn.

12:48.020 --> 12:49.280
Het moet in een batch zijn.

12:49.700 --> 12:57.530
Het netwerk kan alleen een batch invoerwaarnemingen accepteren en daarom zullen we niet alleen een sensor maken

12:57.680 --> 13:04.210
voor invoerstatusvectoren, maar zullen we ook deze nep-dimensie creëren die overeenkomt met de batch.

13:05.060 --> 13:09.350
Dus laten we dit doen en laten we beginnen met het initialiseren van een toortssensor.

13:09.620 --> 13:11.960
Dus om dit te doen, is er niets eenvoudiger.

13:12.380 --> 13:21.770
We nemen dan onze Tahj-bibliotheek en dan gaan we de Tensor-klasse gebruiken, want zoals je misschien al geraden hebt, zal dit

13:21.770 --> 13:29.020
een object creëren voor de tenso-klasse dat een Tenzer-object is en in de zin van klasse.

13:29.180 --> 13:36.110
We moeten één argument invoeren dat de grootte van je Tenzer specificeert, je kunt je een sensor voorstellen als

13:36.110 --> 13:38.400
een array met één enkel type.

13:38.750 --> 13:44.960
Maar wat dit nu in feite zal vertegenwoordigen, is natuurlijk deze invoerstatus, die je als een vector kunt

13:44.960 --> 13:45.400
zien.

13:46.010 --> 13:50.900
Om het aantal elementen te specificeren dat Distancia moet hebben, moeten we

13:50.900 --> 13:56.940
natuurlijk de invoergrootte gebruiken, omdat de invoergrootte precies het aantal dimensies is van onze invoertoestandsvectoren.

13:57.380 --> 13:58.750
Nu moet ik zeggen Tensas.

13:59.000 --> 14:05.210
En dus wat we gewoon moeten invoeren in onze Tenzer-klasse om het Tenzer-object te maken.

14:05.870 --> 14:10.160
Dat is de invoergrootte en later zal de invoergrootte gelijk zijn aan vijf.

14:11.170 --> 14:16.740
Oké, dus dat is goed, dat is het eerste, Don, we hebben zojuist een Tenzer geïnitialiseerd, zoals het hoort.

14:17.380 --> 14:19.900
Maar bedenk dan dat we iets anders moeten doen.

14:19.900 --> 14:25.840
We moeten die nep-dimensie creëren, want dit is wat het netwerk zal verwachten voor zijn input

14:26.020 --> 14:31.750
en om deze ene nep-dimensie te creëren, die trouwens de eerste dimensie moet zijn.

14:32.030 --> 14:36.910
Weet je, de nep-dimensionering die op de weddenschap reageert, zal de eerste dimensie hiervan zijn, laten we zeggen,

14:36.920 --> 14:37.450
levensvatbaar.

14:38.080 --> 14:42.760
Om dit te doen, hoeven we alleen maar een punt toe te voegen en te knijpen.

14:44.040 --> 14:50.490
En dan tussen haakjes, moeten we de index van deze nep-dimensie plaatsen en zoals ik net zei, deze

14:50.550 --> 14:54.140
nep-dimensie moet de eerste dimensie van de staat zijn.

14:54.690 --> 15:02.070
En aangezien indexen in Python nul begonnen, moeten we nul invoeren zodat deze nieuwe dimensie de eerste dimensie

15:02.070 --> 15:02.890
wordt.

15:03.420 --> 15:09.840
We hebben dus een eerste dimensie die overeenkomt met het bed en dan de dimensie die overeenkomt

15:10.020 --> 15:15.930
met de sensor, die de vijf elementen van uw invoerstaten zal bevatten, de drie signalenoriëntatie en

15:15.930 --> 15:16.590
minusoriëntatie.

15:17.220 --> 15:22.410
En dan gaan we, we hebben onze invoerstaten behoorlijk perfect geïnitialiseerd.

15:23.130 --> 15:25.280
En dan nog twee variabelen te gaan.

15:25.470 --> 15:31.550
En dat zal veel gemakkelijker zijn omdat de volgende variabele de laatste actie is.

15:32.070 --> 15:35.930
Dat is een nieuwe variabele die we maken voor de laatste actie van het object.

15:36.330 --> 15:43.410
En onthoud, in de eerste tutorial van de sectie heb ik je verteld dat de acties nul één of

15:43.410 --> 15:44.880
twee zullen zijn.

15:45.240 --> 15:52.560
En dan gebruiken we de actie om de vector te roteren, we zullen deze indexen van deze acties omzetten in de

15:52.560 --> 15:57.650
hoeken van de rotatie, wat ik aan onze nul 20 of min 20 herinner.

15:57.900 --> 16:00.520
Daarmee kunnen we je geheugen echt opfrissen.

16:01.050 --> 16:02.700
Nou, het is precies hier.

16:03.000 --> 16:05.920
Actie tot rotatie als de actie nul is.

16:06.240 --> 16:08.990
Dit komt overeen met de eerste index hier.

16:09.000 --> 16:14.730
Dus nul, als de actie één is, komt dit overeen met de index, een van deze vectoren van twintig

16:14.730 --> 16:15.180
graden.

16:15.480 --> 16:18.720
En als de actie twee is, krijgen we min 20 graden.

16:19.080 --> 16:22.530
Dat wordt de rotatiehoek van onze auto als we de actie spelen.

16:23.320 --> 16:29.470
Oké, en daarom, aangezien de actie nul één of twee zal zijn, is de actie

16:29.470 --> 16:31.420
daarom een eenvoudig getal.

16:31.660 --> 16:35.150
En dus heel eenvoudig, we kunnen het op nul initialiseren.

16:35.530 --> 16:37.960
We hoeven geen kans te creëren om iets anders te horen.

16:38.200 --> 16:40.560
We hoeven het alleen maar met nul te initialiseren.

16:41.230 --> 16:47.970
En tot slot, nou, dat is de laatste beloning voor jezelf die laatste beloning.

16:48.700 --> 16:49.500
Daar gaan we.

16:49.750 --> 16:55.980
En nogmaals, de beloning is een float-getal, waarvan ik eraan herinner dat het tussen min één en plus één ligt.

16:56.380 --> 16:57.480
Dus dat is weer een getal.

16:57.670 --> 17:01.630
En wat de actie betreft, we zullen deze op nul initialiseren.

17:01.960 --> 17:02.800
En daar gaan we.

17:02.810 --> 17:04.600
Gelukwensen staan erin.

17:04.600 --> 17:05.860
Functie is klaar.

17:06.190 --> 17:08.590
Dus nu zijn we klaar om verder te gaan met de spannende dingen.

17:08.710 --> 17:15.790
En eigenlijk het belangrijkste voor A. L. dat is beslissen welke actie op elk moment wordt gespeeld, op elk

17:15.790 --> 17:16.180
moment.

17:16.840 --> 17:22.890
En dat is precies wat we in de volgende tutorial gaan doen door de select action-methode te maken.

17:23.380 --> 17:25.240
Dus laten we dit doen in de volgende ATWAL.

17:25.240 --> 17:26.020
En tot dan.

17:26.320 --> 17:27.250
En ik.
