Hallo en welkom bij deze Python-tutorial.
Nu moeten we de vijf variabelen van deze init-functie definiëren, dat wil zeggen de drie windingen
en de Tufo-verbindingen.
Dus laten we beginnen met de eerste.
Convolutionele men past convolutie toe op de invoerbeelden zodat de originele afbeeldingen en nu ga je zien hoe alles
zo eenvoudig zal worden om deze convolutie te creëren.
Welnu, wat we moeten doen, is een object van een specifieke klasse maken en deze klasse wordt
van hen overgenomen en dan komen de klassen.
Naar t t omdat we met de afbeeldingen werken en nu, zoals je kunt zien, moeten we verschillende argumenten aanvoeren.
De eerste is in kanalen, dus laten we het in kanalen plaatsen.
De tweede is uit kanalen.
De derde is Colonel Size, en de rest is het beste voor de opvulling, de vertraging in groepen en
vooringenomenheid.
En we hebben standaardwaarden voor al deze.
Die gaan we dus niet opleggen.
We gaan de standaardwaarden behouden.
Maar wat belangrijk is, zijn deze drie argumenten in kanalen en kanalen en valuta's.
En dus raad je waar ze mee overeenkomen?
Nou, heel eenvoudig in kanalen komen overeen met de invoer van de convolutie en alle kanalen komen overeen met
de uitvoer van de convolutie.
Dus in kanalen, wat gaat het worden?
Nou, heel eenvoudig, dat wordt het aantal kanalen in onze afbeeldingen.
En eigenlijk gaan we werken met zwart-wit beelden omdat we in principe geen kleuren nodig hebben om
de monsters te herkennen.
De gegevens zijn volledig in staat om de monsters in zwart-wit te herkennen.
Dus we hebben de kleuren niet nodig.
Het zal ze gewoon herkennen aan hun vorm en daarom gaan we één kanaal gebruiken.
Dus één kanaal is wanneer je zwart-wit afbeeldingen hebt en drie kanalen is wanneer je gekleurde afbeeldingen
hebt.
En daarom, aangezien we met zwart-witafbeeldingen in kanalen werken, zal het gelijk zijn aan
één.
Dan onze kanalen, dus onze kanalen zullen gelijk zijn aan de afbeeldingen die je wilt hebben in de convolutionele
daar, wat de output is van deze convolutie.
Dit is in feite gelijk aan het aantal kenmerken dat u in uw originele afbeeldingen wilt detecteren, omdat we
één afbeelding per kenmerk maken dat we willen detecteren, omdat u in feite weet hoe het
werkt.
We passen één kenmerkdetector toe op het invoerbeeld om een specifiek kenmerk in het invoerbeeld en dus het
aantal uitvoerbeelden te detecteren.
Dit is het aantal functies dat we willen detecteren.
Dus nu is de vraag, hoeveel functies willen we detecteren?
Welnu, het is gebruikelijk om te beginnen met 32 functiedetectoren.
En dat leidt ons naar 32 procent afbeeldingen in deze eerste convolutionele laag.
De invoer is dus één zwart-wit beeld, een echt beeld.
En de uitvoer in de eerste convolutionele laag is 32 bewerkte afbeeldingen.
En met verwerkt bedoel ik natuurlijk dat de convolutie werd toegepast op het invoerbeeld om tweeëndertig nieuwe
beelden te krijgen die kenmerken detecteerden.
En dan moeten we een kernelgrootte specificeren, die niets anders is dan de afmetingen van het vierkant
dat door de originele afbeelding gaat.
En in de praktijk gebruiken we ofwel twee bij twee of drie bij drie of vijf bij vijf.
En voor de eerste gaan we een vijf bij vijf kenmerkende detector gebruiken.
Dat is een feature-detector die vijf bij vijf dimensies zal hebben en dan zullen we de grootte van deze
kernel verkleinen voor de volgende convolutionele lagen.
En nu we het er toch over hebben, dit is precies wat we nu gaan doen.
We gaan dit kopiëren om de tweede convolutie te definiëren.
En daarom plaats ik dat hier en nu.
Het is heel grappig en heel gemakkelijk.
Het is als een dominosteen.
Het ingangskanaal van de tweede convolutionele laag is het uitgangskanaal van de eerste convolutionele daar.
Dus dit aantal outputs, tweeëndertig hier is hetzelfde aantal inputs.
Tweeëndertig hier.
En dat komt omdat we tweeëndertig afbeeldingen hebben in de invoerconvolutielaag van de tweede convolutie.
En dus wordt de tweede convolutie toegepast op deze tweede convolutionele laag om een derde convolutionele laag terug te geven.
En dus is nu de vraag hoeveel nieuwe afbeeldingen we willen.
Nou, hetzelfde.
Laten we 32 nieuwe afbeeldingen maken.
Tweeëndertig is eigenlijk een veel voorkomend getal in convolutionele neurale netwerken.
Als je naar de architecturen kijkt, zul je er in veel ervan tweeëndertig vinden.
En dan voor de kernelgrootte, nou ja, we moeten de kernelgrootte verkleinen.
Dat zijn de afmetingen van onze feature detector.
En dus gaan we nu van vijf naar vier of zelfs drie en dan gaan we nog kleiner.
Oke.
Dus onze tweede convolutie is klaar.
Het heeft als invoer nodig om afbeeldingen te verwerken, waarbij elk een eerste kenmerk van het originele invoerbeeld detecteert.
En het creëert 32 nieuwe afbeeldingen dankzij deze kleinere afmetingen van de feature-detector.
En dus laten we dit nu nog meer pushen.
Dus ik kopieer dit en plak dat hier om een derde convolutie te maken om enkele functies te detecteren.
En dus nu is dat hetzelfde de ingangskanalen.
Hier is het aantal invoerbeelden aan de linkerkant van de convolutieverbinding.
En er is een aantal bewerkte afbeeldingen die rechts van de vorige convolutieverbindingen stonden.
Dat is tweeëndertig.
Daarom houden we hier tweeëndertig.
Dat is perfect.
En nu is de vraag opnieuw, hoeveel nieuwe beelden willen we detecteren?
We gaan nu 64 in, dus 64 outputs, verwerkte beelden nemen.
En natuurlijk nemen we nu een kleinere kernelgrootte en we gaan er twee nemen.
En dat is dus een zeer klassieke architectuur van een convolutionele daar.
En het is zeer efficiënt om een hoog niveau van functiedetectie in afbeeldingen te hebben.
Oke.
En dus nu we onze drie convolutionele connecties daar hebben, dankzij onze drie convolutionele connecties hier, nou, nu is
het tijd om onze twee volledige connecties te krijgen die ik eraan herinner.
We nemen deze enorme vector die we verkrijgen na het afvlakken van alle 64 keer, 32 keer, 32 keer, afbeeldingen die
we van al deze windingen hebben gekregen.
Dus we vlakken alle pixels van deze afbeeldingen af en we kunnen één enorme vector maken die de invoer wordt van
een nieuw volledig verbonden neuraal netwerk.
En dat is het moment waarop we deze paar verbindingen moeten maken tussen, eerst, deze enorme vector
en een verborgen laag en dan een tweede volledige verbinding tussen de verborgen laag en de uitvoerlaag die
bestaat uit de uitvoerneuronen, elk corresponderend met een kubuswaarde van de mogelijke acties.
Dus laten we deze twee volledige verbindingen maken.
Je weet hoe je dat moet doen.
Dat is precies wat we deden voor de zelfrijdende auto.
Dus laten we dat nog een keer doen.
Nou, eerst nemen we onze end in module.
Dan nemen we de lineaire klasse, want nogmaals, de volledige verbinding die we maken is een object van de lineaire
klasse.
En dan tussen haakjes, nou, dat is hetzelfde voor ons.
Voer de invoerfuncties in, dat is het aantal, dan de uitvoerfuncties en dus de invoerfuncties voor de
eerste volledige verbinding.
Wat gaat het worden?
Nou, dat zal gelijk zijn aan het aantal pixels in deze enorme vector, verkregen na het afvlakken
van alle verwerkte afbeeldingen na de drie windingen.
En wat is dit nummer dan?
Nou, eigenlijk is er hier een truc.
Dit nummer is eigenlijk moeilijk te krijgen.
We moeten eigenlijk een functie maken om dat getal te berekenen.
We hebben geen variabele die ons dit nummer geeft.
We moeten het berekenen.
En daarom, wat we nu en nu gaan doen, is het erg belangrijk om de mentaliteit van programmeren te
begrijpen die we moeten hebben en proberen te brengen tot de mentaliteit die je nu moet denken om dit obstakel
te overwinnen, want de eerste keer dat je zou kunnen zeggen, hey, ik heb niet dit aantal neuronen
in de afgeplatte vector, wat moet ik doen?
Ik zit hier vast.
Nou, nee, eigenlijk, want wat je nu kunt doen is hier gewoon alles invoeren dat dit
aantal neuronen vertegenwoordigt.
Dus ik noem het aantal neuronen, aantal neuronen.
En dan zullen we gewoon een functie maken die in dit aantal neuronen variabele zal terugkeren, dit aantal pixels waarnaar we
op zoek zijn.
Dat kunnen we dus helemaal.
We kunnen deze variabele volledig plaatsen.
Nou, natuurlijk krijgen we een waarschuwing omdat het nog niet bestaat, maar we zullen het daarna maken
met een functie en dat is helemaal toegestaan, zelfs als de functie daarna komt.
Dus dat is een typisch programmeerdenken dat je moet hebben als je dat soort obstakels tegenkomt.
Nou, je kunt een functie maken om te krijgen wat je mist.
Oke.
En dan functies eruit en functies eruit dat het aantal neuronen in de verborgen laag en dat deze
keer aan jou is.
Dat hangt af van de architectuur van het neurale netwerk dat je wilt creëren.
En dus zou een goed aantal geen klein aantal zijn.
Dus bijvoorbeeld 40 neuronen kunnen prima zijn.
We kunnen proberen het te vergroten.
Als de training niet te langzaam is, kun je proberen deze te verhogen.
Misschien dat dat de voorspellingen verbetert.
Maar laten we beginnen met 40.
Misschien verhogen we dat daarna.
Oke.
Dat was het voor de eerste volledige verbinding.
Dan kopiëren we dit met de afbeelding naar beneden hier voor de tweede volledige verbinding.
Dat is de verbinding tussen de verborgen laag en de uitvoerlaag.
En dus worden de kenmerken hier de buitenste kenmerken van de vorige laag, en dat is 40.
U voert dus 40 in.
Dat is natuurlijk het aantal neuronen in de verborgen laag.
En onze functies hier zullen gelijk zijn aan het aantal output-neuronen dat er in ons netwerk zou moeten zijn.
En aangezien elk outputneuron overeenkomt met één sleutelwaarde en één Kovalik-reactie op één actie, terwijl het
aantal neuronen hier natuurlijk het aantal acties is en we hiervoor één variabele hebben, dat
is geen acties en daarom hier invoer.
Nee.
Acties en daar gaan we, gefeliciteerd, we hebben de architectuur van ons neurale netwerk gedefinieerd, ons neurale
netwerk is samengesteld uit drie convolutionele lagen en een verborgen laag.
Dit alles in één grote CNN en deze CNN zal de functies in het spel detecteren, zodat het oog weet waar het
moet doen, waar het heen moet en waar het moet schieten.
Dus daar gaan we voor deze stap.
Dat is een eerste zeer belangrijke stap gezet.
Nu gaan we naar de volgende stap, en dat is natuurlijk om dit aantal neuronen te krijgen dat nog
steeds ontbreekt.
Dat is eigenlijk waar we de waarschuwing hier hebben en het uiteindelijke aantal neuronen binaries.
Nu zullen we een functie maken die het aantal neuronen in deze enorme vector zal teruggeven en we zullen dat
aantal in een variabele plaatsen die het aantal neuronen zal oproepen.
Dus laten we dit de komende tijd doen.
Dat is onze volgende stap.
En tot die tijd, geniet ervan.