Keras vodič: Što je Keras? Kako instalirati u Python [Primjer]

Što je Keras?

Keras je biblioteka neuronske mreže otvorenog koda napisana u Python koji radi na vrhu Theano ili Tensorflow. Dizajniran je da bude modularan, brz i jednostavan za korištenje. Razvio ga je François Chollet, Googleov inženjer. Keras ne obrađuje proračune niske razine. Umjesto toga, za to koristi drugu biblioteku, nazvanu “Backend.

Keras je API omotač visoke razine za API niske razine, koji može raditi povrh TensorFlow, CNTK ili Theano. Keras High-Level API upravlja načinom na koji izrađujemo modele, definiramo slojeve ili postavljamo više ulazno-izlaznih modela. Na ovoj razini Keras također kompilira naš model s funkcijama gubitka i optimizacije, proces treninga s funkcijom prilagodbe. Keras u Python ne rukuje API-jem niske razine kao što je izrada računskog grafa, izrada tenzora ili drugih varijabli jer je njime upravljao "backend" motor.

Što je Backend?

Backend je izraz u Kerasu koji izvodi sva izračunavanja niske razine kao što su tenzorski produkti, konvolucije i mnoge druge stvari uz pomoć drugih biblioteka kao što su Tensorflow ili Theano. Dakle, "backend engine" će izvršiti proračun i razvoj modela. Tensorflow je zadani "pozadinski motor", ali ga možemo promijeniti u konfiguraciji.

Theano, Tensorflow i CNTK pozadina

Theano je projekt otvorenog koda koji je razvila MILA grupa sa Sveučilišta u Montrealu, Quebec, Kanada. Bio je to prvi široko korišteni Framework. To je a Python knjižnica koja pomaže u višedimenzionalnim nizovima za matematičke operacije pomoću Numpyja ili Scipyja. Theano može koristiti GPU za brže računanje, također može automatski graditi simboličke grafikone za računanje gradijenata. Theano na svojoj web stranici tvrdi da može prepoznati numerički nestabilne izraze i izračunati ih sa stabilnijim algoritmima, što je vrlo korisno za naše nestabilne izraze.

S druge strane, Tensorflow je zvijezda u usponu u okviru dubokog učenja. Razvio ga je Googleov Brain tim i najpopularniji je alat za duboko učenje. S puno značajki, a istraživači doprinose razvoju ovog okvira za potrebe dubokog učenja.

Drugi pozadinski motor za Keras je The Microsoft Cognitive Toolkit ili CNTK. To je okvir dubokog učenja otvorenog koda koji su razvili Microsoft Tim. Može raditi na više GPU-ova ili na više strojeva za treniranje modela dubokog učenja u velikim razmjerima. U nekim je slučajevima CNTK prijavljen brže od drugih okvira kao što su Tensorflow ili Theano. Zatim ćemo u ovom Keras CNN vodiču usporediti pozadinu Theano, TensorFlow i CNTK.

Usporedba pozadina

Moramo napraviti referentnu vrijednost kako bismo znali usporedbu između ova dva pozadina. Kao što vidite u Mjerilo Jeong-Yoon Leeja, uspoređuje se izvedba 3 različita pozadina na različitom hardveru. Rezultat je da je Theano sporiji od druge pozadine, navodi se 50 puta sporiji, ali točnost je blizu jedna drugoj.

Druga referentni test obavlja Jasmeet Bhatia. Izvijestio je da je Theano sporiji od Tensorflowa za neke testove. Ali ukupna točnost je gotovo ista za svaku testiranu mrežu.

Dakle, između Theano, Tensorflow i CTK očito je da je TensorFlow bolji od Theana. Uz TensorFlow, vrijeme izračuna je puno kraće, a CNN je bolji od ostalih.

Sljedeći u ovom Kerasu Python tutorial, naučit ćemo o razlici između Kerasa i TensorFlowa (Keras protiv Tensorflowa).

Keras protiv Tensorflowa

