Keras tutorial

Hvad er Keras?

Keras er et Open Source Neural Network-bibliotek skrevet i Python der kører oven på Theano eller Tensorflow. Den er designet til at være modulopbygget, hurtig og nem at bruge. Det blev udviklet af François Chollet, en Google-ingeniør. Keras håndterer ikke beregninger på lavt niveau. I stedet bruger den et andet bibliotek til at gøre det, kaldet "Backend.

Keras er API-indpakning på højt niveau til lav-niveau API, der kan køre oven på TensorFlow, CNTK eller Theano. Keras High-Level API håndterer den måde, vi laver modeller på, definerer lag eller opsætter flere input-output-modeller. På dette niveau kompilerer Keras også vores model med tabs- og optimeringsfunktioner, træningsproces med fit-funktion. Keras ind Python håndterer ikke Low-Level API, såsom at lave beregningsgrafen, lave tensorer eller andre variabler, fordi det er blevet håndteret af "backend"-motoren.

Hvad er en backend?

Backend er et begreb i Keras, der udfører al beregning på lavt niveau såsom tensorprodukter, foldninger og mange andre ting ved hjælp af andre biblioteker såsom Tensorflow eller Theano. Så "backend-motoren" vil udføre beregningen og udviklingen af ​​modellerne. Tensorflow er standard "backend-motor", men vi kan ændre det i konfigurationen.

Theano, Tensorflow og CNTK Backend

Theano er et open source-projekt, der er udviklet af MILA-gruppen ved University of Montreal, Quebec, Canada. Det var det første udbredte Framework. Det er en Python bibliotek, der hjælper med multidimensionelle arrays til matematiske operationer ved hjælp af Numpy eller Scipy. Theano kan bruge GPU'er til hurtigere beregning, den kan også automatisk bygge symbolske grafer til beregning af gradienter. På sin hjemmeside hævder Theano, at den kan genkende numerisk ustabile udtryk og beregne dem med mere stabile algoritmer, dette er meget nyttigt for vores ustabile udtryk.

På den anden side er Tensorflow den stigende stjerne i deep learning framework. Udviklet af Googles Brain-team er det det mest populære deep learning-værktøj. Med en masse funktioner, og forskere bidrager til at hjælpe med at udvikle denne ramme til deep learning formål.

En anden backend-motor til Keras er The Microsoft Cognitive Toolkit eller CNTK. Det er en open source-deep learning-ramme, der er udviklet af Microsoft Hold. Den kan køre på multi GPU'er eller multi-maskine til træning af dyb læringsmodel i massiv skala. I nogle tilfælde blev CNTK rapporteret hurtigere end andre rammer såsom Tensorflow eller Theano. Næste i denne Keras CNN tutorial, vil vi sammenligne backends af Theano, TensorFlow og CNTK.

Sammenligning af backends

Vi er nødt til at lave et benchmark for at kende sammenligningen mellem disse to backends. Som du kan se i Jeong-Yoon Lees benchmark, sammenlignes ydeevnen af ​​3 forskellige backends på forskellig hardware. Og resultatet er, at Theano er langsommere end den anden backend, forlyder det 50 gange langsommere, men nøjagtigheden er tæt på hinanden.

En anden benchmark test udføres af Jasmeet Bhatia. Han rapporterede, at Theano er langsommere end Tensorflow for nogle test. Men den samlede nøjagtighed er næsten den samme for hvert netværk, der blev testet.

Så mellem Theano, Tensorflow og CTK er det indlysende, at TensorFlow er bedre end Theano. Med TensorFlow er beregningstiden meget kortere, og CNN er bedre end de andre.

Næste i denne Keras Python tutorial, vil vi lære om forskellen mellem Keras og TensorFlow (Keras vs Tensorflow).

Keras vs Tensorflow

