Keras bemutatója

Mi az a Keras?

Keras egy nyílt forráskódú neurális hálózati könyvtár, amelybe írták Python amely a Theano vagy a Tensorflow tetején fut. Úgy tervezték, hogy moduláris, gyors és könnyen használható legyen. François Chollet, a Google mérnöke fejlesztette ki. A Keras nem kezel alacsony szintű számításokat. Ehelyett egy másik könyvtárat használ ehhez, az úgynevezett „Háttér.

A Keras egy magas szintű API burkoló az alacsony szintű API-hoz, amely TensorFlow, CNTK vagy Theano tetején képes futni. A Keras High-Level API kezeli a modellek készítését, a rétegek meghatározását vagy a több bemeneti-kimeneti modell beállítását. Ezen a szinten a Keras is összeállítja a modellünket veszteség és optimalizáló függvényekkel, edzési folyamatot fit funkcióval. Keras be Python nem kezeli az alacsony szintű API-t, mint például a számítási gráf elkészítését, tenzorok vagy más változók létrehozását, mert azt a „backend” motor kezelte.

Mi az a háttérprogram?

A Backend egy olyan kifejezés a Kerasban, amely minden alacsony szintű számítást végrehajt, például tenzorszorzatokat, konvolúciókat és sok más dolgot más könyvtárak, például a Tensorflow vagy a Theano segítségével. Tehát a „háttérmotor” elvégzi a modellek számítását és fejlesztését. A Tensorflow az alapértelmezett „háttérmotor”, de a konfigurációban módosíthatjuk.

Theano, Tensorflow és CNTK Backend

A Theano egy nyílt forráskódú projekt, amelyet a kanadai Quebec állambeli Montreal Egyetem MILA csoportja fejlesztett ki. Ez volt az első széles körben használt keretrendszer. Ez egy Python könyvtár, amely többdimenziós tömbökben segít a Numpy vagy Scipy használatával végzett matematikai műveletekhez. A Theano grafikus processzorokat használhat a gyorsabb számításhoz, valamint automatikusan képes szimbolikus grafikonokat készíteni a gradiensek kiszámításához. Weboldalán a Theano azt állítja, hogy képes felismerni a numerikusan instabil kifejezéseket, és stabilabb algoritmusokkal ki tudja számítani őket, ez nagyon hasznos az instabil kifejezéseinknél.

Másrészt a Tensorflow a feltörekvő csillag a mély tanulási keretrendszerben. A Google Brain csapata által kifejlesztett ez a legnépszerűbb mély tanulási eszköz. Számos funkcióval és kutatók járulnak hozzá ennek a keretrendszernek a mélytanulási célokra való fejlesztéséhez.

A Keras másik háttérmotorja a The Microsoft Kognitív eszköztár vagy CNTK. Ez egy nyílt forráskódú mély tanulási keretrendszer, amelyet a Microsoft Csapat. Több GPU-n vagy több gépen is futhat a mélytanulási modell tömeges betanítására. Egyes esetekben a CNTK gyorsabb volt, mint más keretrendszerek, például a Tensorflow vagy a Theano. Következő ebben a Keras CNN oktatóanyagban a Theano, a TensorFlow és a CNTK háttérprogramjait fogjuk összehasonlítani.

A háttérprogramok összehasonlítása

El kell végeznünk egy benchmarkot, hogy megismerjük a két háttér összehasonlítását. Amint láthatod benne Jeong-Yoon Lee etalonja, 3 különböző háttérrendszer teljesítményét hasonlítják össze különböző hardvereken. Az eredmény pedig az, hogy Theano lassabb, mint a másik háttérprogram 50 idők lassabbak, de a pontosság közel van egymáshoz.

Másik benchmark teszt végzi Jasmeet Bhatia. Beszámolt arról, hogy Theano lassabb, mint a Tensorflow bizonyos tesztek miatt. De az általános pontosság majdnem azonos minden tesztelt hálózatnál.