Parametri	Keras	Tenzor protok
Tip	Omotač API-ja visoke razine	API niske razine
Složenost	Jednostavan za korištenje ako Python jezik	Morate naučiti sintaksu korištenja neke od Tensorflow funkcija
Svrha	Brza implementacija za izradu modela sa standardnim slojevima	Omogućuje izradu proizvoljnog računskog grafikona ili slojeva modela
Alati	Koristi drugi API alat za otklanjanje pogrešaka kao što je TFDBG	Možete koristiti Tensorboard alate za vizualizaciju
Zajednica	Velike aktivne zajednice	Velike aktivne zajednice i široko dijeljeni resursi

Prednosti Kerasa

Brza implementacija i lako razumijevanje

Keras vrlo brzo izrađuje mrežni model. Ako želite napraviti jednostavan mrežni model s nekoliko linija, Python Keras vam može pomoći u tome. Pogledajte primjer Kerasa u nastavku:

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

Zbog prijateljskog API-ja, lako možemo razumjeti proces. Pisanje koda s jednostavnom funkcijom i bez potrebe za postavljanjem više parametara.

Velika podrška zajednice

Postoji puno AI zajednica koje koriste Keras za svoj okvir dubokog učenja. Mnogi od njih objavljuju svoje kodove kao i upute za širu javnost.

Imajte više pozadina

Možete odabrati Tensorflow, CNTK i Theano kao svoj backend s Kerasom. Možete odabrati drugu pozadinu za različite projekte ovisno o vašim potrebama. Svaki backend ima svoju jedinstvenu prednost.

Više platformi i jednostavna implementacija modela

S nizom podržanih uređaja i platformi, možete implementirati Keras na bilo koji uređaj poput

iOS s CoreML-om
Android s Tensorflowom Android,
Web preglednik s podrškom za .js
Cloud engine
Raspberry Pi

Podrška za više grafičkih procesora

Možete trenirati Keras na jednom GPU-u ili koristiti više GPU-a odjednom. Keras ima ugrađenu podršku za paralelizam podataka tako da može obraditi velike količine podataka i ubrzati vrijeme potrebno za njihovo treniranje.

Nedostaci Kerasa

Ne može rukovati API-jem niske razine

Keras obrađuje samo API visoke razine koji radi na vrhu drugog okvira ili pozadinskog motora kao što su Tensorflow, Theano ili CNTK. Stoga nije baš korisno ako želite napraviti vlastiti apstraktni sloj za svoje istraživačke svrhe jer Keras već ima unaprijed konfigurirane slojeve.

Instalacija Kerasa

U ovom ćemo odjeljku pogledati različite metode dostupne za instaliranje Kerasa

Izravna instalacija ili virtualno okruženje

Koji je bolji? Izravno instalirati na trenutni python ili koristiti virtualno okruženje? Predlažem korištenje virtualnog okruženja ako imate mnogo projekata. Želite li znati zašto? To je zato što različiti projekti mogu koristiti različite verzije keras biblioteke.

Na primjer, imam projekt koji treba Python 3.5 koristeći OpenCV 3.3 sa starijom pozadinom Keras-Theano, ali u drugom projektu moram koristiti Keras s najnovijom verzijom i Tensorflowom kao pozadinom s Python 3.6.6 podrška

Ne želimo da se Keras knjižnica sukobljava jedna s drugom, zar ne? Dakle, koristimo virtualno okruženje da lokaliziramo projekt s određenom vrstom biblioteke ili možemo koristiti drugu platformu kao što je Cloud Service da izvrši naš proračun umjesto nas Amazon Web usluga.

Instaliranje Kerasa na Amazon Web usluga (AWS)

Amazon Web usluga je platforma koja nudi Cloud Computing uslugu i proizvode za istraživače ili bilo koje druge svrhe. AWS iznajmljuje njihov hardver, umrežavanje, bazu podataka itd. kako bismo to mogli koristiti izravno s interneta. Jedna od popularnih AWS usluga za potrebe dubokog učenja je Amazon Usluga dubokog učenja strojne slike ili DL

Za detaljne upute o tome kako koristiti AWS, pogledajte ovo udžbenik

Napomena o AMI-ju: imat ćete na raspolaganju sljedeće AMI-je

AWS Deep Learning AMI virtualno je okruženje u AWS EC2 usluzi koje pomaže istraživačima ili praktičarima u radu s dubokim učenjem. DLAMI nudi od malih CPU-a do snažnih multi-GPU-a s unaprijed konfiguriranim CUDA-om, cuDNN-om i dolazi s nizom okvira dubokog učenja.

