Keras Tutorial: Hva er Keras? Hvordan installere i Python [Eksempel]

Hva er Keras?

Keras er et Open Source Neural Network-bibliotek skrevet i Python som kjører på toppen av Theano eller Tensorflow. Den er designet for å være modulær, rask og enkel å bruke. Den ble utviklet av François Chollet, en Google-ingeniør. Keras håndterer ikke beregninger på lavt nivå. I stedet bruker den et annet bibliotek for å gjøre det, kalt "Backend.

Keras er API-innpakning på høyt nivå for lavnivå-API, som kan kjøres på toppen av TensorFlow, CNTK eller Theano. Keras High-Level API håndterer måten vi lager modeller på, definerer lag eller setter opp flere input-output-modeller. På dette nivået sammenstiller Keras også vår modell med taps- og optimeringsfunksjoner, treningsprosess med passformfunksjon. Keras inn Python håndterer ikke Low-Level API som å lage beregningsgrafen, lage tensorer eller andre variabler fordi den har blitt håndtert av "backend"-motoren.

Hva er en backend?

Backend er et begrep i Keras som utfører all lavnivåberegning som tensorprodukter, konvolveringer og mange andre ting ved hjelp av andre biblioteker som Tensorflow eller Theano. Så "backend-motoren" vil utføre beregningen og utviklingen av modellene. Tensorflow er standard "backend-motor", men vi kan endre den i konfigurasjonen.

Theano, Tensorflow og CNTK Backend

Backend av Theano

Theano er et åpen kildekode-prosjekt som ble utviklet av MILA-gruppen ved University of Montreal, Quebec, Canada. Det var det første mye brukte rammeverket. Det er en Python bibliotek som hjelper til med flerdimensjonale arrays for matematiske operasjoner med Numpy eller Scipy. Theano kan bruke GPUer for raskere beregning, den kan også automatisk bygge symbolske grafer for databehandlingsgradienter. På sin nettside hevder Theano at den kan gjenkjenne numerisk ustabile uttrykk og beregne dem med mer stabile algoritmer, dette er veldig nyttig for våre ustabile uttrykk.

Bakenden av TensorFlow

På den annen side er Tensorflow den stigende stjernen i rammeverket for dyp læring. Utviklet av Googles Brain-team er det det mest populære dyplæringsverktøyet. Med mange funksjoner, og forskere bidrar til å utvikle dette rammeverket for dyp læringsformål.

Backend av CNTK

En annen backend-motor for Keras er The Microsoft Cognitive Toolkit eller CNTK. Det er en åpen kildekode for dyp læringsramme som ble utviklet av Microsoft Team. Den kan kjøres på flere GPUer eller multimaskiner for å trene dyp læringsmodell i massiv skala. I noen tilfeller ble CNTK rapportert raskere enn andre rammeverk som Tensorflow eller Theano. Neste i denne Keras CNN-opplæringen vil vi sammenligne backends av Theano, TensorFlow og CNTK.

Sammenligning av backends

Vi må gjøre en benchmark for å kjenne sammenligningen mellom disse to backends. Som du kan se i Jeong-Yoon Lees benchmark, sammenlignes ytelsen til 3 forskjellige backends på forskjellig maskinvare. Og resultatet er at Theano er tregere enn den andre backend, er det rapportert 50 ganger tregere, men nøyaktigheten er nær hverandre.

En annen benchmark test utføres av Jasmeet Bhatia. Han rapporterte at Theano er tregere enn Tensorflow for noen tester. Men den generelle nøyaktigheten er nesten den samme for hvert nettverk som ble testet.

Så mellom Theano, Tensorflow og CTK er det åpenbart at TensorFlow er bedre enn Theano. Med TensorFlow er beregningstiden mye kortere og CNN er bedre enn de andre.

Neste i denne Keras Python veiledning, vil vi lære om forskjellen mellom Keras og TensorFlow (Keras vs Tensorflow).

Keras vs Tensorflow

parametere Keras tensorflow
typen API-innpakning på høyt nivå API på lavt nivå
kompleksitet Enkel å bruke hvis du Python Språk Du må lære syntaksen for å bruke noen av Tensorflow-funksjonene
Formål Rask distribusjon for å lage modell med standardlag Lar deg lage en vilkårlig beregningsgraf eller modelllag
verktøy Bruker andre API-feilsøkingsverktøy som TFDBG Du kan bruke Tensorboard-visualiseringsverktøy
fellesskapet Store aktive samfunn Store aktive samfunn og mye delte ressurser

Fordeler med Keras

Rask distribusjon og enkel å forstå

Keras er veldig rask til å lage en nettverksmodell. Hvis du vil lage en enkel nettverksmodell med noen få linjer, Python Keras kan hjelpe deg med det. Se på Keras-eksemplet nedenfor:

from keras.models import Sequential
from keras.layers import Dense, Activation

model = Sequential()
model.add(Dense(64, activation='relu', input_dim=50)) #input shape of 50
model.add(Dense(28, activation='relu')) #input shape of 50
model.add(Dense(10, activation='softmax'))

På grunn av vennlig API, kan vi enkelt forstå prosessen. Skrive koden med en enkel funksjon og ingen grunn til å angi flere parametere.

Stor samfunnsstøtte

Det er mange AI-miljøer som bruker Keras som rammeverk for dyp læring. Mange av dem publiserer kodene sine i tillegg til opplæringsprogrammer for allmennheten.

Har flere backends

Du kan velge Tensorflow, CNTK og Theano som backend med Keras. Du kan velge en annen backend for forskjellige prosjekter avhengig av dine behov. Hver backend har sin egen unike fordel.

På tvers av plattformer og enkel modellimplementering

