Keras handledning

Vad är Keras?

Keras är ett Open Source Neural Network-bibliotek skrivet i Python som körs ovanpå Theano eller Tensorflow. Den är designad för att vara modulär, snabb och enkel att använda. Det utvecklades av François Chollet, en Google-ingenjör. Keras hanterar inte lågnivåberäkningar. Istället använder den ett annat bibliotek för att göra det, kallat "Backend.

Keras är högnivå API-omslag för lågnivå-API, som kan köras ovanpå TensorFlow, CNTK eller Theano. Keras High-Level API hanterar hur vi gör modeller, definierar lager eller ställer in flera input-output-modeller. På denna nivå sammanställer Keras även vår modell med förlust- och optimeringsfunktioner, träningsprocess med passformsfunktion. Keras in Python hanterar inte Low-Level API som att göra beräkningsgrafen, göra tensorer eller andra variabler eftersom det har hanterats av "backend"-motorn.

Vad är en backend?

Backend är en term i Keras som utför all lågnivåberäkning som tensorprodukter, faltningar och många andra saker med hjälp av andra bibliotek som Tensorflow eller Theano. Så "backend-motorn" kommer att utföra beräkningen och utvecklingen av modellerna. Tensorflow är standard "backend-motor" men vi kan ändra det i konfigurationen.

Theano, Tensorflow och CNTK Backend

Theano är ett öppen källkodsprojekt som utvecklats av MILA-gruppen vid University of Montreal, Quebec, Kanada. Det var det första allmänt använda ramverket. Det är en Python bibliotek som hjälper till med flerdimensionella arrayer för matematiska operationer med Numpy eller Scipy. Theano kan använda GPU:er för snabbare beräkning, den kan också automatiskt bygga symboliska grafer för beräkningsgradienter. På sin hemsida hävdar Theano att den kan känna igen numeriskt instabila uttryck och beräkna dem med mer stabila algoritmer, detta är väldigt användbart för våra instabila uttryck.

Å andra sidan är Tensorflow den stigande stjärnan inom ramverket för djupinlärning. Utvecklat av Googles hjärnteam är det det mest populära verktyget för djupinlärning. Med många funktioner och forskare bidrar till att utveckla detta ramverk för djupt lärande.

En annan backend-motor för Keras är The Microsoft Cognitive Toolkit eller CNTK. Det är ett ramverk för djupinlärning med öppen källkod som utvecklats av Microsoft Team. Den kan köras på flera GPU:er eller flera maskiner för att träna djupinlärningsmodeller i massiv skala. I vissa fall rapporterades CNTK snabbare än andra ramverk som Tensorflow eller Theano. Nästa i denna Keras CNN-handledning kommer vi att jämföra backends av Theano, TensorFlow och CNTK.

Jämför backends

Vi måste göra ett riktmärke för att kunna jämföra dessa två backends. Som du kan se i Jeong-Yoon Lees riktmärke, jämförs prestandan för 3 olika backends på olika hårdvara. Och resultatet är att Theano är långsammare än den andra backend, rapporteras det 50 gånger långsammare, men noggrannheten ligger nära varandra.

Annan benchmark-tester utförs av Jasmeet Bhatia. Han rapporterade att Theano är långsammare än Tensorflow för något test. Men den övergripande noggrannheten är nästan densamma för alla nätverk som testades.

Så mellan Theano, Tensorflow och CTK är det uppenbart att TensorFlow är bättre än Theano. Med TensorFlow är beräkningstiden mycket kortare och CNN är bättre än de andra.

Nästa i denna Keras Python tutorial, vi kommer att lära oss om skillnaden mellan Keras och TensorFlow (Keras vs Tensorflow).

Keras vs Tensorflow

