streamalism.org

1. Oversikt

I denne opplæringen vil vi bygge og trene et konvolusjonalt nevralt nettverk modell ved hjelp av Deeplearning4j-biblioteket i Java.

For mer informasjon om hvordan du oppretter biblioteket, se vår guide på Deeplearning4j.

2. Bildeklassifisering

2.1. Problemstilling

Anta at vi har et sett med bilder. Hvert bilde representerer et objekt av en bestemt klasse. Dessuten tilhører objektet på bildet den eneste kjente klassen. Så, problemstillingen er å bygge modellen som vil kunne gjenkjenne objektets klasse på det gitte bildet.

La oss for eksempel si at vi har et sett med bilder med ti håndbevegelser. Vi bygger en modell og trener den for å klassifisere dem. Så etter trening kan vi sende andre bilder og klassifisere håndbevegelsene på dem. Selvfølgelig bør den gitte gesten tilhøre de kjente klassene.

2.2. Bildepresentasjon

I dataminnet kan bildet vises som en matrise av tall. Hvert tall har en pikselverdi, fra 0 til 255.

Et gråtonebilde er en 2D-matrise. Tilsvarende er RGB-bildet en 3D-matrise med bredde, høyde og dybdemål.

Som vi kanskje ser, bildet er et sett med tall. Derfor kan vi bygge flerlags nettverksmodeller for å trene dem i å klassifisere bilder.

3. Konvolusjonelle nevrale nettverk

A Convolutional Neural Network (CNN) er en flerlags nettverksmodell som har en spesifikk struktur. Strukturen til et CNN kan deles inn i to blokker: lag med konvolusjon og fullt sammenkoblede (eller tette) lag. La oss se på hver av dem.

3.1. Convolutional Layer

Hver konvolusjonslag er et sett med firkantede matriser, kalt kjerner. Fremfor alt trenger vi dem for å utføre konvolusjon på inngangsbildet. Mengden og størrelsen kan variere, avhengig av gitt datasett. Vi bruker for det meste 3 × 3 eller 5 × 5 kjerner, og sjelden 7 × 7. Den nøyaktige størrelsen og mengden velges ved prøving og feiling.

I tillegg velger vi tilfeldig variablene til kjernematriser i begynnelsen av toget. De er vektene i nettverket.

For å utføre konvolusjon kan vi bruke kjernen som skyvevindu. Vi vil multiplisere kjernevektene til de tilsvarende bildepikslene og beregne summen. Deretter kan vi flytte kjernen for å dekke neste del av bildet ved å bruke skritt (flytt til høyre) og polstring (flytt ned). Som et resultat vil vi ha verdier som vil bli brukt i videre beregninger.

Kort oppsummert, med dette laget får vi et konvolvert bilde. Noen variabler kan være mindre enn null. Dette betyr vanligvis at disse variablene er mindre viktige enn de andre. Det er derfor å bruke ReLU-funksjonen er en god tilnærming for å gjøre færre beregninger videre.

3.2. Delsamplingslag

Delsamplingslaget (eller pooling) er et lag av nettverket, vanligvis brukt etter konvolusjonslaget. Etter konvolusjonen får vi mange beregnede variabler. Imidlertid er vår oppgave å velge det mest verdifulle blant dem.

Tilnærmingen er å bruke en skyvevinduealgoritme til det konvolverte bildet. Ved hvert trinn velger vi maksimumsverdien i det firkantede vinduet med en forhåndsdefinert størrelse, vanligvis mellom 2 × 2 og 5 × 5 piksler. Som et resultat har vi færre beregnede parametere. Derfor vil dette redusere beregningene.

3.3. Tett lag

Et tett (eller fullt tilkoblet) lag er et som består av flere nevroner. Vi trenger dette laget for å utføre klassifisering. Videre kan det være to eller flere slike påfølgende lag. Det er viktig at det siste laget skal ha en størrelse lik antall klasser for klassifisering.

Utgangen fra nettverket er sannsynligheten for at bildet tilhører hver av klassene. For å forutsi sannsynlighetene bruker vi Softmax-aktiveringsfunksjonen.

3.4. Optimaliseringsteknikker

For å utføre trening, må vi optimalisere vektene. Husk at vi i utgangspunktet velger disse variablene. Nevrale nettverk er en stor funksjon. Og den har mange ukjente parametere, vektene våre.

Når vi sender et bilde til nettverket, gir det oss svaret. Så kan vi bygge en tapsfunksjon, som vil avhenge av dette svaret. Når det gjelder veiledet læring, har vi også et faktisk svar - den sanne klassen. Våre oppdraget er å minimere denne tapsfunksjonen. Hvis vi lykkes, er modellen vår godt trent.

For å minimere funksjonen, må vi oppdatere vektene til nettverket. For å gjøre det, kan vi beregne derivatet av tapsfunksjonen med hensyn til hver av disse ukjente parametrene. Deretter kan vi oppdatere hver vekt.