Driftsparametre	Keras	Tensorflow
Type	API-indpakning på højt niveau	API på lavt niveau
Kompleksitet	Nem at bruge, hvis du Python Sprog	Du skal lære syntaksen ved at bruge nogle af Tensorflow-funktionerne
Formål	Hurtig implementering til fremstilling af model med standardlag	Giver dig mulighed for at lave en vilkårlig beregningsgraf eller modellag
Værktøjer	Bruger andre API-fejlretningsværktøjer såsom TFDBG	Du kan bruge Tensorboard visualiseringsværktøjer
Fællesskab	Store aktive fællesskaber	Store aktive fællesskaber og bredt delte ressourcer

Fordele ved Keras

Hurtig implementering og let at forstå

Keras er meget hurtig til at lave en netværksmodel. Hvis du vil lave en simpel netværksmodel med et par linjer, Python Det kan Keras hjælpe dig med. Se 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å grund af den venlige API kan vi nemt forstå processen. At skrive koden med en simpel funktion og ingen grund til at indstille flere parametre.

Stor samfundsstøtte

Der er masser af AI-fællesskaber, der bruger Keras til deres Deep Learning-ramme. Mange af dem udgiver deres koder samt tutorials til den brede offentlighed.

Har flere backends

Du kan vælge Tensorflow, CNTK og Theano som din backend med Keras. Du kan vælge en anden backend til forskellige projekter afhængigt af dine behov. Hver backend har sin egen unikke fordel.

På tværs af platforme og nem modelimplementering

Med en række understøttede enheder og platforme kan du implementere Keras på enhver enhed som f.eks

• iOS med CoreML
• Android med Tensorflow Android,
• Webbrowser med .js-understøttelse
• Cloud motor
• raspberry Pi

Understøttelse af flere GPU'er

Du kan træne Keras på en enkelt GPU eller bruge flere GPU'er på én gang. Fordi Keras har en indbygget understøttelse af dataparallelisme, så den kan behandle store mængder data og fremskynde den nødvendige tid til at træne dem.

Ulemper ved Keras

Kan ikke håndtere API på lavt niveau

Keras håndterer kun API på højt niveau, som kører oven på andre rammer eller backend-motorer såsom Tensorflow, Theano eller CNTK. Så det er ikke særlig nyttigt, hvis du vil lave dit eget abstrakte lag til dine forskningsformål, fordi Keras allerede har forudkonfigurerede lag.

Installation af Keras

I dette afsnit vil vi se på forskellige tilgængelige metoder til at installere Keras

Direkte installation eller virtuelt miljø

Hvilken er bedst? Direkte installation til den aktuelle python eller bruge et virtuelt miljø? Jeg foreslår, at du bruger et virtuelt miljø, hvis du har mange projekter. Vil du vide hvorfor? Dette skyldes, at forskellige projekter kan bruge en anden version af et keras-bibliotek.

Jeg har fx et projekt, der trænger til Python 3.5 ved hjælp af OpenCV 3.3 med ældre Keras-Theano backend, men i det andet projekt skal jeg bruge Keras med den nyeste version og en Tensorflow som backend med Python 3.6.6 support

Vi ønsker ikke, at Keras-biblioteket skal komme i konflikt med hinanden, vel? Så vi bruger et virtuelt miljø til at lokalisere projektet med en bestemt type bibliotek, eller vi kan bruge en anden platform såsom Cloud Service til at udføre vores beregninger for os som f.eks. Amazon Webservice.

Installerer Keras på Amazon Webservice (AWS)

Amazon Web Service er en platform, der tilbyder Cloud Computing-tjenester og produkter til forskere eller andre formål. AWS lejer deres hardware, netværk, Database osv. så vi kan bruge det direkte fra internettet. En af de populære AWS-tjenester til deep learning-formål er Amazon Machine Image Deep Learning Service eller DL

Se denne for detaljerede instruktioner om, hvordan du bruger AWS tutorial

Bemærkning om AMI: Du vil have følgende AMI tilgængelig

