Hallo en welkom bij deze tutorial, nu hebben we het brein van het model, we hebben ook de optimizer.
Dus eigenlijk zijn we klaar om onze verschillende agenten te trainen.
Dat zijn onze verschillende hersenen.
Dus dat is vanaf nu dat we deze grote treinfunctie zullen maken, die het hele algoritme
zal bevatten.
En daarom, wat we op het punt staan te implementeren in deze trein, zo mooi is gewoon deze
enorme treinfunctie die gewoon deze grote treinfunctie zal zijn, niets anders, geen klasse.
Maar we zullen deze treinfunctie gebruiken in de laatste stap van deze module met de hoofdcode.
Dus daar gaan we.
Maar voordat we beginnen, kun je opmerken dat we eerst enkele bibliotheken importeren.
Dat zijn dus de klassieke bibliotheken met de zaklampmodule.
Ik bedoel, de fakkelbibliotheek, dan de eindbibliotheek om de Attari-omgeving te creëren, die zal uitbreken.
Dan gaan we natuurlijk importeren of reclasseren uit ons modelbestand, dit.
En tot slot zullen we variabelen van Tahj die grad zijn gebruiken om goed presterende berekeningen van de gradiënt uit te
voeren dankzij de dynamische grafieken.
En dan hebben we deze zeker gedeelde Gretz-functie, waar ik niet te veel tijd aan wil besteden, want ten eerste,
dit is gewoon een functie die ervoor zorgt dat alles correct werkt als het model dat door
de agent wordt gebruikt niet heeft elke afschuifgradiënt.
Dus daarom heet het en kort gedeelde grad's.
En de andere reden is dat ik denk dat deze functie niet nodig is, maar we weten het nooit.
En hiermee ben je tenminste 100 procent zeker dat de code correct wordt uitgevoerd.
Maar dat is niet echt belangrijk.
Waar we ons op moeten concentreren, is deze treinfunctie die nu begint te maken.
Hier gaan we.
Def en train zullen gewoon een trein aanroepen en deze treinfunctie zal verschillende argumenten nodig hebben.
De eerste is rang.
Ik ga uitleggen wat het is.
En de tweede de tweede is forams zodat alle parameters van de omgeving, dan
wordt de derde parameter gedeeld model.
Dus, weet je, het gedeelde model is wat de agent krijgt om zijn kleine verkenning in een bepaald aantal stappen uit
te voeren.
En dan tot slot, het laatste argument zal de optimizer zijn.
Dat is degene die we eerder hebben gemaakt.
Zo perfect.
Dat is voor argumenten.
En nu zijn we klaar om deze treinfunctie te gaan implementeren.
Dus het eerste wat we zullen doen is, weet je, je herinnert je waar het voor staat.
Het staat voor synchrone actieve agenten.
Dus in een 3C is er een synchrone.
Dus zoals je hebt begrepen, moeten we elke trainingsagent synchroniseren en synchroniseren.
Dan gaan we de rang gebruiken om elke stoel met deze rang te verschuiven.
Dus deze rangparameter hier is alleen om een stoel te verschuiven zodat elke trainingsagent wordt gesynchroniseerd.
Dus als er bijvoorbeeld agenten zijn die trainen, gaan de rangen van het ene naar het andere en is er één geheel
getal per agent van het ene naar het andere.
Dus als we de stoel met één draad verschuiven, zijn alle andere willekeurige getallen die door de draad worden gemaakt,
volledig onafhankelijk van de andere draden.
De stoelen zijn echter vaste nummers, dus als we de ervaring reproduceren, zullen we precies dezelfde gebeurtenissen vinden en
dat is omdat het deterministisch is met betrekking tot de stoel.
Het is dus belangrijk om dat te begrijpen.
En daarom moeten we eerst elke trainingsagent synchroniseren door de verkeerde hier te gebruiken om de
stoel met de rang te verschuiven.
Dus laten we dit doen.
Om dat te doen, nemen we onze Tahj-bibliotheek.
Dan gaan we de stoel met handleiding halen.
Onderstreept zaad haakjes.
Dit is een functie en nu gaan we de zaden nemen van alle agenten waartoe we toegang hebben met
programma's die seed en ze verschuiven door de huur om elk van deze agenten het recht te ontnemen.
We zullen hier gewoon toevoegen, plus huur.
En dat zal de snelheid met de rangschikking verschuiven om elke trainingsagent te synchroniseren, omdat er één zaadje
is voor elke trainingsagent.
Oké, het eerste ding gedaan en nu de volgende stap, de volgende stap is om het milieu te krijgen.
Dus we gaan een nieuwe variabele maken die we gaan aanroepen en nu zullen we gebruiken om Attari te
maken en te functioneren vanuit de eindmodule om de omgeving voor uitbraak te creëren.
Dat is om de omgeving van puistjes te krijgen.
Dus we nemen deze functie, maken Attari en.
En nu hoeven we slechts één argument te geven, dat zijn de parameters van de omgeving en we hebben ze omdat
dit een van de invoer is van de treinfunctie.
Dit zijn deze programma's hier, die de parameters zullen zijn van de omgeving van uitbraak.
En daarom, om de breakout-omgeving te krijgen, nemen we dit Perens-argument, dan dat en dan krijgen we en noemen we
welke in de toekomst dat is in de volgende code met de hoofdfunctie die de hele code
zal uitvoeren, breakout breakout visio zal zijn.
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
van de agenten.
En waarom doen we dat?
Het is omdat, onthoud, elke agent van het H3C-model heeft zijn eigen visie op de omgeving, zoals zijn eigen
kopie van de omgeving.
En daarom moeten we elk van de agenten op één specifieke versie van de omgeving afstemmen.
En om dat te doen, gaan we het zaad gebruiken, omdat elk zaadje een specifieke omgeving bepaalt.
Dus door aan elke agent een ander zaadje te koppelen, krijgen we precies wat we willen.
Dat wil zeggen dat elke agent zijn eigen omgeving heeft.
En hoe kunnen we dat dan doen?
We kunnen onze omgeving nemen, dan gebruikt Adut de seed-functie om de seed te kiezen die we voor de omgeving
willen krijgen.
En dus nu het zaad van de omgeving afstemmen op het zaad van de agent.
We moeten dit gewoon hebben omdat dit overeenkomt met het zaad van de agent die is verschoven dankzij
rang om deze gesynchroniseerde trainingsagenten te krijgen, omdat ze allemaal op het andere zaad zitten.
Dus we moeten dat hier gewoon baseren.
En dit zal het zaad van de omgeving op één van de agenten afstemmen.
OK, nu gaan we ons model pakken, dat zijn onze H3C-hersenen.
En dat is nu dat we de AG gaan gebruiken om een klasse van ons modelbestand te maken.
We gaan dus eigenlijk een object van deze activiteitsklasse maken en we gaan dit objectmodel of brein
noemen, als je wilt.
Maar in principe bevat dit object alle windingen, de en de lineaire verbinding en de voorwaartse functie
om het signaal te verspreiden.
Dus het zal in feite de hersenen van de acteur en de criticus bevatten met de mogelijkheid om het signaal door de
hersenen te verspreiden om de uiteindelijke uitvoer te krijgen.
Dus laten we dit doen.
Laten we ons model maken.
Dus zoals we al zeiden, we willen dit objectmodel noemen.
En dus creëren we een object en de act creëert klasse en daarom nemen we een klassenacteur, criticus, en onthouden
nu welke argumenten we moeten invoeren.
Dat zijn eigenlijk de argumenten van de init-functie.
Dus zelf hoeven we het niet in te voeren.
Dat is wat we moeten doen om het object in de methode te gebruiken.
Maar dan zijn de argumenten die we moeten invoeren inputs, die in goede staat zijn.
Dat zijn de afmetingen van onze invoerbeelden en de actieruimte die, je weet wel, de reeks acties
bevat.
Dus laten we deze argumenten en de treinfunctie invoeren.
Dus de eerste, we kunnen het krijgen met onze omgeving en dat, en dan gebruiken we observatieruimte.
Dus dat is de ruimte van observaties, dan dat en dan om het aantal inputs te krijgen dat we vorm krijgen.
Haakje nul.
Oké, dus dat zijn vier ingangen en nu vier actievelden.
Nou, dat is bijna hetzelfde, maar we moeten het uit onze omgeving halen dat we er zin in hebben,
dan dat en dan actieruimte.
Oke.
En dat geeft ons de argumenten die we moeten invoeren bij het maken van een object, het model van de execrated
klasse.
OK, dus nu hebben we ons model en nu is de volgende stap om onze invoerstaten voor te bereiden.
Dus onthoud dat we nog steeds bezig zijn met diepgaand leren.
Dus de invoerstatussen zijn de invoerafbeeldingen en daarom zal dit oorspronkelijk en dan per array zijn, die één kanaal zal
bevatten omdat we met zwart-witafbeeldingen zullen werken en het zal afmetingen hebben van
tweeënveertig bij tweeënveertig.
Maar het is belangrijk om te begrijpen en te onthouden dat de invoerstatussen de invoerafbeeldingen zijn.
Dus eerst en vooral moeten we de nummering krijgen.
Dan gaan we hem ombouwen tot een toortssensor.
Maar de eerste stap, zoals we eerder deden, is het behalen van een MBA en het behalen ervan.
Het is eigenlijk heel simpel.
Welnu, eerst moeten we een variabele maken voor de invoerstatus, die we status zullen noemen.
En dit om het nummer te krijgen, moeten we gewoon onze omgeving nemen en dan Adut en vervolgens de reset-functie
gebruiken.
En dit zal de staat initialiseren als een aantal dimensies.
Eén bij veertig, twee bij veertig tegen één betekent één kanaal.
Dus zwart-wit beeld en tweeënveertig bij tweeënveertig is natuurlijk de afmetingen van het beeld, het aantal pixels en de
breedte en het aantal pixels op de hoogte.
Dus eigenlijk zijn dat alleen de afmetingen en daar werken we mee.
En nu we deze Nampara hebben, omdat dit ons deze beelden van zulke afmetingen in arrays
zal opleveren, kunnen we ze omzetten in toortssensoren.
En om dit goed te doen, gaan we de status opnieuw bijwerken omdat we de cijfers niet hoeven te behouden.
En daar gebruiken we torch the torch module.
En onthoud, dat hebben we al gedaan, want gebruiken we de functie van onderstrepingsteken tussen haakjes en binnen
zijn functie?
We moeten het getal acht invoeren, dat we willen omzetten in een toortssensor.
En dat is de staat waarin de vorige versie van de staat Nampara door hun functie een pijplijn zal worden,
een toortssensor.
Dus dat creëert gewoon een sensor van de staat.
En nu hoeven we alleen nog maar de done heel goed te initialiseren.
Onthoud dat het over het algemeen de variabele is die zegt of een aflevering voorbij is of dat het
spel voorbij is, nou, hier willen we dit heel goed introduceren en initialiseren naar waar om aan te geven dat dit
gedaan heel gelijk is aan waar als het spel klaar is.
Dus dat is handig voor later zodat de A. L. speelt niet voor onbepaalde tijd om uit te breken.
Oké, dus dat was eigenlijk het begin van deze treinfunctie met wat initialisatie en wat
dingen die we moesten doen, het belangrijkste hier was dat we elke trainingsagent moesten
synchroniseren.
Dat is een eerste principe van het ATC-model dat we moeten toepassen.
En nu in de volgende iteratie gaan we verder met de synchronisatie met het gedeelde model.
Laten we niet vergeten dat er de verschillende modellen zijn, maar ook het gedeelde model, een model
dat alle agenten delen.
En dus moeten we synchroniseren met het gedeelde model, zodat elke agent dit gedeelde model kan laten overgaan
tot een kleine verkenning van een bepaald aantal stappen.
Dat gaan we dus doen in de volgende tutorial.
En tot die tijd, geniet ervan.