Hvordan fungerer konvolutionslag i neurale netværk med dybt læring?

Sidst opdateret den 17. april 2020

Konvolutionslag er de vigtigste byggesten, der bruges i sammenfaldne neurale netværk.

En foldning er den enkle anvendelse af et filter på et input, der resulterer i en aktivering. Gentagen anvendelse af det samme filter på en indgang resulterer i et aktiveringskort kaldet et funktionskort, der angiver placeringen og styrken af en detekteret funktion i en indgang, såsom et billede.

Innovationen i sammenfaldende neurale netværk er evnen til automatisk at lære et stort antal filtre parallelt specifikt til et træningsdatasæt under begrænsningerne af et specifikt forudsigeligt modelleringsproblem, såsom billedklassificering. Resultatet er meget specifikke funktioner, der kan detekteres hvor som helst på inputbilleder.

I denne vejledning vil du opdage, hvordan krængninger fungerer i det nedviklede neurale netværk.

Efter at have gennemført denne tutorial, du ved:

• Konvolutionsneurale netværk anvender et filter til en indgang for at oprette et funktionskort, der opsummerer tilstedeværelsen af detekterede funktioner i indgangen.
• Filtre kan håndlaves , som f.eks. linjedetektorer, men innovationen af nedbrydningsneurale netværk er at lære filtrene under træning i forbindelse med et specifikt forudsigelsesproblem. lag i et sammenbrudt neuralt netværk.

Start dit projekt med min nye bog Deep Learning for Computer Vision, inklusive trinvise tutorials og Python-kildekodefiler til alle eksempler.

Lad os komme i gang.

Oversigt over øvelser

Denne vejledning er opdelt i fire dele; de er:

1. Convolution in Convolutional Neural Networks
2. Convolution in Computer Vision
3. Power of Learned Filters
4. Arbejdet eksempel på Konvolutionslag

Vil du have resultater med dyb læring til computersyn?

Tag min gratis 7-dages e-mail-nedbrudskursus nu (med prøvekode).

Klik for at tilmelde dig, og få også en gratis PDF E-bogversion af kurset.

Download din GRATIS Mini- Kurs

Convolution in Convolutional Neural Networks

The convolutional neural network, or CNN for short, is en specialiseret type neuralt netværksmodel designet til at arbejde med todimensionale billeddata, skønt de kan bruges med endimensionelle og tredimensionelle data.

Centralt i det konvolutionsneurale netværk er det konvolutionslag, som giver netværket sit navn. Dette lag udfører en operation kaldet en “foldning”.

I sammenhæng med et nedbrydningsneuralt netværk er en foldning en lineær operation, der involverer multiplikation af et sæt vægte med input, ligesom en traditionel neuralt netværk. I betragtning af at teknikken blev designet til todimensionalt input, udføres multiplikationen mellem en række inputdata og et todimensionalt array af vægte, kaldet et filter eller en kerne.

Filteret er mindre end inputdataene og typen af multiplikation anvendt mellem en filterstørrelse af input og filteret er et prikprodukt. Et prikprodukt er den elementvise multiplikation mellem filterstørrelsen af input og filter, som derefter summeres, hvilket altid resulterer i en enkelt værdi. Da det resulterer i en enkelt værdi, kaldes operationen ofte det “skalære produkt”.

Brug af et filter, der er mindre end input, er forsætligt, da det tillader det samme filter (sæt af vægte) at være ganget med input-arrayet flere gange på forskellige punkter på input. Specifikt påføres filteret systematisk på hver overlappende del eller filterstørrelse af inputdataene, venstre mod højre, top til bund.

Denne systematiske anvendelse af det samme filter på tværs af et billede er en stærk idé . Hvis filteret er designet til at registrere en bestemt type funktion i inputet, giver anvendelsen af dette filter systematisk på tværs af hele inputbilledet filteret en mulighed for at opdage denne funktion hvor som helst i billedet. Denne evne kaldes almindeligvis oversættelsesvariation, f.eks. den generelle interesse i, om funktionen er til stede i stedet for, hvor den var til stede.

