Hallo en welkom bij deze Python-tutorial.
Oké, dus we hebben heel spannende tutorials voor de boeg.
We beginnen met het maken van de architectuur van het neurale netwerk.
Dat wil zeggen, we zullen het neurale netwerk maken dat in het hart van ons oog zal zijn en dat de actie
op elk moment zal laten spelen.
Dus laten we dit doen.
Dus omdat we willen dat ons neurale netwerk een object is, gaan we een klasse maken.
En dat is omdat het veel handiger is.
Weet je, de klas is het model van iets dat we willen bouwen.
We willen een neuraal netwerk bouwen en we moeten een soort instructies maken die allemaal in een klas
zullen zitten.
En in deze les gaan we twee functies maken.
Ten eerste de init-functie, de functie die altijd naar voren komt bij het maken van een klasse
en die in feite de variabele van je object definieert.
Dat is het neurale netwerk, je weet wel, de variabelen die aan het object zijn gekoppeld, in tegenstelling tot de
globale variabelen.
En dit is dus in deze init-functie die de architectuur zal definiëren van het neurale
netwerk gedefinieerd in de invoerlaag, die zal bestaan uit vijf invoerneuronen omdat we vijf dimensies hebben
voor de gecodeerde vector van invoerstatus, dan zullen we enkele verborgen lagen.
Misschien beginnen we met één verborgen laag en dan ben je welkom om enkele andere architecturen van het neurale
netwerk te proberen.
En dan komen we natuurlijk uit bij de uitvoerlaag die de mogelijke acties bevat die we op
elk moment kunnen spelen.
Dus dat is precies wat we in deze functie gaan doen.
En dan zullen we nog een functie maken binnen de klas, die de voorwaartse functie zal
zijn, en dat zal de functie zijn die de neuronen in het neurale netwerk zal activeren, weet
je, die de signalen zal activeren.
En dus zullen we een gelijkrichteractiveringsfunctie gebruiken omdat we natuurlijk te maken hebben met
een puur niet-lineair probleem en deze gelijkrichterfunctie de lineariteit verbreekt.
Maar meestal maken we deze voorwaartse functie om de kernwaarden te retourneren, die de outputs van het netwerk
zijn.
Maar we hebben één sleutelwaarde voor elke actie.
En later zullen we de laatste actie retourneren door ofwel de volgende van de sleutelwaarden te nemen of een
softmax-methode te gebruiken.
Dat zullen we daarna zien.
Dus in deze zelfstudie beginnen we met het implementeren van de Init-functie en vervolgens zullen we de
volgende functie de voorwaartse functie implementeren.
Laten we dit dus eerst doen.
We moeten onze klas voorstellen.
Dus we beginnen met de klas en we geven een naam aan onze klas, wat goed is, we kunnen het netwerk noemen.
En dan en deze netwerkklasse, ik ga een objectprogrammeertechniek gebruiken, die overerving wordt genoemd, en
dat is gewoon om te erven van alle tools van een bovenliggende klasse.
Dus onze netwerkklas die we gaan maken, is een kindtest van een grotere klas, namelijk die
module.
Dus dat is gewoon om te erven van alle tools van deze moduleklasse, die natuurlijk de tools zijn om een
neuraal netwerk te implementeren.
Dus dat is een zeer krachtige en Africentrische en objectgeoriënteerde programmering die overerving wordt genoemd.
En op dit moment erven we van deze module-ouderklasse.
Oke.
En nu zijn we klaar om de klas in te gaan.
Dus ik druk eigenlijk twee keer op enter, omdat we twee functies gaan maken en we beginnen
met de init-functie.
Dus de functie moeten we zo noemen met twee op deze cursus, dan erin.
En nogmaals, om te onderstrepen, dat is gewoon de Python-syntaxis.
Dat is precies hoe we het moeten doen.
En dan moeten we de argumenten aandragen.
We hebben dus drie argumenten.
De eerste is een verplicht argument dat eigenlijk zelf en zelf is.
Er is geen mysterie aan.
Dat verwijst naar het object dat wordt gemaakt van deze klasse die we gaan maken.
Weet je, we maken deze les.
Het is als een instructie, een model van dit neurale netwerk dat we willen bouwen.
En als de klas klaar is, kunnen we zoveel neurale netwerken maken als we willen.
En elk van deze neurale netwerken zal een object van deze klasse zijn.
En aangezien we het object voor een aantal andere doeleinden zullen gebruiken, moeten we zien wat de variabelen van
het object in Spudis zijn.
We gebruiken dit zelf hier om aan te geven dat we naar het object verwijzen.
Dus wanneer ik een variabele van mijn object wil gebruiken, zal ik self vóór de variabele gebruiken om aan te geven dat dit
een variabele van het object is.
Oke.
Dus dat is het eerste argument.
En dan hebben we nog twee andere argumenten, die natuurlijk het aantal inputneuronen en het
aantal outputneuronen zijn.
Dus het aantal inputneuronen, we gaan het inputgrootte noemen.
En dat zijn eigenlijk vijf, omdat onze invoervectoren vijf dimensies hebben, de drie signalen plus
oriëntatie plus minus oriëntatie die vectoren zijn van gecodeerde waarden die één toestand van de omgeving beschrijven.
Deze vijf waarden zijn voldoende om de toestand van het milieu te beschrijven.
We hadden aan minder waarden of meer waarden kunnen denken, maar dat heb ik geprobeerd.
En het is eigenlijk logisch omdat we eigenlijk één signaal van links nodig hebben, één voor ons en
één rechts.
Weet je, toen we in een auto reden, hadden we voor drie zestig signalen kunnen gaan, weet
je, zoals de signalen bovenaan de Google-auto's.
Maar we kunnen helemaal zelf rijden met drie sensoren.
En dan hebben we deze oriëntatie en min oriëntatie om, je weet wel, het doel bij te houden dat we
probeerden te bereiken.
En dan hebben we natuurlijk de outputneuronen van ons neurale netwerk die overeenkomen met de acties.
En we hebben drie mogelijke acties die naar links gaan, naar rechts gaan, naar rechts gaan, en
daarom noem ik het actie en het zullen er drie zijn.
Oke.
Maar tot nu toe hoeven we alleen namen te geven aan de invoer en dan zullen we deze variabelen gebruiken om de berekeningen binnen het neurale
netwerk uit te voeren.
Goed dan, ik ga beginnen met een andere Pittodrie-truc, deze truc is de superfunctie.
Dat is een functie die feitelijk van de motormodule erft.
Daarom moesten we overerving gebruiken om de moduletool te erven.
Dit zijn de eerste twee die we gebruiken.
En dus gebruiken we eigenlijk alleen deze supertruc, de superfunctie, om de tools van module te kunnen
gebruiken.
Dus dat is veel efficiënter en binnen de superfunctie.
Ik moet eerst het netwerk specificeren, zodat onze netwerkklasse, weet je, want dit erft van
de module-ouderklasse en dan ons object en dan voeg ik dat gewoon toe en werk ik erin, precies
zoals we het noemden .
Oke.
Dus dat is maar een truc.
Dat is gewoon om alle tools te gebruiken.
En in die module kunnen we doorgaan naar de volgende stap, namelijk het specificeren van de invoerlaag.
Dus eigenlijk moet ik een nieuwe variabele introduceren die aan het object wordt gekoppeld en
deze variabele zal het aantal inputneuronen bevatten.
Dus niet te verwarren met invoer, grootte, invoergrootte is het argument van de Init-functie, maar dat is niet de variabele die aan het
object is gekoppeld, maar de variabele die aan het object is gekoppeld.
Welnu, zoals ik zojuist al zei, we moeten specificeren dat het in plaats daarvan aan het object is gekoppeld.
Dus we gebruiken een zelf dat en nu geven we een naam aan deze eerste variabele die aan het object is gekoppeld.
En dus kunnen we gewoon dezelfde naam geven als de invoer.
We kunnen het invoergrootte noemen.
En we zullen zeggen dat het gelijk is aan de argumenten van de functie die de invoergrootte is.
Oke.
Dus elke keer dat ik een object uit de netwerkklasse maak en ik de invoergrootte
specificeer, zoals ik bijvoorbeeld vijf invoer, zal er hier een vijf zijn en daarom zal de invoergroottevariabele
van ons object hebben de waarde van vijf omdat deze invoergrootte hier vijf zal zijn en daarom zal
ons nieuwe netwerk vijf invoerneuronen in de invoerlaag hebben.
Oke.
En dan is dat hetzelfde voor de andere variabele die we aan ons object willen koppelen.
En zoals je misschien al geraden had, wordt dit een variabele voor het aantal output-neuronen en om te zeggen
dat we ons object zelf nemen en dan geven we een naam aan deze tweede variabele van het object, we
gaan het noemen en de actie.
En dit zal gelijk zijn aan dit argument hier, gezien het aantal acties, dat is het aantal
outputneuronen.
En dus stellen we het gelijk aan en de actie.
Dus eigenlijk en de actie zal gelijk zijn aan drie.
Daarom krijgen de variabele en de actie die aan ons object aan een netwerk is gekoppeld, de waarde drie.
Eigenlijk kunnen we er hier een zien.
Er staat een ongedefinieerde naam.
En dan, nou, dat is omdat we hier de snelkoppeling en dan gebruiken en we moeten de snelkoppeling hier en
gebruiken voor onze richting en einde-module en dan zal het verdwijnen.
Daar gaan we.
Perfect.
Op dit moment hebben we geen waarschuwingen.
Alle waarschuwingen hier zijn alleen om aan te geven dat wat we importeren nog niet wordt gebruikt.
Maar dat is oke.
Die gaan we later gebruiken.
Oké, dan hebben we nog twee variabelen die we willen definiëren voor object.
En dit zullen de volledige verbindingen zijn, de volledige verbindingen tussen de verschillende lagen van ons neurale
netwerk.
Dus aangezien we nu een neuraal netwerk willen maken dat uit slechts één verborgen laagwereld bestaat, zullen
er twee volledige verbindingen zijn.
Er zal een eerste volledige verbinding zijn tussen de invoerlaag en de verborgen laag en een
tweede volledige verbinding tussen de Hillaire en de uitvoerlaag.
Dus laten we beginnen met de eerste volledige verbinding die we het gaan noemen.
Eenenveertig en nogmaals, ik gebruik hier self om aan te geven dat FS1 een variabele is van mijn object, dus self dat
FS1.
Dat zal gelijk zijn aan en nu gebruiken we de end in module en we gaan een functie gebruiken genaamd lineI, en dat
is precies om deze volledige verbinding te maken tussen de neuronen van de invoerlaag naar de neuronen van de
verborgen laag.
En wat bedoel ik met volledige verbinding?
Dat betekent dat alle neuronen van de invoerlaag allemaal verbonden zullen zijn met alle neuronen van de verborgen
laag.
En om deze volledige verbinding te maken, gebruiken we deze lineaire functie waaraan we enkele argumenten moeten invoeren.
En zoals je kunt zien, zitten deze argumenten in functies.
Dus dat is het aantal neuronen van de first lady dat we willen verbinden, dan de outfitters, dat is
het aantal neuronen van de tweede laag dat we willen verbinden.
Dat is de laag rechts die de verborgen laag is en biopsychosociaal door de fiets door.
We zullen de standaardwaarde behouden om een vooroordeel te hebben.
En niet alleen enkele gewichten die aan de neuronen zijn bevestigd, zullen moeten wachten en één vooroordeel voor elke laag.
En dus, nou, laten we eens kijken wat we moeten invoeren.
Het eerste argument in features is dus het aantal inputneuronen in de inputlaag.
En wat is het dan?
Dat is eigenlijk de invoergrootte.
Dat is het argument van onze init-functie, die later gelijk zal zijn aan vijf van de drie signalen oriëntatie
en minus oriëntatie.
Hier gaan we.
We voeren het eerste argument in, de invoergrootte.
En dan gaat het tweede argument over kenmerken, dat wil zeggen het aantal neuronen dat we in de tweede laag
willen hebben, de tweede laag die volledig verbonden zal zijn met de eerste laag.
En nu is de vraag, hoeveel neuronen willen we in deze verborgen laag?
Ik heb veel Piramida-training gedaan.
Ik heb veel geëxperimenteerd.
Dat is wat we doen in Iowa.
Dat is wat we doen bij deep learning.
In het algemeen.
We experimenteren veel om te zien wat het beste neurale netwerk is voor ons specifieke probleem.
En dus probeerde ik veel waarden en uiteindelijk koos ik 30, 30 neuronen in een verborgen laag.
En je zult zien dat we met dit aantal behoorlijk goede resultaten zullen behalen.
Maar voel je vrij om de architectuur van het neurale netwerk te veranderen.
Speel er gerust mee.
Je kunt niet alleen het aantal verborgen neuronen in een verborgen laag veranderen, maar je kunt ook wat meer
lagen toevoegen zodat je misschien een nog betere auto krijgt.
Maar 30 miljoen neuronen zullen ons een goed neuraal netwerk en een goede auto bezorgen.
Dus daar gaan we voor.
En daar gaan we.
We hebben onze eerste volledige verbinding echt met deze lineaire functie.
We maken de volledige verbinding tussen de invoerlaag en het verborgene.
En nu is het tijd om de tweede volledige verbinding te maken, dat is de volledige verbinding tussen
de verborgen laag en de uitvoerlaag.
Dus daar gaan we.
We gaan deze tweede volledige verbinding F noemen. C. daar gaan we.
En toch, dit is een variabele van ons object.
Dus ik gebruik hier dingen.
En nogmaals, we gebruiken het, eigenlijk kunnen we dit kopiëren omdat we de Enon-module gaan gebruiken
en dan de lineaire functie, maar dan moeten we de argumenten veranderen.
Natuurlijk eerst.
Dat is hetzelfde.
De eerste is het aantal neuronen dat we in de eerste laag van de volledige verbinding willen hebben.
Dus dat is de verborgen laag en daarom is dat 30.
En dan is het tweede argument het aantal neuronen in de tweede laag van de volledige verbinding,
en dat komt overeen met de outputlaag en de outputlaag heeft en de actieneuronen, die later drie zullen zijn
omdat we drie mogelijke acties hebben.
Maar tot nu toe moeten we de namen gebruiken die we hebben gedefinieerd.
Dat zijn de namen van het argument van de Init-functie en daarom voeren we hier en de actie in.
En daar gaan we.
Allereerst zijn twee volledige verbindingen gereed en ten tweede is de init-functie gereed.
Dus dat is wat ons object zal initialiseren wanneer we een object van de netwerkklasse maken.
En dus zodra we een object maken, nou ja, al deze variabelen, de vier variabelen hier,
de invoergrootte en de actie X1 en X2 zullen worden gedefinieerd.
En zo krijgen we de architectuur van ons neurale netwerk.
Voor elk object dat we maken, komt elk object overeen met een neuraal netwerk, vijf
inputneuronen, dertig verborgen neuronen en drie outputneuronen.
Dus daar gaan we.
We zijn klaar met deze eerste functie en nu kunnen we verder gaan met de tweede
functie, de voorwaartse functie, en die zal worden gebruikt om de neuronen in het neurale netwerk te activeren met behulp
van de gelijkrichteractiveringsfunctie en meestal om uiteindelijk de kern terug te geven. waarden, die de output zijn van ons neurale
netwerk.
Dus ik kan niet wachten om dit in de volgende tutorial te doen en tot die tijd, geniet van I.