AWS Deep Learning AMI er et virtuelt miljø i AWS EC2 Service, der hjælper forskere eller praktikere med at arbejde med Deep Learning. DLAMI tilbyder fra små CPU'er-motorer op til højtydende multi-GPU'er-motorer med prækonfigureret CUDA, cuDNN og kommer med en række dybe læringsrammer.

Hvis du vil bruge det med det samme, bør du vælge Deep Learning AMI, fordi det leveres forudinstalleret med populære deep learning-rammer.

Men hvis du vil prøve en brugerdefineret deep learning-ramme til forskning, bør du installere Deep Learning Base AMI, fordi den kommer med grundlæggende biblioteker såsom CUDA, cuDNN, GPU'er-drivere og andre nødvendige biblioteker til at køre med dit dybe læringsmiljø.

Sådan installeres Keras på Amazon SageMaker

Amazon SageMaker er en dyb læringsplatform til at hjælpe dig med at træne og implementere dybt læringsnetværk med den bedste algoritme.

Som nybegynder er dette langt den nemmeste metode til at bruge Keras. Nedenfor er en proces om, hvordan man installerer Keras på Amazon SageMaker:

Trin 1) Åbn Amazon SageMaker

I det første trin skal du åbne Amazon Sagemager konsollen og klik på Opret notesbogsforekomst.

Trin 2) Indtast detaljerne

1. Indtast dit notesbogsnavn.
2. Opret en IAM-rolle. Det vil skabe en AMI-rolle Amazon IAM rolle i formatet af AmazonSageMaker-Executionrole-ÅÅÅÅMMDD|HHmmSS.
3. Til sidst skal du vælge Opret notesbogsforekomst. Efter et par øjeblikke, Amazon Sagemaker lancerer en notebook-forekomst.

Bemærk: Hvis du vil have adgang til ressourcer fra din VPC, skal du indstille den direkte internetadgang som aktiveret. Ellers vil denne notebook-instans ikke have internetadgang, så det er umuligt at træne eller hoste modeller

Trin 3) Start forekomsten

Klik på Åbn for at starte forekomsten

Trin 4) Start kodning

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

Installer Keras i Linux

For at aktivere Keras med Tensorflow som backend-motor, skal vi først installere Tensorflow. Kør denne kommando for at installere tensorflow med CPU (ingen GPU)

pip install --upgrade tensorflow

Hvis du vil aktivere GPU-understøttelse for tensorflow, kan du bruge denne kommando

pip install --upgrade tensorflow-gpu

lad os tjekke ind Python for at se, om vores installation er vellykket, ved at 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 der ikke er nogen fejlmeddelelse, er installationsprocessen vellykket

Installer Keras

Når vi har installeret Tensorflow, lad os begynde at installere keras. Indtast denne kommando i terminalen

pip install keras

det vil begynde at installere Keras og også alle dets afhængigheder. Du skulle se noget som dette:

Nu har vi Keras installeret i vores system!

Bekræftelse

Før vi begynder at bruge Keras, bør vi kontrollere, om vores Keras bruger Tensorflow som backend ved at åbne konfigurationsfilen:

gedit ~/.keras/keras.json

du burde se sådan noget

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

som du kan se, bruger "backend" tensorflow. Det betyder, at keras bruger Tensorflow som backend, som vi forventede

og kør det nu på terminalen ved at 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.
>>> 

Sådan installeres Keras på Windows

Inden vi installerer Tensorflow og Keras, vi burde installere Python, pip og virtualenv. Hvis du allerede har installeret disse biblioteker, skal du fortsætte til næste trin, ellers gør du dette:

Installer Python 3 ved at downloade fra denne link

Installer pip ved at køre denne

Installer virtualenv med denne kommando

pip3 install –U pip virtualenv

Installer Microsoft Visuel C++ 2015 omdistribuerbar opdatering 3

• Gå til Visual Studio-downloadsiden https://www.microsoft.com/en-us/download/details.aspx?id=53587
• Vælg Redistributables og Build Tools
• Download og installer Microsoft Visuel C++ 2015 omdistribuerbar opdatering 3