Driftparametrar	Keras	Tensorflöde
Typ	API-omslag på hög nivå	Lågnivå API
Komplexitet	Lätt att använda om du Python språk	Du måste lära dig syntaxen för att använda några av Tensorflow-funktionerna
Syfte	Snabb distribution för att göra modell med standardlager	Låter dig göra en godtycklig beräkningsgraf eller modelllager
verktyg	Använder andra API-felsökningsverktyg som TFDBG	Du kan använda Tensorboard visualiseringsverktyg
Community	Stora aktiva samhällen	Stora aktiva samhällen och brett delade resurser

Fördelar med Keras

Snabb implementering och lätt att förstå

Keras är väldigt snabb att göra en nätverksmodell. Om du vill göra en enkel nätverksmodell med några rader, Python Keras kan hjälpa dig med det. Titta på Keras-exemplet nedan:

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 av vänlig API kan vi enkelt förstå processen. Att skriva koden med en enkel funktion och inget behov av att ställa in flera parametrar.

Stort samhällsstöd

Det finns massor av AI-gemenskaper som använder Keras för sitt ramverk för Deep Learning. Många av dem publicerar sina koder samt tutorials för allmänheten.

Har flera backends

Du kan välja Tensorflow, CNTK och Theano som din backend med Keras. Du kan välja en annan backend för olika projekt beroende på dina behov. Varje backend har sin egen unika fördel.

Plattformsöverskridande och enkel modellinstallation

Med en mängd olika enheter och plattformar som stöds kan du distribuera Keras på vilken enhet som helst

• iOS med CoreML
• Android med Tensorflow Android,
• Webbläsare med .js-stöd
• Molnmotor
• hallon Pi

Stöd för flera GPU:er

Du kan träna Keras på en enda GPU eller använda flera GPU:er samtidigt. Eftersom Keras har ett inbyggt stöd för dataparallellism så att den kan bearbeta stora datamängder och påskynda tiden som behövs för att träna den.

Nackdelar med Keras

Kan inte hantera API på låg nivå

Keras hanterar bara API på hög nivå som körs ovanpå andra ramverk eller backend-motorer som Tensorflow, Theano eller CNTK. Så det är inte särskilt användbart om du vill göra ditt eget abstrakta lager för dina forskningsändamål eftersom Keras redan har förkonfigurerade lager.

Installerar Keras

I det här avsnittet kommer vi att undersöka olika metoder som är tillgängliga för att installera Keras

Direktinstallation eller virtuell miljö

Vilken är bättre? Direktinstallera till nuvarande python eller använda en virtuell miljö? Jag föreslår att du använder en virtuell miljö om du har många projekt. Vill du veta varför? Detta beror på att olika projekt kan använda en annan version av ett keras-bibliotek.

Jag har till exempel ett projekt som behöver Python 3.5 använder OpenCV 3.3 med äldre Keras-Theano backend men i det andra projektet måste jag använda Keras med den senaste versionen och en Tensorflow som backend med Python 3.6.6-stöd

Vi vill väl inte att Keras-biblioteket ska stå i konflikt med varandra? Så vi använder en virtuell miljö för att lokalisera projektet med en specifik typ av bibliotek eller så kan vi använda en annan plattform som molntjänst för att göra vår beräkning åt oss som Amazon Webb-service.

Installerar Keras på Amazon Webbtjänst (AWS)

Amazon Web Service är en plattform som erbjuder Cloud Computing-tjänster och produkter för forskare eller andra ändamål. AWS hyr ut sin hårdvara, nätverk, Databas etc. så att vi kan använda det direkt från internet. En av de populära AWS-tjänsterna för djupinlärning är Amazon Machine Image Deep Learning Service eller DL

För detaljerade instruktioner om hur du använder AWS, se detta handledning

Anmärkning om AMI: Du kommer att ha följande AMI tillgänglig

AWS Deep Learning AMI är en virtuell miljö i AWS EC2 Service som hjälper forskare eller praktiker att arbeta med Deep Learning. DLAMI erbjuder från små CPU-motorer upp till kraftfulla multi-GPU-motorer med förkonfigurerad CUDA, cuDNN, och kommer med en mängd olika ramverk för djupinlärning.

