Hallo en welkom bij deze Python-tutorial.
Dus nu is de volgende stap om die telneuronen te laten functioneren, die ons zullen geven wat we willen.
Dat is dit aantal neuronen in deze enorme vector nadat de windingen zijn toegepast.
Dat is de enige ontbrekende informatie die we nu nodig hebben.
En we gaan het krijgen met een functie.
Dus laten we deze functie maken.
We gaan het heel eenvoudig het aantal onderstrepingsneuronen noemen.
En wat gaat deze telling-neuronenfunctie als argumenten gebruiken?
Wel, het zal het object zelf nemen, maar dan zal het iets anders nodig hebben,
omdat dit aantal output-neuronen in de afvlakkende laag eigenlijk maar van één ding afhangt.
Het hangt af van de afmetingen van het oorspronkelijke invoerbeeld, het beeld dat helemaal aan het begin van het neurale
netwerk staat.
Het enige argument dat we nu nodig hebben, zijn eigenlijk deze afmetingen, de afmetingen van de
invoerbeelden.
Laten we daarom een naam geven aan dit argument dat de afmetingen van de invoerafbeelding vertegenwoordigt.
En we zouden het imago-dema gaan noemen.
Oke.
En ik kan je nu vertellen dat de werkelijke afmetingen, de invoerafbeeldingen die van jou komen, 80
bij 80 zullen zijn.
We gaan de grootte van de originele afbeeldingen verkleinen tot 80 bij 80.
En dat wordt het formaat van de beelden die in het neurale netwerk gaan.
Dus het beeld wordt eigenlijk één 188.
En de ene komt overeen met het feit dat we met zwart-wit beelden werken, dat wil zeggen met maar
één kanaal.
Dus beeld ze zullen later gelijk zijn aan de tupel.
Tachtig en tachtig.
Oké, dus dat is het enige argument dat we nodig hebben en laten we nu de neuronen tellen.
Dus hoe gaan we dat doen?
Allereerst hebben we momenteel geen invoerafbeelding.
We hebben geen dume-afbeelding die we kunnen importeren.
Dat gaan we later doen.
Dus het eerste dat we moeten doen, is een nep-afbeelding maken.
Maar dat heeft afmetingen 80 bij 80.
We gaan die nepafbeelding maken met neppixels.
En dat geeft ons uiteindelijk toch het aantal dat we willen, want dat aantal hangt alleen af
van de afmetingen en niet van de pixels die in de afbeeldingen zitten.
Dus laten we om te beginnen een nep-afbeelding maken en dan zullen we het aantal neuronen berekenen dat we willen.
Dus de truc om een nep-afbeelding te maken is, nou, we gaan het eerst X noemen.
En dan zouden we de toorts die rand gebruiken, want, weet je, we gaan wat willekeurige pixels
in deze afbeeldingen plaatsen die deze willekeurige functies van Torch gebruiken, wat de RAND-functie is.
Binnen gaan we, zoals je kunt zien, de afmetingen van de afbeeldingen invoeren.
Dat is een 1880.
Maar aangezien we dit beeld in het neurale netwerk gaan invoeren en zoals je je herinnert, kan
het neurale netwerk alleen batches van invoerstatus accepteren die hier zijn, batches invoer, afbeeldingen, we gaan
die nep-dimensie creëren, die we kunnen direct doen in deze ronde functie.
We hoeven eigenlijk alleen maar te beginnen met degene die overeenkomt met de batch
en dan kunnen we gewoon de tuple 188 plaatsen die overeenkomt met de afmetingen van de invoerafbeelding.
En zoals je begreep, zijn deze dimensies vervat in deze afbeelding dan argument, dat
de tupel 188 vertegenwoordigt.
Dus nu hoeven we ze alleen nog maar een afbeelding toe te voegen.
Maar om de elementen van een tuple door te geven, want, weet je, nu is image dan
een tuple als een lijst met argumenten van een functie die we hier moeten toevoegen voor image, dan is dat voor de tuple en
start de ster zal toestaan om de elementen van de afbeelding door te geven en vervolgens tuple als een lijst met argumenten
voor functie.
En zoals je kunt zien, is dat precies wat hier is gespecificeerd met de ster en de afmetingen.
Oke.
Dus dat zal een afbeelding van neppixels creëren die niets met de afbeeldingen te maken hebben.
Maar nogmaals, we zullen nog steeds in staat zijn om het uiteindelijke aantal neuronen te krijgen.
En het laatste wat we moeten doen, onthoud, is om deze input-betere vector om te
zetten in een fakkelvariabele, omdat dit in het neurale netwerk gaat.
Oké, dus dit vertegenwoordigt nu een invoerbeeld van willekeurige pixels die zojuist is omgezet in een fakkelvariabele en die
nu in het neurale netwerk zal gaan en meer specifiek, de convolutionele lagen van het neurale
netwerk, want aangezien we alleen het aantal nodig hebben van neuronen nadat de windingen zijn
toegepast, gaan we gewoon door tot conclusie drie.
Dus direct na de derde convolutionele laag en we zullen hier niet ingaan op de twee volledige verbindingen.
En dat komt omdat het aantal neuronen dat we willen tussen convolutie drie en FS1 ligt.
Oke.
Dus nu we één invoerafbeelding met de juiste afmetingen hebben, is het tijd om deze afbeelding in het neurale
netwerk te verspreiden om de afvlakkingslaag te bereiken.
En dan krijgen we de neuronen in de afvlakkingslaag en krijgen we gewoon de informatie die we
willen.
Dat is het aantal neuronen in deze afvlakkende laag.
Dus wat we nu moeten doen, is precies wat we doen in de voorwaartse functie.
We moeten de signalen in het neurale netwerk verspreiden, maar alleen in de convolutionele lagen totdat we
de afvlakkingslaag bereiken.
Dus laten we dit doen.
We gaan X nu updaten.
X is het invoerbeeld en met de tweede X hier, wordt X, nou ja, de eerste convolutionele laag.
Wat we nu moeten doen, is een proces in drie stappen.
Eerste stap.
We passen de convolutie toe op de invoerbeelden.
Dan de tweede stap, passen we toe op de verkregen ingewikkelde afbeeldingen en dan de derde stap, we activeren
de neuronen in deze samengevoegde, ingewikkelde afbeeldingen.
En zo wordt X deze eerste convolutionele laag die bestaat uit al deze poelen, gecompliceerde beelden.
Dus laten we deze eerste stap doen, de eerste convolutie convolutie één toepassen op de invoerafbeeldingen.
Dus wat we doen is onze convolutie zelf nemen.
Die convolutie.
Daar gaan we.
We passen het toe op onze invoerafbeeldingen, die tot nu toe worden weergegeven door X.
Dus dat is de eerste stap.
Eerste stap gedaan.
Nu, tweede stap.
We gaan Max pooling toepassen op onze ingewikkelde afbeeldingen die zijn geretourneerd door bijdrage één X en Max Pwning
toepassen.
Welnu, we nemen een functie van de functionele module.
Dus we nemen f de snelkoppeling, dan punt en dan gaan we de functie max pool naar G gebruiken.
Dat is degene die we zelfconvolutie één X tussen haakjes plaatsen van de max pool van de functie.
Omdat we aan het spelen zijn, poolen in de ingewikkelde beelden, maar deze maximale pooling-functie vereist
extra argumenten die voorop staan, zegt de kolonel.
Dus nogmaals, dat is de grootte van het venster dat door je afbeeldingen schuift en dat zal het maximum van de pixels
in elk licht nodig hebben.
Die zal de features nog detecteren omdat de features gekoppeld zijn aan een hogere waarde van de pixel in de
arrays, zoals je bij de intuïtieve docent zag.
Dus dit eerste argument dat we hier moeten invoeren, is deze kernelgrootte en we gaan er drie nemen.
Dat is een gebruikelijke keuze voor de kernelgrootte.
En dan moeten we de stappen invoeren, weet je, met hoeveel pixels het in de afbeeldingen gaat schuiven.
En we zouden een staking van twee nemen.
Nogmaals, dat is een veelvoorkomende keuze.
Dus daar gaan we.
Nu is de tweede stap gedaan.
En laten we nu verder gaan met de derde stap, namelijk het activeren van alle neuronen in deze poel en ingewikkelde
beelden in deze eerste convolutionele laag.
En om dit opnieuw te doen, gaan we een functie op dit alles toepassen.
En dus doe ik hem hier weer uit, want we gaan een andere functie nemen, die, zoals je
misschien al geraden had, een activeringsfunctie zal zijn.
Maar welke?
Zoals gewoonlijk wordt het een activeringsfunctie van de gelijkrichter.
En misschien herinner je je de naam daarvoor is dat we gaan, dat is het.
En dus passen we echt toe op onze samengevoegde, ingewikkelde afbeeldingen.
Dat is dit alles.
Oke.
En dat is het.
Drie stappen gedaan.
Dat was heel snel.
Dus onthoud, de manier waarop we hier naar moeten kijken, is dat we eerst de convolutie toepassen op onze invoerafbeeldingen.
Dan passen we, Max, volledig toe op onze ingewikkelde afbeeldingen die met de convolutie zijn verkregen.
En dan activeren we de neuronen in deze gepoolde convolutionele laag met de gelijkrichteractiveringsfunctie.
Zo perfect, we krijgen onze eerste convolutionele laag waarop max pooling is aangebracht en waarin de neuronen
nu worden geactiveerd.
Wat het eigenlijk doet, is dat het de signalen van de eerste convolutionele laag naar de volgende
propageert.
En over de volgende gesproken, dat is precies waar we nu voor gaan zorgen.
We gaan hetzelfde doen als op de eerste convolutionele laag naar de tweede convolutionele laag
om de signalen opnieuw verder in het neurale netwerk te verspreiden door de neuronen van de tweede convolutionele
laag te activeren.
Maar voordat we dit doen, moeten we deze convolutionele laag krijgen.
En dus gaan we convolutie toepassen op X.
Dat is nu de eerste convolutionele laag waarop we convolutie gaan toepassen op X om
de tweede convolutionele laag te verkrijgen, waarna we eraan trekken en dan uiteindelijk zijn Terrans activeren.
Dus laten we dit doen.
Het is eigenlijk heel gemakkelijk.
We hoeven dat alleen maar te kopiëren en hieronder te plakken.
Nu moeten we natuurlijk ook convolutie één door convolutie vervangen.
En daar gaan we.
Dat is eigenlijk klaar c heel gemakkelijk.
En nu met deze lijn, propageren we de signalen van de tweede convolutionele laag naar de volgende, die
de derde convolutionele laag zal zijn.
En om de derde convolutionele laag te krijgen, moeten we die opnieuw toepassen.
Dus ik kopieer dit, plak dat hieronder en vervang convolutie door convolutie drie.
En dat is gedaan.
Is het niet zo praktisch dat we de signalen in de drie convolutionele lagen en een zaklamp verspreiden dankzij
deze geweldige structuur.
Oké, zo perfect.
Nu hebben we onze signalen gepropageerd naar de derde convolutionele laag en daarna en sprekend van daarna, dat leidt ons
naar wat we zoeken, waar we in geïnteresseerd zijn.
Dat is de afvlakking daar.
Oke.
Dus nu we onze derde convolutie daar hebben, dat is de laatste X hier, is het tijd om onze Flatman-laag te krijgen.
En dat is dus precies wat we nu gaan doen.
We gaan alle pixels van deze derde convolutionele laag afvlakken.
Dat wil zeggen dat we alle pixels van alle kanalen van de derde convolutionele laag gaan nemen.
We gaan ze een voor een in een enorme vector plaatsen.
En natuurlijk zal deze enorme vector niets anders zijn dan de afvlakkingslaag.
En tegelijkertijd zullen we een truc gebruiken om het aantal neuronen in deze afvlakkende laag te krijgen.
Dat is precies wat we zoeken.
Dat is het aantal neuronen dat we missen.
En laten we daarom direct teruggeven wat we willen.
En in deze terugkeer gaan we de derde convolutionele laag afvlakken en tegelijkertijd het aantal neuronen in
deze afgeplatte laag krijgen.
Dus we gaan X nemen, wat onze derde convolutie daar is.
We nemen alle kanalen van de derde convolutie daar.
En we gaan een functie gebruiken die de groottefunctie is om alle pixels van al deze kanalen in
éénzelfde enorme vector af te vlakken.
En dus de truc, je kunt het vinden in de Python-tutorial.
Welnu, we nemen eerst de gegevens van X omdat X een speciale structuur is.
Weet je, het is een fakkelvariabele.
Het heeft dus een vrij complexe structuur.
Maar eerst moeten we hier toegang krijgen met gegevens.
Dan moeten we kijken wat erin zit.
Dus we gebruiken deze weergavefunctie en nu moeten we toegang krijgen tot wat we zoeken.
En dat wordt gegeven met de argumenten één en min één.
Je hoeft niet te begrijpen wat er in de structuur zit, maar je kunt gewoon begrijpen dat dit is
hoe we dit aantal neuronen gaan krijgen.
En om te eindigen, moeten we de grootte tussen haakjes toevoegen en binnenin voeren we er een in.
Dus wat we hier doen, is dat we alle pixels van alle kanalen nemen en ze een voor een
in deze enorme vector plaatsen, die de invoer zal zijn van het volledig verbonden netwerk.
Dat is eigenlijk wat deze maat doet.
En hiermee kunnen we het aantal neuronen krijgen waarnaar we op zoek zijn.
Oke.
Dus nu krijgen we wat we willen.
En ten slotte kunnen we hier een aantal neuronen vervangen door wat deze functie teruggeeft wanneer deze wordt
toegepast op het formaat van de afbeeldingen.
Dat is één bij acht bij acht.
Dus wat we nu moeten doen is geen neuronen vervangen, maar we nemen het aantal neuronen.
Functie, die we toepassen op het formaat van de afbeeldingen, die de tupel zal zijn.
Tachtig en tachtig en daar gaan we en natuurlijk vergeten we het zelf niet, want Counts Neuron is eigenlijk een methode van
de CNN-klasse, dus we moeten het zelf toevoegen.
En nu zou de waarschuwing moeten verdwijnen.
En daar gaan we.
Nu is alles goed.
We krijgen de architectuur van het neurale netwerk zonder dat er iets ontbreekt.
En we hebben de functie van aftellen voor het geval je een aantal andere architecturen wilt proberen
en dit aantal neuronen niet handmatig wilt tellen.
Deze functie gebruik je gewoon.
Je past het toe op het formaat van je afbeeldingen.
En hiermee krijgt u direct wat u wilt.
Dat is het aantal neuronen in de overstromende laag zonder iets te hoeven doen en wat de architectuur ook is.
Dus dat is best gaaf.
En nu zijn we klaar met de eerste grote, belangrijke stap van dit brein die we maken.
En we hebben nog een laatste stap.
Dat is een functie minder om te maken, wat de belangrijkste voorwaartse functie zal zijn.
Dus we gaan de signalen vanaf het begin van de hersenen verspreiden.
Dat is van de ogen van het oog tot aan de uitgangslaag die na de tweede doorverbinding is.
Dus dat doen we in de volgende tutorial.
En tot dan en ik.