WEBVTT

00:00.210 --> 00:05.520
Hallo en welkom bij deze tutorial, deze speciale tutorial wordt super spannend omdat

00:05.520 --> 00:08.240
we dichter bij het H3C-algoritme komen.

00:08.550 --> 00:14.100
Je zult zien dat wat we gaan implementeren, en dat heet geschiktheidstracering of Sarcelles,

00:14.340 --> 00:18.990
eigenlijk een algoritme is van de asynchrone algoritmen van actieve agenten.

00:19.200 --> 00:23.130
Maar we kunnen het niet beschouwen als een we zien, omdat we nog steeds één agent hebben.

00:23.370 --> 00:28.290
Maar toch zul je zien dat wat we gaan implementeren eigenlijk afkomstig

00:28.290 --> 00:33.530
is uit het volgende artikel, deze asynchrone methode op papier voor diepgaand leren.

00:33.750 --> 00:39.660
En het is in dit artikel dat de inzendingen, de algoritmen die we zullen implementeren als de laatste bonus van deze

00:39.660 --> 00:40.590
cursus, zullen vinden.

00:40.920 --> 00:47.520
Maar zoals ik al zei, we komen er dichterbij omdat het model dat we nu gaan implementeren

00:48.270 --> 00:51.450
eigenlijk dit is, het asynchrone en stap Q-leren.

00:51.690 --> 00:52.440
Dat is hem.

00:52.680 --> 00:57.750
Dus dat is bijna de bon, die daarna is, maar met één agent.

00:58.020 --> 01:01.740
En het krachtige hieraan is dit en stapsgewijs leren.

01:02.070 --> 01:08.250
We gaan de cumulatieve beloningen leren en het cumulatieve doel op Insteps leren in plaats van één stap

01:08.250 --> 01:09.270
zoals eerder.

01:09.510 --> 01:14.680
En dat maakt de training veel performanter en daardoor veel krachtiger.

01:15.180 --> 01:18.750
We hebben dus eigenlijk de code voor dit algoritme.

01:18.750 --> 01:20.850
Het is dit algoritme zoals hier.

01:21.000 --> 01:21.930
Dus laten we erop klikken.

01:22.170 --> 01:23.110
En daar gaan we.

01:23.130 --> 01:25.560
Dat is het algoritme dat we gaan implementeren.

01:25.740 --> 01:32.160
Maar onthoud, met slechts één agent is het verschil dat ze hier een actie 80 ondernemen, volgens

01:32.160 --> 01:37.710
het Epsilon-beleid, op basis van de waarden voor de huidige staat en het actiebord.

01:38.040 --> 01:41.670
Maar in ons geval hebben we het beleid niet uitgevoerd.

01:41.940 --> 01:43.560
We hebben een softmax geïmplementeerd.

01:43.770 --> 01:44.880
Maar de rest is hetzelfde.

01:45.000 --> 01:50.080
Zoals je kunt zien, gaan we de cumulatieve beloning op Insteps berekenen, eigenlijk tien stappen.

01:50.100 --> 01:51.950
Onthoud dat Wreef gelijk is aan tien.

01:52.260 --> 01:57.310
En dus zullen we deze regel code implementeren in ons algoritme dat we op het punt stonden te implementeren.

01:57.330 --> 02:01.710
Op dit moment gaan we dit krijgen en meestal gaan we dit ook implementeren.

02:01.990 --> 02:07.530
Je zult zien dat we hier het maximum van de kernwaarden voor de huidige staat en de huidige

02:07.530 --> 02:09.090
actie in deze theta krijgen.

02:09.330 --> 02:10.700
Het is gewoon een doelparameter.

02:11.310 --> 02:12.750
Dus laten we dit doen.

02:12.750 --> 02:15.040
Laten we dit algoritme aanvallen.

02:15.210 --> 02:21.900
Deze heet de asynchrone en Step Q Learning, maar we hebben niet het recht om A te zeggen wat ons betreft omdat

02:21.900 --> 02:26.310
we maar één agent hebben, maar daarom kunnen we het noemen en stappen.

02:26.310 --> 02:29.370
Q Leergeschiktheidskenmerken of zelfs Sauza.

02:30.090 --> 02:31.440
Oké, laten we dit doen.

