WEBVTT

00:00.180 --> 00:02.250
Hallo en welkom bij deze Python-tutorial.

00:02.670 --> 00:08.160
Oké, dus vandaag zullen we de update-functie maken, die alles zal updaten wat er is

00:08.160 --> 00:11.920
om te updaten zodra het oog een nieuwe staat bereikt.

00:12.360 --> 00:15.750
Dus als het een nieuwe fase bereikt, weet je, moeten we de actie bijwerken.

00:16.050 --> 00:21.780
De laatste actie wordt de nieuwe actie die werd weergegeven, maar ook de laatste status die de nieuwe

00:21.780 --> 00:22.490
status wordt.

00:22.500 --> 00:26.920
En tot slot, het laatste woord dat het nieuwe woord wordt dat we krijgen als we de actie spelen.

00:27.330 --> 00:33.030
Dus dat is het logische pad dat loopt direct na het selecteren van een actie, we moeten alle

00:33.030 --> 00:34.800
elementen van de overgangen bijwerken.

00:35.130 --> 00:37.060
En natuurlijk krijgen we een nieuwe transitie.

00:37.260 --> 00:39.880
Dus we zullen deze nieuwe overgang naar het geheugen moeten openen.

00:40.170 --> 00:45.780
En tot slot zullen we ook ons beloningsvenster bijwerken, weet je, om de evolutie van hoe de training verloopt

00:45.780 --> 00:49.160
en hoe de verkenning verloopt, in de gaten te houden.

00:49.530 --> 00:55.380
Maar het belangrijkste voor u om te begrijpen is dat we nu eindelijk een verbinding

00:55.380 --> 01:01.440
kunnen maken tussen de A. L. die we nu op onze kaart

01:01.440 --> 01:06.100
implementeren, want als we teruggaan naar onze kaart, onthoud, er is een grote updatefunctie in de gameklasse.

01:06.120 --> 01:11.490
Dus dat is waar we het spel met de auto maken en bepalen hoe de auto moet worden gestraft als

01:11.490 --> 01:12.720
hij een fout maakt.

01:13.050 --> 01:18.720
Maar in deze spelklasse merken we deze updatefunctie op en in deze updatefunctie merken we dat

01:18.720 --> 01:21.170
deze lijnactie gelijk staat aan hersenen.

01:21.210 --> 01:24.380
Die update, minder beloning, minder signaal.

01:24.720 --> 01:28.020
En eigenlijk is dit precies wat we gingen maken.

01:28.350 --> 01:36.060
We staan op het punt deze update-functie te maken die de laatste beloning en het laatste signaal zal krijgen om de volgende actie

01:36.060 --> 01:37.370
te laten spelen.

01:37.710 --> 01:44.310
We zullen dus niet alleen alle verschillende elementen van de overgang updaten, maar meestal zullen we de actie spelen die we

01:44.310 --> 01:48.770
zouden moeten spelen wanneer we de laatste beloning en het laatste signaal krijgen.

01:49.290 --> 01:56.400
En dus zullen we in deze updatefunctie natuurlijk de functie Select Action gebruiken die we zojuist hebben geïmplementeerd voordat

01:56.400 --> 02:02.580
we de functie Select Action integreren in de toekomstige updatefunctie die we gaan maken om de

02:02.580 --> 02:07.470
te spelen reactie te selecteren, naast het maken van alle de updates.

02:07.710 --> 02:10.350
Dus dat is heel belangrijk om deze verbinding met de kaart te maken.

02:10.350 --> 02:10.800
Nu.

02:11.130 --> 02:18.420
Wat we gaan maken is uiteindelijk de verbinding tussen onze AI en de game, de game die we in deze

02:18.420 --> 02:19.210
klas maken.

02:19.590 --> 02:23.880
Dus wat we nu kunnen doen, is deze update direct uitvoeren.

02:23.960 --> 02:30.140
Laatst waren we het laatste signaal, want dat is precies de functie die we hier met deze twee argumenten zullen maken.

02:30.540 --> 02:34.140
En even ter herinnering: de hersenen zijn ons object.

02:34.350 --> 02:37.730
Dat is het doel van de verschillende klasse.

