WEBVTT

00:00.410 --> 00:06.180
Hallo en welkom bij deze tutorial, nu hebben we het brein van het model, we hebben ook de optimizer.

00:06.200 --> 00:09.710
Dus eigenlijk zijn we klaar om onze verschillende agenten te trainen.

00:09.860 --> 00:11.390
Dat zijn onze verschillende hersenen.

00:11.570 --> 00:17.040
Dus dat is vanaf nu dat we deze grote treinfunctie zullen maken, die het hele algoritme

00:17.090 --> 00:17.960
zal bevatten.

00:18.320 --> 00:24.410
En daarom, wat we op het punt staan te implementeren in deze trein, zo mooi is gewoon deze

00:24.410 --> 00:29.120
enorme treinfunctie die gewoon deze grote treinfunctie zal zijn, niets anders, geen klasse.

00:29.300 --> 00:33.640
Maar we zullen deze treinfunctie gebruiken in de laatste stap van deze module met de hoofdcode.

00:33.950 --> 00:34.750
Dus daar gaan we.

00:34.880 --> 00:39.020
Maar voordat we beginnen, kun je opmerken dat we eerst enkele bibliotheken importeren.

00:39.020 --> 00:41.600
Dat zijn dus de klassieke bibliotheken met de zaklampmodule.

00:41.840 --> 00:48.650
Ik bedoel, de fakkelbibliotheek, dan de eindbibliotheek om de Attari-omgeving te creëren, die zal uitbreken.

00:49.040 --> 00:55.460
Dan gaan we natuurlijk importeren of reclasseren uit ons modelbestand, dit.

00:56.210 --> 01:03.380
En tot slot zullen we variabelen van Tahj die grad zijn gebruiken om goed presterende berekeningen van de gradiënt uit te

01:03.380 --> 01:05.330
voeren dankzij de dynamische grafieken.

01:05.810 --> 01:11.900
En dan hebben we deze zeker gedeelde Gretz-functie, waar ik niet te veel tijd aan wil besteden, want ten eerste,

01:11.900 --> 01:17.210
dit is gewoon een functie die ervoor zorgt dat alles correct werkt als het model dat door

01:17.210 --> 01:20.150
de agent wordt gebruikt niet heeft elke afschuifgradiënt.

01:20.270 --> 01:22.820
Dus daarom heet het en kort gedeelde grad's.

01:23.030 --> 01:27.860
En de andere reden is dat ik denk dat deze functie niet nodig is, maar we weten het nooit.

01:27.860 --> 01:32.690
En hiermee ben je tenminste 100 procent zeker dat de code correct wordt uitgevoerd.

01:32.900 --> 01:34.460
Maar dat is niet echt belangrijk.

01:34.730 --> 01:40.210
Waar we ons op moeten concentreren, is deze treinfunctie die nu begint te maken.

01:40.880 --> 01:41.510
Hier gaan we.

01:41.510 --> 01:48.470
Def en train zullen gewoon een trein aanroepen en deze treinfunctie zal verschillende argumenten nodig hebben.

01:48.860 --> 01:50.110
De eerste is rang.

01:50.240 --> 01:51.500
Ik ga uitleggen wat het is.

01:51.500 --> 01:58.880
En de tweede de tweede is forams zodat alle parameters van de omgeving, dan

01:58.880 --> 02:02.450
wordt de derde parameter gedeeld model.

02:03.020 --> 02:08.900
Dus, weet je, het gedeelde model is wat de agent krijgt om zijn kleine verkenning in een bepaald aantal stappen uit

02:08.900 --> 02:09.740
te voeren.

02:10.400 --> 02:14.720
En dan tot slot, het laatste argument zal de optimizer zijn.

02:14.990 --> 02:16.820
Dat is degene die we eerder hebben gemaakt.

02:17.690 --> 02:18.500
Zo perfect.

02:18.500 --> 02:19.910
Dat is voor argumenten.

02:19.910 --> 02:23.650
En nu zijn we klaar om deze treinfunctie te gaan implementeren.

02:24.020 --> 02:28.730
Dus het eerste wat we zullen doen is, weet je, je herinnert je waar het voor staat.

02:28.820 --> 02:32.090
Het staat voor synchrone actieve agenten.

02:32.390 --> 02:34.650
Dus in een 3C is er een synchrone.

02:34.830 --> 02:40.040
Dus zoals je hebt begrepen, moeten we elke trainingsagent synchroniseren en synchroniseren.

02:40.050 --> 02:45.380
Dan gaan we de rang gebruiken om elke stoel met deze rang te verschuiven.