Uoverensstemmelse med lokal oversættelse kan være en meget nyttig egenskab, hvis vi bekymrer os mere om om en eller anden funktion er til stede end præcis hvor den er.For eksempel, når vi bestemmer, om et billede indeholder et ansigt, behøver vi ikke kende placeringen af øjnene med pixel-perfekt nøjagtighed, vi skal bare vide, at der er et øje på venstre side af ansigtet og et øje til højre side af ansigtet.

– Side 342, Deep Learning, 2016.

Output fra multiplikation af filteret med input-arrayet én gang er en enkelt værdi. Da filteret anvendes flere gange på input-arrayet, er resultatet et to-dimensionelt array af output-værdier, der repræsenterer en filtrering af input. Som sådan kaldes det to-dimensionelle output-array fra denne operation et “funktionskort”.

Når et funktionskort er oprettet, kan vi videregive hver værdi i funktionskortet gennem en ikke-linearitet, såsom en ReLU, ligesom vi gør for output af et fuldt tilsluttet lag.

Hvis du kommer fra et digitalt signalbehandlingsfelt eller et beslægtet område i matematik, kan du forstå forståelsesoperationen på en matrix som noget andet . Specifikt vendes filteret (kernen), inden det påføres input. Teknisk set er sammenblandingen som beskrevet i brugen af nedbrydningsneurale netværk faktisk en “krydskorrelation”. Ikke desto mindre kaldes det i dyb læring en “konvolutionsoperation”.

Mange maskinlæringsbiblioteker implementerer krydskorrelation, men kalder det foldning.

– Side 333, Deep Learning, 2016.

Sammenfattende har vi et input, såsom et billede af pixelværdier, og vi har et filter, der er et sæt vægte, og filteret anvendes systematisk på inputdataene for at oprette et funktionskort .

Convolution in Computer Vision

Idéen om at anvende den konvolutionsoperation til billeddata er ikke ny eller unik for nedviklede neurale netværk; det er en almindelig teknik, der anvendes i computersyn.

Historisk set blev filtre designet med hånden af computersynseksperter, som derefter blev anvendt på et billede for at resultere i et funktionskort eller output fra anvendelse af filteret og derefter fremstiller analysen af billedet lettere på en eller anden måde.

For eksempel er nedenfor et håndlavet 3 × 3 elementfilter til detektering af lodrette linjer:

Anvendelse af dette filter på en billede resulterer i et funktionskort, der kun indeholder lodrette linjer. Det er en lodret linjedetektor.

Du kan se dette fra vægtværdierne i filteret; eventuelle pixelværdier i den lodrette midterlinje aktiveres positivt, og alle på begge sider aktiveres negativt. At trække dette filter systematisk over pixelværdier i et billede kan kun fremhæve lodrette liniepixels.

En vandret liniedetektor kunne også oprettes og også anvendes på billedet, for eksempel:

Kombination af resultaterne fra begge filtre, f.eks ved at kombinere begge funktionskort, vil alle linjer i et billede blive fremhævet.

En pakke med titusinder eller endda hundreder af andre små filtre kan designes til at registrere andre funktioner i billedet.

Innovationen ved at bruge konvolutionsoperationen i et neuralt netværk er, at filterets værdier er vægte, der skal læres under træningen af netværket.

Netværket lærer, hvilke typer funktioner der skal uddrag fra input. Specifikt er træning under stokastisk gradientnedstigning tvunget til at lære at udtrække funktioner fra billedet, der minimerer tabet for den specifikke opgave, som netværket trænes i at løse, f.eks. udtræk funktioner, der er de mest nyttige til klassificering af billeder som hunde eller katte.

I denne sammenhæng kan du se, at dette er en stærk idé.

Effekten af indlærede filtre

At lære et enkelt filter, der er specifikt for en maskinindlæringsopgave, er en stærk teknik.

Alligevel opnår konvolutionsneurale netværk meget mere i praksis .