02:38.400 --> 02:45.510
Dus wat we nu gaan doen, is dat we deze update gaan kopiëren, minder beloning, minder signaal, en dat

02:45.510 --> 02:48.300
wordt onze volgende functie die we maken.

02:48.300 --> 02:49.950
En daarom baseer ik dat hier.

02:50.370 --> 02:51.630
Wees dan gewoon voorzichtig.

02:51.630 --> 02:55.890
Ik zou alleen wat andere namen willen geven dan de namen die we hier hebben.

02:56.010 --> 02:57.390
Weet je, we hebben hier minder beloning.

02:57.390 --> 03:01.760
En ik wil deze laatste beloning niet verwarren met deze die gevaarlijk kan zijn.

03:02.070 --> 03:05.850
Dus ik ga het laatste woord hier vervangen door beloning.

03:06.210 --> 03:08.820
En trouwens, hetzelfde voor het laatste signaal.

03:08.820 --> 03:15.540
Laten we gewoon een signaal of zelfs een nieuw signaal plaatsen om aan te geven dat we uw gegevens willen maken wanneer we een

03:15.720 --> 03:18.450
nieuwe staat bereiken en daarom een nieuw signaal krijgen.

03:18.720 --> 03:26.490
Maar dan, natuurlijk, deze beloning hier zal de laatste beloning zijn die we hier krijgen, weet je, wanneer we naar een of andere

03:26.490 --> 03:33.000
verzending gaan of erger, te dicht bij een rand van de kaart komen, daar definiëren we de laatste

03:33.000 --> 03:33.750
beloning .

03:34.050 --> 03:37.290
De beloning is de invoer van de update-functie.

03:37.290 --> 03:39.120
Dus daarom hebben we hier minder beloning.

03:39.450 --> 03:45.800
Maar hier geef ik gewoon een andere naam voor het argument beloning om het niet mee te verwarren.

03:45.810 --> 03:46.690
Laatste woord hier.

03:47.460 --> 03:47.850
Oke.

03:47.860 --> 03:49.820
Dit is dus de Abdeh-functie.

03:50.130 --> 03:53.700
En laten we er nu naar binnen gaan en deze twee dingen doen.

03:53.940 --> 03:58.590
Dat is update's alle elementen van onze overgang en, natuurlijk, selecteer de actie.

03:59.130 --> 04:01.290
OK, dus wat moeten we eerst updaten?

04:01.800 --> 04:06.410
Welnu, zoals u begreep, willen we de updates uitvoeren wanneer een nieuwe staat wordt bereikt.

04:06.720 --> 04:10.350
Dus het eerste wat we gaan updaten is natuurlijk deze nieuwe staat.

04:10.710 --> 04:12.150
Dat is de nieuwe staat die we bereiken.

04:12.690 --> 04:17.110
Dus ik ga deze nieuwe staat noemen, nieuwe staat en dan gelijk.

04:17.160 --> 04:19.460
En hoe kunnen we deze nieuwe staat krijgen?

04:19.880 --> 04:25.160
Dat hangt natuurlijk af van het signaal, het nieuwe signaal dat de sensoren zojuist hebben gedetecteerd.

04:25.650 --> 04:32.700
En ter herinnering: de status is het signaal zelf dat bestaat uit de drie signalen van de sensoren, signaal

04:32.700 --> 04:37.040
één, signaal twee en signalen drie plus oriëntatie en minus oriëntatie.

04:37.410 --> 04:38.270
Dat is onze staat.

04:38.430 --> 04:42.210
Zorg er dus voor dat u begrijpt dat het signaal de status is.

04:42.530 --> 04:45.840
Maar op dit moment is het een eenvoudige lijst van vijf elementen.

04:46.020 --> 04:51.090
En aangezien dit de input van het neurale netwerk zal zijn, onthoud, we moeten het omzetten in

04:51.090 --> 04:51.930
een fakkelsensor.

04:52.350 --> 04:54.410
Dat is dus precies wat we nu gaan doen.

04:54.780 --> 04:59.700
We nemen onze fakkelbibliotheek en nemen dan.

04:59.950 --> 05:10.000
De Tenzer-klasse, daar gaan we, die ons nieuwe signaal zal omzetten in een toortssensor, dan is het beter om ervoor te zorgen

