WEBVTT

00:00.490 --> 00:06.610
Hallo en welkom bij deze python bij Turrill, dus laten we dit doen, laten we deze for-lus maken, beginnend van rechts

00:06.610 --> 00:08.110
en naar links gaand.

00:08.560 --> 00:11.110
En om dit te doen, gaan we er vier toevoegen.

00:11.770 --> 00:17.590
Dus deze keer wordt de iteratorvariabele onze stap omdat we van de laatste stap naar

00:17.590 --> 00:21.480
de eerste stap van de reeks overgangen gaan, enzovoort.

00:21.760 --> 00:27.970
En dan is de truc om van rechts naar links te gaan, vier stappen achteruit te gebruiken.

00:28.870 --> 00:34.990
Omgekeerd en nu hoeven we alleen maar een reeks in deze reeks te plaatsen, dit wordt natuurlijk onze reeks, dus

00:35.230 --> 00:36.670
voer onze reeks in.

00:37.150 --> 00:43.900
Maar zoals je in de krant kunt zien, gaan we van T min één naar T start, dus we gaan niet vanaf de laatste stap.

00:43.900 --> 00:44.980
Dat is de eindtoestand.

00:45.190 --> 00:49.090
Maar de toestand daarvoor, dat is T min één, maar twee T begint.

00:49.120 --> 00:49.970
Dat is de eerste stap.

00:50.260 --> 00:57.730
En dus hier om te gaan van niet de laatste staat, maar de staat ervoor moeten we tussen haakjes toevoegen, kolom

00:58.000 --> 00:58.810
min één.

00:59.200 --> 01:03.640
Ik weet zeker dat voor degenen onder jullie die de cursus machine learning en deep

01:03.640 --> 01:10.420
learning hebben gevolgd, weet je, deze trick-kolom minus één betekent dat je naar het element gaat vóór het laatste element, maar niet naar

01:10.420 --> 01:11.680
het laatste element.

01:11.950 --> 01:14.470
En daarom krijgen we de volgorde die we willen.

01:14.680 --> 01:20.830
Dat wil zeggen dat we van het element voor het laatste element naar het eerste element gaan, en dat we dingen doen om het

01:20.830 --> 01:23.580
om te keren, om van rechts naar links te gaan.

01:24.010 --> 01:24.360
Oke.

01:24.370 --> 01:26.550
Dus we zijn klaar om de volledige lus in te gaan.

01:26.980 --> 01:28.510
En dus binnen is voor lus.

01:28.510 --> 01:29.450
Waar gaan we doen?

01:29.650 --> 01:32.560
Nou, we gaan precies doen zoals in de krant.

01:32.710 --> 01:39.310
We gaan de cumulatieve beloning bijwerken door deze te vermenigvuldigen met Jenna en toe te voegen, willen we een verandering in de huidige

01:39.310 --> 01:41.900
stap die in de stap van de for-lus zit?

01:42.490 --> 01:42.850
Oke.

01:42.850 --> 01:45.190
Dus laten we dit doen, teruggaand naar Python.

01:45.400 --> 01:52.510
En dus willen we onze cumulatieve beloning eerst op de volgende manier bijwerken.

01:53.450 --> 01:54.560
Het vermenigvuldigen.

01:55.530 --> 02:03.660
Door GEMAP, daar gaan we, we vermenigvuldigden samen, en dan willen we de beloning van toevoegen.

02:04.520 --> 02:11.600
De stap die we op deze manier kunnen openen met de speciale structuur, onthoud, die beloning is een attribuut van

02:11.600 --> 02:12.650
het stapobject.

02:12.950 --> 02:15.440
En dus voegen we hier natuurlijk een pluspunt toe.

02:15.860 --> 02:16.230
Oke.

02:16.230 --> 02:23.180
Dus cumulatieve beloning is gelijk aan werken we deze stap waarin we ons nu bevinden, de lus plus soms de vorige cumulatieve

02:23.180 --> 02:24.860
beloning voordat het een is.

02:26.030 --> 02:26.650
Perfect.

02:26.690 --> 02:27.820
Dus nu denk ik dat we goed zitten.

02:28.040 --> 02:29.870
We volgen het algoritme grondig.

02:30.290 --> 02:32.240
En nu tijd voor de volgende stappen.

02:32.690 --> 02:34.690
Nou, nu wordt het vrij eenvoudig.

02:34.940 --> 02:40.310
We gaan terug naar de eerste volledige lus omdat deze volledige lus alleen bedoeld is om de cumulatieve beloningen te berekenen, je