Flere filtre

Convolutionsneurale netværk lærer ikke et enkelt filter; de lærer faktisk flere funktioner parallelt for en given input.

For eksempel er det almindeligt, at et sammenblandingslag lærer fra 32 til 512 filtre parallelt for en given input.

Dette giver modellen 32 eller endda 512 forskellige måder at udtrække funktioner fra en input eller mange forskellige måder til både “at lære at se” og efter træning, mange forskellige måder at “se” inputdataene på.

Denne mangfoldighed tillader specialisering, f.eks ikke kun linjer, men de specifikke linjer, der ses i dine specifikke træningsdata.

Flere kanaler

Farvebilleder har flere kanaler, typisk en for hver farvekanal, såsom rød, grøn, og blå.

Fra et dataperspektiv betyder det, at et enkelt billede, der leveres som input til modellen, faktisk er tre billeder.

Et filter skal altid have det samme nummer af kanaler som input, ofte omtalt som “dybde”. Hvis et inputbillede har 3 kanaler (f.eks. En dybde på 3), skal et filter, der anvendes på dette billede, også have 3 kanaler (f.eks. En dybde på 3). I dette tilfælde ville et 3 × 3-filter faktisk være 3x3x3 eller for rækker, kolonner og dybde. Uanset dybden af indgangen og dybden af filteret påføres filteret indgangen ved hjælp af en punktprodukthandling, der resulterer i en enkelt værdi.

Dette betyder, at hvis et sammenblandingslag har 32 filtre, disse 32 filtre er ikke kun todimensionale for det todimensionale billedinput, men er også tredimensionelle og har specifikke filtervægte for hver af de tre kanaler. Alligevel resulterer hvert filter i et enkelt funktionskort. Hvilket betyder, at dybden af output for at anvende det foldede lag med 32 filtre er 32 for de 32 oprettede funktionskort.

Flere lag

Convolutionslag anvendes ikke kun på inputdata , for eksempel rå pixelværdier, men de kan også anvendes på output fra andre lag.

Stablingen af sammenfoldelige lag muliggør en hierarkisk nedbrydning af inputet.

Overvej, at de filtre, der fungerer direkte på de rå pixelværdier lærer at udtrække funktioner på lavt niveau, såsom linjer.

De filtre, der fungerer på output fra de første linielag, kan udtrække funktioner, der er kombinationer af funktioner på lavere niveau, såsom funktioner, der omfatter flere linjer for at udtrykke former.

Denne proces fortsætter, indtil meget dybe lag trækker ansigter, dyr, huse osv.

Dette er præcis, hvad vi ser i praksis. Abstraktion af funktioner til høje og højere ordrer, når netværksdybden øges.

Arbejdet eksempel på konvolutionslag

Keras dyb læringsbibliotek giver en række konvolutionslag.

Vi kan bedre forstå sammenblandingsoperationen ved at se på nogle bearbejdede eksempler med konstruerede data og håndlavede filtre.

I dette afsnit ser vi på både et endimensionelt foldningslag og et eksempel på et todimensionalt konvolutionslag, der begge gør konvolutionsoperationen konkret og giver et bearbejdet eksempel på brug af Keras-lagene.

Eksempel på 1D-konvolutionslag

Vi kan definere en en- dimensionel input, der har otte elementer, alle med værdien 0,0, med en to-element-bump i midten med værdierne 1.0.

Inputtet til Keras skal være tredimensionelt for et 1D-konvolutionslag.

Den første dimension refererer til hver inputprøve; i dette tilfælde har vi kun en prøve. Den anden dimension henviser til længden af hver prøve; i dette tilfælde er længden otte. Den tredje dimension henviser til antallet af kanaler i hver prøve; i dette tilfælde har vi kun en enkelt kanal.

Derfor vil formen på input-arrayet være.

Vi definerer en model, der forventer, at inputprøver har formen.

Modellen har et enkelt filter med formen på 3 eller tre elementer brede. Keras henviser til filterets form som kernen_størrelse.