05:10.000 --> 05:13.950
dat alle elementen van de toortssensor drijvers zijn.

05:13.960 --> 05:21.370
Dus ik ga een typeconversie maken om ze om te zetten in drijvers zoals deze en dan eindelijk proberen de reflex te

05:21.370 --> 05:24.010
krijgen van wat we vervolgens moeten doen.

05:24.340 --> 05:29.010
Het is natuurlijk om die nep-dimensie te creëren, om een dimensie toe te voegen die overeenkomt met de wedstrijd.

05:29.020 --> 05:36.460
En we doen dit natuurlijk met de on-squeeze-functie waarin we de index moeten invoeren van deze nep-dimensie die we

05:36.460 --> 05:39.830
willen hebben voor de match, die nul is.

05:40.570 --> 05:41.140
Oke.

05:41.150 --> 05:46.720
En nu hebben we onze nieuwe staat samengesteld uit de drie signalen van de drie sensoren, plus

05:46.720 --> 05:47.740
oriëntatie, minus oriëntatie.

05:48.220 --> 05:54.760
En dat hangt natuurlijk af van het nieuwe signaal dat we op dit moment krijgen met deze

05:54.760 --> 05:55.240
updatefunctie.

05:55.450 --> 05:59.310
Laatste signaal, we krijgen de drie signalen plus oriëntatie, minus oriëntatie.

05:59.680 --> 06:05.630
En ter herinnering: de drie signalen zijn de zenddichtheid die rond de sensoren wordt gedetecteerd.

06:06.310 --> 06:06.850
Oke.

06:06.860 --> 06:09.010
Dus we hebben net onze nieuwe staat gekregen.

06:09.020 --> 06:13.260
Dus dat betekent dat we de nieuwe fase hebben bereikt en nu moeten we de volgende update maken.

06:13.600 --> 06:16.140
Dus wat moeten we volgens jou nu updaten?

06:16.510 --> 06:21.940
Wat zou het logische zijn om nu te updaten na het bereiken van deze nieuwe fase?

06:22.480 --> 06:29.680
Welnu, wat we nu moeten bijwerken, is het geheugen, omdat het elke keer is dat een overgang

06:29.680 --> 06:37.300
is samengesteld uit de huidige staat als de volgende staat T plus één, de beloning en de actie 80.

06:37.660 --> 06:39.760
En op dit moment hebben we al S-T.

06:40.060 --> 06:42.850
We hebben er al en we hebben er al 80.

06:43.090 --> 06:46.930
En we hebben net het laatste element van de overgang als plus één.

06:47.440 --> 06:55.060
Dus door deze nieuwe staat ESTIE plus één te krijgen, krijgen we een geheel nieuwe overgang van het geheugen en daarom moeten

06:55.420 --> 07:00.700
we deze geheel nieuwe overgang aan het geheugen toevoegen, want dat is gewoon onze volgende

07:00.700 --> 07:01.250
overgang.

07:01.810 --> 07:03.730
Daarom moeten we het geheugen nu bijwerken.

07:03.910 --> 07:10.930
En daarom, wat ik ga doen, is mijn geheugenobject nemen dat is gemaakt van de replay-geheugenklasse en daarom

07:10.930 --> 07:12.760
ga ik mezelf nemen.

07:13.820 --> 07:21.530
Dat geheugen verwijst naar het object, maar aangezien ik zelf gebruik, moet ik het zelf opnemen in de

07:21.530 --> 07:22.010
update-functie.

07:22.760 --> 07:25.100
Dus nu kun je echt zien waar het zelf voor is.

07:25.340 --> 07:31.970
Het is telkens wanneer je een variabele gebruikt die je hebt gemaakt en geïnitialiseerd, uiteindelijk functioneert het zo zelf dat

07:31.970 --> 07:32.510
geheugen.

07:32.510 --> 07:33.590
En nu moeten we het updaten.

07:33.980 --> 07:36.620
En hoe gaan we dat volgens jou updaten?

07:37.010 --> 07:40.910
Het goede nieuws is dat we daar al een functie voor hebben gemaakt.

07:41.120 --> 07:46.720
Het is de push-functie die een evenement of een overgang naar het geheugen bijwoont.

