WEBVTT

00:00.150 --> 00:02.280
Hallo en welkom bij deze Python-tutorial.

00:02.640 --> 00:06.930
Oké, we hebben één functie minder om te implementeren in onze geheugenklasse.

00:07.080 --> 00:12.600
Dat is de simpele functie en dat is natuurlijk om wat willekeurige steekproeven uit ons geheugen te halen

00:12.600 --> 00:15.370
en daarom zal deze functie deze willekeurige steekproeven teruggeven.

00:15.930 --> 00:16.290
Oke.

00:16.290 --> 00:17.700
Laten we het dus implementeren.

00:17.730 --> 00:20.070
We gaan het simpel noemen.

00:20.490 --> 00:21.230
Daar gaan we.

00:21.270 --> 00:24.740
En deze functie heeft twee argumenten als invoer.

00:25.110 --> 00:29.790
De eerste, zoals gewoonlijk, zelf ons toekomstige doel, de vervangende klasse.

00:30.030 --> 00:33.300
En het tweede argument is: kun je proberen te raden?

00:33.330 --> 00:39.750
Welnu, we nemen enkele monsters, een vaste maat, en daarom moeten we een maat vier monsters kiezen.

00:39.990 --> 00:42.270
En meer precies, we noemen het een batchgrootte.

00:42.720 --> 00:47.600
Dus dat is de naam die we gaan geven aan ons tweede argument, batchgrootte.

00:47.970 --> 00:49.410
En dan gaan we.

00:49.410 --> 00:53.490
We hebben onze twee argumenten en nu kunnen we de voorbeeldfunctie implementeren.

00:54.370 --> 01:00.230
Dus nu wil ik je waarschuwen, dit wordt een beetje technisch, maar ik zal mijn best doen om het uit te leggen.

01:01.120 --> 01:05.070
Dus we beginnen met het maken van de variabele van de simple.

01:05.080 --> 01:08.620
Dit is alleen de variabele die de samples van het geheugen zal bevatten.

01:09.430 --> 01:09.820
Oke.

01:09.820 --> 01:10.970
Zo eenvoudig, gelijk.

01:11.170 --> 01:13.660
En hoe gaan we nu aan deze monsters komen?

01:14.290 --> 01:20.170
Allereerst moeten we ons geheugen nemen, want we krijgen deze monsters uit ons geheugen.

01:20.800 --> 01:26.860
Dan hebben we waarschijnlijk de batchgrootte nodig omdat de monsters die we willen hebben, batchgrootte-elementen

01:26.860 --> 01:27.370
bevatten.

01:27.680 --> 01:33.130
Dus we hebben geheugen nodig, we hebben batchgrootte nodig, en dan hebben we wat taartbrander of python-trucs nodig om het goede

01:33.130 --> 01:34.700
formaat van deze monsters te krijgen.

01:35.470 --> 01:40.720
Dus wat ik ga doen, ik ga de regel code schrijven en dan ga ik het element voor

01:40.720 --> 01:41.370
element uitleggen.

01:41.860 --> 01:42.560
Dus laten we het doen.

01:42.650 --> 01:45.550
Ik begin met het nemen van een zip-functie.

01:46.000 --> 01:47.380
Ik ga binnenkort uitbreiden.

01:47.380 --> 01:49.870
Wat het doet en van binnen is de functie.

01:50.020 --> 01:51.580
Ik ga een ster toevoegen.

01:51.890 --> 01:53.410
Die ga ik ook uitbreiden.

01:53.790 --> 01:55.960
De ster en willekeurig.

01:56.380 --> 02:03.230
Dat monster, zo willekeurig, zoals je misschien al geraden had, is de willekeurige bibliotheek die we hier importeren.

02:03.280 --> 02:08.830
Dat is dus de belangrijkste reden waarom we deze willekeurige bibliotheek moesten importeren omdat we enkele willekeurige steekproeven

02:08.830 --> 02:09.360
namen.

02:09.880 --> 02:14.990
Dus van deze willekeurige bibliotheek gaan we de voorbeeldfunctie gebruiken.

02:15.430 --> 02:17.860
Dit zijn dus onze variabelen en dit is een functie.

02:17.860 --> 02:19.690
Dus ik ga wat haakjes toevoegen.

02:20.020 --> 02:24.340
En nu, zoals je kunt zien, is sample een functie en moeten we wat argumenten gebruiken.