Med en rekke støttede enheter og plattformer kan du distribuere Keras på hvilken som helst enhet som

  • iOS med CoreML
  • Android med Tensorflow Android,
  • Nettleser med .js-støtte
  • Skymotor
  • Raspberry Pi

Støtte for flere GPUer

Du kan trene Keras på en enkelt GPU eller bruke flere GPUer samtidig. Fordi Keras har en innebygd støtte for dataparallellisme, slik at den kan behandle store datamengder og øke tiden som trengs for å trene den.

Ulemper med Keras

Kan ikke håndtere API på lavt nivå

Keras håndterer bare API på høyt nivå som kjører på toppen av andre rammeverk eller backend-motorer som Tensorflow, Theano eller CNTK. Så det er ikke veldig nyttig hvis du vil lage ditt eget abstrakte lag for forskningsformål fordi Keras allerede har forhåndskonfigurerte lag.

Installerer Keras

I denne delen vil vi se på ulike metoder som er tilgjengelige for å installere Keras

Direkte installasjon eller virtuelt miljø

Hvilken er bedre? Installere direkte til gjeldende python eller bruke et virtuelt miljø? Jeg foreslår at du bruker et virtuelt miljø hvis du har mange prosjekter. Vil du vite hvorfor? Dette er fordi forskjellige prosjekter kan bruke en annen versjon av et keras-bibliotek.

Jeg har for eksempel et prosjekt som trenger Python 3.5 bruker OpenCV 3.3 med eldre Keras-Theano backend, men i det andre prosjektet må jeg bruke Keras med den nyeste versjonen og en Tensorflow som backend med Python 3.6.6-støtte

Vi vil vel ikke at Keras-biblioteket skal komme i konflikt med hverandre? Så vi bruker et virtuelt miljø for å lokalisere prosjektet med en bestemt type bibliotek, eller vi kan bruke en annen plattform som Cloud Service for å gjøre beregningene våre for oss som Amazon Webtjeneste.

Installerer Keras på Amazon Netttjeneste (AWS)

Amazon Web Service er en plattform som tilbyr Cloud Computing-tjenester og produkter for forskere eller andre formål. AWS leier deres maskinvare, nettverk, database osv. slik at vi kan bruke det direkte fra internett. En av de populære AWS-tjenestene for dyplæringsformål er Amazon Machine Image Deep Learning Service eller DL

For detaljerte instruksjoner om hvordan du bruker AWS, se denne tutorial

Merknad om AMI: Du vil ha følgende AMI tilgjengelig

Installerer Keras på AWS

AWS Deep Learning AMI er et virtuelt miljø i AWS EC2 Service som hjelper forskere eller praktikere å jobbe med Deep Learning. DLAMI tilbyr fra små CPU-motorer opp til kraftige multi-GPU-motorer med forhåndskonfigurert CUDA, cuDNN, og kommer med en rekke dype læringsrammer.

Hvis du vil bruke den umiddelbart, bør du velge Deep Learning AMI fordi den leveres forhåndsinstallert med populære rammeverk for dyp læring.

Men hvis du vil prøve et tilpasset dyplæringsrammeverk for forskning, bør du installere Deep Learning Base AMI fordi det kommer med grunnleggende biblioteker som CUDA, cuDNN, GPU-drivere og andre nødvendige biblioteker for å kjøre med ditt dype læringsmiljø.

Hvordan installere Keras på Amazon SageMaker

Amazon SageMaker er en dyp læringsplattform for å hjelpe deg med opplæring og distribusjon av dyplæringsnettverk med den beste algoritmen.

Som nybegynner er dette den desidert enkleste metoden for å bruke Keras. Nedenfor er en prosess for hvordan du installerer Keras på Amazon SageMaker:

Trinn 1) Åpne Amazon SageMaker

I det første trinnet åpner du Amazon Sagemaker konsollen og klikk på Opprett notatbokforekomst.

Installer Keras på Amazon SageMaker

Trinn 2) Skriv inn detaljene

  1. Skriv inn notatboknavnet.
  2. Opprett en IAM-rolle. Det vil skape en AMI-rolle Amazon IAM rolle i formatet av AmazonSageMaker-Executionrolle-ÅÅÅÅMMDD|HHmmSS.
  3. Til slutt velger du Opprett notatbokforekomst. Etter noen få øyeblikk, Amazon Sagemaker lanserer en notatbokforekomst.

Installer Keras på Amazon SageMaker

Merknader: Hvis du ønsker å få tilgang til ressurser fra din VPC, setter du direkte internettilgang som aktivert. Ellers vil ikke denne bærbare forekomsten ha internettilgang, så det er umulig å trene eller være vert for modeller

Trinn 3) Start forekomsten

Klikk på Åpne for å starte forekomsten

Installer Keras på Amazon SageMaker

Trinn 4) Start kodingen

In Jupyter, Klikk på Ny> conda_tensorflow_p36 og du er klar til å kode

Installer Keras på Amazon SageMaker

Installer Keras i Linux

For å aktivere Keras med Tensorflow som backend-motor, må vi installere Tensorflow først. Kjør denne kommandoen for å installere tensorflow med CPU (ingen GPU)

pip install --upgrade tensorflow

hvis du vil aktivere GPU-støtten for tensorflow, kan du bruke denne kommandoen

pip install --upgrade tensorflow-gpu

Installer Keras på Linux

la oss sjekke inn Python for å se om installasjonen vår er vellykket ved å skrive

user@user:~$ python
Python 3.6.4 (default, Mar 20 2018, 11:10:20) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import tensorflow
>>>

hvis det ikke er noen feilmelding, er installasjonsprosessen vellykket

Installer Keras