07:47.030 --> 07:48.540
Dat is dus precies wat we gaan gebruiken.

07:48.560 --> 07:54.320
Nu gaan we de push-functie gebruiken om onze nieuwe overgang die we zojuist hebben gemaakt naar het geheugen door te brengen.

07:54.470 --> 08:01.010
En daarom neem ik hier geen gelijke omdat we een methode gaan gebruiken en daarom

08:01.010 --> 08:03.630
kunnen we die push direct gebruiken.

08:04.070 --> 08:08.510
En eerst ga ik de overgang toevoegen, deze nieuwe overgang die we net hebben.

08:08.730 --> 08:13.640
En dat is eerst de laatste date dus zelf die laatste date.

08:14.120 --> 08:17.120
Dus dat is. G. dat is precies deze.

08:17.120 --> 08:18.120
Het bestaat al.

08:18.530 --> 08:23.320
Dan is het volgende element van deze overgang natuurlijk de nieuwe staat die we zojuist hebben bereikt.

08:23.660 --> 08:29.630
En daarom, omdat het niet haalbaar is van de doelstellingen die we in deze functie hebben gemaakt en geïnitialiseerd, plaatsen

08:29.930 --> 08:31.160
we zichzelf hier niet.

08:31.430 --> 08:33.350
We zetten direct de nieuwe staat.

08:35.230 --> 08:40.990
Dan is het volgende element van de overgang de actie en zeggen dat we de laatste actie al hebben, en

08:40.990 --> 08:43.430
dat is dit zelf, de laatste actie hier.

08:43.690 --> 08:45.240
Het is dus natuurlijk gelijk aan nul.

08:45.250 --> 08:49.740
Maar dan wordt het natuurlijk een date met de select action-functie.

08:50.020 --> 08:51.060
Maar dat is deze.

08:51.070 --> 08:55.210
Dus dan is het zelf die laatste handeling.

08:55.720 --> 08:56.710
Maar wees nu voorzichtig.

08:57.040 --> 09:01.240
De elementen die we meenemen in deze transitie zouden allemaal fakkeldansers moeten zijn.

09:01.690 --> 09:03.580
Zoals je kunt zien, is dat het geval voor de laatste staat.

09:03.700 --> 09:04.870
Het is een fakkeldanser.

09:05.200 --> 09:07.290
De nieuwe staat is ook een fakkeldanser.

09:07.720 --> 09:11.740
En dit moet dus hetzelfde zijn voor de actie en dan natuurlijk de beloning.

09:12.070 --> 09:17.080
Maar nu ga je denken, hoe kan het een fakkelconcert zijn, als je bedenkt dat het gewoon een nee is?

09:17.200 --> 09:22.210
Weet je, de actie is nul één of twee, maar in feite is dat geen probleem.

09:22.210 --> 09:28.240
We kunnen deze nul één of twee volleybal nog steeds omzetten in de fakkelcensuur.

09:28.540 --> 09:31.110
Dit wordt precies wat we een lange Tenzer noemen.

09:31.390 --> 09:36.760
De lange is een type, en dat is de spanning die een geheel getal zal bevatten, omdat de laatste sectie een geheel

09:36.760 --> 09:39.030
getal is, het is nul één of twee.

09:39.520 --> 09:43.000
Dus wat we nu gaan gebruiken, is onze bibliotheekfakkel.

09:43.930 --> 09:46.240
Dan gaan we voor de lange termijn.

09:46.240 --> 09:53.260
Het is de lange tensorklasse die een object zal creëren, wat de lange tenzer zelf zal zijn.

09:53.500 --> 10:00.220
En door de functie zelf-laatste actie als invoer te nemen, wordt dit lange Tenzer-object gemaakt, maar het

10:00.220 --> 10:04.570
bevat nog steeds nul één of twee in een lang Tenzer-object.

10:04.690 --> 10:11.140
En dat is gewoon om consistent te zijn met de overgang die alleen censuur zou moeten bevatten omdat we werken met

10:11.140 --> 10:13.900
Torch en we werken met het neurale netwerk.

10:13.990 --> 10:20.440
We moeten dus met censors werken zodat we een fakkellange Tenzer gaan maken en een die conversie moet maken.