Tehát a Theano, a Tensorflow és a CTK között nyilvánvaló, hogy a TensorFlow jobb, mint a Theano. A TensorFlow-val a számítási idő sokkal rövidebb, és a CNN jobb, mint a többi.

Következő ebben a Kerasban Python oktatóanyagból megtudjuk, mi a különbség a Keras és a TensorFlow között (Keras vs Tensorflow).

Keras vs Tensorflow

paraméterek	Keras	tenzor áramlás
típus	Magas szintű API-burkoló	Alacsony szintű API
Bonyolultság	Könnyen használható, ha Python nyelv	Meg kell tanulnia néhány Tensorflow függvény használatának szintaxisát
Cél	Gyors telepítés szabványos rétegekkel rendelkező modellek készítéséhez	Lehetővé teszi tetszőleges számítási gráf vagy modellrétegek készítését
Eszközök	Más API hibakereső eszközt használ, például a TFDBG-t	Használhatja a Tensorboard vizualizációs eszközöket
Közösség	Nagy, aktív közösségek	Nagy aktív közösségek és széles körben megosztott erőforrások

A Keras előnyei

Gyors telepítés és könnyen érthető

A Keras nagyon gyorsan készít hálózati modellt. Ha egyszerű, néhány soros hálózati modellt szeretne készíteni, Python A Keras ebben tud segíteni. Nézze meg az alábbi Keras példát:

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

Az API barátságossága miatt könnyen megérthetjük a folyamatot. A kód írása egyszerű funkcióval, és nem kell több paramétert beállítani.

Nagy közösségi támogatás

Számos mesterséges intelligencia-közösség használja a Keras-t a Deep Learning keretrendszeréhez. Sokan közülük közzéteszik kódjaikat és oktatóanyagokat a nagyközönség számára.

Legyen több háttérprogramod

Kiválaszthatja a Tensorflow-t, a CNTK-t és a Theano-t a Keras háttérprogramjaként. Igényeitől függően más-más háttérrendszert választhat a különböző projektekhez. Mindegyik háttérprogramnak megvan a maga egyedi előnye.

Platformok közötti és egyszerű modellbevezetés

Számos támogatott eszközzel és platformmal telepítheti a Kerast bármilyen eszközre, például

• iOS CoreML-lel
• Android Tensorflow-val Android,
• Webböngésző .js támogatással
• Felhőmotor
• Raspberry Pi

Több GPU támogatás

Taníthatja a Keras-t egyetlen GPU-n, vagy egyszerre több GPU-t is használhat. Mivel a Keras beépített támogatja az adatok párhuzamosságát, így nagy mennyiségű adatot tud feldolgozni, és felgyorsítja a betanításhoz szükséges időt.

A Keras hátrányai

Nem tudja kezelni az alacsony szintű API-t

A Keras csak olyan magas szintű API-t kezel, amely más keretrendszeren vagy háttérmotoron fut, mint például a Tensorflow, a Theano vagy a CNTK. Tehát nem túl hasznos, ha saját absztrakt réteget szeretne készíteni kutatási célokra, mert a Kerasnak már vannak előre konfigurált rétegei.

Keras telepítése

Ebben a részben megvizsgáljuk a Keras telepítéséhez rendelkezésre álló különféle módszereket

Közvetlen telepítés vagy virtuális környezet

Melyik a jobb? Közvetlen telepítés az aktuális pythonra vagy virtuális környezet használata? Virtuális környezet használatát javaslom, ha sok projektje van. Szeretné tudni, miért? Ennek az az oka, hogy a különböző projektek a keras-könyvtár eltérő verzióját használhatják.

Például van egy projektem, amelyre szüksége van Python 3.5 OpenCV 3.3 használata régebbi Keras-Theano háttérrendszerrel, de a másik projektben a Keras legújabb verziójával és Tensorflow-val kell használnom. Python 3.6.6 támogatás