Etter at vi har installert Tensorflow, la oss begynne å installere keras. Skriv inn denne kommandoen i terminalen

pip install keras

den vil begynne å installere Keras og også alle dens avhengigheter. Du bør se noe sånt som dette:

Installer Keras

Nå har vi Keras installert i systemet vårt!

Bekrefter

Før vi begynner å bruke Keras, bør vi sjekke om våre Keras bruker Tensorflow som backend ved å åpne konfigurasjonsfilen:

gedit ~/.keras/keras.json

du burde se noe slikt

{
    "floatx": "float32",
    "epsilon": 1e-07,
    "backend": "tensorflow",
    "image_data_format": "channels_last"
}

som du kan se, bruker "backend" tensorflow. Det betyr at keras bruker Tensorflow som backend som vi forventet

og kjør den nå på terminalen ved å skrive

user@user:~$ python3
Python 3.6.4 (default, Mar 20 2018, 11:10:20) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import keras
Using TensorFlow backend.
>>> 

Hvordan installere Keras på Windows

Før vi installerer tensorflow og Keras, vi burde installere Python, pip og virtualenv. Hvis du allerede har installert disse bibliotekene, bør du fortsette til neste trinn, ellers gjør du dette:

Install Python 3 ved å laste ned fra denne link

Installer pip ved å kjøre denne

Installer virtualenv med denne kommandoen

pip3 install –U pip virtualenv

Install Microsoft Visual C++ 2015 omdistribuerbar oppdatering 3

Kjør deretter dette skriptet

pip3 install virtualenv

Sett opp virtuelt miljø

Dette brukes til å isolere arbeidssystemet med hovedsystemet.

virtualenv –-system-site-packages –p python3 ./venv

Aktiver miljøet

.\venv\Scripts\activate

Etter å ha forberedt miljøet, forblir installasjonen av Tensorflow og Keras den samme som Linux. Neste i denne Deep learning with Keras-opplæringen vil vi lære om Keras grunnleggende for Deep learning.

Keras Fundamentals for Deep Learning

Hovedstrukturen i Keras er modellen som definerer hele grafen til et nettverk. Du kan legge til flere lag til en eksisterende modell for å bygge en tilpasset modell som du trenger for prosjektet ditt.

Her er hvordan du lager en sekvensiell modell og noen få ofte brukte lag i dyp læring

1. Sekvensiell modell

from keras.models import Sequential
from keras.layers import Dense, Activation,Conv2D,MaxPooling2D,Flatten,Dropout

model = Sequential()

2. Konvolusjonslag

Dette er en Keras Python eksempel på konvolusjonslag som inngangslag med inngangsformen 320x320x3, med 48 filtre i størrelsen 3×3 og bruk ReLU som en aktiveringsfunksjon.

input_shape=(320,320,3) #this is the input shape of an image 320x320x3
model.add(Conv2D(48, (3, 3), activation='relu', input_shape= input_shape))

en annen type er

model.add(Conv2D(48, (3, 3), activation='relu'))

3. MaksPooling Lag

For å nedsample inndatarepresentasjonen, bruk MaxPool2d og spesifiser kjernestørrelsen

model.add(MaxPooling2D(pool_size=(2, 2)))

4. Tett lag

legge til et fullstendig tilkoblet lag med bare å spesifisere utdatastørrelsen

model.add(Dense(256, activation='relu'))

5. Frafallslag

Legger til dropout-lag med 50 % sannsynlighet

model.add(Dropout(0.5))

Kompilere, trene og evaluere

Etter at vi har definert modellen vår, la oss begynne å trene dem. Det er nødvendig å kompilere nettverket først med tapsfunksjonen og optimeringsfunksjonen. Dette vil tillate nettverket å endre vekter og minimere tapet.

model.compile(loss='mean_squared_error', optimizer='adam')

Nå for å begynne å trene, bruk fit for å mate trenings- og valideringsdataene til modellen. Dette vil tillate deg å trene nettverket i grupper og sette epoker.

model.fit(X_train, X_train, batch_size=32, epochs=10, validation_data=(x_val, y_val))

Vårt siste trinn er å evaluere modellen med testdataene.

score = model.evaluate(x_test, y_test, batch_size=32)

La oss prøve å bruke enkel lineær regresjon

import keras
from keras.models import Sequential
from keras.layers import Dense, Activation
import numpy as np
import matplotlib.pyplot as plt 
 
x = data = np.linspace(1,2,200)
y = x*4 + np.random.randn(*x.shape) * 0.3


model = Sequential()
model.add(Dense(1, input_dim=1, activation='linear'))

model.compile(optimizer='sgd', loss='mse', metrics=['mse'])

weights = model.layers[0].get_weights()
w_init = weights[0][0][0]
b_init = weights[1][0]
print('Linear regression model is initialized with weights w: %.2f, b: %.2f' % (w_init, b_init)) 


model.fit(x,y, batch_size=1, epochs=30, shuffle=False)

weights = model.layers[0].get_weights()
w_final = weights[0][0][0]
b_final = weights[1][0]
print('Linear regression model is trained to have weight w: %.2f, b: %.2f' % (w_final, b_final))

predict = model.predict(data)

plt.plot(data, predict, 'b', data , y, 'k.')
plt.show()

Etter å ha trent dataene, skal utdataene se slik ut

lineær regresjon

med startvekten

Linear regression model is initialized with weights w: 0.37, b: 0.00

og sluttvekt

Linear regression model is trained to have weight w: 3.70, b: 0.61

Finjuster ferdigtrente modeller i Keras og hvordan du bruker dem

Hvorfor vi bruker Fine Tune-modeller og når vi bruker det