02:45.500 --> 02:51.820
Dus deze rangparameter hier is alleen om een stoel te verschuiven zodat elke trainingsagent wordt gesynchroniseerd.

02:52.430 --> 02:59.030
Dus als er bijvoorbeeld agenten zijn die trainen, gaan de rangen van het ene naar het andere en is er één geheel

02:59.030 --> 03:02.110
getal per agent van het ene naar het andere.

03:02.480 --> 03:08.780
Dus als we de stoel met één draad verschuiven, zijn alle andere willekeurige getallen die door de draad worden gemaakt,

03:08.780 --> 03:10.790
volledig onafhankelijk van de andere draden.

03:11.360 --> 03:18.530
De stoelen zijn echter vaste nummers, dus als we de ervaring reproduceren, zullen we precies dezelfde gebeurtenissen vinden en

03:18.530 --> 03:23.260
dat is omdat het deterministisch is met betrekking tot de stoel.

03:23.540 --> 03:25.250
Het is dus belangrijk om dat te begrijpen.

03:25.370 --> 03:31.280
En daarom moeten we eerst elke trainingsagent synchroniseren door de verkeerde hier te gebruiken om de

03:31.280 --> 03:33.830
stoel met de rang te verschuiven.

03:34.230 --> 03:35.000
Dus laten we dit doen.

03:35.030 --> 03:38.510
Om dat te doen, nemen we onze Tahj-bibliotheek.

03:39.020 --> 03:41.840
Dan gaan we de stoel met handleiding halen.

03:42.760 --> 03:45.180
Onderstreept zaad haakjes.

03:45.250 --> 03:51.040
Dit is een functie en nu gaan we de zaden nemen van alle agenten waartoe we toegang hebben met

03:51.040 --> 03:56.530
programma's die seed en ze verschuiven door de huur om elk van deze agenten het recht te ontnemen.

03:56.710 --> 03:59.440
We zullen hier gewoon toevoegen, plus huur.

04:00.350 --> 04:07.160
En dat zal de snelheid met de rangschikking verschuiven om elke trainingsagent te synchroniseren, omdat er één zaadje

04:07.160 --> 04:09.080
is voor elke trainingsagent.

04:09.800 --> 04:15.130
Oké, het eerste ding gedaan en nu de volgende stap, de volgende stap is om het milieu te krijgen.

04:15.380 --> 04:21.410
Dus we gaan een nieuwe variabele maken die we gaan aanroepen en nu zullen we gebruiken om Attari te

04:21.410 --> 04:25.950
maken en te functioneren vanuit de eindmodule om de omgeving voor uitbraak te creëren.

04:26.000 --> 04:27.730
Dat is om de omgeving van puistjes te krijgen.

04:28.130 --> 04:33.230
Dus we nemen deze functie, maken Attari en.

04:34.100 --> 04:39.860
En nu hoeven we slechts één argument te geven, dat zijn de parameters van de omgeving en we hebben ze omdat

04:39.860 --> 04:42.390
dit een van de invoer is van de treinfunctie.

04:42.590 --> 04:47.030
Dit zijn deze programma's hier, die de parameters zullen zijn van de omgeving van uitbraak.

04:47.390 --> 04:54.950
En daarom, om de breakout-omgeving te krijgen, nemen we dit Perens-argument, dan dat en dan krijgen we en noemen we

04:54.950 --> 05:01.950
welke in de toekomst dat is in de volgende code met de hoofdfunctie die de hele code

05:01.950 --> 05:04.850
zal uitvoeren, breakout breakout visio zal zijn.

05:05.830 --> 05:13.870
Oké, dus dat maakt ons de omgeving perfect en nu is de volgende stap om het zaad van de omgeving af te stemmen op die

05:14.350 --> 05:15.570
van de agenten.

05:15.970 --> 05:17.080
En waarom doen we dat?

05:17.470 --> 05:24.160
Het is omdat, onthoud, elke agent van het H3C-model heeft zijn eigen visie op de omgeving, zoals zijn eigen

05:24.160 --> 05:25.570
kopie van de omgeving.

05:25.840 --> 05:31.720
En daarom moeten we elk van de agenten op één specifieke versie van de omgeving afstemmen.

05:31.960 --> 05:37.090
En om dat te doen, gaan we het zaad gebruiken, omdat elk zaadje een specifieke omgeving bepaalt.

05:37.270 --> 05:42.070
Dus door aan elke agent een ander zaadje te koppelen, krijgen we precies wat we willen.

05:42.070 --> 05:45.740
Dat wil zeggen dat elke agent zijn eigen omgeving heeft.

