bildegjenkjenning Med Maskinlæring på Python, Convolutional Nevrale Nettverk

kilde: Irish times, Pó[email protected] Muirí

etter forbehandling av dataene, er det på tide å bygge vår modell for å utføre bildegjenkjenningsoppgaven. En av teknikken bruker Convolution Nevrale Nettverk.

denne artikkelen følger artikkelen jeg skrev om bildebehandling. Etter at dataene er tilgjengelige for bildegjenkjenningsoppgave, er det på tide å lage en algoritme som skal utføre oppgaven. Blant mange teknikker som brukes til å gjenkjenne bilder som flerlags perceptron modell, Convolution Neural Network (CNN) vises som en svært effektiv en. I denne artikkelen vil vi se hvordan du bygger EN CNN og hvordan du bruker den på et datasett av bilder.

når vi begynner å bygge en bildegjenkjenningsmodell for første gang, er det vanligvis en god ide å trene og evaluere den på et relativt enkelt datasett.

en av de enkleste oppgavene vi kan utføre er håndskrevet digitgjenkjenning. Gitt et bilde av et håndskrevet siffer (dvs., 0, 1, …, 9), vi vil at vår modell skal kunne klassifisere sin numeriske verdi riktig. Selv om denne oppgaven virker relativt enkel, brukes den faktisk ganske ofte i virkeligheten, for eksempel automatisk å trekke ut kredittkortnumre fra et bilde. DATASETTET vi skal bruke for digitalgjenkjenning ER MNIST-datasettet, som er datasettet som brukes til maskinlæringsbasert digitalgjenkjenning.databasen MNIST (Modified National Institute Of Standards and Technology) inneholder 60 000 treningseksempler og 10 000 testeksempler. Databasen inneholder gråtoner håndskrevne sifre som ble endret for å passe i en 20×20 pixel boks, som deretter ble sentrert i en 28×28 bilde (polstret med mellomrom). MNIST-databasen er tilgjengelig Via Python.

I denne artikkelen vil jeg vise deg hvordan du koder Ditt Convolutional Neural Network ved hjelp av keras, Tensorflows API på HØYT NIVÅ. Jeg bruker tensorflow 2.0 i denne artikkelen.

1-Initialisering

siden hvert gråtonebilde har dimensjoner 28×28, er det 784 piksler per bilde. Derfor tilsvarer hvert inngangsbilde en tensor på 784 normaliserte flyttallsverdier mellom 0,0 og 1,0. Etiketten for et bilde er en en-varm tensor med 10 klasser (hver klasse representerer et siffer). Når det gjelder koden vår, har vi img_rows = 28, img_cols = 28 og num_classes = 10. Dermed har inngangen form (number_examples, img_rows, img_cols) dermed 60000x28x28. Et annet viktig element å sette opp er tilfeldig frø som vi ønsker å holde startpunktet når en datamaskin genererer en tilfeldig tallsekvens.

VI importerer OGSÅ MNIST-datasettet.

import tensorflow as tf # tensorflow 2.0
from keras.datasets import mnist
import numpy as npseed=0
np.random.seed(seed) # fix random seed
tf.random.set_seed(seed)# input image dimensions
num_classes = 10 # 10 digits
img_rows, img_cols = 28, 28 # number of pixels
# the data, shuffled and split between train and test sets
(X_train, Y_train), (X_test, Y_test) = mnist.load_data()

2-Omforming og rescaling

som nevnt i forrige avsnitt, innganger har form (number_examples, img_rows, img_cols). Men for å kunne bruke dataene med vårt innviklede nevrale nettverk, må vi få DET INN I NHWC-format.

NHWC-formatet har en form med fire dimensjoner:

  1. Antall bildedataprøver (batchstørrelse)
  2. Høyde på hvert bilde
  3. Bredde på hvert bilde
  4. Kanaler per bilde

høyden og bredden på hvert bilde fra datasettet er img_rows og img_cols, mens antall kanaler er 1 (siden bildene er gråtoner).