02:31.620 --> 02:32.730
Het gaat best leuk worden.

02:32.940 --> 02:37.040
We kunnen in principe de code hier volgen en dat is wat we gaan doen.

02:37.320 --> 02:43.830
En dus, zoals je kunt zien, is een parameter die we opnieuw nodig hebben, de GEMAP-parameter die de parameter is, en daarom

02:44.100 --> 02:49.940
zullen we beginnen met het introduceren van een variabele voor deze GANNA-parameter en het kiezen van een waarde.

02:50.670 --> 02:51.710
Dus laten we dit doen.

02:51.720 --> 02:53.940
We hebben eigenlijk geen klaslokaal nodig om dit te bedoelen.

02:53.940 --> 02:58.740
We kunnen dit eenvoudig implementeren met een functie, want, weet je, we hoeven niet echt

02:58.740 --> 03:00.710
objecten te maken voor dit geschiktheidstracermodel.

03:00.720 --> 03:06.540
Een functie is voldoende, want wat we eigenlijk willen doen, is de invoer en de doelen retourneren, zodat

03:06.780 --> 03:12.420
we later, bij het trainen van de, de afstand tussen de voorspellingen en het doel kunnen minimaliseren

03:12.420 --> 03:14.400
en de voorspellingen kunnen krijgen.

03:14.400 --> 03:19.380
We hebben de inputs nodig omdat we onze hersenen op de inputs gaan toepassen om de outputsignalen te krijgen.

03:19.590 --> 03:20.910
Dat zullen onze voorspellingen zijn.

03:21.090 --> 03:26.550
En zodra we onze voorspellingen en ons doel hebben, zijn we klaar om de A te trainen. L. door te proberen de

03:26.550 --> 03:30.270
vierkante afstand tussen de voorspellingen en de doelen te minimaliseren.

03:30.580 --> 03:32.100
Dus dat is het hele punt om dit te doen.

03:32.100 --> 03:32.520
Nu.

03:32.670 --> 03:37.950
We implementeren deze functie om deze invoer en deze doelen te kunnen retourneren, zodat we klaar

03:37.950 --> 03:42.360
kunnen zijn voor de training om de vierkante afstandsvoorspellingen minus doelen te minimaliseren.

03:42.840 --> 03:43.190
Oke.

03:43.200 --> 03:44.010
Dus laten we dit doen.

03:44.130 --> 03:46.340
Zoals we al zeiden, willen we functies implementeren.

03:46.350 --> 03:48.210
We beginnen met def deze functie.

03:48.210 --> 03:52.560
We gaan het een leesbaarheidsonderstreping Trece noemen.

03:52.710 --> 03:58.380
Je kunt het ook Sauza noemen, je kunt het ook noemen en stap draaien wat je wilt, maar laten we

03:58.380 --> 03:59.520
het geschiktheidskeuze noemen.

03:59.790 --> 04:04.320
En deze functie neemt één argument mee, wat een batch zal zijn.

04:05.070 --> 04:05.910
En waarom dat.

04:06.030 --> 04:12.540
Het is omdat we wat input en wat doelen gaan krijgen, omdat we de AI op batches gaan trainen

04:12.540 --> 04:17.040
en dus zullen de inputs en het doelwit in sommige batches gaan.

04:17.250 --> 04:23.430
En daarom is het invoerargument hier deze batch die verschillende invoer zal bevatten en vervolgens verschillende

04:23.430 --> 04:26.670
doelen die we zullen berekenen zodat we gaan.

04:26.670 --> 04:28.020
Dat is het enige argument dat we nodig hebben.

04:28.360 --> 04:31.680
Laten we nu naar de functie gaan en definiëren wat we moesten doen.

04:32.220 --> 04:37.340
Dus zoals we in de code van het papier zagen, hebben we een gammaparameter nodig.

04:37.370 --> 04:41.400
Dus zoals we al zeiden, beginnen we met het introduceren van deze gammaparameter.

04:42.030 --> 04:47.880
Dus gamma is gelijk aan en we kunnen al beslissen voor waarde en we gaan vier komma negenennegentig kiezen.

04:48.300 --> 04:51.660
Dat is een klassieke goede waarde voor de Gamma en Nori's.

04:51.660 --> 04:54.720
Ik heb gecontroleerd of dit een goede waarde is voor onze AI.

