streamalism.org

1. Oversigt

I denne vejledning vil vi opbygge og træne et sammenbrudt neuralt netværk model ved hjælp af Deeplearning4j-biblioteket i Java.

For yderligere information om, hvordan du opretter biblioteket, henvises til vores guide til Deeplearning4j.

2. Billedklassificering

2.1. Problemformulering

Antag, at vi har et sæt billeder. Hvert billede repræsenterer et objekt i en bestemt klasse. Desuden tilhører objektet på billedet den eneste kendte klasse. Så, problemstillingen er at opbygge den model, der er i stand til at genkende objektets klasse på det givne billede.

Lad os for eksempel sige, at vi har et sæt billeder med ti håndbevægelser. Vi bygger en model og træner den til at klassificere dem. Derefter efter træning kan vi sende andre billeder og klassificere håndbevægelserne på dem. Naturligvis skal den givne gest tilhøre de kendte klasser.

2.2. Billedrepræsentation

I computerens hukommelse kan billedet repræsenteres som en matrix med tal. Hvert tal er en pixelværdi, der spænder fra 0 til 255.

Et gråtonebillede er en 2D-matrix. Tilsvarende er RGB-billedet en 3D-matrix med bredde, højde og dybdemål.

Som vi måske ser, billedet er et sæt tal. Derfor kan vi bygge netværksmodeller i flere lag for at træne dem i at klassificere billeder.

3. Konvolutions neurale netværk

Et Convolutional Neural Network (CNN) er en netværksmodel med flere lag, der har en specifik struktur. Strukturen i et CNN kan opdeles i to blokke: sammenfoldelseslag og fuldt forbundne (eller tætte) lag. Lad os se på hver af dem.

3.1. Convolutional Layer

Hver foldet lag er et sæt firkantede matricer, kaldet kerner. Frem for alt har vi brug for dem til at udføre sammenfald på inputbilledet. Deres størrelse og størrelse kan variere afhængigt af det givne datasæt. Vi bruger for det meste 3 × 3 eller 5 × 5 kerner og sjældent 7 × 7 kerner. Den nøjagtige størrelse og mængde vælges ved prøve og fejl.

Derudover vælger vi tilfældigt variablerne i kernematricer i begyndelsen af ​​toget. De er vægten af ​​netværket.

For at udføre sammenfald kan vi bruge kernen som et skydevindue. Vi multiplicerer kernevægtene med de tilsvarende billedpixels og beregner summen. Derefter kan vi flytte kernen for at dække det næste stykke af billedet ved hjælp af skridt (gå til højre) og polstring (gå ned). Som et resultat har vi værdier, der vil blive brugt i yderligere beregninger.

Kort sagt, med dette lag får vi et indviklet billede. Nogle variabler kan være mindre end nul. Dette betyder normalt, at disse variabler er mindre vigtige end de andre. Derfor er anvendelse af ReLU-funktionen en god tilgang til at gøre færre beregninger yderligere.

3.2. Subsampling Layer

Subsampling (eller pooling) laget er et lag af netværket, der normalt bruges efter det sammenfaldende lag. Efter sammenfaldet får vi mange beregnede variabler. Vores opgave er dog at vælge det mest værdifulde blandt dem.

Metoden er at anvende en glidende vinduesalgoritme på det indviklede billede. Ved hvert trin vælger vi den maksimale værdi i det firkantede vindue med en foruddefineret størrelse, normalt mellem 2 × 2 og 5 × 5 pixels. Som et resultat har vi færre beregnede parametre. Derfor vil dette reducere beregningerne.

3.3. Tæt lag

Et tæt (eller fuldt forbundet) lag er et, der består af flere neuroner. Vi har brug for dette lag for at udføre klassificering. Desuden kan der være to eller flere af sådanne deraf følgende lag. Det er vigtigt, at det sidste lag skal have en størrelse svarende til antallet af klasser til klassificering.

Outputtet fra netværket er sandsynligheden for, at billedet tilhører hver af klasserne. For at forudsige sandsynlighederne bruger vi Softmax-aktiveringsfunktionen.

3.4. Optimeringsteknikker

For at udføre træning er vi nødt til at optimere vægten. Husk, at vi tilfældigt vælger disse variabler oprindeligt. Det neurale netværk er en stor funktion. Og den har mange ukendte parametre, vores vægte.

Når vi sender et billede til netværket, giver det os svaret. Så må vi måske opbygge en tabsfunktion, som afhænger af dette svar. Med hensyn til overvåget læring har vi også et faktisk svar - den sande klasse. Vores mission er at minimere denne tabsfunktion. Hvis vi lykkes, er vores model veluddannet.

