Tutorial Keras

Ce este Keras?

Keras este o bibliotecă Open Source Neural Network scrisă în Python care rulează deasupra Theano sau Tensorflow. Este conceput pentru a fi modular, rapid și ușor de utilizat. A fost dezvoltat de François Chollet, un inginer Google. Keras nu se ocupă de calculul de nivel scăzut. În schimb, folosește o altă bibliotecă pentru a face acest lucru, numită „Backend.

Keras este un pachet API de nivel înalt pentru API-ul de nivel scăzut, capabil să ruleze pe TensorFlow, CNTK sau Theano. Keras High-Level API gestionează modul în care realizăm modele, definim straturi sau setăm mai multe modele de intrare-ieșire. La acest nivel, Keras alcătuiește și modelul nostru cu funcții de pierdere și optimizare, proces de antrenament cu funcție de fit. Keras în Python nu se ocupă de API de nivel scăzut, cum ar fi realizarea graficului de calcul, realizarea de tensori sau alte variabile, deoarece a fost gestionată de motorul „backend”.

Ce este un backend?

Backend este un termen în Keras care efectuează toate calculele de nivel scăzut, cum ar fi produsele tensor, convoluțiile și multe alte lucruri, cu ajutorul altor biblioteci, cum ar fi Tensorflow sau Theano. Deci, „motorul backend” va efectua calculul și dezvoltarea modelelor. Tensorflow este „motorul de backend” implicit, dar îl putem schimba în configurație.

Theano, Tensorflow și CNTK Backend

Theano este un proiect open source care a fost dezvoltat de grupul MILA de la Universitatea din Montreal, Quebec, Canada. A fost primul cadru utilizat pe scară largă. Este o Python bibliotecă care ajută în tablourile multidimensionale pentru operații matematice folosind Numpy sau Scipy. Theano poate folosi GPU-uri pentru calcule mai rapide, de asemenea, poate construi automat grafice simbolice pentru calcularea gradienților. Pe site-ul său, Theano susține că poate recunoaște expresii instabile numeric și le poate calcula cu algoritmi mai stabili, acest lucru este foarte util pentru expresiile noastre instabile.

Pe de altă parte, Tensorflow este steaua în ascensiune în cadrul de deep learning. Dezvoltat de echipa Google Brain, este cel mai popular instrument de învățare profundă. Cu o mulțime de caracteristici, iar cercetătorii contribuie la dezvoltarea acestui cadru în scopuri de învățare profundă.

Un alt motor de backend pentru Keras este The Microsoft Setul de instrumente cognitive sau CNTK. Este un cadru de învățare profundă open-source care a fost dezvoltat de Microsoft Echipă. Poate rula pe mai multe GPU-uri sau pe mai multe mașini pentru antrenamentul modelului de învățare profundă la scară masivă. În unele cazuri, CNTK a fost raportat mai rapid decât alte cadre precum Tensorflow sau Theano. În continuare, în acest tutorial Keras CNN, vom compara backend-urile Theano, TensorFlow și CNTK.

Compararea backend-urilor

Trebuie să facem un benchmark pentru a cunoaște comparația dintre aceste două backend-uri. După cum puteți vedea în Reperul lui Jeong-Yoon Lee, se compară performanța a 3 backend-uri diferite pe hardware diferit. Și rezultatul este că Theano este mai lent decât celălalt backend, se spune 50 ori mai lent, dar precizia este aproape una de alta.

O alta test de referință este realizat de Jasmeet Bhatia. El a raportat că Theano este mai lent decât Tensorflow pentru unele teste. Dar precizia generală este aproape aceeași pentru fiecare rețea care a fost testată.

Deci, între Theano, Tensorflow și CTK este evident că TensorFlow este mai bun decât Theano. Cu TensorFlow, timpul de calcul este mult mai scurt, iar CNN este mai bun decât celelalte.

Următorul în acest Keras Python tutorial, vom afla despre diferența dintre Keras și TensorFlow (Keras vs Tensorflow).

Keras vs Tensorflow