hver piksel inneholder også en gråtoneverdi kvantifisert med et heltall mellom 0 og 255. Så er databasen normalisert for å ha flyttallsverdier mellom 0,0 og 1,0. I dette tilfellet tilsvarer 0,0 en gråtonepikselverdi på 255 (ren hvit), mens 1.0 tilsvarer en gråtonepikselverdi på 0 (ren svart).

X_train = X_train.reshape(X_train.shape, img_rows, img_cols, 1) 
X_test = X_test.reshape(X_test.shape, img_rows, img_cols, 1)input_shape = (img_rows, img_cols, 1)# cast floats to single precision
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')# rescale data in interval
X_train /= 255
X_test /= 255

3 – Casting label vektorer Y

vi må forvandle våre klasser til vektorer. Vi gjør dette ved å trykke på følgende linje:

Y_train = keras.utils.to_categorical(Y_train, num_classes)
Y_test = keras.utils.to_categorical(Y_test, num_classes)

for å få en bedre forklaring på dette trinnet, bør du se denne artikkelen.

Nå som vi har prosess våre data, kan vi begynne å bygge ut modell.

Convolution Neural Network model

som nevnt i slutten av artikkelen jeg skrev Om Bildebehandling, spiller filtre en stor rolle i bildegjenkjenning. Vi bruker filtre til å transformere innganger og trekke ut funksjoner som gjør at modellen vår kan gjenkjenne bestemte bilder. Et meget høyt nivå eksempel på dette ville være en kurve oppdage filter, som gjør at vår modell for å skille mellom sifre med kurver og sifre uten kurver.

1-Filtre

som alle nevrale nettverksvekter er filterets vekter trenbare variabler. Vi trener vårt nevrale nettverk (via kernel matrix weights) for å produsere filtre som er i stand til å trekke ut de mest nyttige skjulte funksjonene.