02:25.360 --> 02:31.300
Dus zoals je kunt zien, is het eerste argument zelf en eigenlijk sprekend over zelf, dit

02:31.480 --> 02:36.690
komt overeen met zelfgeheugen, het geheugen van ons toekomstige exemplaarobject van onze herhalende geheugentest.

02:37.030 --> 02:40.330
Dus ik ga hier zelf die herinnering toevoegen.

02:41.200 --> 02:46.180
En dan is het tweede argument, zoals je misschien al geraden had, de grootte van de batch die we willekeurig

02:46.360 --> 02:51.050
uit ons geheugen willen halen en dat we het een naam hebben gegeven die zo groot is.

02:51.400 --> 02:55.380
Het tweede argument is dus de batchgrootte.

02:55.690 --> 02:56.160
Oke.

02:56.320 --> 03:00.520
Dus de regel code wordt getypt en nu ga ik uitleggen wat het doet.

03:01.360 --> 03:07.720
Dus eerst en vooral, met deze willekeurige punt, eenvoudige functie, namen we enkele willekeurige

03:07.720 --> 03:11.500
steekproeven uit het geheugen met een vaste batchgrootte.

03:12.400 --> 03:17.830
Dus dat is begrijpelijk, maar wat doet deze Zipp-winkelfunctie dan?

03:18.400 --> 03:20.170
Nou, er is geen mysterie aan.

03:20.380 --> 03:22.370
Het is net als de hervormfunctie.

03:22.720 --> 03:27.810
Dus, bijvoorbeeld, ik ga hier iets toevoegen om uit te leggen dat ik het ga verwijderen.

03:28.330 --> 03:33.520
Laten we zeggen dat we bijvoorbeeld een lijst hebben met de volgende elementen.

03:33.520 --> 03:42.160
Bijvoorbeeld eerst één, twee, drie en dan het tweede element, vier, vijf, zes.

03:43.050 --> 03:47.560
We hebben dus een lijst van twee tupels van drie elementen, één, twee, drie en vier, vijf, zes.

03:48.250 --> 03:54.160
Als ik de Z-functie toepas met de ster erop, wat wordt het dan?

03:54.610 --> 04:02.830
Dus de Zipp-sterrenlijst wordt gelijk aan een nieuwe lijst, maar met een andere vorm.

04:03.220 --> 04:11.200
En deze andere vorm wordt een vier, dan twee, drie en dan vijf, zes.

04:12.310 --> 04:12.720
Oke.

04:12.730 --> 04:13.840
Dat is dus precies wat het doet.

04:13.840 --> 04:16.120
Het hervormt gewoon je lijst.

04:16.810 --> 04:23.350
Oké, dus nu je begrijpt wat deze Zipp-sterrenlijst doet, laten we nu uitleggen waarom we het moeten

04:23.350 --> 04:23.810
doen.

04:24.460 --> 04:30.100
Dus, zoals je hebt begrepen, gaan we de gebeurtenissen aan het geheugen toevoegen en de gebeurtenissen hebben de

04:30.280 --> 04:34.230
vorm, eerst de staat, dan de actie en dan de beloning.

04:34.720 --> 04:36.850
Maar voor ons algoritme willen we dit formaat niet.

04:37.210 --> 04:43.480
We willen eigenlijk dat onze voorbeelden het volgende formaat hebben, een formaat dat bestaat uit drie voorbeelden, een eenvoudig

04:43.480 --> 04:48.150
voor de staat, een eenvoudig voor de acties en een eenvoudig voor de beloning.

04:48.670 --> 04:54.850
Laten we bijvoorbeeld zeggen dat deze één, twee, drie toestand één is, actie één, beloning één, en dan

04:54.850 --> 04:56.440
toestand twee, actie twee.

04:56.440 --> 05:03.850
En we waren te goed, wat we willen is één batch voor elke één, maar voor staat één en staat twee, één van de

05:03.850 --> 05:09.520
match voor actie, één in actie twee en een derde batch voor beloning één en we waren twee.

05:10.060 --> 05:15.640
Dat is gewoon een indeling die we als volgende zullen verwachten, want dan zullen we deze batches in

05:15.640 --> 05:22.600
een PI tahj-variabele wikkelen en een deel dat ik me zal herinneren is een variabele die zowel een Tenzer als een verloop

05:22.600 --> 05:23.080
bevat.