parametrii	Keras	flux tensor
Tip	Wrapper API de nivel înalt	API de nivel scăzut
Complexitate	Ușor de utilizat dacă dvs Python limbă	Trebuie să învățați sintaxa utilizării uneia dintre funcțiile Tensorflow
Scop	Implementare rapidă pentru realizarea modelelor cu straturi standard	Vă permite să realizați un grafic de calcul arbitrar sau straturi de model
Instrumente	Utilizează alt instrument de depanare API, cum ar fi TFDBG	Puteți utiliza instrumentele de vizualizare Tensorboard
Comunitate	Comunități mari active	Comunități mari active și resurse partajate pe scară largă

Avantajele Keras

Implementare rapidă și ușor de înțeles

Keras este foarte rapid să realizeze un model de rețea. Dacă doriți să faceți un model de rețea simplu cu câteva linii, Python Keras te poate ajuta cu asta. Uită-te la exemplul Keras de mai jos:

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

Datorită API-ului prietenos, putem înțelege cu ușurință procesul. Scrierea codului cu o funcție simplă și nu este nevoie să setați mai mulți parametri.

Sprijin comunitar mare

Există o mulțime de comunități AI care folosesc Keras pentru cadrul lor de Deep Learning. Mulți dintre ei își publică codurile și tutorialele pentru publicul larg.

Aveți mai multe backend-uri

Puteți alege Tensorflow, CNTK și Theano ca backend cu Keras. Puteți alege un backend diferit pentru diferite proiecte, în funcție de nevoile dvs. Fiecare backend are propriul său avantaj unic.

Implementare multi-platformă și ușoară a modelului

Cu o varietate de dispozitive și platforme acceptate, puteți implementa Keras pe orice dispozitiv

• iOS cu CoreML
• Android cu Tensorflow Android,
• Browser web cu suport .js
• Motor cloud
• Raspberry Pi

Suport pentru mai multe GPU

Puteți antrena Keras pe un singur GPU sau puteți utiliza mai multe GPU-uri simultan. Deoarece Keras are un suport încorporat pentru paralelismul datelor, astfel încât să poată procesa volume mari de date și să accelereze timpul necesar antrenării acestora.

Dezavantajele Keras

Nu se poate gestiona API-ul de nivel scăzut

Keras se ocupă doar de API-uri de nivel înalt care rulează pe alt framework sau motor de backend, cum ar fi Tensorflow, Theano sau CNTK. Deci nu este foarte util dacă doriți să vă faceți propriul strat abstract în scopuri de cercetare, deoarece Keras are deja straturi preconfigurate.

Instalarea Keras

În această secțiune, vom analiza diferite metode disponibile pentru a instala Keras

Instalare directă sau Mediu virtual

Care este mai bun? Instalare directă pe python-ul actual sau folosirea unui mediu virtual? Vă sugerez să folosiți un mediu virtual dacă aveți multe proiecte. Vrei să știi de ce? Acest lucru se datorează faptului că diferite proiecte pot utiliza o versiune diferită a unei biblioteci keras.

De exemplu, am un proiect care are nevoie Python 3.5 folosind OpenCV 3.3 cu backend mai vechi Keras-Theano, dar în celălalt proiect trebuie să folosesc Keras cu cea mai recentă versiune și un Tensorflow ca backend cu Python Suport 3.6.6

Nu vrem ca biblioteca Keras să intre în conflict una cu cealaltă, nu? Așadar, folosim un mediu virtual pentru a localiza proiectul cu un anumit tip de bibliotecă sau putem folosi o altă platformă, cum ar fi Cloud Service, pentru a ne face calculele pentru noi, cum ar fi Amazon Serviciu web.

Instalarea Keras pe Amazon Serviciu web (AWS)

Amazon Serviciul Web este o platformă care oferă servicii și produse Cloud Computing pentru cercetători sau orice alte scopuri. AWS își închiriază hardware-ul, rețelele, baza de date etc., astfel încât să le putem folosi direct de pe internet. Unul dintre serviciile AWS populare pentru scopul învățării profunde este Amazon Machine Image Deep Learning Service sau DL

Pentru instrucțiuni detaliate despre cum să utilizați AWS, consultați aceasta tutorial

Notă despre AMI: veți avea disponibil următorul AMI

AWS Deep Learning AMI este un mediu virtual din AWS EC2 Service care ajută cercetătorii sau practicienii să lucreze cu Deep Learning. DLAMI oferă de la motoare cu procesoare mici până la motoare cu mai multe GPU-uri de mare putere cu CUDA, cuDNN preconfigurate și vine cu o varietate de cadre de învățare profundă.