Ako ga želite koristiti odmah, trebali biste odabrati Deep Learning AMI jer dolazi unaprijed instaliran s popularnim okvirima dubokog učenja.

Ali ako želite isprobati prilagođeni okvir dubokog učenja za istraživanje, trebali biste instalirati Deep Learning Base AMI jer dolazi s temeljnim bibliotekama kao što su CUDA, cuDNN, GPU upravljački programi i druge potrebne biblioteke za rad s vašim okruženjem dubokog učenja.

Kako instalirati Keras na Amazon SageMaker

Amazon SageMaker je platforma za duboko učenje koja vam pomaže u obuci i implementaciji mreže za duboko učenje s najboljim algoritmom.

Kao početniku, ovo je daleko najlakši način korištenja Kerasa. Ispod je postupak kako instalirati Keras Amazon SageMaker:

Korak 1) Otvorite Amazon SageMaker

U prvom koraku otvorite Amazon Sagemaker konzolu i kliknite na Stvori instancu bilježnice.

Korak 2) Unesite pojedinosti

Unesite naziv svoje bilježnice.
Stvorite IAM ulogu. To će stvoriti AMI ulogu Amazon IAM uloga u formatu AmazonSageMaker-Executionrole-GGGGMMDD|HHmmSS.
Na kraju odaberite Stvori instancu bilježnice. Nakon nekoliko trenutaka, Amazon Sagemaker pokreće instancu bilježnice.

bilješke: Ako želite pristupiti resursima sa svog VPC-a, postavite izravni pristup internetu kao omogućen. Inače, ova instanca bilježnice neće imati pristup internetu, tako da je nemoguće trenirati ili ugostiti modele

Korak 3) Pokrenite instancu

Pritisnite Otvori za pokretanje instance

Korak 4) Započnite kodiranje

In JupyterKliknite na Novo> conda_tensorflow_p36 i spremni ste za kodiranje

Instalirajte Keras u Linuxu

Da bismo omogućili Keras s Tensorflowom kao pozadinskim motorom, prvo moramo instalirati Tensorflow. Pokrenite ovu naredbu da instalirate tensorflow s CPU-om (bez GPU-a)

pip install --upgrade tensorflow

ako želite omogućiti GPU podršku za tensorflow možete koristiti ovu naredbu

pip install --upgrade tensorflow-gpu

prijavimo se Python da vidimo je li naša instalacija uspješna upisivanjem

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

ako nema poruke o pogrešci, proces instalacije je uspješan

Instalirajte Keras

Nakon što instaliramo Tensorflow, počnimo instalirati keras. Upišite ovu naredbu u terminal

pip install keras

počet će instalirati Keras i sve njegove ovisnosti. Trebali biste vidjeti nešto poput ovoga:

Sada imamo Keras instaliran u našem sustavu!

Provjera

Prije nego što počnemo koristiti Keras, trebali bismo provjeriti koristi li naš Keras Tensorflow kao svoju pozadinu otvaranjem konfiguracijske datoteke:

gedit ~/.keras/keras.json

trebao bi vidjeti ovako nešto

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

kao što vidite, "backend" koristi tensorflow. To znači da keras koristi Tensorflow kao svoju pozadinu kao što smo i očekivali

a sada ga pokrenite na terminalu upisivanjem

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

Kako instalirati Keras na Windows

Prije nego što instaliramo Tenzor protok i Keras, trebali bismo instalirati Python, pip i virtualenv. Ako ste već instalirali ove biblioteke, trebali biste prijeći na sljedeći korak, inače učinite ovo:

Instalirati Python 3 preuzimanjem s ovog link

Instalirajte pip pokretanjem to

Instalirajte virtualenv ovom naredbom

pip3 install –U pip virtualenv

Instalirati Microsoft Visual C++ Redistributivno ažuriranje 2015 za 3

Idite na stranicu za preuzimanje programa Visual Studio https://www.microsoft.com/en-us/download/details.aspx?id=53587
Odaberite Redistributables i Build Tools
Preuzmite i instalirajte Microsoft Visual C++ Redistributivno ažuriranje 2015 za 3

Zatim pokrenite ovu skriptu

pip3 install virtualenv

Postavljanje virtualnog okruženja