Nem akarjuk, hogy a Keras könyvtár konfliktusba keveredjen egymással, igaz? Tehát virtuális környezetet használunk a projekt lokalizálására egy adott típusú könyvtárral, vagy használhatunk egy másik platformot, például a Cloud Service-t, hogy elvégezzük helyettünk a számításokat, mint pl. Amazon Webes szolgáltatás.

Keras telepítése Amazon Webszolgáltatás (AWS)

Amazon A Web Service egy olyan platform, amely felhőalapú számítástechnikai szolgáltatást és termékeket kínál kutatók vagy bármilyen más célra. Az AWS bérbe adja hardverét, hálózatát, adatbázisát stb., hogy közvetlenül az internetről tudjuk használni. Az egyik népszerű AWS szolgáltatás mély tanulási célokra a Amazon Machine Image Deep Learning Service vagy DL

Az AWS használatára vonatkozó részletes utasításokért tekintse meg ezt oktatói

Megjegyzés az AMI-vel kapcsolatban: A következő AMI-k állnak rendelkezésre

Az AWS Deep Learning AMI egy virtuális környezet az AWS EC2 szolgáltatásban, amely segíti a kutatókat és a gyakorlati szakembereket a Deep Learning használatában. A DLAMI a kis CPU-s motoroktól a nagy teljesítményű több GPU-s motorokig kínál előre konfigurált CUDA-t, cuDNN-t, és számos mély tanulási keretrendszerrel érkezik.

Ha azonnal használni szeretné, válassza a Deep Learning AMI-t, mert előre telepítve van a népszerű mély tanulási keretrendszerekkel.

Ha azonban egyéni mélytanulási keretrendszert szeretne kipróbálni a kutatáshoz, telepítse a Deep Learning Base AMI-t, mert olyan alapvető könyvtárakat tartalmaz, mint a CUDA, cuDNN, GPU-illesztőprogramok és más szükséges könyvtárak a mély tanulási környezethez.

A Keras telepítése Amazon SageMaker

Amazon A SageMaker egy mély tanulási platform, amely segít a képzésben és a mélytanulási hálózat telepítésében a legjobb algoritmussal.

Kezdőként messze ez a legegyszerűbb módszer a Keras használatához. Az alábbiakban bemutatjuk a Keras telepítésének folyamatát Amazon SageMaker:

1. lépés) Nyissa meg Amazon SageMaker

Első lépésben nyissa meg a Amazon Sagemaker konzolt, és kattintson a Jegyzetfüzet példány létrehozása elemre.

2. lépés) Adja meg a részleteket

1. Írja be a jegyzetfüzet nevét.
2. Hozzon létre egy IAM-szerepet. Létrehoz egy AMI-szerepet Amazon IAM szerepe a formátumban AmazonSageMaker-Executionrole-YYYYMMDD|HHmmSS.
3. Végül válassza a Jegyzetfüzet példány létrehozása lehetőséget. Néhány pillanat múlva Amazon A Sagemaker elindít egy notebook példányt.

Megjegyzések: Ha VPC-jéről szeretne erőforrásokat elérni, állítsa be a közvetlen internet-hozzáférést engedélyezve. Ellenkező esetben ennek a notebook példánynak nem lesz internet-hozzáférése, így lehetetlen modelleket betanítani vagy tárolni

3. lépés) Indítsa el a példányt

Kattintson a Megnyitás gombra a példány elindításához

4. lépés) Kezdje el a kódolást

In Jupyter, Kattintson az Új> conda_tensorflow_p36 elemre, és készen áll a kódolásra

Telepítse a Keras-t Linuxra

Ahhoz, hogy a Keras-t Tensorflow háttérmotorjával engedélyezzük, először telepítenünk kell a Tensorflow-t. Futtassa ezt a parancsot a tensorflow CPU-val történő telepítéséhez (nincs GPU)

pip install --upgrade tensorflow

Ha engedélyezni szeretné a GPU-támogatást a tensorflow számára, akkor ezt a parancsot használhatja