Dacă doriți să îl utilizați instantaneu, ar trebui să alegeți Deep Learning AMI deoarece vine preinstalat cu cadre populare de învățare profundă.

Dar dacă doriți să încercați un cadru de deep learning personalizat pentru cercetare, ar trebui să instalați Deep Learning Base AMI, deoarece vine cu biblioteci fundamentale, cum ar fi CUDA, cuDNN, drivere GPU și alte biblioteci necesare pentru a rula cu mediul dvs. de deep learning.

Cum se instalează Keras pe Amazon SageMaker

Amazon SageMaker este o platformă de învățare profundă care vă ajută să antrenați și să implementați rețeaua de învățare profundă cu cel mai bun algoritm.

Ca începător, aceasta este de departe cea mai ușoară metodă de a folosi Keras. Mai jos este un proces despre cum să instalați Keras Amazon SageMaker:

Pasul 1) Deschideți Amazon SageMaker

În primul pas, deschideți Amazon Sagemaker console și faceți clic pe Creare instanță de notebook.

Pasul 2) Introduceți detaliile

1. Introduceți numele blocnotesului dvs.
2. Creați un rol IAM. Va crea un rol AMI Amazon Rolul IAM în formatul de AmazonSageMaker-Executionrole-AAAAMMZZ|HHmmSS.
3. În cele din urmă, alegeți Creare instanță de blocnotes. După câteva clipe, Amazon Sagemaker lansează o instanță de notebook.

notițe: Dacă doriți să accesați resurse de la VPC-ul dvs., setați accesul direct la internet ca fiind activat. În caz contrar, această instanță de notebook nu va avea acces la internet, așa că este imposibil să antrenezi sau să găzduiești modele

Pasul 3) Lansați instanța

Faceți clic pe Deschidere pentru a lansa instanța

Pasul 4) Începeți codarea

In Jupyter, Faceți clic pe New> conda_tensorflow_p36 și sunteți gata să codificați

Instalați Keras în Linux

Pentru a activa Keras cu Tensorflow ca motor backend, trebuie să instalăm mai întâi Tensorflow. Rulați această comandă pentru a instala tensorflow cu CPU (fără GPU)

pip install --upgrade tensorflow

dacă doriți să activați suportul GPU pentru tensorflow, puteți utiliza această comandă

pip install --upgrade tensorflow-gpu

hai sa ne verificam Python pentru a vedea dacă instalarea noastră a reușit tastând

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

dacă nu există niciun mesaj de eroare, procesul de instalare este reușit

Instalați Keras

După ce instalăm Tensorflow, să începem să instalăm keras. Tastați această comandă în terminal

pip install keras

va începe să instaleze Keras și, de asemenea, toate dependențele sale. Ar trebui să vedeți ceva de genul acesta:

Acum avem Keras instalat în sistemul nostru!

verificarea

Înainte de a începe să folosim Keras, ar trebui să verificăm dacă Keras-ul nostru folosește Tensorflow ca backend prin deschiderea fișierului de configurare:

gedit ~/.keras/keras.json

ar trebui sa vezi asa ceva

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

după cum puteți vedea, „backend-ul” folosește tensorflow. Înseamnă că Keras utilizează Tensorflow ca backend așa cum ne așteptam

și acum rulați-l pe terminal tastând

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

Cum se instalează Keras pe Windows

Înainte de a instala flux tensor și Keras, ar trebui să instalăm Python, pip și virtualenv. Dacă ați instalat deja aceste biblioteci, ar trebui să continuați cu pasul următor, altfel procedați astfel:

Instalare Python 3 prin descărcarea de pe aceasta legătură

Instalați pip rulând acest

Instalați virtualenv cu această comandă

pip3 install –U pip virtualenv

Instalare Microsoft Vizual C++ Actualizarea redistribuibilă din 2015 3

• Accesați site-ul de descărcare Visual Studio https://www.microsoft.com/en-us/download/details.aspx?id=53587
• Selectați Redistributables și Build Tools
• Descărcați și instalați Microsoft Vizual C++ Actualizarea redistribuibilă din 2015 3

Apoi rulați acest script

pip3 install virtualenv

Configurați mediul virtual

Acesta este folosit pentru a izola sistemul de lucru cu sistemul principal.

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