02:40.700 --> 02:44.920
weet wel, van rechts naar links gaand door op deze manier bij te werken, volgens het algoritme.

02:45.710 --> 02:51.800
En nu, zoals je je herinnert, is het doel van dit alles om onze input en onze doelen klaar te krijgen, zodat

02:52.010 --> 02:55.500
we het kwadratische verschil tussen de twee voor de training kunnen minimaliseren.

02:55.760 --> 03:00.690
En dus is het enige dat we nu nog moeten doen, deze inputs en doelen gereed te maken.

03:01.070 --> 03:03.170
Laten we dit dus eerst doen.

03:03.170 --> 03:08.180
Wat we moeten doen, is de eerste datum van de serie toevoegen aan onze invoerlijst.

03:08.360 --> 03:13.880
Tot nu toe bevindt deze invoerstatus zich in deze invoervariabele, maar dat was alleen om de uitvoer te berekenen.

03:14.150 --> 03:19.190
Dus we gaan deze invoerstatus van de eerste stap afzonderlijk ophalen, want dat is precies wat we

03:19.190 --> 03:20.990
in onze invoerlijst moeten uitgeven.

03:21.230 --> 03:22.850
Dus laten we dit apart nemen.

03:23.240 --> 03:25.280
Daarom gaan we het staat noemen.

03:25.820 --> 03:27.980
En dus precies hetzelfde als hier.

03:28.100 --> 03:34.220
We kunnen het op deze manier krijgen door de eerste index van de reeks te nemen, die de eerste overgang bevat, en dan die staat

03:34.370 --> 03:37.680
toe te voegen om de staat van deze eerste overgang te krijgen.

03:38.210 --> 03:44.300
Dus dat is de status die we nodig hebben en dan zeggen we dat we bij de eerste overgang afzonderlijk het doel gaan krijgen

03:44.660 --> 03:46.360
dat aan deze invoerstatus is gekoppeld.

03:46.700 --> 03:53.170
En dus introduceer ik hier een nieuw vernietigbaar doel, dat gelijk zal zijn aan de Q-waarde van de eerste stap.

03:53.330 --> 03:59.930
En aangezien de Q-waarde wordt geretourneerd door het neurale netwerk en zijn inhoud en uitvoer, en aangezien uitvoer de

03:59.930 --> 04:06.080
uitvoer is die is gekoppeld aan deze invoer, die het eerste element van de overgang bevat, kunnen

04:06.080 --> 04:12.560
we deze waarde van de eerste toestand krijgen door gewoon hier de output nemen en de index nul nemen.

04:12.920 --> 04:20.540
En dan voegen we DOT-gegevens toe die ons eenvoudig de waarde van de invoerstatus van de eerste overgang geven, en dat

04:20.870 --> 04:22.680
is precies de doelwaarde.

04:22.940 --> 04:24.500
Dus daarom nemen we het.

04:25.190 --> 04:31.370
Vervolgens gaan we deze doelvariabele bijwerken, maar alleen voor de actie die is geselecteerd in de eerste stap van de

04:31.370 --> 04:35.510
reeks en om toegang te krijgen tot deze eerste stap van de reeks.

04:35.720 --> 04:42.020
Welnu, we moeten de eerste reeks nul nemen, want dit is precies de eerste stap in de reeks drie nul

04:42.020 --> 04:47.120
en om de actie te beoordelen die overeenkomt met deze eerste stap van de reeks.

04:47.390 --> 04:48.740
Nou, we moeten hier toevoegen.

04:49.720 --> 04:56.350
Die actie, nogmaals, dat is deze attribuutstructuur die we gebruiken, weet je, actie is een attribuut van de

04:56.560 --> 04:58.750
eerste stap van de reeks.

04:58.750 --> 05:03.880
Dat is de eerste overgang van de reeks, omdat elke overgang van de reeks

05:03.880 --> 05:08.280
de volgende structuur heeft, staat actie beloning en actie hier gedaan.

05:08.320 --> 05:13.300
Deze attribuutactie hier betekent dat we gewoon de actie van deze eerste date krijgen.

05:14.150 --> 05:21.260
En dus is het doel voor die specifieke actie van de eerste stap precies wat moet worden bijgewerkt door het

05:21.290 --> 05:22.300
cumulatieve woord.

05:22.730 --> 05:29.030
Dus eigenlijk gaan we hier gewoon naar rechts dat het doelwit dat is gekoppeld aan de actie die werd

05:29.330 --> 05:35.330
gespeeld in de eerste stap van de serie deze cumulatieve beloning is die we zojuist hebben berekend.

05:35.960 --> 05:36.650
Oke.