pip install --upgrade tensorflow-gpu

jelentkezzünk be Python gépeléssel ellenőrizheti, hogy sikeres-e a telepítésünk

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

ha nincs hibaüzenet, a telepítés sikeres

Telepítse a Kerast

A Tensorflow telepítése után kezdjük el a keras telepítését. Írja be ezt a parancsot a terminálba

pip install keras

elkezdi telepíteni a Kerast és annak összes függőségét. Valami ilyesmit kell látnia:

Most már Keras is telepítve van rendszerünkben!

ellenőrzése

A Keras használatának megkezdése előtt a konfigurációs fájl megnyitásával ellenőriznünk kell, hogy Kerasunk használja-e a Tensorflow-t háttérként:

gedit ~/.keras/keras.json

valami ilyesmit kellene látnod

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

amint látja, a „backend” tensorflow-t használ. Ez azt jelenti, hogy a keras a Tensorflow-t használja háttérként, ahogy azt vártuk

és most gépeléssel futtassa a terminálon

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

A Keras telepítése Windows

Mielőtt telepítenénk tenzor áramlás és Keras, telepítenünk kell Python, pip és virtualenv. Ha már telepítette ezeket a könyvtárakat, folytassa a következő lépéssel, ellenkező esetben tegye ezt:

Telepítés Python 3 innen letöltve link

Telepítse a pip-et futtatással ezt

Telepítse a virtualenv-t ezzel a paranccsal

pip3 install –U pip virtualenv

Telepítés Microsoft Vizuális C++ 2015. évi újraterjeszthető frissítés 3

• Nyissa meg a Visual Studio letöltési webhelyét https://www.microsoft.com/en-us/download/details.aspx?id=53587
• Válassza az Újraterjeszthető és Építőeszközök lehetőséget
• Töltse le és telepítse a Microsoft Vizuális C++ 2015. évi újraterjeszthető frissítés 3

Ezután futtassa ezt a szkriptet

pip3 install virtualenv

Virtuális környezet beállítása

Ez a működő rendszer és a fő rendszer elkülönítésére szolgál.

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

Aktiválja a környezetet

.\venv\Scripts\activate

A környezet előkészítése után a Tensorflow és a Keras telepítése ugyanaz marad, mint a Linux. A következő oktatóanyagban a Mély tanulás Kerasszal a Keras alapjairól fogunk tanulni a mély tanuláshoz.

Keras alapjai a mély tanuláshoz

A Keras fő szerkezete a modell, amely egy hálózat teljes gráfját határozza meg. További rétegek hozzáadásával egy meglévő modellhez egyéni modellt hozhat létre, amelyre szüksége van a projekthez.

Így készíthet szekvenciális modellt és néhány gyakran használt réteget a mélytanulásban

1. Szekvenciális modell

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

model = Sequential()

2. Konvolúciós réteg

Ez egy Keras Python példa a konvolúciós rétegre mint bemeneti rétegre 320x320x3 bemeneti formájú, 48 db 3x3 méretű szűrővel, és aktiválási funkcióként használja a ReLU-t.

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

egy másik típus

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

3.MaxPooling Réteg

A bemeneti reprezentáció lemintázásához használja a MaxPool2d-t, és adja meg a kernel méretét

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

4. Sűrű réteg

Teljesen összekapcsolt réteg hozzáadása a kimeneti méret megadásával

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

5. Lemorzsolódási réteg

Kieső réteg hozzáadása 50%-os valószínűséggel

model.add(Dropout(0.5))

Összeállítás, képzés és értékelés

Miután meghatároztuk a modellünket, kezdjük el őket képezni. Először le kell fordítani a hálózatot a veszteségfüggvénnyel és az optimalizáló funkcióval. Ez lehetővé teszi a hálózat számára, hogy módosítsa a súlyokat, és minimalizálja a veszteséget.

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