Activați mediul

.\venv\Scripts\activate

După pregătirea mediului, instalarea Tensorflow și Keras rămâne aceeași ca Linux. În continuare, în acest tutorial Deep learning with Keras, vom afla despre elementele fundamentale Keras pentru Deep learning.

Fundamentele Keras pentru învățarea profundă

Structura principală din Keras este Modelul care definește graficul complet al unei rețele. Puteți adăuga mai multe straturi la un model existent pentru a construi un model personalizat de care aveți nevoie pentru proiectul dvs.

Iată cum să creați un model secvenţial și câteva straturi utilizate în mod obișnuit în deep learning

1. Model secvenţial

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

model = Sequential()

2. Stratul convoluțional

Acesta este un Keras Python exemplu de strat convoluțional ca strat de intrare cu forma de intrare de 320x320x3, cu 48 de filtre de dimensiune 3×3 și folosește ReLU ca funcție de activare.

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

alt tip este

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

3.MaxPooling Strat

Pentru a reduce eșantionarea reprezentării de intrare, utilizați MaxPool2d și specificați dimensiunea nucleului

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

4. Strat dens

adăugarea unui strat complet conectat cu doar specificarea dimensiunii de ieșire

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

5. Stratul de abandon

Adăugarea unui strat de abandon cu 50% probabilitate

model.add(Dropout(0.5))

Compilarea, instruirea și evaluarea

După ce ne definim modelul, să începem să-i antrenăm. Este necesar să compilați mai întâi rețeaua cu funcția de pierdere și funcția de optimizare. Acest lucru va permite rețelei să schimbe greutățile și să minimizeze pierderea.

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

Acum, pentru a începe antrenamentul, utilizați fit pentru a furniza datele de antrenament și validare la model. Acest lucru vă va permite să antrenați rețeaua în loturi și să setați epocile.

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

Pasul nostru final este să evaluăm modelul cu datele de testare.

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

Să încercăm să folosim regresia liniară simplă

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

După antrenamentul datelor, rezultatul ar trebui să arate astfel

cu greutatea initiala

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

si greutatea finala

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

Ajustați modelele pre-antrenate în Keras și cum să le utilizați

De ce folosim Fine Tune Models și când le folosim

Reglarea fină este o sarcină de a modifica un model pre-antrenat, astfel încât parametrii să se adapteze la noul model. Când vrem să ne antrenăm de la zero pe un model nou, avem nevoie de o cantitate mare de date, astfel încât rețeaua să poată găsi toți parametrii. Dar în acest caz, vom folosi un model pre-antrenat, astfel încât parametrii sunt deja învățați și au o greutate.

De exemplu, dacă dorim să ne antrenăm propriul model Keras pentru a rezolva o problemă de clasificare, dar avem doar o cantitate mică de date, atunci putem rezolva acest lucru folosind o Transferul învățării + Metoda de reglare fină.

Folosind o rețea pre-antrenată și greutăți, nu trebuie să antrenăm întreaga rețea. Trebuie doar să antrenăm ultimul strat care este folosit pentru a ne rezolva sarcina, așa cum o numim metoda de reglare fină.

Pregătirea modelului de rețea

Pentru modelul pre-antrenat, putem încărca o varietate de modele pe care Keras le are deja în biblioteca sa, cum ar fi:

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

Dar în acest proces, vom folosi modelul de rețea VGG16 și imageNet ca greutate pentru model. Vom ajusta o rețea pentru a clasifica 8 tipuri diferite de clase folosind Imagini din Kaggle Natural Images Dataset

Arhitectura modelului VGG16

sursă

Încărcarea datelor noastre în AWS S3 Bucket

Pentru procesul nostru de antrenament, vom folosi o imagine cu imagini naturale din 8 clase diferite, cum ar fi avioane, mașină, pisică, câine, floare, fructe, motocicletă și persoană. În primul rând, trebuie să ne încărcăm datele în Amazon Găleată S3.

Amazon Găleată S3

Pas 1) După ce v-ați conectat la contul dvs. S3, să creăm o găleată prin ceas Creați o găleată

Pas 2) Acum alegeți un nume de grup și regiunea dvs. în funcție de contul dvs. Asigurați-vă că numele compartimentului este disponibil. După acel clic Crea.