05:36.650 --> 05:43.040
En nu zijn we eindelijk klaar om onze invoer bij te werken door deze eerste invoer toe te voegen.

05:43.050 --> 05:43.690
Blijf hier.

05:43.700 --> 05:46.570
En dit eerste doelwit hier voor de eerste stap.

05:46.850 --> 05:52.520
We hoeven alleen de eerste stap van de serie bij te werken, want, weet je, we trainen het oog op 10 stappen en

05:52.790 --> 05:55.790
daarom is de invoer de eerste stap van de 10 stappen.

05:56.000 --> 05:58.010
En ook krijgen we het doel in deze eerste stap.

05:58.370 --> 06:03.380
Maar dan hoeven we geen input of doelen te krijgen in de volgende stappen van de 10 stappen, omdat

06:03.380 --> 06:05.880
het leren in principe 10 stappen daarna plaatsvindt.

06:06.320 --> 06:10.890
Dus daarom krijgen we op dit moment alleen de staat en het doelwit van de eerste stap van de serie.

06:11.690 --> 06:13.240
Het is dus belangrijk om dat te begrijpen.

06:13.250 --> 06:18.290
En daarom, als we dat begrijpen, begrijpen we nu dat we ze moeten invoeren in onze lijst met inputs

06:18.290 --> 06:19.940
en onze lijst met doelen.

06:20.540 --> 06:22.040
Laten we dit dus eerst doen.

06:22.400 --> 06:25.040
Laten we de staten aan onze invoer toevoegen.

06:25.040 --> 06:33.620
Dus we nemen onze invoerlijst en we gebruiken de append-functie om de status toe te voegen, wat onthouden is de invoerstatus van de

06:33.620 --> 06:35.750
eerste stap van de reeks.

06:36.790 --> 06:43.060
En dan zullen we je vertellen dat de eerste stap naar onze lijst met doelen en om dit te doen, we

06:43.060 --> 06:48.780
onze lijst met doelen nemen en zeggen dat we de app-functie gebruiken om dit eerste doel toe te voegen.

06:49.570 --> 06:51.180
We gaan bijna klaar.

06:51.190 --> 06:55.960
En nu moeten we de laatste dingen teruggeven, wat natuurlijk is wat we nodig hebben.

06:55.970 --> 07:01.380
Dat is wat we aan het begin van de tutorial zeiden, de invoer en de doelen die nu zijn bijgewerkt.

07:01.930 --> 07:06.040
Dus we gaan hier return toevoegen en we gaan eerst onze input krijgen.

07:06.370 --> 07:07.510
Maar daar gaat het dan om.

07:07.510 --> 07:14.200
We moeten ze eerst converteren naar een getallenreeks en vervolgens een typeconversie uitvoeren om er zeker

07:14.200 --> 07:21.340
van te zijn dat we een enkel type hebben met deze typegelijken en dat 30 naar hetzelfde drijft.

07:21.730 --> 07:27.100
En die zetten we dan om in een fakkeltensor want we werken natuurlijk met toorts.

07:27.580 --> 07:29.390
Dat is helemaal verplicht.

07:29.410 --> 07:35.800
En dus gebruik ik de zaklamp zonder functie weer.

07:37.000 --> 07:41.790
En dat geeft ons onze input nu perfect voor hetzelfde voor het doel.

07:42.370 --> 07:44.310
Nu gaan we deze truc gebruiken, die sneller is.

07:44.530 --> 07:46.590
We gaan samen de doelen aanvallen.

07:46.720 --> 07:53.500
En om dit te doen, moeten we eerst onze fakkelbibliotheek nemen, omdat we de stapelfunctie per zaklamp gaan

07:53.950 --> 07:56.440
gebruiken om de doelen te stapelen.

07:57.060 --> 07:57.460
Oke.

07:57.470 --> 08:03.940
En dus retourneert deze regel code in feite de invoer en de doelen die zojuist zijn opgeblazen door

08:03.940 --> 08:08.740
deze geschiktheids-traceerbron, het algoritme, of we kunnen het noemen en stapsgewijs leren.

08:09.100 --> 08:14.920
En dus gefeliciteerd, we zijn klaar om de laatste training te doen omdat de training in feite bestaat

08:14.920 --> 08:20.600
uit het minimaliseren van de kwadratische verschillen tussen de voorspellingen van onze inputs en de doelen.

08:21.040 --> 08:22.510
Dus laten we slim zijn.

08:22.670 --> 08:25.010
Het zal slim worden in de volgende zwoegen.

08:25.030 --> 08:26.840
En dus tot die tijd, geniet van I.