Most a képzés megkezdéséhez használja a fitt a betanítási és érvényesítési adatok betáplálásához a modellbe. Ez lehetővé teszi a hálózat kötegekben történő betanítását és a korszakok beállítását.

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

Utolsó lépésünk a modell értékelése a tesztadatokkal.

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

Próbáljuk meg az egyszerű lineáris regressziót használni

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

Az adatok betanítása után a kimenetnek így kell kinéznie

a kezdeti súllyal

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

és a végső súly

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

Finomhangolja az előre betanított modelleket a Kerasban és hogyan kell használni őket

Miért használunk Fine Tune modelleket és mikor használjuk?

A finomhangolás az a feladat, hogy egy előre betanított modellt úgy módosítsunk, hogy a paraméterek alkalmazkodjanak az új modellhez. Amikor egy új modellen a semmiből akarunk edzeni, nagy mennyiségű adatra van szükségünk, hogy a hálózat minden paramétert megtaláljon. De ebben az esetben egy előre betanított modellt fogunk használni, így a paraméterek már megtanultak, és súlyuk van.

Például, ha a saját Keras modellünket szeretnénk betanítani egy osztályozási probléma megoldására, de csak kevés adatunk van, akkor ezt egy Transzfer tanulás + Finomhangolási módszer.

Előre betanított hálózat és súlyok használatával nem kell az egész hálózatot betanítanunk. Csak meg kell tanítanunk az utolsó réteget, amelyet a feladatunk megoldására használunk, ahogy Fine-Tuning módszernek nevezzük.

Hálózati modell előkészítése

Az előre betanított modellhez számos olyan modellt tölthetünk be, amelyeket a Keras már tartalmaz a könyvtárában, például:

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

De ebben a folyamatban a VGG16 hálózati modellt és az imageNet-et fogjuk használni a modell súlyaként. Finomhangoljuk a hálózatot, hogy 8 különböző típusú osztályt osztályozhassunk a Képek innen: segítségével Kaggle Natural Images Dataset

VGG16 modell architektúra

forrás

Adataink feltöltése az AWS S3 Bucketbe

A képzési folyamatunkhoz 8 különböző osztályból származó természeti képeket fogunk használni, mint például repülőgépek, autók, macskák, kutyák, virágok, gyümölcsök, motorok és személyek. Először is fel kell töltenünk adatainkat ide Amazon S3 Vödör.

Amazon S3 Vödör

Step 1) Miután bejelentkezett az S3-fiókjába, hozzon létre egy vödröt az órajellel Vödör létrehozása

Step 2) Most válasszon egy csoportnevet és régióját a fiókjának megfelelően. Győződjön meg arról, hogy a vödör neve elérhető. Ezt követően kattintson Létrehozása.

Step 3) Amint látja, a Bucket használatra kész. De amint látja, az Access nem nyilvános, jó neked, ha privátban szeretnéd tartani magadnak. Megváltoztathatja ezt a tárolót nyilvános hozzáférésre a Vágó tulajdonságaiban

Step 4) Most elkezdheti az edzési adatok feltöltését a Bucket-be. Ide fogom feltölteni a tar.gz fájlt, amely képekből áll a képzési és tesztelési folyamathoz.

Step 5) Most kattintson a fájlra, és másolja ki Link hogy le tudjuk tölteni.

Adatok előkészítése

Edzési adatainkat a Keras ImageData segítségével kell generálnunkGenerator.

Először is le kell töltenie a wget segítségével az S3 Bucket fájljára mutató hivatkozást.

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

Az adatok letöltése után kezdjük el a képzési folyamatot.

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)

Az ImageDataGenerator egy X_training adatot készít egy könyvtárból. A könyvtárban lévő alkönyvtár osztályként lesz használva minden objektumhoz. A kép az RGB színmóddal, az Y_training adatok kategorikus osztálymódjával, 16-os kötegmérettel lesz betöltve. Végül keverje meg az adatokat.

Nézzük véletlenszerűen a képeinket a matplotlib segítségével

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