Kør derefter dette script

pip3 install virtualenv

Konfigurer virtuelt miljø

Dette bruges til at isolere arbejdssystemet med hovedsystemet.

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

Aktiver miljøet

.\venv\Scripts\activate

Efter at have forberedt miljøet, forbliver Tensorflow- og Keras-installationen den samme som Linux. Næste i denne Deep learning with Keras-tutorial vil vi lære om Keras fundamentals for Deep learning.

Keras Fundamentals for Deep Learning

Hovedstrukturen i Keras er modellen, som definerer den komplette graf for et netværk. Du kan tilføje flere lag til en eksisterende model for at bygge en brugerdefineret model, som du har brug for til dit projekt.

Sådan laver du en sekventiel model og et par almindeligt anvendte lag i deep learning

1. Sekventiel model

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

model = Sequential()

2. Konvolutionerende lag

Dette er en Keras Python eksempel på foldningslag som inputlag med inputformen 320x320x3, med 48 filtre i størrelsen 3×3 og brug ReLU som en aktiveringsfunktion.

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 anden type er

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

3. MaksPooling lag

For at downsample input-repræsentationen skal du bruge MaxPool2d og angive kernestørrelsen

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

4. Tæt lag

tilføjelse af et fuldt tilsluttet lag med blot at angive outputstørrelsen

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

5. Frafaldslag

Tilføjelse af dropout-lag med 50% sandsynlighed

model.add(Dropout(0.5))

Kompilering, træning og evaluering

Når vi har defineret vores model, lad os begynde at træne dem. Det er nødvendigt at kompilere netværket først med tabsfunktionen og optimeringsfunktionen. Dette vil give netværket mulighed for at ændre vægt og minimere tabet.

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

For at starte træningen skal du bruge fit til at føre trænings- og valideringsdata til modellen. Dette giver dig mulighed for at træne netværket i batches og indstille epoker.

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

Vores sidste trin er at evaluere modellen med testdataene.

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

Lad os prøve at bruge simpel lineær regression

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()

Efter træning af dataene skal output se sådan ud

med startvægten

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

og endelig vægt

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

Finjuster fortrænede modeller i Keras og hvordan man bruger dem

Hvorfor vi bruger Fine Tune-modeller, og hvornår vi bruger det

Finjustering er en opgave at finjustere en fortrænet model, således at parametrene vil tilpasse sig den nye model. Når vi vil træne fra bunden på en ny model, har vi brug for en stor mængde data, så netværket kan finde alle parametre. Men i dette tilfælde vil vi bruge en præ-trænet model, så parametrene allerede er lært og har en vægt.

For eksempel, hvis vi ønsker at træne vores egen Keras-model til at løse et klassifikationsproblem, men vi kun har en lille mængde data, så kan vi løse dette ved at bruge en Overfør læring + Finjusteringsmetode.

Ved at bruge et fortrænet netværk og vægte behøver vi ikke træne hele netværket. Vi mangler blot at træne det sidste lag, der bruges til at løse vores opgave, som vi kalder det Fine-Tuning metode.

Udarbejdelse af netværksmodel

For den fortrænede model kan vi indlæse en række forskellige modeller, som Keras allerede har i sit bibliotek, såsom:

• VGG16
• InceptionV3
• ResNet
• MobileNet
• Xception
• InceptionResNetV2

Men i denne proces vil vi bruge VGG16 netværksmodellen og imageNet som vores vægt for modellen. Vi vil finjustere et netværk for at klassificere 8 forskellige typer klasser ved hjælp af billeder fra Kaggle Natural Images Dataset

VGG16 model arkitektur

kilde

Uploader vores data til AWS S3 Bucket

Til vores træningsproces vil vi bruge et billede af naturlige billeder fra 8 forskellige klasser såsom fly, bil, kat, hund, blomst, frugt, motorcykel og person. Først skal vi uploade vores data til Amazon S3 spand.

Amazon S3 spand