når inngangsdataene har flere kanaler, vil et filter ha en separat kjernematrise per kanal. MNIST-datasettet har bare en kanal, MEN for andre typer bildedata (F.EKS.

2-Convolution

Vi har nå nådd fokuspunktet for convolutional neural networks:convolution. Konvolusjonen representerer hvordan vi bruker våre filtervekter til inngangsdata. Hovedoperasjonen som brukes av en konvolusjon er matrisepunktproduktet, dvs. en summering over det elementvise produktet av to matriser.

antall matrix dot produkter i en konvolusjon avhenger av dimensjonene av inngangsdata og kjernematrise, samt skrittstørrelsen. Skrittstørrelsen er den vertikale / horisontale forskyvningen av kjernematrisen når den beveger seg langs inngangsdataene.

3-Padding

noen ganger, når vi gjør dot produktoperasjonen som sett før, bruker vi ikke en rad eller en kolonne. For å unngå dette fenomenet kan vi bruke polstring.

Dermed, Hvis vi ønsker å bruke alle inngangsdata i vår konvolusjon, kan vi pad input data matrix med 0 ‘s. Dette betyr at vi legger til rader / kolonner laget helt av 0’ s til kantene av input data matrix. Siden 0 multiplisert med et hvilket som helst tall resulterer i 0, påvirker ikke polstringen matrix dot-produkter. Dette er viktig fordi vi ikke ønsker å legge til noen forvrengninger til vår konvolusjon.

4-Konvolusjonslag

et konvolusjonslag i EN CNN bruker flere filtre til inngangstensoren. Mens hvert filter har en egen kjernematrise for hver av inngangskanalene, er det totale resultatet av et filters konvolusjon summen av viklingene over alle inngangskanalene.

Ved Å Legge til flere filtre i et konvolusjonslag kan laget bedre trekke ut skjulte funksjoner. Dette kommer imidlertid på bekostning av ekstra treningstid og beregningskompleksitet, siden filtre legger ekstra vekter til modellen. Antall kanaler for utdataene er lik antall filtre som konvolusjonslaget bruker.

Pooling

mens konvolusjonslaget trekker ut viktige skjulte funksjoner, kan antall funksjoner fortsatt være ganske store. Vi kan bruke pooling for å redusere størrelsen på dataene i høyde og bredde dimensjoner. Dette gjør at modellen kan utføre færre beregninger og til slutt trene raskere. Det forhindrer også overfitting, ved å trekke ut bare de mest fremtredende funksjonene og ignorere potensielle forvrengninger eller uvanlige funksjoner som finnes i bare noen få eksempler.

hvordan fungerer pooling?

I Likhet med en konvolusjon bruker vi filtermatriser i pooling. Pooling-filteret har imidlertid ingen vekter, og det utfører heller ikke matrix dot-produkter. I stedet gjelder det en reduksjonsoperasjon for delseksjoner av inngangsdataene.

typen pooling som vanligvis brukes i CNNs, refereres til som max pooling. Filtrene for max pooling bruker max-operasjonen for å oppnå maksimalt antall i hver submatrix av inngangsdataene.

Flere lag

1-Legge til ekstra lag

Som alle nevrale nettverk kan Cnn-er dra nytte av flere lag. De ekstra lagene tillater EN CNN å i hovedsak stable flere filtre sammen for bruk på bildedataene. Men i likhet med å bygge et nevralt nettverk, må vi være forsiktige med hvor mange ekstra lag vi legger til. Hvis vi legger for mange lag til en modell, risikerer vi å ha det overfit til treningsdataene og derfor generalisere svært dårlig. Videre legger hvert ekstra lag til beregningskompleksitet og øker treningstiden for vår modell.

2-Øk filtre

vi øker vanligvis antall filtre i et konvolusjonslag jo dypere det er i vår modell. I dette tilfellet har vårt andre konvolusjonslag 64 filtre, sammenlignet med de 32 filtrene i det første konvolusjonslaget. Jo dypere konvolusjonslaget, desto mer detaljert blir de ekstraherte funksjonene. Det første konvolusjonslaget kan for eksempel ha filtre som trekker ut funksjoner som linjer, kanter og kurver. Når vi kommer til andre nivå, kan filtrene i konvolusjonslaget nå trekke ut flere kjennetegn, for eksempel den skarpe vinkelen til en 77 eller de kryssende kurver av en 88.

fullt tilkoblet lag

1-fullt tilkoblet lag

vi bruker et fullt tilkoblet lag av størrelse 1024 (dvs. antall nevroner i laget) til utgangsdataene til det andre poolinglaget. Antall enheter er noe vilkårlig. Nok til å være kraftig, men ikke så mye som å være for ressurskrevende. Formålet med det fullt tilkoblede laget er å samle datafunksjonene før vi konverterer dem til klasser. Dette gjør at modellen kan gjøre bedre spådommer enn om vi nettopp hadde konvertert pooling-utgangen direkte til klasser.

2-Flattning

dataene vi har brukt i vår modell er AV NHWC-formatet. For å kunne bruke et fullt tilkoblet lag trenger vi imidlertid at dataene skal være en matrise, hvor antall rader representerer batchstørrelsen og kolonnene representerer datafunksjonene. Denne gangen må vi omforme i motsatt retning og konvertere FRA NHWC til en 2-D matrise.

Dropout

1 – Co-adaptation

Co-adaptation refererer til når flere nevroner i et lag trekker ut de samme eller svært like skjulte funksjonene fra inngangsdataene. Dette kan skje når tilkoblingsvektene for to forskjellige nevroner er nesten identiske.

når et fullt tilkoblet lag har et stort antall nevroner, er co-tilpasning mer sannsynlig å forekomme. Dette kan være et problem av to grunner. For det første er det sløsing med beregning når vi har overflødige nevroner som beregner samme utgang. For det andre, hvis mange nevroner trekker ut de samme funksjonene, legger det mer betydning for disse funksjonene for vår modell. Dette fører til overfitting hvis de dupliserte ekstraherte funksjonene er spesifikke for bare treningssettet.

2-Dropout

måten vi minimerer co-tilpasning for fullt tilkoblede lag med mange nevroner, er ved å bruke dropout under trening. I dropout slår vi tilfeldig ned en brøkdel av et lags nevroner ved hvert treningstrinn ved å nullstille nevronverdiene.

Soft-max Layer

Siden det er 10 mulige sifre ET MNIST-bilde kan være, bruker vi et 10 neuron fullt tilkoblet lag for å oppnå klassene for hver sifferklasse. Softmax-funksjonen brukes på klassene for å konvertere dem til sannsynligheter per klasse.

Bygge modellen

nå er vi klare til å bygge vår modell. Her er koden:

from keras.models import Sequential
from keras.layers import Dense, Conv2D, Flatten
from keras.layers import MaxPooling2D, Dropoutmodel = Sequential()#add model layers
model.add(Conv2D(32, kernel_size=(5, 5),
activation='relu',
input_shape=input_shape))
model.add(MaxPooling2D(pool_size=(2, 2)))# add second convolutional layer with 20 filters
model.add(Conv2D(64, (5, 5), activation='relu'))
# add 2D pooling layer
model.add(MaxPooling2D(pool_size=(2, 2)))
# flatten data
model.add(Flatten())
# add a dense all-to-all relu layer
model.add(Dense(1024, activation='relu'))
# apply dropout with rate 0.5
model.add(Dropout(0.5))
# soft-max layer
model.add(Dense(num_classes, activation='softmax'))

modelltypen som vi skal bruke Er Sekvensiell. Sekvensiell er den enkleste måten å bygge en modell I Keras. Det lar deg bygge et modelllag for lag.

vi bruker add () – metoden for å legge lag til vår modell. I forbindelse med vårt innledende eksempel er det nok å fokusere På Tette lag for enkelhet. Hvert Tett () lag aksepterer som sitt første nødvendige argument et heltall som angir antall nevroner. Typen av aktiveringsfunksjon for laget er definert ved hjelp av aktiveringsvalgsargumentet, hvis inngang er navnet på aktiveringsfunksjonen i strengformat. Eksempler er relu, tanh, elu, sigmoid, softmax.

i dette nevrale nettverket har vi 2 konvolusjonslag fulgt hver gang av et poolinglag. Da flater vi dataene for å legge til et tett lag som vi bruker utfall med en hastighet på 0,5. Til slutt legger vi til et tett lag for å tildele hvert bilde med riktig klasse.

Kompilere modellen

Neste må vi kompilere vår modell. Kompilering av modellen tar tre parametere: optimizer, tap og beregninger.

optimalisereren styrer læringshastigheten. Vi skal bruke ‘adam’ som vår optimizer. Adam er generelt en god optimizer å bruke i mange tilfeller. Adam optimizer justerer læringshastigheten gjennom hele treningen.

læringsraten bestemmer hvor raskt de optimale vektene for modellen beregnes. En mindre læringsrate kan føre til mer nøyaktige vekter (opp til et bestemt punkt), men nedbemanningen er databehandlingstiden.

Vi vil bruke ‘categorical_crossentropy’ for vår tap funksjon. Dette er det vanligste valget for klassifisering. En lavere score indikerer at modellen presterer bedre.

for å gjøre ting enda enklere å tolke, bruker vi ‘nøyaktighetsmålingen’ for å se nøyaktighetspoengene på valideringssettet når vi trener modellen.

#compile model using accuracy to measure model performance
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=)