Pas 3) După cum puteți vedea, Bucket-ul dvs. este gata de utilizare. Dar, după cum puteți vedea, Accesul nu este public, este bine pentru dvs. dacă doriți să îl păstrați privat pentru dvs. Puteți schimba acest compartiment pentru acces public în Proprietăți compartiment

Pas 4) Acum începeți să încărcați datele de antrenament în Bucket. Aici voi încărca fișierul tar.gz care constă în imagini pentru procesul de instruire și testare.

Pas 5) Acum faceți clic pe fișierul dvs. și copiați Link ca să-l putem descărca.

Pregătirea datelor

Trebuie să generăm datele noastre de antrenament folosind Keras ImageDataGenerator.

Mai întâi trebuie să descărcați folosind wget cu linkul către fișierul dvs. din S3 Bucket.

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

După ce descărcați datele, să începem Procesul de Formare.

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)

ImageDataGenerator va face un X_training date dintr-un director. Subdirectorul din acel director va fi folosit ca o clasă pentru fiecare obiect. Imaginea va fi încărcată cu modul de culoare RGB, cu modul de clasă categorială pentru datele Y_training, cu o dimensiune a lotului de 16. În cele din urmă, amestecați datele.

Să vedem imaginile noastre aleatoriu prin trasarea lor cu 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()

După aceea, să creăm modelul nostru de rețea din VGG16 cu greutatea pre-antrenată imageNet. Vom îngheța aceste straturi, astfel încât straturile să nu poată fi antrenate pentru a ne ajuta să reducem timpul de calcul.

Crearea modelului nostru din 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())

După cum puteți vedea mai jos, rezumatul modelului nostru de rețea. Dintr-o intrare de la Straturi VGG16, apoi adăugăm 2 Straturi Fully Connected care vor extrage 1024 de caracteristici și un strat de ieșire care va calcula cele 8 clase cu activarea softmax.

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

Pregătire

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

REZULTATE

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

După cum puteți vedea, pierderile noastre sunt reduse semnificativ, iar acuratețea este de aproape 100%. Pentru a testa modelul nostru, am ales aleatoriu imagini de pe internet și le-am pus în folderul de testare cu o clasă diferită de testat

Testarea modelului nostru

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

Și testul nostru este așa cum este prezentat mai jos! Doar 1 imagine este prezisă greșit dintr-un test de 14 imagini!

Rețea neuronală de recunoaștere a feței cu Keras

De ce avem nevoie de recunoaștere

Avem nevoie de Recunoaștere pentru a ne face mai ușor să recunoaștem sau să identificăm fața unei persoane, tipul de obiecte, vârsta estimată a unei persoane de pe fața sa sau chiar să cunoaștem expresiile faciale ale acelei persoane.

Poate îți dai seama de fiecare dată când încerci să marchezi chipul prietenului tău într-o fotografie, funcția din Facebook a făcut-o pentru tine, adică marchează fața prietenului tău fără să fii nevoie să-l marchezi mai întâi. Aceasta este recunoașterea facială aplicată de Facebook pentru a ne facilita etichetarea prietenilor.

Deci cum funcționează? De fiecare dată când marchem chipul prietenului nostru, AI-ul Facebook îl va învăța și va încerca să o prezică până când va obține rezultatul corect. Același sistem pe care îl vom folosi pentru a face propria noastră recunoaștere a feței. Să începem să facem propria noastră recunoaștere a feței folosind Deep Learning

Model de rețea

Vom folosi un model de rețea VGG16, dar cu greutatea VGGFace.

Arhitectura modelului VGG16

Ce este VGGFace? este implementarea Keras a Deep Face Recognition introdusă de Parkhi, Omkar M. et al. „Recunoaștere profundă a feței”. BMVC (2015). Cadrul folosește VGG16 ca arhitectură de rețea.

Puteți descărca VGGFace de la 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()

După cum puteți vedea rezumatul rețelei

_________________________________________________________________
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):

vom face o Transferul învățării + Reglare fină pentru a accelera antrenamentul cu seturi de date mici. În primul rând, vom îngheța straturile de bază, astfel încât straturile să nu poată fi antrenate.

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

apoi adăugăm propriul strat pentru a ne recunoaște fețele de testare. Vom adăuga 2 straturi complet conectate și un strat de ieșire cu 5 persoane de detectat.

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)