Vi kan øke eller redusere vektverdien for å finne det lokale minimumet for vår tapfunksjon fordi vi kjenner bakken. Videre denne prosessen er iterativ og kalles Gradient Descent. Backpropagation bruker gradientnedstigning for å overføre vektoppdateringen fra slutten til begynnelsen av nettverket.

I denne opplæringen bruker vi optimaliseringsalgoritmen Stochastic Gradient Decent (SGD). Hovedideen er at vi tilfeldig velger antall togbilder ved hvert trinn. Så bruker vi backpropagation.

3.5. Evalueringsmålinger

Til slutt, etter å ha trent nettverket, må vi få informasjon om hvor godt modellen vår presterer.

Den mest brukte beregningen er nøyaktighet. Dette er forholdet mellom korrekt klassifiserte bilder og alle bilder. I mellomtiden, tilbakekalling, presisjon og F1-poengsum er veldig viktige beregninger for bildeklassifisering også.

4. Datasett Klargjøring

I denne delen forbereder vi bildene. La oss bruke det innebygde CIFAR10-datasettet i denne opplæringen. Vi oppretter iteratorer for å få tilgang til bildene:

offentlig klasse CifarDatasetService implementerer IDataSetService {private CifarDataSetIterator trainIterator; privat CifarDataSetIterator testIterator; public CifarDatasetService () {trainIterator = new CifarDataSetIterator (trainBatch, trainImagesNum, true); testIterator = ny CifarDataSetIterator (testBatch, testImagesNum, false); } // andre metoder og feltdeklarasjon}

Vi kan velge noen parametere alene. TrainBatch og testBatch er henholdsvis antall bilder per tog og evalueringstrinn. TrainImagesNum og testImagesNum er antall bilder for trening og testing. En epoke varer trainImagesNum / trainBatch trinn. Så å ha 2048 togbilder med en batchstørrelse = 32 vil føre til 2048/32 = 64 trinn per en epoke.

5. Convolutional Neural Network in Deeplearning4j

5.1. Bygge modellen

La oss deretter bygge vår CNN-modell fra bunnen av. Å gjøre det, vi bruker konvolusjonslag, undersampling (pooling) og fullt tilkoblede (tette) lag.

MultiLayerConfiguration konfigurasjon = ny NeuralNetConfiguration.Builder () .frø (1611) .optimizationAlgo (OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT) .learningRate (egenskaper.getLearningRate ()) .regularization (true) .updater (egenskaper. GetOptimizer). (0, conv5x5 ()) .layer (1, pooling2x2Stride2 ()) .layer (2, conv3x3Stride1Padding2 ()) .layer (3, pooling2x2Stride1 ()) .layer (4, conv3x3Stride1Padding1 ()) .layer (5, pooling2 )) .layer (6, tett ()) .pretrain (false) .backprop (true) .setInputType (dataSetService.inputType ()) .build (); nettverk = nytt MultiLayerNetwork (konfigurasjon);

Her spesifiserer vi læringsgraden, oppdateringsalgoritmen, inngangstypen til modellen vår og den lagdelte arkitekturen. Vi kan eksperimentere med disse konfigurasjonene. Dermed kan vi trene mange modeller med forskjellige arkitekturer og opplæringsparametere. Videre kan vi sammenligne resultatene og velge den beste modellen.

5.2. Trening av modellen

Deretter trener vi den innebygde modellen. Dette kan gjøres i noen få kodelinjer:

public void train () {network.init (); IntStream.range (1, epochsNum + 1) .forEach (epoke -> {network.fit (dataSetService.trainIterator ());}); }

Antall epoker er parameteren vi kan spesifisere selv. Vi har et lite datasett. Som et resultat vil flere hundre epoker være nok.

5.3. Evaluering av modellen

Til slutt kan vi evaluere den nå trente modellen. Biblioteket Deeplearning4j gir deg muligheten til å gjøre det enkelt:

offentlig evaluering evaluere () {return network.evaluate (dataSetService.testIterator ()); }

Evaluering er et objekt som inneholder beregnede beregninger etter opplæring av modellen. Det er de nøyaktighet, presisjon, tilbakekalling og F1-poengsum. Videre har den et vennlig, utskrivbart grensesnitt:

============================ Poeng ======================== Antall klasser: 11 Nøyaktighet: 0,8406 Presisjon: 0,7303 Tilbakekalling: 0,6820 F1 Score: 0,6466 ============================== =============================

6. Konklusjon

I denne veiledningen har vi lært om arkitekturen til CNN-modeller, optimaliseringsteknikker og evaluering. Videre har vi implementert modellen ved hjelp av Deeplearning4j-biblioteket i Java.

Som vanlig er kode for dette eksemplet tilgjengelig på GitHub.