Trin 1) Efter login på din S3-konto, lad os oprette en bøtte ved at klokke Opret spand

Trin 2) Vælg nu et Bucket-navn og din region i henhold til din konto. Sørg for, at spandnavnet er tilgængeligt. Efter det klik Opret.

Trin 3) Som du kan se, er din Bucket klar til brug. Men som du kan se, er adgangen ikke offentlig, den er god for dig, hvis du vil holde den privat for dig selv. Du kan ændre denne bucket til offentlig adgang i Bucket Properties

Trin 4) Nu begynder du at uploade dine træningsdata til din Bucket. Her vil jeg uploade tar.gz filen som består af billeder til træning og testproces.

Trin 5) Klik nu på din fil og kopier den Link så vi kan downloade det.

Dataforberedelse

Vi skal generere vores træningsdata ved hjælp af Keras ImageDataGenerator.

Først skal du downloade ved hjælp af wget med linket til din fil fra S3 Bucket.

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

Når du har downloadet dataene, lad os starte træningsprocessen.

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)

BilleddataGenerator vil lave en X_training data fra en mappe. Underbiblioteket i den mappe vil blive brugt som en klasse for hvert objekt. Billedet vil blive indlæst med RGB-farvetilstanden, med den kategoriske klassetilstand for Y_træningsdataene, med en batchstørrelse på 16. Bland endelig dataene.

Lad os se vores billeder tilfældigt ved at 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()

Lad os derefter skabe vores netværksmodel fra VGG16 med imageNet fortrænet vægt. Vi vil fryse disse lag, så lagene ikke kan trænes for at hjælpe os med at reducere beregningstiden.

Oprettelse af vores model 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, er sammenfatningen af ​​vores netværksmodel. Fra et input fra VGG16 Layers tilføjer vi 2 Fully Connected Layer, som vil udtrække 1024 funktioner og et outputlag, der vil beregne de 8 klasser 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

Kurser

# # 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

Som du kan se, er vores tab faldet betydeligt, og nøjagtigheden er næsten 100%. For at teste vores model valgte vi tilfældigt billeder over internettet og lagde dem i testmappen med en anden klasse at teste

Tester vores model

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 vores test er som vist nedenfor! Kun 1 billede er forudsagt forkert ud fra en test af 14 billeder!

Ansigtsgenkendelse neuralt netværk med Keras

Hvorfor vi har brug for anerkendelse

Vi har brug for anerkendelse for at gøre det nemmere for os at genkende eller identificere en persons ansigt, objekttype, anslåede alder på en person ud fra hans ansigt eller endda kende personens ansigtsudtryk.

Måske indser du, at hver gang du prøver at markere din vens ansigt på et billede, har funktionen i Facebook gjort det for dig, det vil sige at markere din vens ansigt uden at du behøver at markere det først. Dette er ansigtsgenkendelse anvendt af Facebook for at gøre det nemmere for os at tagge venner.

Så hvordan virker det? Hver gang vi markerer vores vens ansigt, vil Facebooks AI lære det og vil forsøge at forudsige det, indtil det får det rigtige resultat. Det samme system vil vi bruge til at lave vores egen ansigtsgenkendelse. Lad os begynde at lave vores egen ansigtsgenkendelse ved hjælp af Deep Learning

Netværksmodel

Vi vil bruge en VGG16 netværksmodel, men med VGGFace-vægt.

VGG16 model arkitektur

Hvad er VGGFace? det er Keras implementering af Deep Face Recognition introduceret af Parkhi, Omkar M. et al. "Dyb ansigtsgenkendelse." BMVC (2015). Rammen bruger VGG16 som netværksarkitektur.

Du kan downloade 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 netværksoversigten

_________________________________________________________________
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 gøre en Overfør læring + Finjustering for at gøre træningen hurtigere med små datasæt. Først vil vi fryse bundlagene, så lagene ikke kan trænes.

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

så tilføjer vi vores eget lag for at genkende vores testansigter. Vi tilføjer 2 fuldt forbundne lag og et outputlag med 5 personer til at opdage.

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)

Lad os se vores netværksoversigt

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, vil det efter pool5-laget blive fladt sammen til en enkelt funktionsvektor, der vil blive brugt af det tætte lag til den endelige genkendelse.

Forberedelse af vores ansigter

Lad os nu forberede vores ansigter. Jeg lavede en mappe bestående af 5 kendte personer

• Jack Ma
• Jason Statham
• Johnny Depp
• Robert Downey Jr. Jr
• Røn Atkinson

Hver mappe indeholder 10 billeder, for hver trænings- og evalueringsproces. Det er en meget lille mængde data, men det er udfordringen, ikke?

Vi vil bruge hjælpen fra Keras værktøj til at hjælpe os med at forberede dataene. Denne funktion vil iterere i datasætmappen og derefter forberede den, så den kan bruges i træningen.

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,
)

Træning af vores model

Lad os begynde vores træningsproces med at kompilere vores netværk med tabsfunktion og optimering. Her bruger vi sparse_categorical_crossentropy som vores tabsfunktion ved hjælp af SGD som vores læringsoptimering.

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 vores valideringsnøjagtighed op til 64%, dette er et godt resultat for en lille mængde træningsdata. Vi kan forbedre dette ved at tilføje flere lag eller tilføje flere træningsbilleder, så vores model kan lære mere om ansigterne og opnå mere nøjagtighed.

Lad os teste vores model med et testbillede

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 at bruge Robert Downey Jr.-billede som vores testbillede, viser det, at det forudsagte ansigt er sandt!

Forudsigelse ved hjælp af Live Cam!

Hvad med, hvis vi tester vores evner med at implementere det med input fra et webcam? Ved at bruge OpenCV med Haar Face cascade til at finde vores ansigt og ved hjælp af vores netværksmodel kan vi genkende personen.

Det første skridt er at forberede dig og din vens ansigter. Jo flere data vi har, jo bedre er resultatet!

Forbered og træne dit netværk som det forrige trin, når træningen er fuldført, tilføj denne linje for at få inputbilledet 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 bedst? Keras eller Tensorflow

Keras tilbyder enkelhed, når du skriver manuskriptet. Vi kan begynde at skrive og forstå direkte med Keras, da det ikke er for svært at forstå. Det er mere brugervenligt og nemt at implementere, ingen grund til at lave mange variabler for at køre modellen. Så vi behøver ikke at forstå alle detaljer i backend-processen.

På den anden side er Tensorflow operationerne på lavt niveau, der tilbyder fleksibilitet og avancerede operationer, hvis du vil lave en vilkårlig beregningsgraf eller model. Tensorflow kan også visualisere processen ved hjælp af TensorBoard og et specialiseret debugger-værktøj.

Så hvis du vil begynde at arbejde med dyb læring med ikke så meget kompleksitet, så brug Keras. Fordi Keras tilbyder enkelhed og brugervenlig at bruge og nem at implementere end Tensorflow. Men hvis du vil skrive din egen algoritme i deep learning projekt eller forskning, bør du bruge Tensorflow i stedet.

Resumé

Så lad os opsummere alt, hvad vi har diskuteret og gjort i denne tutorial.

• Keras i en API på højt niveau, der bruges til at gøre deep learning-netværk nemmere ved hjælp af backend-motor.
• Keras er nem at bruge og forstå med python-understøttelse, så den føles mere naturlig end nogensinde. Det er godt for begyndere, der ønsker at lære om dyb læring, og for forskere, der ønsker let at bruge API.
• Installationsprocessen er nem, og du kan bruge et virtuelt miljø eller bruge en ekstern platform som f.eks AWS.
• Keras kommer også med forskellige slags netværksmodeller, så det gør os nemmere at bruge den tilgængelige model til at fortræne og finjustere vores egen netværksmodel.
• Der er også en masse tutorials og artikler om brug af Keras fra fællesskaber verden over koder til dyb læringsformål.