Om du vill använda det direkt bör du välja Deep Learning AMI eftersom det kommer förinstallerat med populära ramar för djupinlärning.

Men om du vill prova ett anpassat ramverk för djupinlärning för forskning, bör du installera Deep Learning Base AMI eftersom det kommer med grundläggande bibliotek som CUDA, cuDNN, GPU-drivrutiner och andra nödvändiga bibliotek för att köra med din djupinlärningsmiljö.

Hur man installerar Keras på Amazon SageMaker

Amazon SageMaker är en plattform för djupinlärning som hjälper dig med utbildning och implementering av nätverk för djupinlärning med den bästa algoritmen.

Som nybörjare är detta den överlägset enklaste metoden att använda Keras. Nedan är en process om hur man installerar Keras på Amazon SageMaker:

Steg 1) Öppna Amazon SageMaker

I det första steget, Öppna Amazon Sagemaker konsolen och klicka på Skapa anteckningsboksinstans.

Steg 2) Ange detaljerna

1. Ange ditt anteckningsblocks namn.
2. Skapa en IAM-roll. Det kommer att skapa en AMI-roll Amazon IAM roll i formatet AmazonSageMaker-Executionrole-ÅÅÅÅMMDD|HHmmSS.
3. Slutligen väljer du Skapa anteckningsboksinstans. Efter några ögonblick, Amazon Sagemaker lanserar en anteckningsbok-instans.

Anmärkningar: Om du vill komma åt resurser från din VPC, ställ in den direkta internetåtkomsten som aktiverad. Annars kommer den här notebook-instansen inte att ha tillgång till internet, så det är omöjligt att träna eller vara värd för modeller

Steg 3) Starta instansen

Klicka på Öppna för att starta instansen

Steg 4) Börja koda

In Jupyter, Klicka på Ny> conda_tensorflow_p36 och du är redo att koda

Installera Keras i Linux

För att aktivera Keras med Tensorflow som backend-motor måste vi först installera Tensorflow. Kör det här kommandot för att installera tensorflow med CPU (ingen GPU)

pip install --upgrade tensorflow

om du vill aktivera GPU-stödet för tensorflow kan du använda det här kommandot

pip install --upgrade tensorflow-gpu

låt oss checka in Python för att se om vår installation är framgångsrik genom att skriva

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

om det inte finns något felmeddelande är installationsprocessen framgångsrik

Installera Keras

När vi har installerat Tensorflow, låt oss börja installera keras. Skriv detta kommando i terminalen

pip install keras

det kommer att börja installera Keras och även alla dess beroenden. Du bör se något i stil med detta:

Nu har vi Keras installerat i vårt system!

verifiera

Innan vi börjar använda Keras bör vi kontrollera om våra Keras använder Tensorflow som backend genom att öppna konfigurationsfilen:

gedit ~/.keras/keras.json

du borde se något sånt här

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

som du kan se använder "backend" tensorflow. Det betyder att keras använder Tensorflow som backend som vi förväntade oss

och kör det nu på terminalen genom att skriva

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

Hur man installerar Keras på Windows

Innan vi installerar Tensorflöde och Keras, vi borde installera Python, pip och virtualenv. Om du redan har installerat dessa bibliotek bör du fortsätta till nästa steg, annars gör du så här:

installera Python 3 genom att ladda ner från denna länk

Installera pip genom att köra detta

Installera virtualenv med detta kommando

pip3 install –U pip virtualenv

installera Microsoft Visuell C++ 2015 omdistribuerbar uppdatering 3

• Gå till nedladdningssidan för Visual Studio https://www.microsoft.com/en-us/download/details.aspx?id=53587
• Välj Redistributables and Build Tools
• Hämta och installera Microsoft Visuell C++ 2015 omdistribuerbar uppdatering 3

Kör sedan det här skriptet

pip3 install virtualenv

Ställ in virtuell miljö

Detta används för att isolera arbetssystemet med huvudsystemet.

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

Aktivera miljön

.\venv\Scripts\activate

Efter att ha förberett miljön förblir installationen av Tensorflow och Keras samma som Linux. Nästa i den här självstudien för djupinlärning med Keras kommer vi att lära oss om Keras grunder för djupinlärning.

Keras Fundamentals for Deep Learning

Huvudstrukturen i Keras är modellen som definierar hela grafen för ett nätverk. Du kan lägga till fler lager i en befintlig modell för att bygga en anpassad modell som du behöver för ditt projekt.

Så här gör du en sekventiell modell och några vanliga lager inom djupinlärning

1. Sekventiell modell

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

model = Sequential()

2. Konvolutionellt lager

Det här är en Keras Python exempel på faltningslager som ingångslager med ingångsformen 320x320x3, med 48 filter i storleken 3×3 och använd 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 annan typ är

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

3.MaxPooling Lager

För att nedsampla indatarepresentationen, använd MaxPool2d och ange kärnans storlek

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

4. Tät lager

lägga till ett helt anslutet lager genom att bara ange utdatastorleken

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

5. Avhoppslager

Lägger till dropout-lager med 50 % sannolikhet

model.add(Dropout(0.5))

Sammanställa, träna och utvärdera

När vi har definierat vår modell, låt oss börja träna dem. Det krävs att först kompilera nätverket med förlustfunktionen och optimeringsfunktionen. Detta kommer att tillåta nätverket att ändra vikter och minimera förlusten.

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

För att börja träna, använd passform för att mata tränings- och valideringsdata till modellen. Detta gör att du kan träna nätverket i omgångar och ställa in epoker.

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

Vårt sista steg är att utvärdera modellen med testdata.

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

Låt oss försöka använda enkel linjä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 att ha tränat data ska utdata se ut så här

med den ursprungliga vikten

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

och slutvikt

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

Finjustera förtränade modeller i Keras och hur man använder dem

Varför vi använder Fine Tune Models och när vi använder det

Finjustering är en uppgift att justera en förtränad modell så att parametrarna skulle anpassa sig till den nya modellen. När vi vill träna från grunden på en ny modell behöver vi en stor mängd data, så att nätverket kan hitta alla parametrar. Men i det här fallet kommer vi att använda en förtränad modell så att parametrarna redan är inlärda och har en vikt.

Om vi ​​till exempel vill träna vår egen Keras-modell för att lösa ett klassificeringsproblem men vi bara har en liten mängd data, kan vi lösa detta genom att använda en Överför lärande + Finjusteringsmetod.

Med hjälp av ett förtränat nätverk och vikter behöver vi inte träna hela nätverket. Vi behöver bara träna det sista lagret som används för att lösa vår uppgift som vi kallar det Fine-Tuning-metoden.

Förberedelse av nätverksmodeller

För den förtränade modellen kan vi ladda en mängd olika modeller som Keras redan har i sitt bibliotek som:

• VGG16
• Start V3
• ResNet
• MobileNet
• Xception
• InceptionResNetV2

Men i denna process kommer vi att använda VGG16 nätverksmodell och imageNet som vår vikt för modellen. Vi kommer att finjustera ett nätverk för att klassificera 8 olika typer av klasser med hjälp av bilder från Kaggle Natural Images Dataset

VGG16 modellarkitektur

källa

Ladda upp vår data till AWS S3 Bucket

För vår träningsprocess kommer vi att använda en bild av naturliga bilder från 8 olika klasser som flygplan, bil, katt, hund, blomma, frukt, motorcykel och person. Först måste vi ladda upp vår data till Amazon S3 hink.

Amazon S3 hink

Steg 1) Efter att ha loggat in på ditt S3-konto, låt oss skapa en hink genom att klocka Skapa hink

Steg 2) Välj nu ett Bucket Name och din region enligt ditt konto. Se till att hinkens namn är tillgängligt. Efter det klicka Skapa.

Steg 3) Som du kan se är din hink redo att användas. Men som du kan se är Access inte offentlig, det är bra för dig om du vill hålla det privat för dig själv. Du kan ändra den här hinken för allmän åtkomst i Bucket Properties

Steg 4) Nu börjar du ladda upp din träningsdata till din Bucket. Här kommer jag att ladda upp filen tar.gz som består av bilder för träning och testprocess.

Steg 5) Klicka nu på din fil och kopiera Länk så att vi kan ladda ner den.

Förberedelse av data

Vi måste generera våra träningsdata med hjälp av Keras ImageDataGenerator.

Först måste du ladda ner med wget med länken till din fil från S3 Bucket.

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

När du har laddat ner data, låt oss börja utbildningsprocessen.

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)

BilddataGenerator kommer att göra en X_training data från en katalog. Underkatalogen i den katalogen kommer att användas som en klass för varje objekt. Bilden kommer att laddas med RGB-färgläget, med det kategoriska klassläget för Y_training-data, med en batchstorlek på 16. Blanda slutligen data.

Låt oss se våra bilder slumpmässigt genom att plotta 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()

Låt oss sedan skapa vår nätverksmodell från VGG16 med imageNet förtränad vikt. Vi kommer att frysa dessa lager så att lagren inte går att träna för att hjälpa oss att minska beräkningstiden.

Skapar vår modell från 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 nedan, sammanfattningen av vår nätverksmodell. Från en ingång från VGG16 Layers lägger vi till 2 Fully Connected Layer som extraherar 1024 funktioner och ett utdatalager som kommer att beräkna de 8 klasserna 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

Utbildning

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

Resultat

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 minskar våra förluster avsevärt och noggrannheten är nästan 100%. För att testa vår modell valde vi slumpmässigt bilder över internet och la dem i testmappen med en annan klass att testa

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

Och vårt test är enligt nedan! Endast 1 bild förutspås fel från ett test av 14 bilder!

Neuralt nätverk för ansiktsigenkänning med Keras

Varför vi behöver erkännande

Vi behöver igenkänning för att göra det lättare för oss att känna igen eller identifiera en persons ansikte, föremålstyp, beräknade ålder på en person utifrån hans ansikte, eller till och med känna till den personens ansiktsuttryck.

Kanske inser du att varje gång du försöker markera din väns ansikte i ett foto, har funktionen i Facebook gjort det åt dig, det vill säga att markera din väns ansikte utan att du behöver markera det först. Detta är ansiktsigenkänning som tillämpas av Facebook för att göra det enklare för oss att tagga vänner.

Så hur fungerar det? Varje gång vi markerar vår väns ansikte kommer Facebooks AI att lära sig det och försöka förutsäga det tills det får rätt resultat. Samma system kommer vi att använda för att göra vår egen ansiktsigenkänning. Låt oss börja göra vår egen ansiktsigenkänning med hjälp av Deep Learning

Nätverksmodell

Vi kommer att använda en VGG16 Network Model men med VGGFace-vikt.

VGG16 modellarkitektur

Vad är VGGFace? det är Keras implementering av Deep Face Recognition introducerad av Parkhi, Omkar M. et al. "Djup ansiktsigenkänning." BMVC (2015). Ramverket använder VGG16 som nätverksarkitektur.

Du kan ladda ner VGGFace från 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 nätverkssammanfattningen

_________________________________________________________________
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 kommer att göra en Överför lärande + Finjustering för att göra träningen snabbare med små datamängder. Först ska vi frysa baslagren så att lagren inte går att träna.

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

sedan lägger vi till vårt eget lager för att känna igen våra testansikten. Vi kommer att lägga till 2 helt anslutna lager och ett utdatalager med 5 personer att upptäcka.

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)