Să vedem rezumatul rețelei noastre

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

După cum puteți vedea mai sus, după stratul pool5, acesta va fi aplatizat într-un singur vector caracteristic care va fi folosit de stratul dens pentru recunoașterea finală.

Ne pregătim fețele

Acum să ne pregătim fețele. Am făcut un director format din 5 oameni celebri

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

Fiecare folder conține 10 imagini, pentru fiecare proces de instruire și evaluare. Este o cantitate foarte mică de date, dar aceasta este provocarea, nu?

Vom folosi ajutorul instrumentului Keras pentru a ne ajuta să pregătim datele. Această funcție va repeta în folderul setului de date și apoi o va pregăti astfel încât să poată fi utilizată în antrenament.

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

Pregătirea modelului nostru

Să începem procesul de instruire prin compilarea rețelei noastre cu funcția de pierdere și optimizator. Aici, folosim sparse_categorical_crossentropy ca funcție de pierdere, cu ajutorul SGD ca optimizator de învățare.

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

După cum puteți vedea, precizia noastră de validare este de până la 64%, acesta este un rezultat bun pentru o cantitate mică de date de antrenament. Putem îmbunătăți acest lucru adăugând mai multe straturi sau adăugând mai multe imagini de antrenament, astfel încât modelul nostru să poată afla mai multe despre fețe și să obțină mai multă acuratețe.

Să testăm modelul nostru cu o imagine de test

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

folosind imaginea lui Robert Downey Jr. ca imagine de test, arată că chipul prezis este adevărat!

Prognoza folosind Live Cam!

Ce zici dacă ne testăm abilitățile cu implementarea acesteia cu o intrare de la o cameră web? Folosind OpenCV cu cascada Haar Face pentru a ne găsi fața și cu ajutorul modelului nostru de rețea, putem recunoaște persoana.

Primul pas este să vă pregătiți fețele dvs. și ale prietenului dvs. Cu cât avem mai multe date, cu atât rezultatul este mai bun!

Pregătiți-vă și antrenați-vă rețeaua ca la pasul anterior, după finalizarea antrenamentului, adăugați această linie pentru a obține imaginea de intrare de la cameră

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

Care este mai bun? Keras sau Tensorflow

Keras oferă simplitate atunci când scrieți scenariul. Putem începe să scriem și să înțelegem direct cu Keras, deoarece nu este prea greu de înțeles. Este mai ușor de utilizat și mai ușor de implementat, nu este nevoie să faceți multe variabile pentru a rula modelul. Deci, nu trebuie să înțelegem fiecare detaliu din procesul de backend.

Pe de altă parte, Tensorflow este operațiunile de nivel scăzut care oferă flexibilitate și operații avansate dacă doriți să realizați un grafic sau un model de calcul arbitrar. De asemenea, Tensorflow poate vizualiza procesul cu ajutorul TensorBoard și un instrument specializat de depanare.

Așadar, dacă doriți să începeți să lucrați cu învățarea profundă fără atât de multă complexitate, utilizați Keras. Pentru că Keras oferă simplitate și ușor de utilizat și ușor de implementat decât Tensorflow. Dar dacă doriți să scrieți propriul algoritm într-un proiect de învățare profundă sau în cercetare, ar trebui să utilizați Tensorflow.

Rezumat

Deci, haideți să rezumam tot ce am discutat și făcut în acest tutorial.

• Keras într-un API de nivel înalt care este folosit pentru a face rețelele de învățare profundă mai ușoare cu ajutorul motorului backend.
• Keras este ușor de utilizat și de înțeles cu suportul python, astfel încât să se simtă mai natural ca niciodată. Este bun pentru începătorii care doresc să învețe despre deep learning și pentru cercetătorii care doresc API ușor de utilizat.
• Procesul de instalare este ușor și puteți utiliza un mediu virtual sau folosind o platformă externă, cum ar fi AWS.
• Keras vine, de asemenea, cu diverse tipuri de modele de rețea, astfel încât ne face mai ușor să folosim modelul disponibil pentru pregătirea prealabilă și reglarea fină a modelului nostru de rețea.
• De asemenea, există o mulțime de tutoriale și articole despre utilizarea codurilor Keras din comunitățile din întreaga lume în scopuri de învățare profundă.