Finjustering er en oppgave for å tilpasse en forhåndstrent modell slik at parameterne tilpasser seg den nye modellen. Når vi skal trene fra bunnen av på en ny modell, trenger vi en stor mengde data, slik at nettverket kan finne alle parametere. Men i dette tilfellet vil vi bruke en forhåndstrent modell slik at parametrene allerede er lært og har en vekt.

For eksempel, hvis vi ønsker å trene vår egen Keras-modell for å løse et klassifiseringsproblem, men vi bare har en liten mengde data, kan vi løse dette ved å bruke en Overfør læring + Finjusteringsmetode.

Ved å bruke et forhåndstrent nettverk og vekter trenger vi ikke å trene hele nettverket. Vi trenger bare å trene det siste laget som brukes til å løse oppgaven vår som vi kaller det Fine-Tuning-metoden.

Forberedelse av nettverksmodell

For den forhåndstrente modellen kan vi laste inn en rekke modeller som Keras allerede har i biblioteket, for eksempel:

  • VGG16
  • BegynnelseV3
  • ResNet
  • MobileNet
  • Xception
  • InceptionResNetV2

Men i denne prosessen vil vi bruke VGG16 nettverksmodell og imageNet som vekt for modellen. Vi vil finjustere et nettverk for å klassifisere 8 forskjellige typer klasser ved å bruke Bilder fra Kaggle Natural Images Datasett

VGG16 modellarkitektur

VGG16 modellarkitektur

kilde

Laster opp dataene våre til AWS S3 Bucket

For treningsprosessen vår vil vi bruke et bilde av naturlige bilder fra 8 forskjellige klasser som fly, bil, katt, hund, blomst, frukt, motorsykkel og person. Først må vi laste opp dataene våre til Amazon S3 bøtte.

Amazon S3 bøtte

Trinn 1) Etter å ha logget på S3-kontoen din, la oss lage en bøtte ved å klokke Lag bøtte

Laster opp data til AWS S3 Bucket

Trinn 2) Velg nå et bøttenavn og din region i henhold til kontoen din. Sørg for at bøttenavnet er tilgjengelig. Etter det klikk Skape.

Laster opp data til AWS S3 Bucket

Trinn 3) Som du kan se, er bøtten din klar til bruk. Men som du kan se, er tilgangen ikke offentlig, den er bra for deg hvis du vil holde den privat for deg selv. Du kan endre denne bøtten for offentlig tilgang i bøtteegenskaper

Laster opp data til AWS S3 Bucket

Trinn 4) Nå begynner du å laste opp treningsdataene dine til Bucket. Her vil jeg laste opp tar.gz-filen som består av bilder for trening og testprosess.

Laster opp data til AWS S3 Bucket

Trinn 5) Klikk nå på filen og kopier link slik at vi kan laste den ned.

Laster opp data til AWS S3 Bucket

Dataklargjøring

Vi må generere treningsdataene våre ved å bruke Keras ImageDataGenerator.

Først må du laste ned ved hjelp av wget med lenken til filen din fra S3 Bucket.

!wget https://s3.us-east-2.amazonaws.com/naturalimages02/images.tar.gz		
!tar -xzf images.tar.gz

Etter at du har lastet ned dataene, la oss starte opplæringsprosessen.

from keras.preprocessing.image import ImageDataGenerator
import numpy as np
import matplotlib.pyplot as plt

train_path = 'images/train/'
test_path = 'images/test/'
batch_size = 16
image_size = 224
num_class = 8


train_datagen = ImageDataGenerator(validation_split=0.3,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

train_generator = train_datagen.flow_from_directory(
                        directory=train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='categorical',
                        color_mode='rgb',
                        shuffle=True)

BildedataeneGenerator vil lage en X_treningsdata fra en katalog. Underkatalogen i den katalogen vil bli brukt som en klasse for hvert objekt. Bildet vil bli lastet med RGB-fargemodus, med kategorisk klassemodus for Y_treningsdata, med en batchstørrelse på 16. Til slutt blander du dataene.

La oss se bildene våre tilfeldig ved å plotte dem med matplotlib

x_batch, y_batch = train_generator.next()

fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows):
    num = np.random.randint(batch_size)
    image = x_batch[num].astype(np.int)
    fig.add_subplot(rows, columns, i)
    plt.imshow(image)
plt.show()

Dataklargjøring

La oss deretter lage vår nettverksmodell fra VGG16 med forhåndstrent imageNet vekt. Vi vil fryse disse lagene slik at lagene ikke er trenbare for å hjelpe oss med å redusere beregningstiden.

Oppretter vår modell fra VGG16

import keras
from keras.models import Model, load_model
from keras.layers import Activation, Dropout, Flatten, Dense
from keras.preprocessing.image import ImageDataGenerator
from keras.applications.vgg16 import VGG16


#Load the VGG model
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(image_size, image_size, 3))

print(base_model.summary())

    # Freeze the layers 
for layer in base_model.layers:
    layer.trainable = False
 
# # Create the model
model = keras.models.Sequential()

# # Add the vgg convolutional base model
model.add(base_model)
 
# # Add new layers
model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dense(1024, activation='relu'))
model.add(Dense(num_class, activation='softmax'))
 
# # Show a summary of the model. Check the number of trainable parameters    
print(model.summary())

Som du kan se nedenfor, sammendraget av nettverksmodellen vår. Fra en inngang fra VGG16 Layers legger vi til 2 Fully Connected Layer som vil trekke ut 1024 funksjoner og et utgangslag som vil beregne de 8 klassene med softmax-aktiveringen.