10:20.710 --> 10:25.360
We moeten er zeker van zijn dat wat er in deze longkanker zit een geheel getal is.

10:25.660 --> 10:30.400
En om er zeker van te zijn, zelfs als we al weten dat de laatste sectie nul

10:30.400 --> 10:37.630
één of twee is, om er zeker van te zijn dat we dit weer gaan omzetten in typeconversie, zetten we onszelf de laatste actie om in een

10:37.810 --> 10:38.560
geheel getal.

10:39.160 --> 10:39.730
Daar gaan we.

10:39.730 --> 10:47.400
En dan moeten we de integer onbaatzuchtige sectie hier tussen haakjes plaatsen, zodat we nu een lang soort van één element

10:47.440 --> 10:52.350
krijgen, wat deze laatste sectie nul één of twee zelf zal zijn.

10:52.660 --> 10:58.960
Dus het belangrijkste is dat je zo een eenvoudig getal, nul één of twee, omzet in atención met fakkel.

10:59.880 --> 11:05.670
Oké, en dan tot slot, het laatste element van de overgang, en dat is natuurlijk het laatste woord dat

11:05.760 --> 11:06.410
we kregen.

11:06.630 --> 11:12.770
Dus dat is precies het laatste woord voidable dat we hebben gemaakt in de functie die is geïnitialiseerd op nul.

11:12.930 --> 11:19.140
Maar dan wordt het natuurlijk hier in deze code geüpdatet, ofwel wanneer we in een of andere zending gaan, wat een negatieve beloning

11:19.140 --> 11:24.540
is, of als we verder van het doel af komen, die weer, negatieve beloning, als we dichter bij het

11:24.540 --> 11:30.420
doel komen, dat is een positieve beloning en de ergste straf als we te dicht bij een rand van de kaart

11:30.420 --> 11:30.940
komen.

11:31.140 --> 11:34.800
Dat is een vreselijke negatieve beloning, min één, en dat is alles.

11:36.130 --> 11:43.180
Dus laten we dit laatste element van de overgang zelf toevoegen, die beloning, dus ik kopieer dit, plak dat hier

11:43.180 --> 11:48.640
en nu moeten we nog een conversie maken, die natuurlijk precies hetzelfde zal zijn als

11:48.640 --> 11:49.290
deze.

11:49.600 --> 11:52.800
Alleen omdat de beloning geen geheel getal is, maar een float.

11:52.810 --> 11:57.150
Nee, we zullen gewoon een fakkel maken die tensor-conversie.

11:57.340 --> 12:01.780
Maar zonder dat houdt het de haakjes hier omdat, weet je, we eerst het

12:01.780 --> 12:06.670
nummer in een lijst moeten plaatsen en dan zal deze lijst als invoer in de toortsstencilklasse gaan.

12:06.850 --> 12:10.990
Maar dat hoeven we bij conversie niet te maken, omdat de laatste beloning een float-nummer is.

12:11.410 --> 12:19.930
Dus wat we gaan doen is hier simpelweg de toorts, punt, tensor naar dat centrum toe te voegen, dan haakjes tussen

12:20.380 --> 12:21.070
haakjes.

12:21.490 --> 12:26.840
En we gaan de haakjes hier sluiten en we sluiten de haakjes.

12:27.310 --> 12:27.940
Daar gaan we.

12:28.690 --> 12:34.480
Dus om samen te vatten, met de nieuwe staat die we zojuist hebben bereikt en de beloning, observeren we een nieuwe gebeurtenis

12:34.480 --> 12:36.850
van overgang die we aan de herinnering toevoegen.

12:37.360 --> 12:43.750
En deze overgang bevat de laatste staat en stad, de nieuwe staat ESTIE plus één, de laatst

12:43.750 --> 12:46.300
gespeelde actie en de laatste beloning.

12:47.830 --> 12:48.310
Oke.

12:48.310 --> 12:50.910
En nu zijn we goed met onze geheugenupdate.

12:51.280 --> 12:55.350
Dus laten we een korte pauze nemen en we zorgen voor de volgende update in de volgende tutorial.

12:55.780 --> 12:57.370
Tot dan en ik.
