Hallo en welkom bij het super spannende deel van onze creatie, het deel waar we het slim maken.
Dat is dus precies wat er gebeurt als je de lucht traint.
Ik zal zijn intelligentie trainen om het doel te bereiken dat we wilden bereiken.
En om dit te doen, gaan we het neurale netwerk trainen om de juiste voorspellingen uit te voeren.
En dan is alles al klaar, want deze uitgangssignalen van de hersenen hebben al de juiste overdracht naar
het lichaam om de laatste acties uit te voeren.
Dus eigenlijk is wat we nu gaan doen iets wat we al eerder deden.
We gaan gewoon wat willekeurige batches uit het geheugen halen, onze invoer uit deze monsters halen, de uitvoer
krijgen, het doel krijgen, de voorspellingen krijgen, de laatste fout tussen de voorspellingen en het doel berekenen, en
dan achterwaartse voortplanting uitvoeren was om de gradiëntafdaling te krijgen om de gewichten bij te werken op basis
van hoeveel ze hebben bijgedragen aan deze laatste fout.
Dus laten we dit allemaal doen.
Je zult zien hoe het zo gemakkelijk gaat, want we hebben al alle tools om dit te
implementeren.
We hebben niet alleen het pad naar tools zoals de optimizer en de loss-functies, maar we hebben ook alle klassen
die we eerder hebben gemaakt, zoals onze hersenen natuurlijk, die we gaan gebruiken om de voorspellingen
te krijgen.
Vervolgens wordt onze ervaring, herhaling van de geschiktheid van de implementatie en al deze tools gecombineerd tot de pilot,
welke tools de training superprestaties zullen maken en daarom zullen we uiteindelijk een superkrachtige A
krijgen. L. Dus laten we deze training waarmaken.
Laten we onze ogen slim maken.
En het eerste wat we nu gaan doen is de laatste functie die we tijdens de training zullen gebruiken
bij het berekenen van de fout ophalen en optimaliseren.
Dat is het eerste wat we gaan doen.
Laten we dus een variabele maken voor de laatste functie.
We gaan het verlies noemen.
En dit is gelijk aan de MSE-verliesfunctie van de eindmodule.
En dan die Mercilus.
Dat is de laatste functie die we zullen gebruiken, omdat onze voorspellingen in feite waarden zijn.
Weet je, we voorspellen de kernwaarden van de verschillende acties.
En daarom, aangezien dit reële getallen zijn, doen we een soort neuraal netwerk voor regressie en daarom
is de verliesfunctie het middel voor fouten.
Dat is de verliesfunctie die we in het algemeen gebruiken voor regressie.
Oke.
Dus nu we onze laatste functie hebben, laten we onze optimizer hier zo geoptimaliseerd krijgen.
Dat is de variabele die we voor it-optimizer maken.
En we gaan zoals gewoonlijk.
Wat betreft de zelfrijdende auto, de atom optimizer, dat is een zeer krachtige optimizer die wonderen zal doen voor
de training.
Dus laten we deze naar dat atoom brengen.
En onthoud, dat is precies wat de zelfrijdende auto moet hebben om twee essentiële argumenten in te voeren.
De eerste is degene die de verbinding zal maken tussen de optimizer en de parameters van ons neurale netwerk, dat
wil zeggen de gewichten van de neuronen van onze hersenen.
En om dit te doen, nemen we onze hersenen, die we CNN noemden.
Dat is het object dat we voor onze hersenen hebben gemaakt.
En dus CNN die parameters onthoudt die we gaan en wat haakjes.
Dus dat maakt de verbinding tussen de optimizer en de gewichten van de neuronen in de
hersenen van onze A. L. En dan is het tweede argument een leertempo, en dat wordt gegeven door l. R.
En dus moeten we hier een kleinere leersnelheid nemen omdat we niet te snel willen convergeren en we willen wat verkenning hebben
en daarom een goede manier van leren waarvan we kunnen zeggen dat hier een kleine is die vier
punten is of een die is 0. 01 procent.
Ik denk dat dat dezelfde is die we gebruikten voor de zelfrijdende auto.
Oké, dus nu hebben we een verloren functie-optimizer, dus we zijn bijna klaar om de volledige lus te starten.
Nou, eigenlijk beginnen we nu met de volledige lus.
Maar net voordat we het doen, gaan we de grootte bepalen van het aantal tijdperken waarin
we zullen veranderen en daarom creëren we hier een nieuwe variabele die zal reageren op dit aantal tijdperken.
En laten we het gelijk stellen aan honderd.
Dat is goed genoeg om de lucht te trainen en ik wed zelfs dat de lucht de beste
weg zal bereiken voor honderd, twintig of dertig.
Laten we eens kijken.
Maar laten we er nu honderd nemen.
En als we het nodig hebben, vergroten we het.
Maar ik denk niet dat dat nodig zal zijn.
Oké, dus nu we ons aantal luchthavens hebben, kunnen we beginnen met het maken van de volledige lus,
je weet wel, deze volledige hoofdlus van de training wanneer we over de luchthavens trainen.
Dus voorlopig gaat het hele volleybal aan het werk.
Daar kiezen we voor terug in.
Nu gaan we natuurlijk de bereikfunctie gebruiken om te zeggen dat we van de eerste naar het aantal
van ongeveer willen gaan.
Plus één, want onthoud dat de bovengrens van een bereik niet is inbegrepen, en daarom, als
je tot 100 wilt gaan, nou, we moeten specificeren en een plus één zijn om tot 100 te gaan.
Oke.
Dus, Colin.
En laten we nu in de lus gaan.
Oke.
Dus het eerste wat we gaan doen is 200 runs van tien stappen doen.
Dus elke époque zal 200 runs zijn, de een na de ander van 10 stappen.
En om dit te doen, hebben we deze eenstaps-functie uit onze ervaringsklasse en daarom gebruiken we
deze functie, wat eigenlijk een methode is omdat we het uit ons geheugenobject halen,
wat een object uit de vervangingsklasse is om deze twee runs te genereren van tien stappen.
We moeten ons geheugenobject nemen dat ik je eraan herinner dat we hier hebben gemaakt.
Geheugen is een doel om geheugenklasse opnieuw af te spelen met Insteps.
Dat is 10 treden en een capaciteit van tienduizend.
We hebben dit object gemaakt en van dit object nemen we goed, deze Rundstedt-functie voert stappen uit en we
specificeren tweehonderd opeenvolgende ronden van tien stappen, zodat we gewoon bij elk in principe 200 stappen uitvoeren.
En nu we deze 200 stappen bij elke apoc hebben lopen, is het tijd om enkele batches van deze runs
te bemonsteren en deze batches te bemonsteren.
We hebben nog een andere functie uit ons geheugen, dat is een monsterbatch, en die zal precies enkele
batches van deze 200 runs genereren.
Maar onthoud, deze batches zijn deze keer batches van een reeks overgangen die een reeks van tien stappen zijn, in tegenstelling
tot voorheen, waar de batches hier slechts enkele batches van enkele overgangen waren.
Deze keer worden het batches van tien stappen, tien overgangen, en daarom is het nu tijd
om deze willekeurige batches uit ons geheugen te halen en ze op te halen.
We gebruikten de eenvoudige batchfunctie waarop we de batchgrootte moeten toepassen en voor de batchgrootte
waar we tweeëndertig of zelfs vierenzestig of zelfs honderdachtentwintig kunnen nemen.
Denk eraan, voor die maat is het gebruikelijk om tweeëndertig te gebruiken.
Dat is wat je in het algemeen zult zien in de neurale netwerkarchitecturen wanneer je wat batch-learning doet.
Maar deze keer is het heel anders.
Wij, we nemen slechts enkele batches van 10 stappen, dus het is beter om batches met grotere maten te nemen.
Dus daar kunnen we vierenzestig, honderdachtentwintig nemen.
Dus we gaan honderdachtentwintig nemen.
En eigenlijk zal dit binnen de lus zijn omdat we verschillende batches willen nemen en we nemen ze op
in wat wordt geretourneerd door deze eenvoudige batchfunctie.
Dus deze volledige lus voor batch in geheugen monster batch, honderd achtentwintig betekent dat elke honderd
achtentwintig stappen, ons geheugen ons een batch van grootte zal geven, honderd achtentwintig, die
eigenlijk de laatste zal bevatten honderdachtentwintig stappen die we zojuist hebben uitgevoerd.
We krijgen gewoon een paar batches van zes, honderdachtentwintig en het leren gaat gebeuren op
deze batches.
En behalve in deze batches, zullen we in aanmerking komende trays draaien, weet je, om elke 10 stappen
te leren.
Oke.
Dus nu binnen deze lus, die nog steeds in één tijdperk plaatsvindt, maar nu zitten we in een specifieke
batch.
Het eerste wat we nu gaan doen, is dat we onze input en ons doel afzonderlijk gaan krijgen.
En dat, zoals ik je al zei, heel gemakkelijk is.
We kunnen het doen met een van de tools die we hebben geïmplementeerd, namelijk het traceren van geschiktheid.
Zoals u hier kunt zien, neemt deze functie voor het traceren van geschiktheid de invoer als invoer en nu hebben we
de batch en retouren als uitvoer, de invoer en de doelen.
Dus wat we nu eenvoudig kunnen doen, is twee nieuwe variabelen maken, die de invoer en het doel
zullen zijn.
En of deze invoer op doelen komt, is precies hetzelfde als wat deze traceerfunctie voor geschiktheid van toepassing is op een
batch.
Dus we zullen deze functie toepassen op de batch van onze lus.
En dus wat we zullen doen, is gewoon in aanmerking komen.
Trace toegepast op de partij van onze hoop.
Oké, dus dat geeft ons de input en de doelen, maar in strakke wads is er altijd iets meer dat we
moeten doen.
En dit is natuurlijk om de invoer van het neurale netwerk en ook het doelwit om te zetten in enkele
tahj-variabelen.
Maar er is ook niets nieuws.
Wij weten hoe het moet.
We kunnen het op deze manier doen.
We nemen onze input, dan onze doelen en nou ja, ze zullen gelijk zijn aan verbaal.
Ingangen.
Dat is voor de input en verbaal.
Doelen, en dat is voor de doelen.
Oké, dus de input van de hersenen wordt omgezet in enkele tahj-variabelen en de doelen worden ook omgezet
in enkele tahj-variabelen.
Dus nu kunnen we de input in het neurale netwerk krijgen.
En waarom moeten we dit doen?
Omdat de volgende stap is om de voorspellingen te krijgen, hebben we de input die we moeten targeten.
Nu hebben we natuurlijk onze voorspellingen nodig, want wat er dan gebeurt, is dat we het verlies tussen
de voorspellingen en de doelen gaan berekenen.
Dus laten we deze voorspellingen krijgen om ze te krijgen.
Nou, nogmaals, dit is zo eenvoudig.
Nu hoeven we alleen ons brein, dat is CNN, ons convolutionele neurale netwerk, te nemen en het toe
te passen op onze input.
Daar gaan we.
De invoer gaat naar het neurale netwerk en het neurale netwerk zal de voorspellingen uitvoeren.
Perfect, dus nu hebben we de voorspellingen, we hebben de doelen zodat we de wetten kunnen krijgen en dat
is de volgende stap, we gaan een nieuwe meer introduceren omdat we nu de laatste fout krijgen, die anders is
dan de laatste functie, omdat we het gebruiken als een functie om de laatste fout te krijgen.
Dus minder fouten hier en dat we het zullen krijgen met de minder functie die wordt toegepast op onze voorspellingen en de doelen
die we gaan bekijken hoe alles nu soepel verloopt.
Alles is logisch.
We krijgen eerst de input, de doelen, en dankzij de input krijgen we de voorspellingen.
En dan dankzij de voorspellingen en de doelen die we krijgen, hoe minder fouten.
Heel logisch en vlot dus, en wat is nu de volgende stap?
Welnu, hetzelfde logische pad nu we het laatste hebben, we kunnen deze minder fout terug propageren in het nieuwe netwerk
om de gewichten bij te werken.
En dat doen we met stochastische gradiëntafdaling en om stochastische gradiëntafdaling uit te voeren.
We hebben onze optimizer nodig, maar die hebben we al.
Hier zijn Adam Optimizer.
Maar onthoud nu op dit punt wat we moeten doen.
We moeten het initialiseren en initialiseren.
Onthoud dat we ons optimalisatieobject nemen en vervolgens de nulgradenmethode toepassen.
Daar gaan we, we vergeten de haakjes die het initialiseren niet, en nu is de volgende stap om
de laatste fout terug te propageren in het nieuwe netwerk en dit te doen waar we onze laatste fout nemen
en we passen erop de achterwaartse methode toe.
Dus dat is precies om achterwaartse voortplanting toe te passen.
En dan tot slot, nu de laatste fout terug is, propageer deze naar het nieuwe netwerk.
Welnu, we kunnen de gewichten bijwerken met de Cassi-gradiëntafdaling.
En om dit te doen, onthoud dat we onze optimizer nemen en vervolgens de stapmethode toepassen.
Daar gaan we.
De gewichten zijn nu bijgewerkt.
Zoals ik je al zei, we hebben het niet alleen al gedaan, maar nu lijkt het zo eenvoudig en zo natuurlijk.
Dus nu gaan we iets leuks doen.
We gaan de gemiddelde beloning elke apoc afdrukken.
Dus, weet je, we kunnen bijhouden hoe de A. L. gaat, hoe de opleiding gaat.
We willen de gemiddelde beloning zien toenemen over de stappen, over de doos.
En eerst is er natuurlijk deze verkenningsfase.
Dus de gemiddelde beloning zal in het begin misschien niet toenemen, maar als het eenmaal de exploitatiefase bereikt,
zullen we zien dat de gemiddelde beloning zeker toeneemt en het zal toenemen tot een bepaald niveau, dat is wanneer
het het westen zo snel als mogelijk.
Dus laten we beginnen met de afdruk.
Weet je, we doen dit in één keer, dus we moeten terug naar de meer lusvormige
afdruk en dan gaan we goed afdrukken, eerst ongeveer een kolom, dan procent.
S, want we gaan alles converteren naar een string die beter is en dan gaan
we de gemiddelde beloning toevoegen.
En dan tellen we ook nog eens procent op, dan gaan we de quote sluiten.
En dan voegen we een percentage toe en aan de andere kant, weet je, voeren we de variabelen in die de
eerste persoon zullen zijn, want dat is hier het epos en de tweede variabele die overeenkomt met de gemiddelde beloning, die
nu wordt berekend.
De gemiddelde beloningsvariabele bestaat dus nog niet.
We gaan het nu maken.
Dus we gaan ETR op het werk gebruiken.
Zelfs als Époque het getal is, zetten we dat om in een string.
Dat is beter en.
We gaan eraan toevoegen, Estie, dat dit de gemiddelde beloning zal zijn en dus gaan
we een variabele maken die we een grote beloning gaan noemen en nu gaan we deze variabele maken en berekenen ?
Oké, laten we dit doen.
Dat is het enige wat we nog moeten doen.
Dus Époque hebben we al.
Laten we nu de gemiddelde wereld berekenen en we moeten het hier berekenen.
Nog steeds in de lus, maar uit de lus, want nu hebben we onze batch gesampled en hebben we onze training in
de batch.
Maar nu wordt de voorwaartse voortplanting plus de achterwaartse voortplanting in de batch gedaan.
Dus we komen weer in de lus en we kunnen nu de cumulatieve beloningen berekenen die we kunnen doen met
ons wreefobject.
Omdat ons insteps-object deze functie bevat, zouden we stappen uitvoeren waarmee we de cumulatieve beloningen in de
stappen kunnen krijgen, weet je, tijdens de instep-run.
Dus we gaan het nu gebruiken om de nieuwe beloningen van de stappen bij te werken.
En dan zullen we het voortschrijdend gemiddelde object bijwerken door de cumulatieve beloningen toe te voegen aan het bewegende alledaagse object en vervolgens
het gemiddelde opnieuw te berekenen.
En zo gaan we de gemiddelde beloning krijgen.
Dus laten we dit doen.
Het eerste dat we nodig hebben, zijn de DARABA-gegevens voor beloningen.
Dus laten we ze beloningen noemen.
Stappen en dan, zoals we zeiden, nemen we ons eindstappen-object, dat, ik herinner me, hier een object van de
instant-progress-klasse was vanuit onze ervaring dat we zo'n gevoelig onderwerp bevuilen.
Vervolgens voegen we beloningen, stappen en vervolgens enkele haakjes toe.
Oke.
Dat zal ons de nieuwe cumulatieve beloningen van de stappen opleveren.
Oke.
Maar dan moeten we deze nieuwe cumulatieve beloningen toevoegen aan onze voortschrijdend gemiddelde objecten.
En om dit te doen, hebben we deze keer een methode in de klasse voortschrijdend gemiddelde, namelijk deze advertentiemethode die heel eenvoudig
is.
We nemen ons voortschrijdend gemiddelde object, dat we hier in honderd stappen hebben gemaakt.
Dan gaan we onze ADD-methode gebruiken en dan voeren we in de atmosfeer onze beloningsstappen in en dit zal de beloningen
van de stappen toevoegen aan het voortschrijdend gemiddelde.
Oke.
En tot slot kunnen we de gemiddelde beloning berekenen en dat is goed, weet je, dat is dezelfde variabele
hier.
Dus dat is wat gelijk zal zijn aan de gemiddelde beloning.
En om het te krijgen, hoeven we deze keer alleen de gemiddelde methode te gebruiken van ons voortschrijdend gemiddelde object.
En dat doen we en een puntgemiddelde zomaar, omdat ons voortschrijdend gemiddelde al was bijgewerkt met de nieuwe beloningsstappen
die we zojuist hebben toegevoegd aan de ADD-methode.
Geweldig.
Dus nu hebben we onze gemiddelde prijs, dus dat is erg populair hier en dit wordt elk jaar gedrukt.
Oké, dus we zijn klaar.
Dus ik ben zo benieuwd naar de resultaten.
En eigenlijk heb ik een verrassing voor je in de volgende tutorial terwijl ik naar de resultaten kijk.
Het wordt dus best spannend.
En nu denk ik dat het tijd is om met de lucht te spelen en plezier te hebben.
Oke.
Dus bereid jezelf een goede koffie of een goede thee.
Nu is het tijd om comfortabel in onze stoel te gaan zitten en een aantal zeer coole video's van ons vliegtuig te bekijken om te laten zien,
dat is in de volgende tutorial.
En tot die tijd, geniet ervan.