Layer (type)                 Output Shape              Param #   
=================================================================
vgg16 (Model)                (None, 7, 7, 512)         14714688  
_________________________________________________________________
flatten_1 (Flatten)          (None, 25088)             0         
_________________________________________________________________
dense_1 (Dense)              (None, 1024)              25691136  
_________________________________________________________________
dense_2 (Dense)              (None, 1024)              1049600   
_________________________________________________________________
dense_3 (Dense)              (None, 8)                 8200      
=================================================================
Total params: 41,463,624
Trainable params: 26,748,936
Non-trainable params: 14,714,688

Kurs

# # Compile the model
from keras.optimizers import SGD

model.compile(loss='categorical_crossentropy',
          optimizer=SGD(lr=1e-3),
          metrics=['accuracy'])

# # Start the training process
# model.fit(x_train, y_train, validation_split=0.30, batch_size=32, epochs=50, verbose=2)

# # #save the model
# model.save('catdog.h5')

history = model.fit_generator(
        train_generator,
        steps_per_epoch=train_generator.n/batch_size,
        epochs=10)
        
model.save('fine_tune.h5')

# summarize history for accuracy
import matplotlib.pyplot as plt

plt.plot(history.history['loss'])
plt.title('loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['loss'], loc='upper left')
plt.show()

Resultater

Epoch 1/10
432/431 [==============================] - 53s 123ms/step - loss: 0.5524 - acc: 0.9474 
Epoch 2/10
432/431 [==============================] - 52s 119ms/step - loss: 0.1571 - acc: 0.9831
Epoch 3/10
432/431 [==============================] - 51s 119ms/step - loss: 0.1087 - acc: 0.9871
Epoch 4/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0624 - acc: 0.9926
Epoch 5/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0591 - acc: 0.9938
Epoch 6/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0498 - acc: 0.9936
Epoch 7/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0403 - acc: 0.9958
Epoch 8/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0248 - acc: 0.9959
Epoch 9/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0466 - acc: 0.9942
Epoch 10/10
432/431 [==============================] - 52s 120ms/step - loss: 0.0338 - acc: 0.9947

Kurs

Som du kan se, er tapene våre betydelig redusert og nøyaktigheten er nesten 100 %. For å teste modellen vår valgte vi tilfeldig bilder over internett og la dem i testmappen med en annen klasse for å teste

Tester vår modell

model = load_model('fine_tune.h5')

test_datagen = ImageDataGenerator()
train_generator = train_datagen.flow_from_directory(
                        directory=train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='categorical',
                        color_mode='rgb',
                        shuffle=True)

test_generator = test_datagen.flow_from_directory(
                        directory=test_path, 
                        target_size=(image_size, image_size),
                        color_mode='rgb',
                        shuffle=False,
                        class_mode='categorical',
                        batch_size=1)

filenames = test_generator.filenames
nb_samples = len(filenames)

fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows -1):
    x_batch, y_batch = test_generator.next()

    name = model.predict(x_batch)
    name = np.argmax(name, axis=-1)
    true_name = y_batch
    true_name = np.argmax(true_name, axis=-1)

    label_map = (test_generator.class_indices)
    label_map = dict((v,k) for k,v in label_map.items()) #flip k,v
    predictions = [label_map[k] for k in name]
    true_value = [label_map[k] for k in true_name]

    image = x_batch[0].astype(np.int)
    fig.add_subplot(rows, columns, i)
    plt.title(str(predictions[0]) + ':' + str(true_value[0]))
    plt.imshow(image)
plt.show()

Og testen vår er som gitt nedenfor! Kun 1 bilde er spådd feil fra en test av 14 bilder!

Testmodell

Ansiktsgjenkjenning nevralt nettverk med Keras

Hvorfor vi trenger anerkjennelse

Vi trenger anerkjennelse for å gjøre det lettere for oss å gjenkjenne eller identifisere en persons ansikt, gjenstandstype, beregnet alder på en person fra ansiktet hans, eller til og med kjenne ansiktsuttrykkene til den personen.

Ansiktsgjenkjenning nevralt nettverk med Keras

Kanskje du innser at hver gang du prøver å merke vennens ansikt i et bilde, har funksjonen i Facebook gjort det for deg, det vil si å merke vennens ansikt uten at du trenger å merke det først. Dette er ansiktsgjenkjenning brukt av Facebook for å gjøre det enklere for oss å tagge venner.

Så hvordan fungerer det? Hver gang vi markerer ansiktet til vennen vår, vil Facebooks AI lære det og vil prøve å forutsi det til det får det riktige resultatet. Det samme systemet vil vi bruke til å lage vår egen ansiktsgjenkjenning. La oss begynne å lage vår egen ansiktsgjenkjenning ved hjelp av Deep Learning

Nettverksmodell

Vi vil bruke en VGG16 nettverksmodell, men med VGGFace-vekt.

VGG16 modellarkitektur

Nettverksmodell

Hva er VGGFace? det er Keras implementering av Deep Face Recognition introdusert av Parkhi, Omkar M. et al. "Dyp ansiktsgjenkjenning." BMVC (2015). Rammeverket bruker VGG16 som nettverksarkitektur.

Du kan laste ned VGGFace fra GitHub

from keras.applications.vgg16 import VGG16
from keras_vggface.vggface import VGGFace

face_model = VGGFace(model='vgg16', 
                weights='vggface',
                input_shape=(224,224,3)) 
face_model.summary()

