Hallo en welkom bij deze Python-tutorial.
Oké, dus in deze nieuwe codesectie gaan we ervaring implementeren om te spelen.
Dus we gaan een nieuwe klasse maken, die we replay-geheugen zullen noemen, en die ervaring zal implementeren.
We spelen precies zoals je zag in de intuïtiecolleges.
Maar laten we eerst een korte herinnering geven aan wat ervaringsherhaling is.
Dus, weet je, al deze kunstmatige intelligentie is gebaseerd op marktbeslissingsprocessen en marktbeslissingsprocessen bestaan
uit het kijken naar een reeks gebeurtenissen.
Dus de gebeurtenissen gaan bijvoorbeeld van de ene staatsstad naar de volgende staat en stad plus één.
Maar als de gebeurtenissen zo waren, nou, aangezien de volgende staat erg gecorreleerd is met de huidige staat,
zou het netwerk niet zo goed leren.
Dus voor degenen die van de deep learning-cursus komen, dat is precies hetzelfde als waar we onze tijdreeksen
hebben geleerd met slechts één tijdstap.
Het was niets leren omdat één tijdstap niet voldoende was om een model
langetermijncorrelaties te laten begrijpen.
Dus dat is hier hetzelfde.
En daarom moeten we experience replay implementeren.
Dus hoe werkt het?
Nou, dat is heel eenvoudig.
In plaats van alleen naar de huidige toestand te kijken, is dat slechts één toestand tegelijk. We gaan er meer in
het verleden bekijken.
Dus precies zoals vier of lijsten en daarom zal onze reeks evenementen niet Estie en C plus één zijn.
Dit zullen bijvoorbeeld de 100 staten in het verleden zijn.
Dus als T min honderd schat negenennegentig tot SC min één en dan s-t.
Dus met andere woorden, we stoppen de 100 overgangen minder in wat we het geheugen noemen, en
daar hebben we een langetermijngeheugen in tegenstelling tot een kortetermijngeheugen of zelfs een instantgeheugen.
En daardoor werkt het hele deep learning-proces veel beter.
En als we eenmaal deze herinnering aan de laatste 100 gebeurtenissen hebben gemaakt, gaan we proeven.
Dat wil zeggen, we zullen enkele willekeurige batches van deze overgangen nemen om onze volgende update uit te voeren.
Dat is onze volgende zet door de volgende sectie te selecteren.
En daarom zullen we in deze herhalingsgeheugenklasse die we implementeren voor ervaren herhalingen, drie
functies maken.
Allereerst functioneert de init zoals gewoonlijk.
Dat is bij elke klas zo.
En dus zullen we in deze init-functie de variabelen definiëren die aan de toekomstige instanties van de klasse zullen worden gekoppeld, dat
wil zeggen de toekomstige objecten die van deze klasse zullen worden gemaakt.
En zo heel eenvoudig, deze variabelen zullen het geheugen zijn van de honderd overgangen naar
honderd gebeurtenissen en de capaciteit die het honderdtal is.
U bent van harte welkom om een langer geheugen te proberen door de capaciteit te vergroten.
Dus dat is de eerste functie init functie.
En dan maken we nog twee andere functies, één push-functie om ervoor te zorgen dat het geheugen
nooit meer dan honderd overgangen bevat.
En hiervoor zal de capaciteit worden gebruikt door slechts één simpele if-voorwaarde te doen.
En dan zullen we uiteindelijk de eenvoudige functie maken.
En dat zal natuurlijk zijn om enkele overgangen eenvoudig te maken in deze herinnering aan de laatste honderd overgangen.
Oke.
Dus laten we beginnen met de introductie van de klas.
Dus, zoals gewoonlijk, beginnen we met de klas en dan geven we de klas een naam.
We noemen het replay-geheugen.
En dan tussen haakjes, voeren we object in, dan Colin, en dan gaan we.
We beginnen met de eerste functie.
Het einde is functie.
Dat is dus precies hetzelfde als voorheen.
We beginnen met def dan twee op deze cursus daarin twee onderstrepingstekens en dan de variabelen.
Dus er is natuurlijk zelf, de variabele die is gekoppeld aan de toekomstige instanties van het toekomstige object van de
klasse.
En dan hebben we nog een variabele voor je, zodat je een andere ervaring kunt proberen, een
aantal herinneringen kunt vervangen en dat wordt de capaciteit.
Dus deze capaciteit zal gewoon het getal honderd zijn omdat we ervaring gaan maken,
vervangen door de honderd overgangen.
Oke.
En dan Colin.
En hier gaan we.
Laten we naar de functie gaan en de variabelen van onze replay-geheugenobjecten definiëren.
Dus de eerste zal zelf die capaciteit zijn.
En zoals je waarschijnlijk hebt begrepen, zal dit de capaciteit zijn die het maximale aantal overgangen is dat
we in ons geheugen van gebeurtenissen willen hebben, en dit zal gelijk zijn aan het argument dat we zullen
invoeren bij het maken van een object van de replay-geheugenklasse, en dus dat is capaciteit.
Dat is het argument van de init-functie.
Dus capaciteit.
Dus nogmaals, niet te verwarren met zelf, die capaciteit is de naam van de variabele die aan het object
en de capaciteit is gekoppeld.
Dit is het argument dat we zullen invoeren bij het maken van een object van de geheugenklasse.
Oke.
En dan hebben we nog een tweede variabele.
Dat is natuurlijk het geheugen.
Dus zelf die herinnering.
Oké, en waar zal deze geheugenvariabele dan gelijk aan zijn?
Welnu, dit geheugen zou de laatste 100 gebeurtenissen moeten bevatten en daarom zou dit een eenvoudige lijst moeten zijn, weet
je, een lijst die de laatste 100 gebeurtenissen, de laatste 100 overgangen zal bevatten.
En om de lijst te initialiseren, is er niets eenvoudiger.
We voegen gewoon wat haakjes toe en daar gaan we.
Ons geheugen is geïnitialiseerd.
Dus, natuurlijk, aan het begin van het experiment of meer precies het begin van de expiratie, zal
het geheugen een lege lijst zijn en dan zullen we de overgangen plaatsen elke keer dat we een toekomstige staat bereiken.
Daarover gesproken, dat is precies wat we gaan doen met de volgende functie die we de
push-functie gaan noemen.
We zullen deze push-functie maken om de gebeurtenissen in deze geheugenlijst toe te voegen, en dan zullen we de capaciteit
gebruiken om ervoor te zorgen dat deze geheugenlijst altijd 100 gebeurtenissen bevat en nooit meer.
Oke.
Dus laten we dit in de volgende ook doen.
En tot die tijd, geniet van I.