05:23.350 --> 05:29.490
En dat is om te kunnen differentiëren naar zijn antwoord, om te kunnen differentiëren naar

05:29.500 --> 05:30.790
zijn antwoord.

05:31.030 --> 05:35.020
We hebben de structuur nodig van een variabele die intenser en een gradiënt bevat.

05:35.380 --> 05:37.370
Nogmaals, zo werkt PI Torch.

05:37.690 --> 05:44.440
Dus om samen te vatten, we maken één batch voor elk van de acties en beloningen van de staat en dan

05:44.440 --> 05:50.530
gaan we elk van deze overeenkomsten afzonderlijk in een aantal tightwads-variabelen plaatsen, die elk een gradiënt krijgen, zodat we

05:50.680 --> 05:54.010
uiteindelijk in staat zullen zijn om elk van hen onderscheiden.

05:54.460 --> 05:54.880
Oke.

05:54.880 --> 05:57.220
Dat is dus het doel van de Z-functie.

05:57.370 --> 06:00.130
Dus laat ik deze reactie maar verwijderen.

06:00.340 --> 06:05.680
En nu hoeven we alleen nog de monsters terug te sturen.

06:06.100 --> 06:11.440
Dus, zoals ik zojuist heb uitgelegd, kunnen we de monsters niet rechtstreeks retourneren om de eenvoudige reden

06:11.440 --> 06:15.060
dat we de monsters erin willen plaatsen met een toortsvariabele.

06:15.520 --> 06:22.390
Dus om dit voor elk van de voorbeelden te doen, gaan we de kaartfunctie en deze kaartfunctie gebruiken.

06:22.390 --> 06:29.580
We doen de mapping van de monsters naar toortsvariabelen die een geïntegreerde sensor bevatten.

06:30.040 --> 06:33.280
Zoals je kunt zien, heeft deze kaartfunctie verschillende argumenten.

06:33.460 --> 06:38.530
Het eerste argument is een functie en deze functie wordt de functie die de steekproeven

06:38.530 --> 06:40.240
omzet in enkele tahj-variabelen.

06:40.600 --> 06:45.050
En het tweede argument is waar we deze functie op willen toepassen.

06:45.430 --> 06:48.190
Dus dat zal het argument van deze functie zijn.

06:48.700 --> 06:50.160
En daarom: wat wordt het?

06:50.440 --> 06:52.390
Dat zijn natuurlijk de monsters.

06:52.680 --> 06:58.540
Dus het tweede argument hier zijn de steekproeven, maar laten we dan de functie definiëren waarop we elk

06:58.540 --> 07:00.280
van de steekproeven willen toepassen.

07:00.910 --> 07:06.420
Dus om hier een functie te definiëren, moeten we ze eerst aan de functie geven die Lambda zal aanroepen.

07:06.940 --> 07:13.950
Dat is gewoon een naam en gegeven lambda dan X, wat de variabele van deze functie wordt.

07:14.260 --> 07:16.450
Dus dat is slechts een naam en gegeven voor de variabele.

07:16.960 --> 07:17.500
En toen.

07:18.310 --> 07:21.010
En hier geven we de uitdrukking van de functie.

07:21.010 --> 07:24.070
Dat is wat we willen dat deze lambda-functie teruggeeft.

07:25.240 --> 07:26.540
En dus wat het gaat worden.

07:26.890 --> 07:33.070
Het zou iets moeten zijn dat onze monsters zal omzetten in een martelvariabele.

07:33.700 --> 07:39.190
En om dit te doen, hebben we het al genoemd in enkele eerdere tutorials waar we de variabele functie voor

07:39.190 --> 07:39.520
hebben.

07:39.970 --> 07:46.600
De variabele functie maakt die conversie van een toortssensor naar een variabele die de sensor en

07:46.600 --> 07:48.310
de hellingen bevat.

07:48.700 --> 07:55.720
Dus het eerste dat ik hier ga toevoegen, is een variabele variabele waarbinnen ik X ga converteren

07:55.870 --> 08:01.300
omdat X de eenvoudige zal zijn zodra Lambda op de symbolen wordt toegepast.

08:02.290 --> 08:08.320
Maar dat is niet alles, er is nog een laatste technisch ding dat we moeten implementeren, het is het

08:08.530 --> 08:14.170
feit dat voor elke batch, die in een monster zit, bijvoorbeeld de batch van de acties, een

08:14.170 --> 08:20.500
één, een twee, een drie en de andere acties, we moeten het samenvoegen met betrekking tot de eerste dimensie, die