Som du kan se nettverkssammendraget

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_1 (InputLayer)         (None, 224, 224, 3)       0         
_________________________________________________________________
conv1_1 (Conv2D)             (None, 224, 224, 64)      1792      
_________________________________________________________________
conv1_2 (Conv2D)             (None, 224, 224, 64)      36928     
_________________________________________________________________
pool1 (MaxPooling2D)         (None, 112, 112, 64)      0         
_________________________________________________________________
conv2_1 (Conv2D)             (None, 112, 112, 128)     73856     
_________________________________________________________________
conv2_2 (Conv2D)             (None, 112, 112, 128)     147584    
_________________________________________________________________
pool2 (MaxPooling2D)         (None, 56, 56, 128)       0         
_________________________________________________________________
conv3_1 (Conv2D)             (None, 56, 56, 256)       295168    
_________________________________________________________________
conv3_2 (Conv2D)             (None, 56, 56, 256)       590080    
_________________________________________________________________
conv3_3 (Conv2D)             (None, 56, 56, 256)       590080    
_________________________________________________________________
pool3 (MaxPooling2D)         (None, 28, 28, 256)       0         
_________________________________________________________________
conv4_1 (Conv2D)             (None, 28, 28, 512)       1180160   
_________________________________________________________________
conv4_2 (Conv2D)             (None, 28, 28, 512)       2359808   
_________________________________________________________________
conv4_3 (Conv2D)             (None, 28, 28, 512)       2359808   
_________________________________________________________________
pool4 (MaxPooling2D)         (None, 14, 14, 512)       0         
_________________________________________________________________
conv5_1 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
conv5_2 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
conv5_3 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
pool5 (MaxPooling2D)         (None, 7, 7, 512)         0         
_________________________________________________________________
flatten (Flatten)            (None, 25088)             0         
_________________________________________________________________
fc6 (Dense)                  (None, 4096)              102764544 
_________________________________________________________________
fc6/relu (Activation)        (None, 4096)              0         
_________________________________________________________________
fc7 (Dense)                  (None, 4096)              16781312  
_________________________________________________________________
fc7/relu (Activation)        (None, 4096)              0         
_________________________________________________________________
fc8 (Dense)                  (None, 2622)              10742334  
_________________________________________________________________
fc8/softmax (Activation)     (None, 2622)              0         
=================================================================
Total params: 145,002,878
Trainable params: 145,002,878
Non-trainable params: 0
_________________________________________________________________
Traceback (most recent call last):

vi vil gjøre en Overfør læring + Finjustering for å gjøre treningen raskere med små datasett. Først skal vi fryse grunnlagene slik at lagene ikke er trenbare.

for layer in face_model.layers:
    layer.trainable = False

så legger vi til vårt eget lag for å gjenkjenne testansiktene våre. Vi vil legge til 2 fullt tilkoblede lag og et utgangslag med 5 personer for å oppdage.

from keras.models import Model, Sequential
from keras.layers import Input, Convolution2D, ZeroPadding2D, MaxPooling2D, Flatten, Dense, Dropout, Activation

person_count = 5

last_layer = face_model.get_layer('pool5').output

x = Flatten(name='flatten')(last_layer)
x = Dense(1024, activation='relu', name='fc6')(x)
x = Dense(1024, activation='relu', name='fc7')(x)
out = Dense(person_count, activation='softmax', name='fc8')(x)

custom_face = Model(face_model.input, out)

La oss se nettverkssammendraget vårt

Layer (type)                 Output Shape              Param #
=================================================================
input_1 (InputLayer)         (None, 224, 224, 3)       0
_________________________________________________________________
conv1_1 (Conv2D)             (None, 224, 224, 64)      1792
_________________________________________________________________
conv1_2 (Conv2D)             (None, 224, 224, 64)      36928
_________________________________________________________________
pool1 (MaxPooling2D)         (None, 112, 112, 64)      0
_________________________________________________________________
conv2_1 (Conv2D)             (None, 112, 112, 128)     73856
_________________________________________________________________
conv2_2 (Conv2D)             (None, 112, 112, 128)     147584
_________________________________________________________________
pool2 (MaxPooling2D)         (None, 56, 56, 128)       0
_________________________________________________________________
conv3_1 (Conv2D)             (None, 56, 56, 256)       295168
_________________________________________________________________
conv3_2 (Conv2D)             (None, 56, 56, 256)       590080
_________________________________________________________________
conv3_3 (Conv2D)             (None, 56, 56, 256)       590080
_________________________________________________________________
pool3 (MaxPooling2D)         (None, 28, 28, 256)       0
_________________________________________________________________
conv4_1 (Conv2D)             (None, 28, 28, 512)       1180160
_________________________________________________________________
conv4_2 (Conv2D)             (None, 28, 28, 512)       2359808
_________________________________________________________________
conv4_3 (Conv2D)             (None, 28, 28, 512)       2359808
_________________________________________________________________
pool4 (MaxPooling2D)         (None, 14, 14, 512)       0
_________________________________________________________________
conv5_1 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
conv5_2 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
conv5_3 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
pool5 (MaxPooling2D)         (None, 7, 7, 512)         0
_________________________________________________________________
flatten (Flatten)            (None, 25088)             0
_________________________________________________________________
fc6 (Dense)                  (None, 1024)              25691136
_________________________________________________________________
fc7 (Dense)                  (None, 1024)              1049600
_________________________________________________________________
fc8 (Dense)                  (None, 5)                 5125
=================================================================
Total params: 41,460,549
Trainable params: 26,745,861
Non-trainable params: 14,714,688

Som du kan se ovenfor, etter pool5-laget, vil det bli flatet ut til en enkelt funksjonsvektor som vil bli brukt av det tette laget for den endelige gjenkjenningen.

Forbereder ansiktene våre

La oss nå forberede ansiktene våre. Jeg laget en katalog bestående av 5 kjente personer

  • Jack Ma
  • Jason Statham
  • Johnny Depp
  • Robert Downey jr
  • Rowan Atkinson

