Hallo en welkom bij deze Python-tutorial.
Oke.
Nu, in de volgende functie die we gaan implementeren, zullen we het diepe neurale netwerk trainen dat
zich in onze kunstmatige intelligentie bevindt.
Dus eigenlijk gaan we het hele proces van voorwaartse voortplanting en dan terugvermeerdering doen.
Dat wil zeggen, we gaan onze output krijgen.
We gaan het doelwit halen.
We zullen de uitvoer vergelijken met het doel om de laatste fout te berekenen.
Dan gaan we deze fout terug propageren in het neurale netwerk.
En met behulp van stochastische gradiëntafdaling, zullen we moeten wegen op basis van hoeveel ze hebben bijgedragen aan de
laatste fout.
Dus laten we dit allemaal doen voor degenen onder jullie die van het diepe komen, want dit zal goed spul zijn.
Maar voor de anderen, maak je geen zorgen, ik ga dat nog eens uitbreiden.
Dus we gaan deze nieuwe functie leren noemen.
En voor deze leerfunctie zijn verschillende argumenten nodig.
Eerst zichzelf natuurlijk, die zal verwijzen naar het object van de klasse.
Dan nemen we onze batchstatus voor de huidige status, dan is onze batchstatus die
beloning.
En tot slot, onze partij.
Actie.
Dus waarom nemen we dit, je herkende waarschijnlijk wat de serie is?
Nou, dat is natuurlijk een transitie, een transitie van het marktbeslissingsproces dat aan de basis ligt
van deep learning.
En waarom nemen we ze allemaal in sommige batches?
Wel, dat is omdat, weet je, onthoud, we beschouwen de overgangen niet door een reeks van om de huidige
staat omver te werpen naast de huidige beloning en huidige actie.
We hebben hier enkele eenvoudige batches gemaakt dankzij de eenvoudige functie.
En dus zijn onze overgangen nu in de vorm van een eerste batch voor de staat, een tweede batch voor de volgende, een
batch voor de beloning en een batch voor de actie.
Dat is de vorm van onze overgangen nu.
En ze zijn allemaal goed uitgelijnd met betrekking tot tijd, dankzij deze aaneenschakeling die we hier hebben gemaakt met
betrekking tot de eerste dimensie.
Dus het punt is dat we nu deze overgang van batches hebben, één batch voor elk van de staat, volgende datums,
beloning en actie.
En we doen dit allemaal omdat we deze ervarings-replay-truc gebruiken.
Dus dat is dat ons diepe neurale netwerk iets kan leren.
Onthoud dat als we alleen de overgangen alleen zouden hebben, wat het zou zijn om direct te leren of als
je heel kort geheugen wilt leren en daarom zou de modus niets leren.
We moeten dus deze batches uit het geheugen halen die onze overgangen worden, en uiteindelijk zullen we de verschillende
outputs krijgen voor elk van de statussen van de inputbatchstatus.
En we zullen dit doen voor de betere staat en voor de volgende staat, omdat we beide nodig hebben om het verlies te
berekenen.
Ik zal binnenkort de balansvergelijking herinneren die de kern vormt van het deep learning-algoritme.
Dus laten we nu naar de functie gaan en eerst de outputs van de slechte staat krijgen.
Dus ik ga deze eerste variabele outputs noemen en dan gaan we natuurlijk ons
zelf nemen, dat model, dus zelf dat model, omdat we onze modeloutputs willen krijgen van de input staten van de staat.
En aangezien ons model eigenlijk een batch invoerstatus verwacht, kunnen we die status nu volledig invoeren voor
de invoer van het model.
Dat is precies hoe we de toestanden hebben geïnitialiseerd die het netwerk binnengaan met de toorts-tensor met deze
nep-dimensie voor de batch.
Dus dat is perfect.
We krijgen nu de output van het model.
Maar dan is er nog een technische truc.
Als we alleen dat model in een slechte staat doen, nou, dan krijgen we de resultaten van alle mogelijke acties, je weet wel, nul,
één en twee.
Maar dat is niet wat we willen.
We zijn alleen geïnteresseerd in de acties die zijn gekozen, de acties die door het netwerk zijn besloten om op
elk moment te spelen.
En dus om deze actie te krijgen waar we in geïnteresseerd zijn, zijn de acties die goed worden gespeeld.
We moeten deze verzamelfunctie gebruiken waarin we er een invoeren omdat we alleen de actie willen die is gekozen.
En dan voegen we hier Bache-actie aan toe, de ene en de match-actie.
We zullen elke keer de beste actie verzamelen om te spelen voor elk van de invoerstatussen van de staat.
We willen alleen de actie die wordt gespeeld, de actie die wordt gekozen, en we krijgen dit met
deze andere en batchactie.
Maar wees dan voorzichtig.
De batchstatus hier heeft deze nepdimensie die overeenkomt met de batch en batchactie heeft deze
niet terug.
State heeft het omdat we de untwist hier gebruiken, maar we hebben er geen op squeeze gebruikt voor de acties.
Dus we moeten het hier toevoegen zodat de batchactie exact dezelfde dimensie heeft als de slechte staat.
Dus we gaan een stip toevoegen op scherm nul.
Hier en eigenlijk is dit niet nul, maar één omdat nul overeenkomt met de geloofsdimensie van de staat en
één zal overeenkomen met de geloofsdimensie van de acties.
En tot slot, het laatste dat we hier moeten doen, is dat we deze nep-batch met een kneep moeten doden.
En waarom moeten we dat doen?
Omdat we nu uit het neurale netwerk zijn.
We hebben onze outputs, maar we willen ze niet in een batch.
We willen ze.
En het simpele antwoord is simpele vector een vector van outputs.
De batch is precies wanneer we in het neurale netwerk werken, omdat het neurale netwerk het formaat
van sensoren in een batch verwacht.
Maar nu hebben we onze output en in de volgende balansvergelijking van de Deepu-learning hebben we ze niet in een
batch nodig.
Dus ik vermoord de batch hier en dood de nep-dimensie om de eenvoudige vorm van onze output terug te krijgen.
Dus ik voeg hier gewoon een punt toe en knijp dan.
En dan omdat ik de nep-dimensie die overeenkomt met de batch van de actie wil doden.
Omdat deze nep-dimensie er een heeft geïndexeerd, voeg ik er hier een toe.
Oke.
En nu we gaan, hebben we onze output, oké?
We hebben een kleine waarschuwing.
Wat is het?
Lokale variabele uitgangen worden toegewezen maar nooit gebruikt.
Dat is goed.
We zullen het heel snel gebruiken.
Dus dat is onze output.
En nu willen we onze volgende krijgen.
Uitgangen.
Dus nu denk je misschien, waarom hebben we de volgende output nodig?
Om dit te begrijpen, moeten we teruggaan naar het deep learning-algoritme, dat hier staat.
Dat is onderdeel van het logica-handboek.
Dus dat is het hele decoderingsproces.
In het begin initialiseerden we alle sleutelwaarden en vervolgens op elk moment, T..
Nou, daar gaan we.
We selecteren de actie.
Wij Softmax, dat hebben we gedaan met de select action-functie.
Dan openen we de overgang.
En dan, zoals je kunt zien, krijgen we de voorspelling, krijgen we het doelwit en kunnen we de laatste zijn.
Dus waarom hebben we de volgende uitgangen ook nodig?
Dat komt door het doel.
Het doel is gelijk aan gammatijden, de volgende output plus de beloning.
En we zullen het doel direct daarna berekenen.
Maar aangezien we de volgende uitvoer voor het doel nodig hebben, laten we dit eerst berekenen.
Dus nogmaals, om de volgende uitvoer zo eenvoudig te krijgen, zal de volgende uitvoer het resultaat zijn
van ons neurale netwerk wanneer de batch volgende datum het als invoer invoert.
Dus heel eenvoudig, we nemen ons model dat ons neurale netwerk is, en deze keer zal de invoer van
het neurale netwerk de batch volgende status zijn.
De beste volgende datum, maar onthoud nu, als we teruggaan naar het deep learning-algoritme, wel, je
kunt zien dat de volgende uitvoer het maximum is van de waarden voor de volgende status met betrekking tot alle acties.
Dus op dit moment, om de volgende uitvoer te krijgen, moeten we het maximum van deze waarden krijgen.
En daarom ga ik hier een detach doen, weet je, om alle outputs van het model los te koppelen, omdat we
verschillende toestanden in deze batch hebben.
Volgende toestanden, dat is de batch van alle volgende toestanden in alle overgangen uit de willekeurige steekproef van ons
geheugen.
Dus ik ontkoppel ze allemaal met behulp van de detach-functie, en dan neem ik het maximum van al deze
sleutelwaarden.
En aangezien we het maximum van deze waarden nemen met betrekking tot de actie, moeten we specificeren dat dit is
met betrekking tot de actie.
En aangezien de actie wordt vertegenwoordigd door de index één, nou ja, nogmaals, we moeten de index één hier plaatsen
en dan moeten we specificeren dat we de kernwaarden van ESTIE plus één nemen.
Dat is de volgende datum en de volgende datum wordt weergegeven door de index nul omdat de index nul overeenkomt met
de staat.
En daarom moeten we hier haakjes toevoegen met de index nul.
Op die manier krijgen we het maximum van de waarden die de volgende staat vertegenwoordigd door de index
nul volgens alle acties die worden vertegenwoordigd door de index één en hoe perfect we onze volgende output krijgen.
Dit is een nieuwe stap.
Daarom hadden we de waarschuwing.
Maar dat is prima.
We zullen het nu gebruiken om het doel te berekenen.
En over het doel gesproken, dat is de volgende stap van deze leerfunctie.
Dus daar gaan we.
Doel is gelijk aan.
Laten we nu teruggaan naar ons handboek.
Het doel is gelijk aan de beloning.
Plus gamma-tijden.
De volgende output is het maximum van de waarden in de volgende toestand volgens de acties.
Dus daar gaan we.
Laten we dat doen.
Dus dat is gelijk aan jezelf.
Dat Gamma en Zelda Gamma is geïnitialiseerd.
Hier wordt het geïntroduceerd.
Dat is een variabele van een object-gecentreerde gamma-tijden.
De volgende output, zoals we net zeiden, plus de beloning.
Dat is de beste beloning.
We werken hier met patches.
Dus plus-batch.
Beloning, en dat is het doelwit in één symbool van het geheugen, gemap vermenigvuldigd met de volgende output, plus de
beloning.
Oké, perfect.
Dus nu hebben we onze output's.
We hebben ook ons doel en daarom kunnen we het verlies berekenen, het verlies dat de fout van
de voorspelling vertegenwoordigt.
Dus laten we dit verlies T noemen. G. verlies TDRS, natuurlijk, voor het temporele verschil dat, nogmaals, de kern
vormt van Q Learning.
En dit verlies zal gelijk zijn aan het besef van de WHO dat het leren veel verbetert.
Dat is de verloren functie die we zullen kiezen voor onze kunstmatige intelligentie.
Voor degenen onder u die van de deep learning-cursus komen, is dat echt de laatste die ik aanbeveel als
u deep learning wilt implementeren.
En hoe gaan we dit Hueber-verlies krijgen?
Nou, nogmaals, we gaan een functie nemen van de functionele module vertegenwoordigd door F, en
daarom ga ik hier onze functionele module F gebruiken.
En de Hubble kan worden verkregen dankzij de functie smooth's L1 Luss, die zo presidenta is.
En dat is echt de beste verloren functie die ik aanbeveel voor diep.
V Leren.
Het verbetert echt het Q-leren, maar dit is een functie, dus ik voeg wat haakjes toe en nu
is er niets eenvoudiger.
De argumenten die we moeten invoeren zijn de voorspellingen en de doelen.
Dus de voorspelling is natuurlijk onze output, want dat is de output van het neurale netwerk.
Weet je, de output van het neurale netwerk is wat het neurale netwerk voorspelt.
Dat is dus de voorspelling.
Het eerste argument hier is dus outputs.
En dan is het tweede argument natuurlijk het doelwit.
Het ding dat we proberen te krijgen en het is al perfect berekend, we kunnen direct doelen invoeren.
Perfect.
En nu hebben we de VS gewoon een beetje vergeten hier.
Daar gaan we.
Nu zou de waarschuwing moeten verdwijnen.
Ja perfect.
En nu we de laatste fout hebben, kunnen we deze fout terug in het netwerk propageren om de gewichten
bij te werken met stochastische gradiëntafdaling.
En dat is precies wat we gaan doen in de volgende stap.
Dus wat we nu natuurlijk moeten doen, zoals je zou kunnen raden, is onze optimizer, onze optimizer,
die we hier opnieuw introduceren.
We hebben het geïnitialiseerd.
En dat is een Atom Optimizer, die eigenlijk een object is van de Atom-klasse.
En het is al uitgerust met de parameters van ons model.
En we kozen al voor een leersnelheid van 0. 01 procent.
Zo perfect, onze optimizer is klaar, maar nu moeten we hem toepassen op de laatste fout om een stochastische gradiëntafdaling uit
te voeren.
En als ze dat doen bij het werken met jagers, is het eerste wat we moeten doen, het bij elke iteratie van de
lus opnieuw te initialiseren.
We moeten de optimizer van de ene interation naar de andere in de lus hiervan opnieuw initialiseren om de gradiëntafdaling te krijgen
en deze bij elke iteratie van de lus opnieuw te initialiseren.
Welnu, we gaan de volgende methode gebruiken, die nul gret is.
Daar gaan we.
Zero gravity zal uw optimizer bij elke iteratie van de lus opnieuw initialiseren.
Laten we dan de haakjes niet vergeten.
Perfect.
En nu het opnieuw is geïnitialiseerd, kunnen we achterwaartse voortplanting uitvoeren met onze optimizer.
En hoe doen we dat?
Welnu, we nemen ons verlies en we gaan het terug naar het netwerk verspreiden en het terug naar het
netwerk verspreiden.
We moeten de achterwaartse functie gebruiken en binnen deze achterwaartse functie raad ik aan om variabelen in te voeren, te
behouden, te onderstrepen en gelijk te stellen aan waar.
Ik raad aan om dit te doen omdat dit de terugvermeerdering zal verbeteren.
Het gebruik van retourvariabelen is gelijk aan waar om wat geheugen vrij te maken en we moeten het geheugen vrijmaken
omdat we meerdere keren op het verlies gaan.
Dus dat zal de trainingsprestaties zeker verbeteren.
En tot slot, de laatste stap van deze leerfunctie is het bijwerken van de gewichten volgens de achterwaartse voortplanting.
Dat is in overeenstemming met hoeveel het gewicht heeft bijgedragen aan de fout.
En om dit te doen, nemen we onze optimizer opnieuw, die werd geïnitialiseerd en opnieuw geïnitialiseerd, en we
gebruiken de stapfunctie.
En gewoon met deze regel code, door de stapfunctie te gebruiken, worden de gewichten bijgewerkt.
Dat is deze regel code die wordt bijgewerkt naar gewicht, deze regel code die de fout in het neurale
netwerk verspreidt.
En deze regel code gebruikt de optimizer om de gewichten bij te werken.
En dan gaan we, we hebben een lerend neuraal netwerk.
Oké, dus gefeliciteerd.
Dit was waarschijnlijk het meest technische en moeilijkste deel van dit diepgaande leermodel waarvan ik weet dat het tegenwoordig soms
lastig kan zijn met deze op knijpen en knijpen.
Maar uiteindelijk, beloof ik, krijg je een zeer functioneel neuraal netwerk en dus
een diepgaand leermodel en uiteindelijk een geweldige kunstmatige intelligentie.
Dus laten we nu verder gaan met de volgende stap van ons deep learning-model, de update-functie die uiteraard wordt
bijgewerkt wanneer de A. L. zal de nieuwe staat ontdekken.
Dus, weet je, het zal de nieuwe staat ontdekken en dan zal het de beloning ontvangen, afhankelijk van
de actie die wordt weergegeven en deze nieuwe staat.
We zullen dit dus regelen met de update-functie en dit zullen we doen in de volgende tutorial.
Tot die tijd, geniet van A. L..