05:46.360 --> 05:47.620
En hoe kunnen we dat dan doen?

05:47.770 --> 05:56.170
We kunnen onze omgeving nemen, dan gebruikt Adut de seed-functie om de seed te kiezen die we voor de omgeving

05:56.170 --> 05:57.050
willen krijgen.

05:57.340 --> 06:01.180
En dus nu het zaad van de omgeving afstemmen op het zaad van de agent.

06:01.420 --> 06:07.930
We moeten dit gewoon hebben omdat dit overeenkomt met het zaad van de agent die is verschoven dankzij

06:08.080 --> 06:13.590
rang om deze gesynchroniseerde trainingsagenten te krijgen, omdat ze allemaal op het andere zaad zitten.

06:14.050 --> 06:16.210
Dus we moeten dat hier gewoon baseren.

06:16.360 --> 06:19.960
En dit zal het zaad van de omgeving op één van de agenten afstemmen.

06:20.930 --> 06:26.710
OK, nu gaan we ons model pakken, dat zijn onze H3C-hersenen.

06:27.010 --> 06:31.830
En dat is nu dat we de AG gaan gebruiken om een klasse van ons modelbestand te maken.

06:32.200 --> 06:38.980
We gaan dus eigenlijk een object van deze activiteitsklasse maken en we gaan dit objectmodel of brein

06:38.980 --> 06:40.710
noemen, als je wilt.

06:41.050 --> 06:47.290
Maar in principe bevat dit object alle windingen, de en de lineaire verbinding en de voorwaartse functie

06:47.290 --> 06:49.200
om het signaal te verspreiden.

06:49.450 --> 06:55.570
Dus het zal in feite de hersenen van de acteur en de criticus bevatten met de mogelijkheid om het signaal door de

06:55.570 --> 06:58.360
hersenen te verspreiden om de uiteindelijke uitvoer te krijgen.

06:59.050 --> 07:00.010
Dus laten we dit doen.

07:00.010 --> 07:02.340
Laten we ons model maken.

07:02.560 --> 07:06.360
Dus zoals we al zeiden, we willen dit objectmodel noemen.

07:06.940 --> 07:14.500
En dus creëren we een object en de act creëert klasse en daarom nemen we een klassenacteur, criticus, en onthouden

07:14.680 --> 07:16.960
nu welke argumenten we moeten invoeren.

07:17.200 --> 07:20.130
Dat zijn eigenlijk de argumenten van de init-functie.

07:20.500 --> 07:22.240
Dus zelf hoeven we het niet in te voeren.

07:22.570 --> 07:25.920
Dat is wat we moeten doen om het object in de methode te gebruiken.

07:26.380 --> 07:31.500
Maar dan zijn de argumenten die we moeten invoeren inputs, die in goede staat zijn.

07:31.510 --> 07:37.900
Dat zijn de afmetingen van onze invoerbeelden en de actieruimte die, je weet wel, de reeks acties

07:37.900 --> 07:38.340
bevat.

07:38.560 --> 07:42.240
Dus laten we deze argumenten en de treinfunctie invoeren.

07:42.610 --> 07:49.540
Dus de eerste, we kunnen het krijgen met onze omgeving en dat, en dan gebruiken we observatieruimte.

07:51.000 --> 07:56.640
Dus dat is de ruimte van observaties, dan dat en dan om het aantal inputs te krijgen dat we vorm krijgen.

07:57.460 --> 07:58.750
Haakje nul.

07:59.020 --> 08:04.310
Oké, dus dat zijn vier ingangen en nu vier actievelden.

08:04.690 --> 08:09.940
Nou, dat is bijna hetzelfde, maar we moeten het uit onze omgeving halen dat we er zin in hebben,

08:09.940 --> 08:11.660
dan dat en dan actieruimte.

08:12.730 --> 08:13.180
Oke.

08:13.180 --> 08:19.380
En dat geeft ons de argumenten die we moeten invoeren bij het maken van een object, het model van de execrated

08:19.390 --> 08:19.810
klasse.

08:20.230 --> 08:24.890
OK, dus nu hebben we ons model en nu is de volgende stap om onze invoerstaten voor te bereiden.

08:25.030 --> 08:27.520
Dus onthoud dat we nog steeds bezig zijn met diepgaand leren.

08:27.520 --> 08:34.330
Dus de invoerstatussen zijn de invoerafbeeldingen en daarom zal dit oorspronkelijk en dan per array zijn, die één kanaal zal

08:34.330 --> 08:39.250
bevatten omdat we met zwart-witafbeeldingen zullen werken en het zal afmetingen hebben van