Hver mappe inneholder 10 bilder, for hver opplærings- og evalueringsprosess. Det er en veldig liten mengde data, men det er utfordringen, ikke sant?

Vi vil bruke hjelpen fra Keras-verktøyet for å hjelpe oss med å forberede dataene. Denne funksjonen vil iterere i datasettmappen og deretter forberede den slik at den kan brukes i opplæringen.

from keras.preprocessing.image import ImageDataGenerator
batch_size = 5
train_path = 'data/'
eval_path = 'eval/'

train_datagen = ImageDataGenerator(rescale=1./255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

valid_datagen = ImageDataGenerator(rescale=1./255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

train_generator = train_datagen.flow_from_directory(
                        train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='sparse',
                        color_mode='rgb')

valid_generator = valid_datagen.flow_from_directory(
    directory=eval_path,
    target_size=(224, 224),
    color_mode='rgb',
    batch_size=batch_size,
    class_mode='sparse',
    shuffle=True,
)

Trening vår modell

La oss begynne treningsprosessen vår ved å kompilere nettverket vårt med tapsfunksjon og optimizer. Her bruker vi sparse_categorical_crossentropy som vår tapsfunksjon, ved hjelp av SGD som vår læringsoptimalisator.

from keras.optimizers import SGD

custom_face.compile(loss='sparse_categorical_crossentropy',
                         optimizer=SGD(lr=1e-4, momentum=0.9),
                         metrics=['accuracy'])

history = custom_face.fit_generator(
        train_generator,
        validation_data=valid_generator,
        steps_per_epoch=49/batch_size,
        validation_steps=valid_generator.n,
        epochs=50)

custom_face.evaluate_generator(generator=valid_generator)
        
custom_face.save('vgg_face.h5')
Epoch 25/50
10/9 [==============================] - 60s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5659 - val_acc: 0.5851
Epoch 26/50
10/9 [==============================] - 59s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5638 - val_acc: 0.5809
Epoch 27/50
10/9 [==============================] - 60s 6s/step - loss: 1.4779 - acc: 0.8597 - val_loss: 1.5613 - val_acc: 0.5477
Epoch 28/50
10/9 [==============================] - 60s 6s/step - loss: 1.4755 - acc: 0.9199 - val_loss: 1.5576 - val_acc: 0.5809
Epoch 29/50
10/9 [==============================] - 60s 6s/step - loss: 1.4794 - acc: 0.9153 - val_loss: 1.5531 - val_acc: 0.5892
Epoch 30/50
10/9 [==============================] - 60s 6s/step - loss: 1.4714 - acc: 0.8953 - val_loss: 1.5510 - val_acc: 0.6017
Epoch 31/50
10/9 [==============================] - 60s 6s/step - loss: 1.4552 - acc: 0.9199 - val_loss: 1.5509 - val_acc: 0.5809
Epoch 32/50
10/9 [==============================] - 60s 6s/step - loss: 1.4504 - acc: 0.9199 - val_loss: 1.5492 - val_acc: 0.5975
Epoch 33/50
10/9 [==============================] - 60s 6s/step - loss: 1.4497 - acc: 0.8998 - val_loss: 1.5490 - val_acc: 0.5851
Epoch 34/50
10/9 [==============================] - 60s 6s/step - loss: 1.4453 - acc: 0.9399 - val_loss: 1.5529 - val_acc: 0.5643
Epoch 35/50
10/9 [==============================] - 60s 6s/step - loss: 1.4399 - acc: 0.9599 - val_loss: 1.5451 - val_acc: 0.5768
Epoch 36/50
10/9 [==============================] - 60s 6s/step - loss: 1.4373 - acc: 0.8998 - val_loss: 1.5424 - val_acc: 0.5768
Epoch 37/50
10/9 [==============================] - 60s 6s/step - loss: 1.4231 - acc: 0.9199 - val_loss: 1.5389 - val_acc: 0.6183
Epoch 38/50
10/9 [==============================] - 59s 6s/step - loss: 1.4247 - acc: 0.9199 - val_loss: 1.5372 - val_acc: 0.5934
Epoch 39/50
10/9 [==============================] - 60s 6s/step - loss: 1.4153 - acc: 0.9399 - val_loss: 1.5406 - val_acc: 0.5560
Epoch 40/50
10/9 [==============================] - 60s 6s/step - loss: 1.4074 - acc: 0.9800 - val_loss: 1.5327 - val_acc: 0.6224
Epoch 41/50
10/9 [==============================] - 60s 6s/step - loss: 1.4023 - acc: 0.9800 - val_loss: 1.5305 - val_acc: 0.6100
Epoch 42/50
10/9 [==============================] - 59s 6s/step - loss: 1.3938 - acc: 0.9800 - val_loss: 1.5269 - val_acc: 0.5975
Epoch 43/50
10/9 [==============================] - 60s 6s/step - loss: 1.3897 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.6432
Epoch 44/50
10/9 [==============================] - 60s 6s/step - loss: 1.3828 - acc: 0.9800 - val_loss: 1.5210 - val_acc: 0.6556
Epoch 45/50
10/9 [==============================] - 59s 6s/step - loss: 1.3848 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.5975
Epoch 46/50
10/9 [==============================] - 60s 6s/step - loss: 1.3716 - acc: 0.9800 - val_loss: 1.5216 - val_acc: 0.6432
Epoch 47/50
10/9 [==============================] - 60s 6s/step - loss: 1.3721 - acc: 0.9800 - val_loss: 1.5195 - val_acc: 0.6266
Epoch 48/50
10/9 [==============================] - 60s 6s/step - loss: 1.3622 - acc: 0.9599 - val_loss: 1.5108 - val_acc: 0.6141
Epoch 49/50
10/9 [==============================] - 60s 6s/step - loss: 1.3452 - acc: 0.9399 - val_loss: 1.5140 - val_acc: 0.6432
Epoch 50/50
10/9 [==============================] - 60s 6s/step - loss: 1.3387 - acc: 0.9599 - val_loss: 1.5100 - val_acc: 0.6266

Som du kan se, er vår valideringsnøyaktighet opptil 64 %, dette er et godt resultat for en liten mengde treningsdata. Vi kan forbedre dette ved å legge til flere lag eller legge til flere treningsbilder slik at modellen vår kan lære mer om ansiktene og oppnå mer nøyaktighet.

La oss teste modellen vår med et testbilde

Testbilde

from keras.models import load_model
from keras.preprocessing.image import load_img, save_img, img_to_array
from keras_vggface.utils import preprocess_input

test_img = image.load_img('test.jpg', target_size=(224, 224))
img_test = image.img_to_array(test_img)
img_test = np.expand_dims(img_test, axis=0)
img_test = utils.preprocess_input(img_test)
predictions = model.predict(img_test)
predicted_class=np.argmax(predictions,axis=1)

labels = (train_generator.class_indices)
labels = dict((v,k) for k,v in labels.items())
predictions = [labels[k] for k in predicted_class]
print(predictions)
['RobertDJr']

ved å bruke Robert Downey Jr.-bilde som vårt testbilde, viser det at det forutsagte ansiktet er sant!

Forutsigelse ved hjelp av Live Cam!

Hva med om vi tester ferdighetene våre med å implementere det med innspill fra et webkamera? Ved å bruke OpenCV med Haar Face-kaskade for å finne ansiktet vårt, og ved hjelp av vår nettverksmodell kan vi gjenkjenne personen.

Det første trinnet er å forberede deg og vennens ansikter. Jo mer data vi har, jo bedre blir resultatet!

Forbered og tren nettverket ditt som forrige trinn, etter at treningen er fullført, legg til denne linjen for å få inndatabildet fra cam

#Load trained model
from keras.models import load_model
from keras_vggface import utils
import cv2

image_size = 224
device_id = 0 #camera_device id 

model = load_model('my faces.h5')

#make labels according to your dataset folder 
labels = dict(fisrtname=0,secondname=1) #and so on
print(labels)

cascade_classifier = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
camera = cv2.VideoCapture(device_id)

while camera.isOpened():
    ok, cam_frame = camera.read()
    if not ok:
        break
    
    gray_img=cv2.cvtColor(cam_frame, cv2.COLOR_BGR2GRAY)
    faces= cascade_classifier.detectMultiScale(gray_img, minNeighbors=5)

    for (x,y,w,h) in faces:
        cv2.rectangle(cam_frame,(x,y),(x+w,y+h),(255,255,0),2)
        roi_color = cam_frame [y:y+h, x:x+w]
        roi color = cv2.cvtColor(roi_color, cv2.COLOR_BGR2RGB)
        roi_color = cv2.resize(roi_color, (image_size, image_size))
        image = roi_color.astype(np.float32, copy=False)
        image = np.expand_dims(image, axis=0)
        image = preprocess_input(image, version=1) # or version=2
        preds = model.predict(image)
        predicted_class=np.argmax(preds,axis=1)

        labels = dict((v,k) for k,v in labels.items())
        name = [labels[k] for k in predicted_class]

        cv2.putText(cam_frame,str(name), 
                    (x + 10, y + 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,0,255), 2)
        
    cv2.imshow('video image', cam_frame)
    key = cv2.waitKey(30)
    if key == 27: # press 'ESC' to quit
        break

camera.release()
cv2.destroyAllWindows()

Hvilken er bedre? Keras eller Tensorflow

Keras tilbyr enkelhet når du skriver manuset. Vi kan begynne å skrive og forstå direkte med Keras, siden det ikke er så vanskelig å forstå. Det er mer brukervennlig og enkelt å implementere, du trenger ikke lage mange variabler for å kjøre modellen. Så vi trenger ikke å forstå alle detaljer i backend-prosessen.

På den annen side er Tensorflow operasjonene på lavt nivå som tilbyr fleksibilitet og avanserte operasjoner hvis du vil lage en vilkårlig beregningsgraf eller modell. Tensorflow kan også visualisere prosessen ved hjelp av TensorBoard og et spesialisert feilsøkingsverktøy.

Så hvis du vil begynne å jobbe med dyp læring med ikke så mye kompleksitet, bruk Keras. Fordi Keras tilbyr enkelhet og brukervennlig å bruke og enkel å implementere enn Tensorflow. Men hvis du vil skrive din egen algoritme i dyplæringsprosjekt eller forskning, bør du bruke Tensorflow i stedet.

Oppsummering

Så la oss oppsummere alt vi har diskutert og gjort i denne opplæringen.

  • Keras i et høynivå-API som brukes til å gjøre dyplæringsnettverk enklere ved hjelp av backend-motoren.
  • Keras er lett å bruke og forstå med python-støtte, så det føles mer naturlig enn noen gang. Det er bra for nybegynnere som ønsker å lære om dyp læring og for forskere som ønsker brukervennlig API.
  • Installasjonsprosessen er enkel og du kan bruke et virtuelt miljø eller bruke en ekstern plattform som f.eks AWS.
  • Keras kommer også med ulike typer nettverksmodeller slik at det gjør oss lettere å bruke den tilgjengelige modellen for å forhåndstrene og finjustere vår egen nettverksmodell.
  • Det er også mange opplæringsprogrammer og artikler om bruk av Keras fra fellesskap over hele verden for dyplæringsformål.