Ezt követően készítsük el a VGG16-ból a hálózati modellünket imageNet előre betanított súllyal. Lefagyasztjuk ezeket a rétegeket, hogy a rétegek ne legyenek betaníthatóak, ami segít csökkenteni a számítási időt.

Modellünk készítése VGG16-ból

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

Amint az alábbiakban látható, a hálózati modellünk összefoglalása. A VGG16 Layers bemenetéből hozzáadunk 2 teljesen összekapcsolt réteget, amely 1024 funkciót bont ki, és egy kimeneti réteget, amely a softmax aktiválásával számítja ki a 8 osztályt.

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

Képzések

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

Eredmények

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

Amint látja, veszteségeink jelentősen csökkentek, és a pontosság majdnem 100%. Modellünk teszteléséhez véletlenszerűen kiválasztottunk képeket az interneten, és a teszt mappába helyeztük egy másik osztályba, hogy teszteljük.

Modellünk tesztelése

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

És tesztünk az alábbiak szerint készült! Egy 1 képből álló tesztből csak 14 kép jósolható rosszul!

Arcfelismerő neurális hálózat Kerasszal

Miért van szükségünk Elismerésre

Felismerésre azért van szükségünk, hogy könnyebben felismerhessük vagy azonosíthassuk egy személy arcát, tárgytípusát, egy személy becsült életkorát az arcáról, vagy akár ismerjük az adott személy arckifejezését.

Talán rájössz, valahányszor megpróbálod megjelölni a barátod arcát egy fényképen, a Facebook funkciója megtette ezt helyetted, vagyis megjelöli ismerőse arcát anélkül, hogy először meg kellene jelölnie. Ez a Facebook által alkalmazott arcfelismerés, amely megkönnyíti az ismerősök megjelölését.

Szóval hogyan működik? Minden alkalommal, amikor megjelöljük barátunk arcát, a Facebook mesterséges intelligencia megtanulja, és addig próbálja megjósolni, amíg meg nem kapja a megfelelő eredményt. Ugyanezt a rendszert fogjuk használni saját arcfelismerésünk elkészítéséhez. Kezdjük el elkészíteni saját arcfelismerésünket a Deep Learning segítségével

Hálózati modell

VGG16 hálózati modellt fogunk használni, de VGGFace súllyal.

VGG16 modell architektúra

Mi az a VGGFace? ez a Deep Face Recognition Keras implementációja, amelyet Parkhi, Omkar M. és munkatársai vezettek be. "Mély arcfelismerés." BMVC (2015). A keretrendszer a VGG16-ot használja hálózati architektúraként.

A VGGFace letölthető innen 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()

Mint látható a hálózat összefoglalójában

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

megtesszük a Transzfer tanulás + Finomhangolás az edzés gyorsabbá tételéhez kis adatkészletekkel. Először is lefagyasztjuk az alaprétegeket, hogy a rétegek ne legyenek képezhetők.

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

majd hozzáadjuk a saját rétegünket, hogy felismerjük tesztarcainkat. Hozzáadunk 2 teljesen összekapcsolt réteget és egy kimeneti réteget 5 emberrel az észlelésre.

from keras.models import Model, Sequential
from keras.layers import Input, Convolution2D, ZeroPadding2D, MaxPooling2D, Flatten, Dense, Dropout, Activation

person_count = 5

last_layer = face_model.get_layer('pool5').output

x = Flatten(name='flatten')(last_layer)
x = Dense(1024, activation='relu', name='fc6')(x)
x = Dense(1024, activation='relu', name='fc7')(x)
out = Dense(person_count, activation='softmax', name='fc8')(x)

custom_face = Model(face_model.input, out)

Lássuk a hálózat összefoglalóját

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

Amint fentebb látható, a pool5 réteg után egyetlen jellemzővektor lesz, amelyet a sűrű réteg fogja használni a végső felismeréshez.

Arcunk előkészítése