For at minimere funktionen er vi nødt til at opdatere netværkets vægte. For at gøre det kan vi beregne afledningen af ​​tabsfunktionen med hensyn til hver af disse ukendte parametre. Derefter kan vi opdatere hver vægt.

Vi kan øge eller sænke vægtværdien for at finde det lokale minimum af vores tabsfunktion, fordi vi kender hældningen. I øvrigt, denne proces er iterativ og kaldes Gradient Descent. Backpropagation bruger gradientnedstigning til at udbrede vægtopdateringen fra slutningen til begyndelsen af ​​netværket.

I denne vejledning bruger vi Stochastic Gradient Decent (SGD) optimeringsalgoritmen. Hovedideen er, at vi tilfældigt vælger antallet af togbilleder ved hvert trin. Så anvender vi backpropagation.

3.5. Evalueringsmålinger

Endelig efter træning af netværket er vi nødt til at få oplysninger om, hvor godt vores model klarer sig.

Den mest anvendte metric er nøjagtighed. Dette er forholdet mellem korrekt klassificerede billeder og alle billeder. I mellemtiden tilbagekaldelse, præcision og F1-score er meget vigtige målinger til billedklassificering såvel.

4. Forberedelse af datasæt

I dette afsnit forbereder vi billederne. Lad os bruge det indlejrede CIFAR10-datasæt i denne vejledning. Vi opretter iteratorer for at få adgang til billederne:

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 felter erklæring}

Vi kan vælge nogle parametre alene. TrainBatch og testBatch er henholdsvis antallet af billeder pr. tog og evalueringstrin. TrainImagesNum og testImagesNum er antallet af billeder til træning og test. En periode varer trainImagesNum / trainBatch trin. Så at have 2048 togbilleder med en batchstørrelse = 32 vil føre til 2048/32 = 64 trin pr. Periode.

5. Konvolutions neuralt netværk i Deeplearning4j

5.1. Opbygning af modellen

Lad os derefter bygge vores CNN-model fra bunden. At gøre det, vi bruger foldnings-, undersampling (pooling) og fuldt forbundne (tætte) lag.

MultiLayerConfiguration konfiguration = ny NeuralNetConfiguration.Builder () .seed (1611) .optimizationAlgo (OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT) .learningRate (egenskaber.getLearningRate ()) .regularization (true) .updater (egenskaber.getOptimizer) (0, conv5x5 ()) .lag (1, pooling2x2Stride2 ()) .lag (2, conv3x3Stride1Padding2 ()). Lag (3, pooling2x2Stride1 ()). Lag (4, conv3x3Stride1Padding1 ()) .lag (5, pool2 )) .lag (6, tæt ()). fortolkning (falsk). backprop (sand) .setInputType (dataSetService.inputType ()) .build (); netværk = nyt MultiLayerNetwork (konfiguration);

Her specificerer vi læringshastigheden, opdateringsalgoritmen, inputtypen på vores model og den lagdelte arkitektur. Vi kan eksperimentere med disse konfigurationer. Således kan vi træne mange modeller med forskellige arkitekturer og træningsparametre. Desuden kan vi sammenligne resultaterne og vælge den bedste model.

5.2. Træning af modellen

Derefter træner vi den indbyggede model. Dette kan gøres i et par kodelinjer:

offentligt ugyldigt tog () {network.init (); IntStream.range (1, epochsNum + 1) .forEach (epoke -> {network.fit (dataSetService.trainIterator ());}); }

Antallet af epoker er den parameter, som vi selv kan specificere. Vi har et lille datasæt. Som et resultat vil flere hundrede epoker være nok.

5.3. Evaluering af modellen

Endelig kan vi evaluere den nu uddannede model. Deeplearning4j-biblioteket giver mulighed for at gøre det let:

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

Evaluering er et objekt, der indeholder beregnede metrics efter træning af modellen. De er nøjagtighed, præcision, tilbagekaldelse og F1-score. Desuden har den en venlig udskrivbar grænseflade:

=========================== Scores ======================= Antal af klasser: 11 Nøjagtighed: 0,8406 Præcision: 0,7303 Tilbagekaldelse: 0,6820 F1 Score: 0,6466 ============================= =============================

6. Konklusion

I denne vejledning har vi lært om arkitekturen af ​​CNN-modeller, optimeringsteknikker og evaluering. Desuden har vi implementeret modellen ved hjælp af Deeplearning4j-biblioteket i Java.

Som sædvanlig er koden til dette eksempel tilgængelig på GitHub.