Trening av modellen

nå skal vi trene vår modell. For å trene bruker vi’ fit () ‘ – funksjonen på vår modell med følgende parametere: treningsdata (X_train), måldata (Y_train), valideringsdata og antall epoker.

for våre valideringsdata bruker vi testsettet som er gitt til oss i datasettet vårt, som vi har delt inn I X_test og Y_test.

antall epoker er antall ganger modellen vil sykle gjennom dataene. Jo flere epoker vi kjører, desto mer vil modellen bli bedre, opp til et visst punkt. Etter det punktet vil modellen slutte å forbedre seg i hver epoke. For vår modell vil vi sette antall epoker til 3.

#train the model
model.fit(X_train, Y_train, validation_data=(X_test, Y_test), epochs=3)

Evaluer modellen

nå har vi trent vår modell vi kan evaluere ytelsen:

# evaluate the model
score = model.evaluate(X_test, Y_test, verbose=1)
# print performance
print()
print('Test loss:', score)
print('Test accuracy:', score)

dermed har vi en nøyaktighet på 99,3% og en tapt på 0.025 på testsettet som er veldig bra. Vi kan fortsatt forbedre modellen ved å øke antall epoker og ved å innføre en batchstørrelse.

Foreta spådommer

hvis du vil se de faktiske spådommene som vår modell har laget for testdataene, kan vi bruke predict_classes-funksjonen. Vi kan ogsa til dette ved a bruke predict-funksjonen vil du gi en matrise med 10 tall. Disse tallene er sannsynlighetene for at inngangsbildet representerer hvert siffer (0-9). Matriseindeksen med det høyeste tallet representerer modellforutsigelsen. Summen av hver matrise er lik 1 (siden hvert tall er en sannsynlighet).