Most készítsük elő az arcunkat. Csináltam egy könyvtárat 5 híres emberből

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

Minden mappa 10 képet tartalmaz, minden képzési és értékelési folyamathoz. Ez nagyon kevés adat, de ez a kihívás, igaz?

Az adatok elkészítéséhez a Keras eszközt fogjuk használni. Ez a funkció ismétlődik az adatkészlet mappában, majd előkészíti, hogy felhasználhassa a képzésben.

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

Modellünk képzése

Kezdjük a képzési folyamatot azzal, hogy összeállítjuk hálózatunkat veszteségfüggvénnyel és optimalizálóval. Itt a sparse_categorical_crossentropy-t használjuk veszteségfüggvényként, az SGD segítségével tanulásoptimalizálóként.

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

Amint látja, az érvényesítési pontosságunk akár 64%, ez jó eredmény kis mennyiségű edzési adathoz. Ezt javíthatjuk több réteg hozzáadásával vagy több képzési kép hozzáadásával, hogy modellünk többet tudjon meg az arcokról és nagyobb pontosságot érjen el.

Teszteljük modellünket próbaképpel

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

Robert Downey Jr. képét tesztképként használva megmutatja, hogy a megjósolt arc igaz!

Előrejelzés élő kamera segítségével!

Mit szólnál, ha egy webkamera bemenetével tesztelnénk tudásunkat a megvalósítással? Az OpenCV és a Haar Face kaszkád segítségével megtaláljuk az arcunkat, és a hálózati modellünk segítségével felismerjük a személyt.

Az első lépés az Ön és barátja arcának előkészítése. Minél több adatunk van, annál jobb az eredmény!

Készítse elő és képezze be a hálózatát az előző lépéshez hasonlóan, miután a képzés befejeződött, adja hozzá ezt a sort, hogy megkapja a bemeneti képet a kamerától

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

Melyik a jobb? Keras vagy Tensorflow

A Keras egyszerűséget kínál a forgatókönyv megírásakor. Kerasszal közvetlenül elkezdhetünk írni és megérteni, mert nem túl nehéz megérteni. Felhasználóbarátabb és könnyebben megvalósítható, nem kell sok változót megadni a modell futtatásához. Tehát nem kell minden részletet megértenünk a háttérfolyamatban.

Másrészt a Tensorflow az alacsony szintű műveletek, amelyek rugalmasságot és fejlett műveleteket kínálnak, ha tetszőleges számítási gráfot vagy modellt szeretne készíteni. A Tensorflow a folyamatot is képes megjeleníteni a segítségével TensorBoard és egy speciális hibakereső eszköz.

Tehát, ha nem túl bonyolultan szeretne mély tanulással dolgozni, használja a Keras-t. Mert a Keras egyszerűséget és felhasználóbarát használatot kínál, valamint könnyen megvalósítható, mint a Tensorflow. De ha saját algoritmust szeretne írni egy mély tanulási projektben vagy kutatásban, használja inkább a Tensorflow-t.

Összegzésként

Tehát foglaljuk össze mindazt, amit ebben az oktatóanyagban megbeszéltünk és tettünk.

• Keras egy magas szintű API-ban, amelyet a mély tanulási hálózatok megkönnyítésére használnak a háttérmotor segítségével.
• A Keras könnyen használható és érthető a python támogatásával, így természetesebb, mint valaha. Jó kezdőknek, akik szeretnének tanulni a mély tanulásról, és azoknak a kutatóknak, akik könnyen használható API-t szeretnének.
• A telepítési folyamat egyszerű, és használhat virtuális környezetet vagy külső platformot, mint pl AWS.
• A Keras különféle hálózati modellekkel is érkezik, így könnyebben használhatjuk a rendelkezésre álló modellt saját hálózati modellünk előre betanítására és finomhangolására.
• Ezenkívül számos oktatóanyag és cikk található a Keras használatáról a közösségek világszerte kódjaiból mély tanulási célokra.