Hallo en welkom bij deze Python-tutorial in deze tutorial, we gaan de eerste stap zetten in het
implementeren van het deep learning-model.
Dus eigenlijk staan we op het punt om het hele proces van het algoritme te implementeren.
En dus gaan we gebruiken wat we eerder hebben gemaakt.
Dat is de architectuur van het nieuwe netwerk om geheugen te vervangen, om dit te integreren in het hele
deep learning-proces.
En dit hele algoritme voor het leren uit de wachtrij gaat in één klas passen.
Dus dat is de laatste taak die we maken om kunstmatige intelligentie te implementeren.
En deze klasse zal gewoon verschillende functies bevatten.
We zullen dus de energiefuncties hebben die alle variabelen die aan onze toekomst zijn gekoppeld, zullen creëren en
initialiseren.
Deep learning-objecten, die zelf een deep learning-model vertegenwoordigen.
En dan hebben we nog wat andere functies.
Een daarvan zal natuurlijk zijn om op elk moment de juiste actie te selecteren.
We zullen ook een update-functie hebben als kernfunctie om deze kern te krijgen en een idee te hebben van hoe het
leren gaat.
Als het goed gaat, als de verkenning goed gaat, en als het kan overgaan tot exploitatie, en dan hebben we
dezelfde functie om het model te redden, namelijk het brein van de auto redden en uiteindelijk
een laadfunctie .
We moeten dus een aantal functies maken.
We gaan één functie maken voor elke Statoil.
En vandaag gaan we zoals gewoonlijk beginnen met de init-functie als we een klas maken.
Maar laten we eerst niet vergeten de klas voor te stellen.
Dus we gaan het diep noemen.
V En voor een diep netwerk, dan een paar haakjes.
Kullen en daar gaan we met onze eerste functie.
Dus laten we deze def doen, dan verdubbelen en scoren.
Het onderstreept niet opnieuw en haakjes.
Dus zoals je in deze init-functie hebt begrepen, gaan we de variabelen introduceren die aan ons object
zijn gekoppeld.
We zullen dus een aantal regels hebben die helemaal vanzelf beginnen en we zullen in principe alle variabelen
creëren en initialiseren die nodig zijn om een diep Q-netwerk te implementeren.
We gaan dus bijvoorbeeld een object of netwerk maken omdat we natuurlijk ons diepe neurale netwerk nodig hebben.
Dan hebben we ons geheugen nodig.
We zullen een andere variabele voor het geheugen maken.
Dus we zullen een andere variabele zelf hebben, dat geheugen.
Maar dan is dat niet alles wat we ook zullen moeten creëren.
Enkele variabelen voor de laatste datum, de laatste actie en de laatste beloning.
Dat zijn natuurlijk de variabelen die je ziet in het deep learning-algoritme.
En wat dan nog?
We hebben ook een optimalisatieprogramma nodig om een stochastische gradiëntafdaling uit te voeren om de gewichten
bij te werken op basis van hoeveel ze zullen bijdragen aan de fout wanneer de AIA een fout maakt.
En dan denk ik dat dat dus eigenlijk de variabelen zijn die we nu moeten maken en initialiseren.
Maar in deze eindfunctie zullen we een aantal argumenten invoeren.
Eerst, zoals gewoonlijk, zelf, dat zijn de argumenten die verwijzen naar ons object.
Sindsdien, weet je, gaan we een object van de netwerkklasse maken.
Welnu, aangezien de netwerkklasse zijn argument opneemt in de invoergrootte van de functie init en de actie, is dat
hier hetzelfde.
Wanneer we een object van de netwerkklasse maken, moeten we een argument voor de invoergrootte kiezen en
het actieargument beëindigen.
Daarom kunnen we ze gewoon kopiëren.
En.
Ze hier en daar gaan we.
Dus deze argumenten worden nu ook enkele argumenten van de klas wanneer we toekomstige objecten van de andere klas
maken, dat wil zeggen enkele toekomstige modellen voor diep leren.
Welnu, we zullen de invoergrootte moeten specificeren, waarvan ik eraan herinner dat het een aantal dimensies is
en de vectoren die uw staat, uw invoerstatussen en een aantal acties omvatten, wat een aantal mogelijke acties is die
de auto kan uitvoeren.
Dus ik herinner eraan dat deze ofwel links, rechtdoor of rechtsaf zijn.
Oke perfect.
Dan, weet je, zullen we een object van de replay-geheugenklasse maken om het geheugenobject te
maken om ons geheugen van de overgangen te krijgen en in de eindfunctie hebben we het capaciteitsargument.
Maar aangezien we het maar één keer zullen gebruiken, eigenlijk wanneer we een geheugen maken
en niet ergens daarna, hoeven we geen capaciteitsargument op te geven.
We zouden dit kunnen doen, maar we zullen direct het aantal overgangen invoeren dat we willen dat ons geheugen heeft.
Maar dan hebben we nog een laatste argument nodig, namelijk de GEMAP-parameter in het diepe Cutrone-model.
Onthoud dat deze gammaparameter de vertragingscoëfficiënt is.
Dat is een barometer van de vergelijking.
En daarom zullen we het hier plaatsen omdat we het daarna meerdere keren zullen gebruiken.
Dus laten we het hier plaatsen.
We gaan het Gamma noemen.
Dus daarvoor is alleen de naam van het argument.
En dan gaan we dat alle argumenten nodig zijn voor deze init-functie.
Dus dat betekent dat wanneer we ons diepe KRY-model maken, dat is wanneer we een object van de
klasse maken, we als argumenten de invoergrootte, het aantal acties en de gamma-parameter moeten specificeren en
de echte waarden zullen opnemen voor hen.
Oke.
Laten we nu naar de Init-functie gaan.
OK, dus nu wordt dit in principe gemakkelijk.
We staan op het punt om alle variabelen te maken en te initialiseren die we nodig hebben.
En laten we beginnen met de eerste.
Laten we beginnen met Gamma.
Eigenlijk de vertragingscoëfficiënt.
Dus omdat dit een variabele is, willen we aan ons object worden gehecht.
We beginnen bij onszelf.
Dus Gamma wordt een variabele van ons DeQuan-model.
Dus zelf dat gamma is gelijk aan de argumenten die worden ingevoerd bij het maken van een object van de klasse.
Gamma dus.
En dan gaan we met het tweede argument naar het tweede argument, het beloningsvenster.
Dus wat betekent dit beloningsvenster?
Nou, dat wordt het glijdende venster van het gemiddelde van de laatste honderd beloningen, dat alleen zal worden
gebruikt om de evolutie van de prestatie te evalueren, weet je, het gemiddelde van de beloning in dit beloningsvenster dat
in de loop van de tijd zal verschuiven .
En wat we willen observeren is een gemiddelde van de laatste honderd beloningen die met de tijd toenemen.
Dus laten we het initialiseren met zelf, dat beloningsonderstrepingsvenster.
En aangezien dit een schuifvenster wordt van de evoluerende betekenis van de laatste honderd beloningen, gaan we het initialiseren
als een lege lijst en dan zullen we het gemiddelde van de beloningen in de loop van de tijd
bekijken.
Oké, spannender, laten we ons neurale netwerk maken.
We gaan het dus een autodidactisch model noemen, want dat is in feite het hart van het model.
Dus ik noem het model.
En dit model zal niets anders zijn dan een object van de netwerkklasse en om zo'n object te
maken.
We nemen ons klassennetwerk, dan haakjes, en hier voeren we alleen de argumenten van de netwerkklasse in.
Maar we plaatsen deze argumenten in de argumenten van de init-functie en daarom hoeven we ze alleen
maar hier te kopiëren en ze in de netwerkklasse te plaatsen.
En dan gaan we met deze regel code.
We creëren één neuraal netwerk voor een grappig model.
Perfect, laten we dan een herinnering maken.
Dus nogmaals, we gaan een nieuw logo maken dat we zelf dat geheugen noemen.
En nogmaals, dit wordt een object van de replaying memory-klasse.
Dus laten we gewoon de naam van onze klas nemen.
Laten we het kopiëren.
Laten we dat hier onder ogen zien.
En tussen sommige haakjes moeten we de capaciteit invoeren omdat de capaciteit een argument is van de
Init-functie.
En dat is het enige argument dat we hier hoeven in te voeren.
Dus welke capaciteit gaan we kiezen?
Onthoud dat dit overeenkomt met het aantal overgangen, het aantal gebeurtenissen, de laatste acht nieuwe staat, de
laatste actie en minder beloning.
En dus, zoals vermeld in een van de vorige, gaan we honderdduizendhonderdduizend overgangen in het geheugen nemen en
dan zullen we uit dit geheugen monsters nemen om een klein aantal willekeurige overgangen
te krijgen.
En daar zal het model van leren.
OK, dus nu hebben we ons geheugen perfect.
Laten we er nu voor gaan.
Dus nogmaals, zelf, we creëren een nieuwe variabele die we optimizer noemen.
Dus optimizer is een andere variabele van onze toekomst, een object uit de wachtrij halen, dus zelf
die optimizer, en als we nu teruggaan, kun je zien dat we geïmporteerd hebben naar die AP'TIN, een module van torch
die alle tools bevat om stochastische gradiëntafdaling uitvoeren.
Dus het bevat natuurlijk enkele optimizers en we hebben het de snelkoppeling gegeven.
Upton en daarom gaan we hier de uptime van het model nemen, die zo optimaal is.
En uit deze module gaan we een van de optimizers nemen.
Dus zoals je kunt zien, worden ze hier allemaal vermeld.
Velen van hen zijn uitstekend.
Armis Prop is bijvoorbeeld een uitstekende optimizer die bijvoorbeeld sterk wordt aanbevolen voor reguliere neurale netwerken
of afhankelijk is van onbewaakt.
Maar de andere die uitstekend is en die we zullen kiezen, is de atom-optimizer.
Dat is degene waarmee je dat zult zien.
Deze krijgt een goede zelfrijdende auto.
Maar nogmaals, je bent van harte welkom om andere te proberen.
Je kunt de armsteun proberen, maar als model zullen we Adam kiezen.
Dus ik druk op enter.
En in feite merk je dat er hier een AI met een hoofdletter is.
Dat komt omdat we een object van de atoomklasse maken.
Dit is een klasse, maar het object zal zelf een atom-optimizer zijn.
Maar aangezien dit een klasse is, moeten we enkele argumenten invoeren.
De argumenten van de atoomklasse en de argumenten of alle parameters die uw atoomoptimalisatieprogramma kunnen
aanpassen.
Dat is bijvoorbeeld typisch de leersnelheid, het verval of andere parameters.
En naast het nemen van alle parameters van ons model, zullen we een leersnelheid specificeren.
Dus als we het hebben over de parameters van ons model, we kunnen ze krijgen met onszelf, dat model.
Dus dat is het model dat we hier hebben gemaakt.
Autodidactisch model uit onze netwerkklas.
Een soort model dus.
En om vervolgens de parameters van het model te accepteren, voegen we heel eenvoudig nog een punt toe en vervolgens parameters tussen
haakjes.
Dus dat is alleen om de Atom Optimizer te verbinden met ons neurale netwerk, degene die we hier opnieuw hebben gemaakt.
Zoals we net zeiden, gaan we een leersnelheid toevoegen en het argument hiervoor is een R en we zullen
deze gelijk stellen aan een waarde zodat het leren niet te snel gebeurt.
Als we een leertempo te groot krijgen, dan leert de A1 goed.
We willen onze A. L. wat tijd om te verkennen, te leren van zijn fouten.
Weet je, als we het straffen, als het een paar fouten maakt, zoals op de een of andere manier naar de zin gaan of te dicht
bij een muur komen.
Nou, we willen de A. L. wat tijd om te leren.
We willen wachten tot het neurale netwerk correct werkt.
En dus een goede waarde voor het leertempo dat ik kreeg nadat ik er een aantal had geprobeerd, is een punt of één.
Oke.
En dat is alles wat we nodig hebben om een optimizer te maken.
Dus eigenlijk creëren we een object van de atoomklasse.
Geweldig.
En dan zijn de laatste drie variabelen die we nodig hebben de variabelen die onze overgangsgebeurtenissen samenstellen, zodat de laatste datum,
de laatste actie en de laatste beloning.
En dat is dus eigenlijk wat we nu gaan maken en we hoeven ze alleen maar te initialiseren.
Dus laten we beginnen met de laatste datum, de laatste datum die we zichzelf die laatste onderstrepingsstatus gaan noemen.
En hoe gaan we het dan initialiseren?
Onthoud dat de laatste datum een vector van vijf dimensies is, een vector die codeert voor één toestand van
de omgeving.
En ter herinnering, deze vijf dimensies zijn de drie signalen van de drie sensoren
links en rechts en oriëntatie en minus oriëntatie.
Dit is dus een vector in intuïtieve zin, maar voor achteruit moet het meer zijn dan een vector.
Het moet eigenlijk een toortssensor zijn.
Maar het moet niet alleen een toortssensor zijn, maar het moet ook nog een dimensie hebben die ik
graag een nep-dimensie noem die overeenkomt met de batch.
En dat komt omdat de laatste datum de invoer van het neurale netwerk zal zijn.
Maar als je werkt met neurale netwerken in het algemeen, of het nu gaat om verzorgers met een hogere dichtheid
of Bythewood, dan kunnen de invoervectoren op zichzelf geen eenvoudige vector zijn.
Het moet in een batch zijn.
Het netwerk kan alleen een batch invoerwaarnemingen accepteren en daarom zullen we niet alleen een sensor maken
voor invoerstatusvectoren, maar zullen we ook deze nep-dimensie creëren die overeenkomt met de batch.
Dus laten we dit doen en laten we beginnen met het initialiseren van een toortssensor.
Dus om dit te doen, is er niets eenvoudiger.
We nemen dan onze Tahj-bibliotheek en dan gaan we de Tensor-klasse gebruiken, want zoals je misschien al geraden hebt, zal dit
een object creëren voor de tenso-klasse dat een Tenzer-object is en in de zin van klasse.
We moeten één argument invoeren dat de grootte van je Tenzer specificeert, je kunt je een sensor voorstellen als
een array met één enkel type.
Maar wat dit nu in feite zal vertegenwoordigen, is natuurlijk deze invoerstatus, die je als een vector kunt
zien.
Om het aantal elementen te specificeren dat Distancia moet hebben, moeten we
natuurlijk de invoergrootte gebruiken, omdat de invoergrootte precies het aantal dimensies is van onze invoertoestandsvectoren.
Nu moet ik zeggen Tensas.
En dus wat we gewoon moeten invoeren in onze Tenzer-klasse om het Tenzer-object te maken.
Dat is de invoergrootte en later zal de invoergrootte gelijk zijn aan vijf.
Oké, dus dat is goed, dat is het eerste, Don, we hebben zojuist een Tenzer geïnitialiseerd, zoals het hoort.
Maar bedenk dan dat we iets anders moeten doen.
We moeten die nep-dimensie creëren, want dit is wat het netwerk zal verwachten voor zijn input
en om deze ene nep-dimensie te creëren, die trouwens de eerste dimensie moet zijn.
Weet je, de nep-dimensionering die op de weddenschap reageert, zal de eerste dimensie hiervan zijn, laten we zeggen,
levensvatbaar.
Om dit te doen, hoeven we alleen maar een punt toe te voegen en te knijpen.
En dan tussen haakjes, moeten we de index van deze nep-dimensie plaatsen en zoals ik net zei, deze
nep-dimensie moet de eerste dimensie van de staat zijn.
En aangezien indexen in Python nul begonnen, moeten we nul invoeren zodat deze nieuwe dimensie de eerste dimensie
wordt.
We hebben dus een eerste dimensie die overeenkomt met het bed en dan de dimensie die overeenkomt
met de sensor, die de vijf elementen van uw invoerstaten zal bevatten, de drie signalenoriëntatie en
minusoriëntatie.
En dan gaan we, we hebben onze invoerstaten behoorlijk perfect geïnitialiseerd.
En dan nog twee variabelen te gaan.
En dat zal veel gemakkelijker zijn omdat de volgende variabele de laatste actie is.
Dat is een nieuwe variabele die we maken voor de laatste actie van het object.
En onthoud, in de eerste tutorial van de sectie heb ik je verteld dat de acties nul één of
twee zullen zijn.
En dan gebruiken we de actie om de vector te roteren, we zullen deze indexen van deze acties omzetten in de
hoeken van de rotatie, wat ik aan onze nul 20 of min 20 herinner.
Daarmee kunnen we je geheugen echt opfrissen.
Nou, het is precies hier.
Actie tot rotatie als de actie nul is.
Dit komt overeen met de eerste index hier.
Dus nul, als de actie één is, komt dit overeen met de index, een van deze vectoren van twintig
graden.
En als de actie twee is, krijgen we min 20 graden.
Dat wordt de rotatiehoek van onze auto als we de actie spelen.
Oké, en daarom, aangezien de actie nul één of twee zal zijn, is de actie
daarom een eenvoudig getal.
En dus heel eenvoudig, we kunnen het op nul initialiseren.
We hoeven geen kans te creëren om iets anders te horen.
We hoeven het alleen maar met nul te initialiseren.
En tot slot, nou, dat is de laatste beloning voor jezelf die laatste beloning.
Daar gaan we.
En nogmaals, de beloning is een float-getal, waarvan ik eraan herinner dat het tussen min één en plus één ligt.
Dus dat is weer een getal.
En wat de actie betreft, we zullen deze op nul initialiseren.
En daar gaan we.
Gelukwensen staan erin.
Functie is klaar.
Dus nu zijn we klaar om verder te gaan met de spannende dingen.
En eigenlijk het belangrijkste voor A. L. dat is beslissen welke actie op elk moment wordt gespeeld, op elk
moment.
En dat is precies wat we in de volgende tutorial gaan doen door de select action-methode te maken.
Dus laten we dit doen in de volgende ATWAL.
En tot dan.
En ik.