Som standard initialiseres filtre i et konvolutionslag med tilfældige vægte. I dette konstruerede eksempel vil vi manuelt specificere vægtene for det enkelte filter. Vi definerer et filter, der er i stand til at detektere ujævnheder, det vil sige en høj inputværdi omgivet af lave inputværdier, som vi definerede i vores inputeksempel.

Det treelementfilter, vi definerer, ser således ud:

Det konvolutionslag har også en bias-inputværdi, der også kræver en vægt, som vi vil sætte til nul.

Derfor vi kan tvinge vægtene af vores endimensionelle sammenblandingslag til at bruge vores håndlavede filter som følger:

Vægtene skal angives i kl. tredimensionel struktur med hensyn til rækker, kolonner og kanaler. Filteret har en enkelt række, tre kolonner og en kanal.

Vi kan hente vægtene og bekræfte, at de var indstillet korrekt.

Endelig kan vi anvende det enkelte filter på vores inputdata.

Vi kan opnå dette ved at kalde forudsigelsesfunktionen () på modellen. Dette returnerer funktionskortet direkte: det vil sige output for at anvende filteret systematisk på tværs af indgangssekvensen.

At binde alt dette sammen er det komplette eksempel angivet nedenfor.

Når du kører eksemplet, udskrives først netværkets vægte; det er bekræftelsen på, at vores håndlavede filter blev indstillet i modellen, som vi forventede.

Derefter påføres filteret på inputmønsteret, og funktionskortet beregnes og vises. Vi kan se på funktionskortets værdier, at bumpen blev registreret korrekt.

Lad os se nærmere på, hvad der skete her.

Husk at input er en otte elementvektor med værdierne:.

Først blev treelementfiltret anvendt på de første tre indgange af sat ved at beregne punktproduktet (“.” -operatøren), hvilket resulterede i en enkelt outputværdi i funktionskortet nul.

I vores manuelle eksempel er dette som følger:

Filteret blev derefter flyttet langs et element af input-sekvensen og processen blev gentaget; specifikt blev det samme filter anvendt på indgangssekvensen ved indeks 1, 2 og 3, hvilket også resulterede i nul output i funktionskortet.

Vi er systematiske, så igen, filter flyttes langs et yderligere element i input og påføres input ved indeks 2, 3 og 4. Denne gang er output en værdi af en i funktionskortet. Vi registrerede funktionen og aktiverede passende.

Processen gentages, indtil vi beregner hele funktionskort.

Bemærk, at funktionskortet har seks elementer, mens vores input har otte elementer. Dette er en artefakt af, hvordan filteret blev anvendt på indgangssekvensen. Der er andre måder at anvende filteret på indgangssekvensen, der ændrer formen på det resulterende funktionskort, såsom polstring, men vi diskuterer ikke disse metoder i dette indlæg.

Du kan forestille dig det med forskellige input kan vi muligvis registrere funktionen med mere eller mindre intensitet og med forskellige vægte i filteret, at vi vil opdage forskellige funktioner i indgangssekvensen.

Eksempel på 2D-konvolutionslag

Vi kan udvide bumpdetekteringseksemplet i det foregående afsnit til en lodret liniedetektor i et todimensionelt billede.

Igen , kan vi begrænse input, i dette tilfælde til et firkantet 8 × 8 pixel inputbillede med en enkelt kanal (f.eks. gråtoner) med en enkelt lodret linje i midten.

Input til et Conv2D-lag skal være firedimensionelt.

Den første dimension definerer prøverne; i dette tilfælde er der kun en enkelt prøve. Den anden dimension definerer antallet af rækker; i dette tilfælde otte. Den tredje dimension definerer antallet af kolonner, igen otte i dette tilfælde, og endelig antallet af kanaler, hvilket er en i dette tilfælde.

Derfor skal input have den firedimensionale form eller i denne case.

Vi definerer Conv2D med et enkelt filter, som vi gjorde i det foregående afsnit med Conv1D-eksemplet.