08:21.040 --> 08:22.490
overeenkomt met de toestanden.

08:22.930 --> 08:24.940
En waarom moeten we deze aaneenschakeling maken?

08:25.390 --> 08:27.390
Het is gewoon om alles goed op elkaar af te stemmen.

08:27.550 --> 08:35.440
Dat wil zeggen dat in elke rij de status, de actie en de beloning overeenkomen met dezelfde tijd t, zodat we uiteindelijk een lijst

08:35.440 --> 08:41.930
met overeenkomsten krijgen die allemaal goed op elkaar zijn afgestemd en elke batch een pad is naar levensvatbaar.

08:42.340 --> 08:47.770
Dus hoe kunnen we deze aaneenschakeling maken als we de kat-functie uit de fakkelbibliotheek moeten gebruiken?

08:48.010 --> 08:55.270
Dus we gaan hier toorts toevoegen waaraan we toevoegen dat wordt toegepast op X, maar dan in deze cat-functie moeten

08:55.270 --> 09:00.150
we de dimensie specificeren met betrekking tot welke we die aaneenschakeling willen maken.

09:00.670 --> 09:04.950
En zoals ik net zei, dit is de eerste dimensie met index nul.

09:05.740 --> 09:06.610
En hier gaan we.

09:06.640 --> 09:08.310
We hebben onze functie klaar.

09:08.710 --> 09:14.140
Deze getalfunctie neemt de monsters, voegt ze samen met betrekking tot de eerste dimensie,

09:14.320 --> 09:20.950
en uiteindelijk zetten we deze sensoren om in enkele tahj-variabelen die zowel een sensor als een gradiënt

09:20.950 --> 09:26.620
bevatten, zodat we later, wanneer we stochastische gradiëntafdaling toepassen, kunnen differentiëren om de gewichten bij

09:26.860 --> 09:27.880
te werken.

09:28.450 --> 09:28.810
Oke.

09:28.830 --> 09:29.950
Dus deze functie is klaar.

09:30.220 --> 09:38.080
En dan hier bij het tweede argument van de kaartfunctie, moeten we specificeren waarop we deze lambda-functie willen

09:38.080 --> 09:38.980
toepassen.

09:39.310 --> 09:43.510
En dat is op al onze monsters die we gebruiken.

09:43.690 --> 09:50.620
We zullen deze lambda-functie op alle monsters toepassen, zodat we uiteindelijk een lijst met overeenkomsten krijgen waarbij elke

09:50.830 --> 09:52.960
overeenkomst wordt toegepast op variabele.

09:53.680 --> 09:54.070
Oke.

09:54.070 --> 09:58.060
Dat was dus best technisch, maar nu werkt alles in ieder geval.

09:58.060 --> 10:00.460
Nou, we zullen deze techniek achteraf niet gebruiken.

10:00.460 --> 10:01.740
We gebruiken het alleen hier.

10:01.750 --> 10:06.340
Dus als je geen diepgaand begrip wilt hebben van de technische details hier, dan is dat prima.

10:06.340 --> 10:10.360
U kunt deze drie regels code gewoon kopiëren om uw geheugen te testen.

10:10.510 --> 10:14.260
Als je een kunstmatige intelligentie wilt maken met by Tahj, dan is het zoals je wilt.

10:14.440 --> 10:21.010
Maar nu is het goede nieuws dat we klaar zijn met deze replay memory class experience replay is nu geïmplementeerd en

10:21.280 --> 10:26.480
we kunnen doorgaan naar de volgende en laatste klas, die het hele dequeue leermodel zal zijn.

10:26.830 --> 10:32.680
Dus in dit deep learning-model hebben we natuurlijk een netwerk dat ervaring toevoegt om te spelen

10:32.980 --> 10:36.190
en dan de rest van het deep learning-algoritme.

10:36.490 --> 10:38.990
Het wordt dus een veel grotere klas.

10:39.010 --> 10:44.170
We gaan ongeveer 10 functies maken, maar dat is alleen omdat we dit stap voor stap doen, zodat je beter kunt begrijpen

10:44.170 --> 10:45.660
wat er aan de hand is.

10:46.390 --> 10:49.090
Ik kan dus niet wachten om ons deep learning-model te implementeren.

10:49.090 --> 10:49.960
En tot dan.

10:49.960 --> 10:50.830
En ik.