Ovo se koristi za izolaciju radnog sustava od glavnog sustava.

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

Aktivirajte okolinu

.\venv\Scripts\activate

Nakon pripreme okruženja, instalacija Tensorflowa i Kerasa ostaje ista kao i Linux. Zatim ćemo u ovom vodiču za duboko učenje s Kerasom učiti o osnovama Kerasa za duboko učenje.

Keras osnove za duboko učenje

Glavna struktura u Kerasu je model koji definira kompletan graf mreže. Možete dodati više slojeva postojećem modelu kako biste izradili prilagođeni model koji vam je potreban za vaš projekt.

Evo kako napraviti sekvencijalni model i nekoliko često korištenih slojeva u dubokom učenju

1. Sekvencijalni model

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

model = Sequential()

2. Konvolucijski sloj

Ovo je Keras Python primjer konvolucijskog sloja kao ulaznog sloja s ulaznim oblikom 320x320x3, s 48 filtera veličine 3×3 i korištenjem ReLU kao aktivacijske funkcije.

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

druga vrsta je

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

3. MaksPooling Sloj

Za smanjivanje uzorkovanja ulazne reprezentacije, koristite MaxPool2d i odredite veličinu kernela

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

4. Gusti sloj

dodavanje potpuno povezanog sloja uz samo navođenje izlazne veličine

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

5. Ispadajući sloj

Dodavanje ispadajućeg sloja s 50% vjerojatnosti

model.add(Dropout(0.5))

Sastavljanje, obuka i evaluacija

Nakon što definiramo naš model, počnimo ih trenirati. Potrebno je prvo kompajlirati mrežu s funkcijom gubitka i funkcijom optimizacije. To će omogućiti mreži promjenu težine i minimizirati gubitak.

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

Sada za početak obuke, koristite fit da unesete podatke o obuci i validaciji u model. To će vam omogućiti da trenirate mrežu u serijama i postavite epohe.

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

Naš posljednji korak je procjena modela s testnim podacima.

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

Pokušajmo upotrijebiti jednostavnu linearnu regresiju

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

Nakon uvježbavanja podataka, izlaz bi trebao izgledati ovako

s početnom težinom

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

i konačnu težinu

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

Fino podešavanje unaprijed obučenih modela u Kerasu i kako ih koristiti

Zašto koristimo modele Fine Tune i kada ih koristimo

Fino podešavanje je zadatak ugađanja prethodno obučenog modela tako da se parametri prilagode novom modelu. Kada želimo trenirati od nule na novom modelu, potrebna nam je velika količina podataka, kako bi mreža mogla pronaći sve parametre. Ali u ovom slučaju koristit ćemo unaprijed obučeni model tako da su parametri već naučeni i imaju težinu.

Na primjer, ako želimo uvježbati vlastiti Kerasov model za rješavanje problema klasifikacije, ali imamo samo malu količinu podataka, tada to možemo riješiti korištenjem Prijenos učenja + Metoda finog podešavanja.

Korištenjem unaprijed uvježbane mreže i utega ne trebamo trenirati cijelu mrežu. Samo trebamo istrenirati posljednji sloj koji se koristi za rješavanje našeg zadatka kako to nazivamo metodom finog podešavanja.

Priprema modela mreže

Za unaprijed obučeni model, možemo učitati različite modele koje Keras već ima u svojoj biblioteci, kao što su:

VGG16
Početak V3
ResNet
MobileNet
Xception
InceptionResNetV2

Ali u ovom procesu koristit ćemo mrežni model VGG16 i imageNet kao našu težinu za model. Fino ćemo podesiti mrežu za klasificiranje 8 različitih vrsta klasa pomoću slika iz Skup podataka Kaggle prirodnih slika

Arhitektura modela VGG16

izvor

Prijenos naših podataka u AWS S3 Bucket

Za naš proces obuke koristit ćemo sliku prirodnih slika iz 8 različitih klasa kao što su avioni, automobil, mačka, pas, cvijet, voće, motocikl i osoba. Prvo moramo prenijeti svoje podatke na Amazon S3 Kanta.

Amazon S3 Kanta

Korak 1) Nakon što se prijavite na svoj S3 račun, kreirajmo kantu taktom Stvori kantu