04:55.550 --> 04:56.790
Goed dan volgende stap.

04:57.060 --> 04:59.700
De volgende stap is om onze input voor te bereiden.

05:00.720 --> 05:06.390
En zijn doelen, want dat is precies wat we willen retourneren, we willen de inputs en de doelen

05:06.390 --> 05:13.230
teruggeven om de training voor te bereiden, en dus kunnen we ze al initialiseren met een lege lijst, want natuurlijk, in

05:13.230 --> 05:18.150
deze inputs binnen de beste, we gaan verschillende ingangen allemaal in een lijst hebben.

05:18.390 --> 05:24.730
En daarom initialiseer ik de invoer als een lijst, evenals de doelen die we gaan.

05:24.870 --> 05:27.210
Dus hebben we onze input en ons doel geïnitialiseerd.

05:27.360 --> 05:34.050
En uiteindelijk zal deze functie voor geschiktheidskeuze precies deze invoer en deze doelen retourneren.

05:34.260 --> 05:39.780
Maar natuurlijk, Filton, we zullen verschillende inputs hebben en de bijbehorende verschillende doelen in wat door de

05:39.780 --> 05:41.140
functie wordt geretourneerd.

05:42.150 --> 05:42.480
Oke.

05:42.480 --> 05:45.420
De volgende stap is het starten van een volledige lus.

05:45.720 --> 05:51.350
En dat is precies omdat we de pseudocode van het papier volgen, deze set code.

05:51.360 --> 05:55.770
En zoals je kunt zien, is er dit herhaalcodegedeelte en herhaal het.

05:55.770 --> 05:57.240
Precies een volledige lus.

05:57.250 --> 06:03.600
En dus de code die we gaan berekenen, de cumulatieve beloning hier verzameld over de 10 stappen.

06:03.750 --> 06:04.880
En hoe wordt het berekend?

06:05.130 --> 06:07.890
Welnu, bij elke stap is dat niet de laatste stap.

06:07.890 --> 06:11.940
Hierbij gaan we het maximum halen uit de kernwaarden van de huidige staat waarin we ons bevinden.

06:11.940 --> 06:12.770
En laten we rennen.

06:13.050 --> 06:17.720
En als we de laatste acht tot tien stappen bereiken, nou, dan is dit gelijk aan nul.

06:17.730 --> 06:19.350
Dat wil zeggen, we willen het niet meer dateren.

06:19.890 --> 06:23.070
En dan hebben we deze for-lus, die weer een for-lus wordt.

06:23.310 --> 06:25.500
Ze zeggen hier niet herhalen, maar dat is hetzelfde.

06:25.500 --> 06:28.080
Het wordt een second-for-lus in ons algoritme.

06:28.410 --> 06:29.880
Nou, dat gaan we updaten.

06:29.880 --> 06:35.290
We werkten op deze manier door het te vermenigvuldigen met de vervalparameter gamma en de beloning toe te voegen.

06:35.880 --> 06:36.840
Dus laten we dit doen.

06:36.840 --> 06:41.270
Laten we teruggaan naar Python en laten we beginnen met onze volledige lus tot nu toe.

06:41.790 --> 06:44.620
En wat wordt de iteratieve variabele?

06:44.910 --> 06:49.950
Nou, dat wordt onze reeks van tien stappen, je weet wel, onze reeks van tien overgangen.

06:50.340 --> 06:57.540
Dus we gaan deze variabele reeksen noemen die een reeks van tien overgangen voorstellen, zoals een reeks van

06:57.540 --> 06:58.440
tien overgangen.

06:58.740 --> 07:00.630
Dus vier series binnen.

07:01.020 --> 07:02.050
En wat denk je dan?

07:02.460 --> 07:05.190
Nou, onze serie wordt gedaan met onze batch.

07:05.520 --> 07:11.520
Dat zijn de banken waarop we de A gaan trainen. L. enzovoort, serie en batch, dat is

07:11.520 --> 07:14.130
voor alle series van tien overgangen in onze invoerbatch.

07:14.670 --> 07:18.720
Wanneer gaan we er goed aan doen om een cumulatieve beloning te krijgen?

07:18.720 --> 07:24.060
Je ziet een absolute code dat we de staat van de eerste overgang van de reeks nodig hebben en ook de

07:24.060 --> 07:26.270
staat van de laatste overgang van de reeks.

07:26.610 --> 07:29.640
Dus wat we nu moeten doen, is deze invoerstatussen krijgen.

07:29.940 --> 07:36.510
En dus gaan we deze twee invoerstatussen in een variabele plaatsen die we invoer gaan noemen

07:36.660 --> 07:42.090
en we krijgen deze twee invoerstatussen, de eerste van de reeks en de

07:42.090 --> 07:45.090
laatste die we in een nummer array.

07:45.600 --> 07:46.620
Maar geen zorgen.

07:46.620 --> 07:48.250
We blijven niet bij dit nummer.

07:48.310 --> 07:50.790
Dat zetten we natuurlijk om in een totale terugroepactie.

07:50.970 --> 07:56.330
Maar de eerste stap is om deze twee invoerstaten, de eerste in de laatste, in een rijk te plaatsen.

07:57.120 --> 08:03.780
En dus hier in deze Nampara, voegen we de eerste invoer toe, wat de invoerstatus is van de eerste overgang van

08:03.780 --> 08:04.500
de reeks.

08:04.650 --> 08:06.180
En dat is een serie.

08:07.760 --> 08:12.650
En om dan de eerste overgang te nemen, nemen we de index nul van de reeks, dat is de

08:13.160 --> 08:17.600
eerste overgang, en dan kunnen we er toegang toe krijgen door zijn attribuut te nemen, namelijk staat.

08:18.110 --> 08:24.080
En dat is omdat we in onze ervaring het gevoel hadden dat we een speciale structuur hadden gedefinieerd voor elk van de overgangen.

08:24.260 --> 08:29.150
En, weet je, de structuur, elke overgang is samengesteld uit een toestand, een actie, een beloning.

08:29.420 --> 08:31.630
Maar dan het laatste element dat wordt gedaan.

08:32.000 --> 08:37.670
Dus deze speciale structuur die we nu mochten gebruiken, komt voort uit de manier waarop we een overgang en ervaring

08:37.670 --> 08:38.270
hebben gedefinieerd.

08:38.270 --> 08:38.330
We.

08:39.110 --> 08:39.520
Oke.

08:39.530 --> 08:43.010
Dus hiermee krijgen we de invoerstatus van de eerste overgang.

08:43.280 --> 08:48.220
En laten we nu ook de invoerstatus van de laatste overgang van de reeks bekijken.

08:48.620 --> 08:49.940
En om dit te doen, is dat hetzelfde.

08:49.940 --> 08:51.680
We kunnen dit gewoon kopiëren.

08:53.360 --> 09:00.170
En geplakt en vervangen, zoals je hier bent, door de laatste index van de serie, waartoe we toegang hebben met deze

09:00.170 --> 09:06.530
truc, min één serie, min één, dat gezegd hebbende, we krijgen de invoerstatus van de laatste uitzending van de

09:06.530 --> 09:07.220
serie .

09:08.090 --> 09:14.180
Oké, dan moeten we deze twee elementen tussen vierkante haken plaatsen.

09:15.130 --> 09:21.640
Want dat is wat de Nampara-functie verwacht en dan is het belangrijk om te doen, omdat

09:21.640 --> 09:25.780
we dat gaan omzetten in een toortssensor in een toortsvariabele.

09:26.140 --> 09:31.490
Wel, onthoud, een toortssensor is per definitie een speciale array met één enkel type.

09:31.750 --> 09:34.410
En dus moeten we afdwingen om één enkel type te hebben.

09:34.570 --> 09:41.950
En zoals gewoonlijk kiezen we het vlottertype en sommigen voegen deze parameter hier toe, D-type is gelijk

09:42.670 --> 09:51.700
aan en P dat zweeft, zodat je deze kunt nemen en nu kunnen we dat omzetten in een toortssensor in een toorts.

09:52.390 --> 09:54.390
Dus laten we dit doen om dit te doen.

09:54.580 --> 09:57.140
Laten we dat eerst omzetten in een toortssensor.

09:57.400 --> 10:02.380
En onthoud, we kunnen de toorts gebruiken van non-pay.

10:03.710 --> 10:11.000
Daar gaan we, en we plaatsen de hele reeks van de Verenigde Staten in deze toortsspanner met de toorts

10:11.000 --> 10:12.920
van hen per functie, perfect.

10:13.160 --> 10:17.810
Dus dat zal deze arrays van de twee invoeren in een toortssensor omzetten.

10:18.200 --> 10:21.590
En nu stoppen we deze zaklampsensor in een zaklamp.

10:21.590 --> 10:24.040
Heel goed gebruik van het variabele glas.

10:25.380 --> 10:32.250
Dus invoer zal een object zijn van de verbale klasse en in feite, zoals je hebt begrepen, neemt deze variabele klasse

10:32.250 --> 10:35.760
dit alles als een argument en dat creëert het object.

10:36.500 --> 10:41.990
Oké, dus nu zouden we goed moeten zijn, we hebben onze twee inputs die we nodig hebben, dat is de inputset

10:41.990 --> 10:44.920
van de eerste transitie en de inputstatus van de laatste transitie.

10:45.590 --> 10:48.770
En nu we de input hebben, wat kunnen we krijgen?

10:48.890 --> 10:53.600
We kunnen het uitgangssignaal van de hersenen van de A krijgen. L. Dat is de voorspelling.

10:53.870 --> 10:55.490
Maar we gaan het output noemen.

10:56.480 --> 10:57.620
Dat is het uitgangssignaal.

10:57.950 --> 10:59.150
En om de output te krijgen.

10:59.170 --> 11:04.610
Nou, dat is heel gemakkelijk omdat we al een brein hebben gecreëerd, wat ons convolutionele neurale netwerk is,

11:04.610 --> 11:07.430
en dus kunnen we gewoon ons brein nemen.

11:07.730 --> 11:16.400
CNN toegepast op de invoer die de voorspelling zal retourneren, dat is de uitvoer zo simpel als dat.

11:16.610 --> 11:19.330
En nu zijn we al klaar om door te gaan naar de volgende stap.

11:20.550 --> 11:24.640
En de volgende stap is om deze cumulatieve beloning te gaan berekenen.

11:24.930 --> 11:31.020
Dus nu gaan we precies hetzelfde doen als ons S2-algoritme, de schotel, of moeten we het insteps learning

11:31.200 --> 11:31.550
noemen?

11:32.130 --> 11:38.460
We gaan de Kumu-beloningsvariabele introduceren, die de cumulatieve beloning zal zijn.

11:39.530 --> 11:44.780
Laten we teruggaan naar het papier, zoals je nu kunt zien, wat we moeten doen om deze cumulatieve

11:44.780 --> 11:52.250
beloning te krijgen, die hier is, nou, bij elke stap van de 10 stappen die worden uitgevoerd, moeten we het bijwerken door een nul toe te voegen

11:52.250 --> 11:53.420
aan deze cumulatieve beloning.

11:53.750 --> 11:59.870
Als we de laatste fase van de reeks of het maximum van de kernwaarden hebben bereikt, als we de laatste fase van de reeks

11:59.870 --> 12:03.110
niet hebben bereikt, dat is voor alle stappen behalve de laatste stap.

12:03.620 --> 12:05.540
Laten we dit dus gewoon implementeren.

12:05.840 --> 12:06.940
Laten we teruggaan naar Python.

12:07.490 --> 12:14.450
Dus deze gemeenschapsbeloning, zoals we net zagen, zal gelijk zijn aan nul komma nul als.

12:15.120 --> 12:23.160
We hebben de laatste staat bereikt en we kunnen deze toestand op deze manier berijden, als een reeks van index minus één de

12:23.160 --> 12:29.850
laatste uitzending van de reeks is, dan hebben we dat gedaan omdat er eigenlijk een attribuut is van deze

12:30.120 --> 12:33.450
overgangsstructuur die we hebben gedefinieerd en ervaren .

12:33.450 --> 12:35.340
We spelen op onze kosten, we spelen fout.

12:35.610 --> 12:41.910
En deze komt eigenlijk van de openingsstructuren, want als we naar de Open Air-website gaan, die eigenlijk

12:42.420 --> 12:44.730
hier is, heb ik die voorbereid.

12:45.130 --> 12:46.820
Dat is de ondergang van V0.

12:47.130 --> 12:53.100
En als we naar de documentatie gaan en als we dat doen, dan is dat de tutorial.