08:39.250 --> 08:40.390
tweeënveertig bij tweeënveertig.

08:40.870 --> 08:46.060
Maar het is belangrijk om te begrijpen en te onthouden dat de invoerstatussen de invoerafbeeldingen zijn.

08:46.540 --> 08:49.240
Dus eerst en vooral moeten we de nummering krijgen.

08:49.510 --> 08:51.700
Dan gaan we hem ombouwen tot een toortssensor.

08:51.880 --> 08:57.460
Maar de eerste stap, zoals we eerder deden, is het behalen van een MBA en het behalen ervan.

08:57.670 --> 08:58.840
Het is eigenlijk heel simpel.

08:58.870 --> 09:03.580
Welnu, eerst moeten we een variabele maken voor de invoerstatus, die we status zullen noemen.

09:04.030 --> 09:11.710
En dit om het nummer te krijgen, moeten we gewoon onze omgeving nemen en dan Adut en vervolgens de reset-functie

09:12.010 --> 09:12.580
gebruiken.

09:13.000 --> 09:17.590
En dit zal de staat initialiseren als een aantal dimensies.

09:17.620 --> 09:21.720
Eén bij veertig, twee bij veertig tegen één betekent één kanaal.

09:21.730 --> 09:27.580
Dus zwart-wit beeld en tweeënveertig bij tweeënveertig is natuurlijk de afmetingen van het beeld, het aantal pixels en de

09:27.580 --> 09:30.340
breedte en het aantal pixels op de hoogte.

09:30.730 --> 09:34.210
Dus eigenlijk zijn dat alleen de afmetingen en daar werken we mee.

09:34.600 --> 09:41.290
En nu we deze Nampara hebben, omdat dit ons deze beelden van zulke afmetingen in arrays

09:41.290 --> 09:45.130
zal opleveren, kunnen we ze omzetten in toortssensoren.

09:45.340 --> 09:50.530
En om dit goed te doen, gaan we de status opnieuw bijwerken omdat we de cijfers niet hoeven te behouden.

09:51.010 --> 09:54.750
En daar gebruiken we torch the torch module.

09:55.060 --> 10:02.560
En onthoud, dat hebben we al gedaan, want gebruiken we de functie van onderstrepingsteken tussen haakjes en binnen

10:02.710 --> 10:04.030
zijn functie?

10:04.030 --> 10:08.080
We moeten het getal acht invoeren, dat we willen omzetten in een toortssensor.

10:08.410 --> 10:15.580
En dat is de staat waarin de vorige versie van de staat Nampara door hun functie een pijplijn zal worden,

10:15.850 --> 10:16.840
een toortssensor.

10:17.140 --> 10:20.350
Dus dat creëert gewoon een sensor van de staat.

10:20.350 --> 10:24.730
En nu hoeven we alleen nog maar de done heel goed te initialiseren.

10:24.730 --> 10:30.370
Onthoud dat het over het algemeen de variabele is die zegt of een aflevering voorbij is of dat het

10:30.730 --> 10:36.780
spel voorbij is, nou, hier willen we dit heel goed introduceren en initialiseren naar waar om aan te geven dat dit

10:36.780 --> 10:40.360
gedaan heel gelijk is aan waar als het spel klaar is.

10:41.050 --> 10:45.490
Dus dat is handig voor later zodat de A. L. speelt niet voor onbepaalde tijd om uit te breken.

10:46.640 --> 10:53.360
Oké, dus dat was eigenlijk het begin van deze treinfunctie met wat initialisatie en wat

10:53.360 --> 10:59.480
dingen die we moesten doen, het belangrijkste hier was dat we elke trainingsagent moesten

10:59.480 --> 11:00.290
synchroniseren.

11:00.500 --> 11:04.640
Dat is een eerste principe van het ATC-model dat we moeten toepassen.

11:04.970 --> 11:09.530
En nu in de volgende iteratie gaan we verder met de synchronisatie met het gedeelde model.

11:09.710 --> 11:14.510
Laten we niet vergeten dat er de verschillende modellen zijn, maar ook het gedeelde model, een model

11:14.510 --> 11:15.710
dat alle agenten delen.

11:16.010 --> 11:21.860
En dus moeten we synchroniseren met het gedeelde model, zodat elke agent dit gedeelde model kan laten overgaan

11:21.860 --> 11:25.190
tot een kleine verkenning van een bepaald aantal stappen.

11:25.840 --> 11:27.940
Dat gaan we dus doen in de volgende tutorial.

11:27.950 --> 11:29.420
En tot die tijd, geniet ervan.
