Hallo en welkom bij deze tutorial, deze speciale tutorial wordt super spannend omdat
we dichter bij het H3C-algoritme komen.
Je zult zien dat wat we gaan implementeren, en dat heet geschiktheidstracering of Sarcelles,
eigenlijk een algoritme is van de asynchrone algoritmen van actieve agenten.
Maar we kunnen het niet beschouwen als een we zien, omdat we nog steeds één agent hebben.
Maar toch zul je zien dat wat we gaan implementeren eigenlijk afkomstig
is uit het volgende artikel, deze asynchrone methode op papier voor diepgaand leren.
En het is in dit artikel dat de inzendingen, de algoritmen die we zullen implementeren als de laatste bonus van deze
cursus, zullen vinden.
Maar zoals ik al zei, we komen er dichterbij omdat het model dat we nu gaan implementeren
eigenlijk dit is, het asynchrone en stap Q-leren.
Dat is hem.
Dus dat is bijna de bon, die daarna is, maar met één agent.
En het krachtige hieraan is dit en stapsgewijs leren.
We gaan de cumulatieve beloningen leren en het cumulatieve doel op Insteps leren in plaats van één stap
zoals eerder.
En dat maakt de training veel performanter en daardoor veel krachtiger.
We hebben dus eigenlijk de code voor dit algoritme.
Het is dit algoritme zoals hier.
Dus laten we erop klikken.
En daar gaan we.
Dat is het algoritme dat we gaan implementeren.
Maar onthoud, met slechts één agent is het verschil dat ze hier een actie 80 ondernemen, volgens
het Epsilon-beleid, op basis van de waarden voor de huidige staat en het actiebord.
Maar in ons geval hebben we het beleid niet uitgevoerd.
We hebben een softmax geïmplementeerd.
Maar de rest is hetzelfde.
Zoals je kunt zien, gaan we de cumulatieve beloning op Insteps berekenen, eigenlijk tien stappen.
Onthoud dat Wreef gelijk is aan tien.
En dus zullen we deze regel code implementeren in ons algoritme dat we op het punt stonden te implementeren.
Op dit moment gaan we dit krijgen en meestal gaan we dit ook implementeren.
Je zult zien dat we hier het maximum van de kernwaarden voor de huidige staat en de huidige
actie in deze theta krijgen.
Het is gewoon een doelparameter.
Dus laten we dit doen.
Laten we dit algoritme aanvallen.
Deze heet de asynchrone en Step Q Learning, maar we hebben niet het recht om A te zeggen wat ons betreft omdat
we maar één agent hebben, maar daarom kunnen we het noemen en stappen.
Q Leergeschiktheidskenmerken of zelfs Sauza.
Oké, laten we dit doen.
Het gaat best leuk worden.
We kunnen in principe de code hier volgen en dat is wat we gaan doen.
En dus, zoals je kunt zien, is een parameter die we opnieuw nodig hebben, de GEMAP-parameter die de parameter is, en daarom
zullen we beginnen met het introduceren van een variabele voor deze GANNA-parameter en het kiezen van een waarde.
Dus laten we dit doen.
We hebben eigenlijk geen klaslokaal nodig om dit te bedoelen.
We kunnen dit eenvoudig implementeren met een functie, want, weet je, we hoeven niet echt
objecten te maken voor dit geschiktheidstracermodel.
Een functie is voldoende, want wat we eigenlijk willen doen, is de invoer en de doelen retourneren, zodat
we later, bij het trainen van de, de afstand tussen de voorspellingen en het doel kunnen minimaliseren
en de voorspellingen kunnen krijgen.
We hebben de inputs nodig omdat we onze hersenen op de inputs gaan toepassen om de outputsignalen te krijgen.
Dat zullen onze voorspellingen zijn.
En zodra we onze voorspellingen en ons doel hebben, zijn we klaar om de A te trainen. L. door te proberen de
vierkante afstand tussen de voorspellingen en de doelen te minimaliseren.
Dus dat is het hele punt om dit te doen.
Nu.
We implementeren deze functie om deze invoer en deze doelen te kunnen retourneren, zodat we klaar
kunnen zijn voor de training om de vierkante afstandsvoorspellingen minus doelen te minimaliseren.
Oke.
Dus laten we dit doen.
Zoals we al zeiden, willen we functies implementeren.
We beginnen met def deze functie.
We gaan het een leesbaarheidsonderstreping Trece noemen.
Je kunt het ook Sauza noemen, je kunt het ook noemen en stap draaien wat je wilt, maar laten we
het geschiktheidskeuze noemen.
En deze functie neemt één argument mee, wat een batch zal zijn.
En waarom dat.
Het is omdat we wat input en wat doelen gaan krijgen, omdat we de AI op batches gaan trainen
en dus zullen de inputs en het doelwit in sommige batches gaan.
En daarom is het invoerargument hier deze batch die verschillende invoer zal bevatten en vervolgens verschillende
doelen die we zullen berekenen zodat we gaan.
Dat is het enige argument dat we nodig hebben.
Laten we nu naar de functie gaan en definiëren wat we moesten doen.
Dus zoals we in de code van het papier zagen, hebben we een gammaparameter nodig.
Dus zoals we al zeiden, beginnen we met het introduceren van deze gammaparameter.
Dus gamma is gelijk aan en we kunnen al beslissen voor waarde en we gaan vier komma negenennegentig kiezen.
Dat is een klassieke goede waarde voor de Gamma en Nori's.
Ik heb gecontroleerd of dit een goede waarde is voor onze AI.
Goed dan volgende stap.
De volgende stap is om onze input voor te bereiden.
En zijn doelen, want dat is precies wat we willen retourneren, we willen de inputs en de doelen
teruggeven om de training voor te bereiden, en dus kunnen we ze al initialiseren met een lege lijst, want natuurlijk, in
deze inputs binnen de beste, we gaan verschillende ingangen allemaal in een lijst hebben.
En daarom initialiseer ik de invoer als een lijst, evenals de doelen die we gaan.
Dus hebben we onze input en ons doel geïnitialiseerd.
En uiteindelijk zal deze functie voor geschiktheidskeuze precies deze invoer en deze doelen retourneren.
Maar natuurlijk, Filton, we zullen verschillende inputs hebben en de bijbehorende verschillende doelen in wat door de
functie wordt geretourneerd.
Oke.
De volgende stap is het starten van een volledige lus.
En dat is precies omdat we de pseudocode van het papier volgen, deze set code.
En zoals je kunt zien, is er dit herhaalcodegedeelte en herhaal het.
Precies een volledige lus.
En dus de code die we gaan berekenen, de cumulatieve beloning hier verzameld over de 10 stappen.
En hoe wordt het berekend?
Welnu, bij elke stap is dat niet de laatste stap.
Hierbij gaan we het maximum halen uit de kernwaarden van de huidige staat waarin we ons bevinden.
En laten we rennen.
En als we de laatste acht tot tien stappen bereiken, nou, dan is dit gelijk aan nul.
Dat wil zeggen, we willen het niet meer dateren.
En dan hebben we deze for-lus, die weer een for-lus wordt.
Ze zeggen hier niet herhalen, maar dat is hetzelfde.
Het wordt een second-for-lus in ons algoritme.
Nou, dat gaan we updaten.
We werkten op deze manier door het te vermenigvuldigen met de vervalparameter gamma en de beloning toe te voegen.
Dus laten we dit doen.
Laten we teruggaan naar Python en laten we beginnen met onze volledige lus tot nu toe.
En wat wordt de iteratieve variabele?
Nou, dat wordt onze reeks van tien stappen, je weet wel, onze reeks van tien overgangen.
Dus we gaan deze variabele reeksen noemen die een reeks van tien overgangen voorstellen, zoals een reeks van
tien overgangen.
Dus vier series binnen.
En wat denk je dan?
Nou, onze serie wordt gedaan met onze batch.
Dat zijn de banken waarop we de A gaan trainen. L. enzovoort, serie en batch, dat is
voor alle series van tien overgangen in onze invoerbatch.
Wanneer gaan we er goed aan doen om een cumulatieve beloning te krijgen?
Je ziet een absolute code dat we de staat van de eerste overgang van de reeks nodig hebben en ook de
staat van de laatste overgang van de reeks.
Dus wat we nu moeten doen, is deze invoerstatussen krijgen.
En dus gaan we deze twee invoerstatussen in een variabele plaatsen die we invoer gaan noemen
en we krijgen deze twee invoerstatussen, de eerste van de reeks en de
laatste die we in een nummer array.
Maar geen zorgen.
We blijven niet bij dit nummer.
Dat zetten we natuurlijk om in een totale terugroepactie.
Maar de eerste stap is om deze twee invoerstaten, de eerste in de laatste, in een rijk te plaatsen.
En dus hier in deze Nampara, voegen we de eerste invoer toe, wat de invoerstatus is van de eerste overgang van
de reeks.
En dat is een serie.
En om dan de eerste overgang te nemen, nemen we de index nul van de reeks, dat is de
eerste overgang, en dan kunnen we er toegang toe krijgen door zijn attribuut te nemen, namelijk staat.
En dat is omdat we in onze ervaring het gevoel hadden dat we een speciale structuur hadden gedefinieerd voor elk van de overgangen.
En, weet je, de structuur, elke overgang is samengesteld uit een toestand, een actie, een beloning.
Maar dan het laatste element dat wordt gedaan.
Dus deze speciale structuur die we nu mochten gebruiken, komt voort uit de manier waarop we een overgang en ervaring
hebben gedefinieerd.
We.
Oke.
Dus hiermee krijgen we de invoerstatus van de eerste overgang.
En laten we nu ook de invoerstatus van de laatste overgang van de reeks bekijken.
En om dit te doen, is dat hetzelfde.
We kunnen dit gewoon kopiëren.
En geplakt en vervangen, zoals je hier bent, door de laatste index van de serie, waartoe we toegang hebben met deze
truc, min één serie, min één, dat gezegd hebbende, we krijgen de invoerstatus van de laatste uitzending van de
serie .
Oké, dan moeten we deze twee elementen tussen vierkante haken plaatsen.
Want dat is wat de Nampara-functie verwacht en dan is het belangrijk om te doen, omdat
we dat gaan omzetten in een toortssensor in een toortsvariabele.
Wel, onthoud, een toortssensor is per definitie een speciale array met één enkel type.
En dus moeten we afdwingen om één enkel type te hebben.
En zoals gewoonlijk kiezen we het vlottertype en sommigen voegen deze parameter hier toe, D-type is gelijk
aan en P dat zweeft, zodat je deze kunt nemen en nu kunnen we dat omzetten in een toortssensor in een toorts.
Dus laten we dit doen om dit te doen.
Laten we dat eerst omzetten in een toortssensor.
En onthoud, we kunnen de toorts gebruiken van non-pay.
Daar gaan we, en we plaatsen de hele reeks van de Verenigde Staten in deze toortsspanner met de toorts
van hen per functie, perfect.
Dus dat zal deze arrays van de twee invoeren in een toortssensor omzetten.
En nu stoppen we deze zaklampsensor in een zaklamp.
Heel goed gebruik van het variabele glas.
Dus invoer zal een object zijn van de verbale klasse en in feite, zoals je hebt begrepen, neemt deze variabele klasse
dit alles als een argument en dat creëert het object.
Oké, dus nu zouden we goed moeten zijn, we hebben onze twee inputs die we nodig hebben, dat is de inputset
van de eerste transitie en de inputstatus van de laatste transitie.
En nu we de input hebben, wat kunnen we krijgen?
We kunnen het uitgangssignaal van de hersenen van de A krijgen. L. Dat is de voorspelling.
Maar we gaan het output noemen.
Dat is het uitgangssignaal.
En om de output te krijgen.
Nou, dat is heel gemakkelijk omdat we al een brein hebben gecreëerd, wat ons convolutionele neurale netwerk is,
en dus kunnen we gewoon ons brein nemen.
CNN toegepast op de invoer die de voorspelling zal retourneren, dat is de uitvoer zo simpel als dat.
En nu zijn we al klaar om door te gaan naar de volgende stap.
En de volgende stap is om deze cumulatieve beloning te gaan berekenen.
Dus nu gaan we precies hetzelfde doen als ons S2-algoritme, de schotel, of moeten we het insteps learning
noemen?
We gaan de Kumu-beloningsvariabele introduceren, die de cumulatieve beloning zal zijn.
Laten we teruggaan naar het papier, zoals je nu kunt zien, wat we moeten doen om deze cumulatieve
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
aan deze cumulatieve beloning.
Als we de laatste fase van de reeks of het maximum van de kernwaarden hebben bereikt, als we de laatste fase van de reeks
niet hebben bereikt, dat is voor alle stappen behalve de laatste stap.
Laten we dit dus gewoon implementeren.
Laten we teruggaan naar Python.
Dus deze gemeenschapsbeloning, zoals we net zagen, zal gelijk zijn aan nul komma nul als.
We hebben de laatste staat bereikt en we kunnen deze toestand op deze manier berijden, als een reeks van index minus één de
laatste uitzending van de reeks is, dan hebben we dat gedaan omdat er eigenlijk een attribuut is van deze
overgangsstructuur die we hebben gedefinieerd en ervaren .
We spelen op onze kosten, we spelen fout.
En deze komt eigenlijk van de openingsstructuren, want als we naar de Open Air-website gaan, die eigenlijk
hier is, heb ik die voorbereid.
Dat is de ondergang van V0.
En als we naar de documentatie gaan en als we dat doen, dan is dat de tutorial.
Ik moedig je echt aan om er eens naar te kijken.
U kunt een omgeving uitvoeren.
Dan kun je meestal zien dat onze waarnemingen die als onze overgangen worden gedefinieerd door een waarneming, een beloning
en dat hier gedaan en gedaan wordt, precies betekent dat een overgang of een stap voorbij is.
En dus gaan we dit hier gebruiken voor onze if-conditie.
Daarom, als er min één punt is gedaan, betekent dat als de laatste uitzending van de serie voorbij is, is voltooid.
En dus zal deze cumulatieve beloning gelijk zijn aan nul als de laatste uitzending van de
serie is gedaan en anders als we de laatste uitzending niet hebben bereikt.
Welnu, cumulatieve beloning zal worden bijgewerkt met, zoals we al zeiden, het maximum van de belangrijkste waarden.
En aangezien deze output hier de output van de hersenen is, zijn dat de voorspellingen van het neurale netwerk.
En zoals je weet, zijn de voorspellingen van het neurale netwerk de voorspelde waarden.
Welnu, deze uitvoer bevat de belangrijkste waarden.
En aangezien we de volgende van de sleutelwaarden moeten nemen, moeten we eerst deze index nemen, omdat
deze structuur de sleutelwaarden in de indexwaarde bevat.
En dan moeten we gegevens toevoegen om toegang te krijgen tot de gegevens van deze uitvoerstructuur.
Weet je, het heeft de speciale structuur van een fakkelvariabele.
Dus hiermee halen we onze kernwaarden en dan willen we het maximale uit onze kernwaarden halen.
En dus voegen we dat eenvoudig toe en nu krijgen we precies wat we willen, zoals in de krant, dit maximum van
de kernwaarden voor de niet-terminale staat als t perfect.
Wat we nu gaan doen, is de tweede volledige lus maken.
Dat is voor de tien stappen van de serie.
We gaan het cumulatieve werk op deze manier bijwerken door eerst te vermenigvuldigen met GEMAP, de vervalparameter, die we al hebben,
en dan de beloning toe te voegen.
Dus laten we dit doen.
We gaan eigenlijk precies hetzelfde doen als in de code.
Zoals je kunt zien, beginnen ze van rechts.
Ze beginnen dus niet met de eerste stap en gaan naar de laatste stappen.
Ze beginnen met de laatste stap T min één tot de eerste stap om te beginnen.
Dus dat is precies wat we daarin gaan doen, omdat we uiteindelijk
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
de macht van tien of tien.
Waar zijn er een of twee die tien zijn, zijn de beloningen die worden verkregen in elk van de stappen van de serie.
Dus laten we een korte pauze nemen voordat we de tweede volledige lus nemen en ik zie je in de volgende Atauro.
Tot die tijd, geniet van I.