12:53.100 --> 12:54.810
Ik moedig je echt aan om er eens naar te kijken.

12:55.290 --> 12:56.610
U kunt een omgeving uitvoeren.

12:56.820 --> 13:04.230
Dan kun je meestal zien dat onze waarnemingen die als onze overgangen worden gedefinieerd door een waarneming, een beloning

13:04.530 --> 13:11.550
en dat hier gedaan en gedaan wordt, precies betekent dat een overgang of een stap voorbij is.

13:11.980 --> 13:15.200
En dus gaan we dit hier gebruiken voor onze if-conditie.

13:15.450 --> 13:22.890
Daarom, als er min één punt is gedaan, betekent dat als de laatste uitzending van de serie voorbij is, is voltooid.

13:23.550 --> 13:28.410
En dus zal deze cumulatieve beloning gelijk zijn aan nul als de laatste uitzending van de

13:28.410 --> 13:32.640
serie is gedaan en anders als we de laatste uitzending niet hebben bereikt.

13:32.940 --> 13:40.650
Welnu, cumulatieve beloning zal worden bijgewerkt met, zoals we al zeiden, het maximum van de belangrijkste waarden.

13:41.040 --> 13:47.190
En aangezien deze output hier de output van de hersenen is, zijn dat de voorspellingen van het neurale netwerk.

13:47.310 --> 13:51.120
En zoals je weet, zijn de voorspellingen van het neurale netwerk de voorspelde waarden.

13:51.480 --> 13:54.690
Welnu, deze uitvoer bevat de belangrijkste waarden.

13:54.930 --> 14:00.870
En aangezien we de volgende van de sleutelwaarden moeten nemen, moeten we eerst deze index nemen, omdat

14:00.870 --> 14:04.110
deze structuur de sleutelwaarden in de indexwaarde bevat.

14:04.410 --> 14:09.180
En dan moeten we gegevens toevoegen om toegang te krijgen tot de gegevens van deze uitvoerstructuur.

14:09.340 --> 14:11.710
Weet je, het heeft de speciale structuur van een fakkelvariabele.

14:12.150 --> 14:16.770
Dus hiermee halen we onze kernwaarden en dan willen we het maximale uit onze kernwaarden halen.

14:17.040 --> 14:25.650
En dus voegen we dat eenvoudig toe en nu krijgen we precies wat we willen, zoals in de krant, dit maximum van

14:25.650 --> 14:29.740
de kernwaarden voor de niet-terminale staat als t perfect.

14:30.090 --> 14:33.270
Wat we nu gaan doen, is de tweede volledige lus maken.

14:33.780 --> 14:35.880
Dat is voor de tien stappen van de serie.

14:36.090 --> 14:43.170
We gaan het cumulatieve werk op deze manier bijwerken door eerst te vermenigvuldigen met GEMAP, de vervalparameter, die we al hebben,

14:43.410 --> 14:45.880
en dan de beloning toe te voegen.

14:46.260 --> 14:47.160
Dus laten we dit doen.

14:47.460 --> 14:50.670
We gaan eigenlijk precies hetzelfde doen als in de code.

14:50.850 --> 14:52.640
Zoals je kunt zien, beginnen ze van rechts.

14:52.890 --> 14:56.310
Ze beginnen dus niet met de eerste stap en gaan naar de laatste stappen.

14:56.640 --> 15:01.840
Ze beginnen met de laatste stap T min één tot de eerste stap om te beginnen.

15:02.160 --> 15:06.090
Dus dat is precies wat we daarin gaan doen, omdat we uiteindelijk

15:06.090 --> 15:15.030
willen dat de cumulatieve beloning gelijk is aan onze gelijken of nul plus of één plus gamma in het kwadraat of twee plus dat die plus gamma bij

15:15.030 --> 15:17.310
de macht van tien of tien.

15:17.460 --> 15:24.770
Waar zijn er een of twee die tien zijn, zijn de beloningen die worden verkregen in elk van de stappen van de serie.

15:25.470 --> 15:29.610
Dus laten we een korte pauze nemen voordat we de tweede volledige lus nemen en ik zie je in de volgende Atauro.

15:29.820 --> 15:31.470
Tot die tijd, geniet van I.