Filteret vil være todimensionalt og kvadratisk med formen 3 × 3. Laget forventer, at inputeksempler har form eller.

Vi definerer en lodret linjedetektorfilter til at registrere den enkelte lodrette linje i vores inputdata.

Filteret ser således ud:

Vi kan implementere dette som følger:

Endelig vil vi anvende filteret på inputbilledet, hvilket vil resultere i et funktionskort, som vi forventer at vise påvisning af den lodrette linje i inputbilledet.

Formen på funktionskortudgangen vil være firedimensionel med formen. Vi udfører en enkelt batch, og vi har et enkelt filter (et filter og en inputkanal), derfor er outputformen. Vi kan udskrive indholdet af det enkelte funktionskort som følger:

Binder alt dette sammen , vises det komplette eksempel nedenfor.

At køre eksemplet først bekræfter, at det håndlavede filter var korrekt defineret i lagvægtene

Dernæst udskrives det beregnede funktionsoversigt. Vi kan se fra tallets skala, at filteret faktisk har registreret den enkelte lodrette linje med stærk aktivering midt på funktionskortet.

Lad os se nærmere på, hvad der blev beregnet.

Først blev filteret anvendt i det øverste venstre hjørne af billedet eller et billedplaster med 3 × 3-elementer. Teknisk set er billedplasteret tredimensionelt med en enkelt kanal, og filteret har de samme dimensioner. Vi kan ikke implementere dette i NumPy ved hjælp af dot () -funktionen, i stedet skal vi bruge tensordot () -funktionen, så vi kan opsummere passende på tværs af alle dimensioner, for eksempel:

Denne beregning resulterer i en enkelt outputværdi på 0,0, f.eks. blev funktionen ikke registreret. Dette giver os det første element i øverste venstre hjørne af funktionskortet.

Manuelt ville dette være som følger:

Filteret flyttes langs en kolonne til venstre, og processen gentages. Igen registreres funktionen ikke.

Yderligere en bevægelse til venstre til næste kolonne, og funktionen registreres for første gang, hvilket resulterer i en stærk aktivering.

Denne proces gentages, indtil filterets kant hviler mod kanten eller den sidste kolonne i inputbilledet. Dette giver det sidste element i den første fulde række af funktionskortet.

Filteret bevæger sig derefter ned en række og tilbage til den første kolonne og processen er relateret fra venstre til højre for at give den anden række på funktionskortet. Og til, indtil bunden af filteret hviler på den nederste eller sidste række af inputbilledet.

Igen, som med det foregående afsnit, kan vi se, at funktionskortet er en 6 × 6 matrix, mindre end 8 × 8-inputbilledet på grund af begrænsningerne i, hvordan filteret kan anvendes på inputbilledet.

Yderligere læsning

Dette afsnit giver flere ressourcer om emnet, hvis du er ønsker at gå dybere.

Indlæg

• Crash Course in Convolutional Neural Networks for Machine Learning

Books

• Kapitel 9: Konvolutionsnetværk, Deep Learning, 2016.
• Kapitel 5: Deep Learning for Computer Vision, Deep Learning with Python, 2017.

API

• Keras Convolutional Layers API
• numpy.asarray API

Oversigt

I denne vejledning opdagede du hvordan indviklinger fungerer i det konvolutionelle neurale netværk.

Specifikt lærte du:

• Convolutionsneurale netværk anvender et filter til en input for at oprette et funktionskort, der opsummerer tilstedeværelsen af registrerede funktioner i inputet.
• Filtre kan håndlaves, f.eks. linjedetektorer, men innovationen af nedviklede neurale netværk er at lære filtrene under træning i sammenhæng med et specifikt forudsigelsesproblem.
• Sådan beregnes funktionskortet for et- og todimensionalt sammenblandingslag i et nedbrydningsneuralt netværk.

Har du spørgsmål?
Stil dine spørgsmål i kommentarerne nedenfor, så vil jeg gøre mit bedst at svare.