Korak 2) Sada odaberite naziv spremnika i svoju regiju u skladu s vašim računom. Provjerite je li naziv spremnika dostupan. Nakon tog klika Stvoriti.

Korak 3) Kao što vidite, vaš Bucket je spreman za korištenje. Ali kao što vidite, pristup nije javan, dobro je za vas ako ga želite zadržati privatnim za sebe. Ovu kantu možete promijeniti za javni pristup u Svojstvima kante

Korak 4) Sada počinjete učitavati svoje podatke o vježbanju u svoju kantu. Ovdje ću učitati datoteku tar.gz koja se sastoji od slika za proces obuke i testiranja.

Korak 5) Sada kliknite svoju datoteku i kopirajte Veza kako bismo ga mogli preuzeti.

Priprema podataka

Moramo generirati podatke o treningu pomoću Keras ImageDataGenerator.

Prvo morate preuzeti pomoću wget-a s vezom na vašu datoteku iz S3 Bucket-a.

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

Nakon što preuzmete podatke, počnimo proces obuke.

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 će napraviti X_training podatke iz direktorija. Poddirektorij u tom direktoriju koristit će se kao klasa za svaki objekt. Slika će se učitati s RGB načinom boja, s kategoričkim načinom klase za podatke Y_training, s veličinom serije 16. Na kraju, promiješajte podatke.

Pogledajmo naše slike nasumično iscrtavajući ih pomoću matplotliba

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

Nakon toga kreirajmo naš mrežni model iz VGG16 s imageNet unaprijed obučenom težinom. Zamrznut ćemo te slojeve tako da se slojevi ne mogu uvježbati kako bismo smanjili vrijeme izračuna.

Izrada našeg modela iz 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())

Kao što možete vidjeti u nastavku, sažetak našeg mrežnog modela. Iz ulaza iz VGG16 slojeva, zatim dodajemo 2 potpuno povezana sloja koji će izdvojiti 1024 značajke i izlazni sloj koji će izračunati 8 klasa uz softmax aktivaciju.

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

Trening

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

Rezultati

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

Kao što vidite, naši su gubici značajno smanjeni, a točnost je gotovo 100%. Za testiranje našeg modela nasumično smo odabrali slike preko interneta i stavili ih u testnu mapu s drugom klasom za testiranje

Testiranje našeg modela

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

A naš test je kao što je navedeno u nastavku! Samo je 1 slika pogrešno predviđena od testa od 14 slika!

Neuronska mreža za prepoznavanje lica s Kerasom

Zašto nam je potrebno priznanje

Prepoznavanje nam je potrebno kako bismo lakše prepoznali ili identificirali nečije lice, vrstu predmeta, procijenjenu dob osobe s njenog lica ili čak znali izraze lica te osobe.

Možda shvatite da svaki put kada pokušate označiti lice svog prijatelja na fotografiji, značajka na Facebooku je to učinila umjesto vas, a to je označavanje lica vašeg prijatelja bez potrebe da ga vi prvo označite. Ovo je prepoznavanje lica koje Facebook primjenjuje kako bi nam olakšao označavanje prijatelja.

Dakle, kako to radi? Svaki put kada označimo lice našeg prijatelja, Facebookova umjetna inteligencija će to naučiti i pokušati predvidjeti dok ne dobije pravi rezultat. Isti sustav ćemo koristiti za izradu našeg vlastitog prepoznavanja lica. Počnimo stvarati vlastito prepoznavanje lica koristeći Deep Learning

Model mreže

Koristit ćemo VGG16 mrežni model, ali s težinom VGGFace.

Arhitektura modela VGG16

Što je VGGFace? to je Kerasova implementacija dubokog prepoznavanja lica koju su predstavili Parkhi, Omkar M. et al. “Duboko prepoznavanje lica.” BMVC (2015). Okvir koristi VGG16 kao mrežnu arhitekturu.

VGGFace možete preuzeti sa 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()

Kao što vidite sažetak mreže

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

mi ćemo učiniti a Prijenos učenja + Fino podešavanje za bržu obuku s malim skupovima podataka. Prvo ćemo zamrznuti osnovne slojeve tako da se slojevi ne mogu trenirati.

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