Låt oss se vår nätverkssammanfattning

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 ovan, efter pool5-lagret, kommer det att tillplattas till en enda funktionsvektor som kommer att användas av det täta lagret för den slutliga igenkänningen.

Förbereder våra ansikten

Låt oss nu förbereda våra ansikten. Jag gjorde en katalog bestående av 5 kända personer

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

Varje mapp innehåller 10 bilder, för varje utbildnings- och utvärderingsprocess. Det är en mycket liten mängd data men det är utmaningen, eller hur?

Vi kommer att använda hjälpen av Keras verktyg för att hjälpa oss att förbereda data. Denna funktion kommer att iterera i datamappen och sedan förbereda den så att den kan användas i utbildningen.

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

Utbilda vår modell

Låt oss börja vår träningsprocess genom att sammanställa vårt nätverk med förlustfunktion och optimerare. Här använder vi sparse_categorical_crossentropy som vår förlustfunktion, med hjälp av SGD som vår inlärningsoptimerare.

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 är vår valideringsnoggrannhet upp till 64%, detta är ett bra resultat för en liten mängd träningsdata. Vi kan förbättra detta genom att lägga till fler lager eller lägga till fler träningsbilder så att vår modell kan lära sig mer om ansiktena och uppnå större noggrannhet.

Låt oss testa vår modell med en testbild

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']

med Robert Downey Jr.-bild som vår testbild visar det att det förutspådda ansiktet är sant!

Förutsägelse med Live Cam!

Vad sägs om om vi testar vår skicklighet med att implementera det med indata från en webbkamera? Genom att använda OpenCV med Haar Face cascade för att hitta vårt ansikte och med hjälp av vår nätverksmodell kan vi känna igen personen.

Det första steget är att förbereda dig och din väns ansikten. Ju mer data vi har då desto bättre blir resultatet!

Förbered och träna ditt nätverk som föregående steg, efter att träningen är klar, lägg till den här raden för att få ingångsbilden från 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()

Vilken är bättre? Keras eller Tensorflow

Keras erbjuder enkelhet när du skriver manuset. Vi kan börja skriva och förstå direkt med Keras eftersom det inte är så svårt att förstå. Det är mer användarvänligt och enkelt att implementera, du behöver inte göra många variabler för att köra modellen. Så vi behöver inte förstå varje detalj i backend-processen.

Å andra sidan är Tensorflow operationerna på låg nivå som erbjuder flexibilitet och avancerade operationer om du vill göra en godtycklig beräkningsgraf eller modell. Tensorflow kan också visualisera processen med hjälp av TensorBoard och ett specialiserat felsökningsverktyg.

Så om du vill börja arbeta med djupinlärning med inte så mycket komplexitet, använd Keras. Eftersom Keras erbjuder enkelhet och användarvänlig att använda och lätt att implementera än Tensorflow. Men om du vill skriva din egen algoritm i djupinlärningsprojekt eller forskning bör du istället använda Tensorflow.

Sammanfattning

Så låt oss sammanfatta allt vi har diskuterat och gjort i denna handledning.

• Keras i ett högnivå-API som används för att göra djupinlärningsnätverk enklare med hjälp av backend-motorn.
• Keras är lätt att använda och förstå med python-stöd så det känns mer naturligt än någonsin. Det är bra för nybörjare som vill lära sig om djupinlärning och för forskare som vill ha lättanvänd API.
• Installationsprocessen är enkel och du kan använda en virtuell miljö eller använda en extern plattform som t.ex AWS.
• Keras kommer också med olika typer av nätverksmodeller så det gör oss lättare att använda den tillgängliga modellen för att förträna och finjustera vår egen nätverksmodell.
• Det finns också många handledningar och artiklar om hur man använder Keras från gemenskaper över hela världen för djupinlärningsändamål.