For å vise dette, viser vi spådommene for de første 4 bildene i testsettet.

Merk: hvis vi har nye data, kan vi legge inn våre nye data i predict-funksjonen for å se prognosene vår modell gjør på de nye dataene. Siden vi ikke har noen nye usette data, vil vi vise spådommer ved hjelp av testsettet for nå.

#predict first 4 images in the test set
model.predict_classes(X_test)

#predict first 4 images in the test set
model.predict(X_test)

We can see that our model predicted 7, 2, 1 and 0 for the first four images.

Let’s compare this with the actual results.

#actual results for first 4 images in test set
y_test

de faktiske resultatene viser at de fire første bildene også er 7, 2,1 og 0. Vår modell spådd riktig!

hele modellen

import tensorflow as tf # tensorflow 2.0
from keras.datasets import mnist
import numpy as np
seed=0
np.random.seed(seed) # fix random seed
tf.random.set_seed(seed)
# input image dimensions
num_classes = 10 # 10 digitsimg_rows, img_cols = 28, 28 # number of pixels# the data, shuffled and split between train and test sets
(X_train, Y_train), (X_test, Y_test) = mnist.load_data()X_train = X_train.reshape(X_train.shape, img_rows, img_cols, 1)
X_test = X_test.reshape(X_test.shape, img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)# cast floats to single precision
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')# rescale data in interval
X_train /= 255
X_test /= 255Y_train = keras.utils.to_categorical(Y_train, num_classes)
Y_test = keras.utils.to_categorical(Y_test, num_classes)from keras.models import Sequential
from keras.layers import Dense, Conv2D, Flatten
from keras.layers import MaxPooling2D, Dropout
model = Sequential()#add model layers
model.add(Conv2D(32, kernel_size=(5, 5),
activation='relu',
input_shape=input_shape))
model.add(MaxPooling2D(pool_size=(2, 2)))
# add second convolutional layer with 20 filters
model.add(Conv2D(64, (5, 5), activation='relu'))
# add 2D pooling layer
model.add(MaxPooling2D(pool_size=(2, 2)))
# flatten data
model.add(Flatten())
# add a dense all-to-all relu layer
model.add(Dense(1024, activation='relu'))
# apply dropout with rate 0.5
model.add(Dropout(0.5))
# soft-max layer
model.add(Dense(num_classes, activation='softmax'))#compile model using accuracy to measure model performance
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=)#train the model
model.fit(X_train, Y_train, validation_data=(X_test, Y_test), epochs=3)# evaluate the model
score = model.evaluate(X_test, Y_test, verbose=1)# print performance
print()
print('Test loss:', score)
print('Test accuracy:', score)#predict first 4 images in the test set
model.predict(X_test)model.predict_classes(X_test)#actual results for first 4 images in test set
Y_test

videreføres…

i denne artikkelen, jeg taklet den andre delen av bildegjenkjenning som er å bygge En Convolution Nevrale Nettverk.

jeg håper du fant det du kom hit for i denne artikkelen og bli med meg for de neste episodene av denne bildegjenkjenningsturen!PS: JEG er For Tiden En Master Of Engineering Student Ved Berkeley, og hvis du vil diskutere emnet, vær så snill å nå meg. Her er min e-post.

Legg igjen en kommentar

Din e-postadresse vil ikke bli publisert.