zatim dodajemo vlastiti sloj za prepoznavanje naših testnih lica. Dodat ćemo 2 potpuno povezana sloja i izlazni sloj s 5 osoba za otkrivanje.

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)

Pogledajmo sažetak naše mreže

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

Kao što možete vidjeti gore, nakon sloja pool5, bit će spljošten u jedan vektor značajki koji će koristiti gusti sloj za konačno prepoznavanje.

Priprema naših lica

Sada pripremimo lica. Napravio sam imenik koji se sastoji od 5 poznatih osoba

Jack Ma
Jason Statham
Johnny Depp
Robert Downey Jr
Rowan Atkinson

Svaka mapa sadrži 10 slika za svaki proces obuke i evaluacije. To je vrlo mala količina podataka, ali to je izazov, zar ne?

Za pripremu podataka koristit ćemo pomoć Keras alata. Ova funkcija će ponavljati mapu skupa podataka i zatim je pripremiti tako da se može koristiti u obuci.

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

Obuka našeg modela

Započnimo naš proces obuke sastavljanjem naše mreže s funkcijom gubitka i optimizatorom. Ovdje koristimo sparse_categorical_crossentropy kao našu funkciju gubitka, uz pomoć SGD-a kao našeg optimizatora učenja.

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

Kao što vidite, točnost naše provjere je do 64%, ovo je dobar rezultat za malu količinu podataka o obuci. To možemo poboljšati dodavanjem više slojeva ili dodavanjem više slika za obuku kako bi naš model mogao naučiti više o licima i postići veću točnost.

Testirajmo naš model probnom slikom

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

koristeći sliku Roberta Downeya Jr. kao našu testnu sliku, pokazuje da je predviđeno lice istinito!

Predviđanje pomoću Live Cam!

Što kažete na to da testiramo svoju vještinu u implementaciji s unosom s web kamere? Koristeći OpenCV s Haar Face kaskadom za pronalaženje našeg lica i uz pomoć našeg mrežnog modela, možemo prepoznati osobu.

Prvi korak je pripremiti lice sebe i prijatelja. Što više podataka imamo, rezultat je bolji!

Pripremite i obučite svoju mrežu kao u prethodnom koraku, nakon završetka obuke dodajte ovaj redak da biste dobili ulaznu sliku s kamere

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

Koji je bolji? Keras ili Tensorflow

Keras nudi jednostavnost pisanja scenarija. Možemo početi pisati i razumjeti izravno s Kerasom jer nije previše teško razumjeti. Jednostavniji je za korištenje i jednostavan za implementaciju, nema potrebe za stvaranjem mnogo varijabli za pokretanje modela. Dakle, ne moramo razumjeti svaki detalj u pozadinskom procesu.

S druge strane, Tensorflow su operacije niske razine koje nude fleksibilnost i napredne operacije ako želite napraviti proizvoljan računski graf ili model. Tensorflow također može vizualizirati proces uz pomoć TensorBoard i specijalizirani alat za ispravljanje pogrešaka.

Dakle, ako želite početi raditi s dubokim učenjem bez toliko složenosti, koristite Keras. Budući da Keras nudi jednostavnost i lakoću korištenja te laku implementaciju od Tensorflowa. Ali ako želite napisati vlastiti algoritam u projektu dubokog učenja ili istraživanju, trebali biste umjesto toga upotrijebiti Tensorflow.

Rezime

Dakle, rezimirajmo sve o čemu smo razgovarali i napravili u ovom vodiču.

Keras u API-ju visoke razine koji se koristi za olakšavanje mreža dubokog učenja uz pomoć pozadinskog motora.
Keras je jednostavan za korištenje i razumijevanje s podrškom za python pa se čini prirodnijim nego ikada. Dobar je za početnike koji žele naučiti o dubokom učenju i za istraživače koji žele jednostavan API.
Proces instalacije je jednostavan i možete koristiti virtualno okruženje ili korištenje vanjske platforme kao što je AWS.
Keras također dolazi s raznim vrstama mrežnih modela tako da nam olakšava korištenje dostupnog modela za prethodno treniranje i fino podešavanje vlastitog mrežnog modela.
Također, postoji mnogo vodiča i članaka o korištenju Kerasa iz kodova zajednica širom svijeta u svrhe dubinskog učenja.

Možda ti se svidi: