Keras Tutorial: Hvad er Keras? Sådan installeres i Python [Eksempel]
Evelyn Clarke
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
| parametre | 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 |
| Community | 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
- Indtast dit notesbogsnavn.
- Opret en IAM-rolle. Det vil skabe en AMI-rolle Amazon IAM rolle i formatet af AmazonSageMaker-Executionrole-ÅÅÅÅMMDD|HHmmSS.
- 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
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.
