Výukový program Keras: Co je Keras? Jak nainstalovat do Python [Příklad]
Evelyn Clarkeová
Co je Keras?
Keras je open source knihovna neuronových sítí napsaná v Python který běží nad Theano nebo Tensorflow. Je navržen tak, aby byl modulární, rychlý a snadno použitelný. Byl vyvinut Françoisem Cholletem, inženýrem společnosti Google. Keras nezvládá nízkoúrovňové výpočty. Místo toho k tomu používá jinou knihovnu nazvanou „Backend.
Keras je vysokoúrovňový obal API pro nízkoúrovňové API, který může běžet nad TensorFlow, CNTK nebo Theano. Keras High-Level API zpracovává způsob, jakým vytváříme modely, definujeme vrstvy nebo nastavujeme více vstupně-výstupních modelů. V této úrovni Keras také kompiluje náš model se ztrátovými a optimalizačními funkcemi, tréninkový proces s fit funkcí. Keras dovnitř Python nezpracovává Low-Level API, jako je vytváření výpočtového grafu, vytváření tenzorů nebo jiných proměnných, protože to bylo zpracováno „backendovým“ enginem.
Co je to backend?
Backend je termín v Kerasu, který provádí všechny nízkoúrovňové výpočty, jako jsou tensor produkty, konvoluce a mnoho dalších věcí s pomocí jiných knihoven, jako je Tensorflow nebo Theano. Takže „backend engine“ bude provádět výpočty a vývoj modelů. Tensorflow je výchozí „backend engine“, ale můžeme to změnit v konfiguraci.
Theano, Tensorflow a Backend CNTK
Theano je open source projekt, který vyvinula skupina MILA na University of Montreal, Quebec, Kanada. Byl to první široce používaný rámec. Je to a Python knihovna, která pomáhá ve vícerozměrných polích pro matematické operace pomocí Numpy nebo Scipy. Theano může používat GPU pro rychlejší výpočty a může také automaticky vytvářet symbolické grafy pro výpočet gradientů. Theano na svých stránkách tvrdí, že dokáže rozpoznat numericky nestabilní výrazy a vypočítat je pomocí stabilnějších algoritmů, což je velmi užitečné pro naše nestabilní výrazy.
Na druhou stranu je Tensorflow vycházející hvězdou v rámci hlubokého učení. Vyvinutý týmem Google Brain je nejoblíbenějším nástrojem hlubokého učení. Díky mnoha funkcím a výzkumníci přispívají k rozvoji tohoto rámce pro účely hlubokého učení.
Dalším backendovým enginem pro Keras je The Microsoft Cognitive Toolkit nebo CNTK. Jedná se o open-source rámec hlubokého učení, který byl vyvinut společností Microsoft Tým. Může běžet na více GPU nebo na více strojích pro trénink modelu hlubokého učení v masivním měřítku. V některých případech byl CNTK hlášen rychleji než jiné rámce, jako je Tensorflow nebo Theano. Dále v tomto tutoriálu Keras CNN porovnáme backendy Theano, TensorFlow a CNTK.
Porovnání backendů
Potřebujeme udělat benchmark, abychom poznali srovnání mezi těmito dvěma backendy. Jak můžete vidět v Jeong-Yoon Leeův benchmark, porovnává se výkon 3 různých backendů na různém hardwaru. A výsledek je, že Theano je pomalejší než druhý backend, uvádí se 50 krát pomalejší, ale přesnost je blízko sebe.
Další srovnávací test provádí Jasmeet Bhatia. Uvedl, že Theano je v některých testech pomalejší než Tensorflow. Celková přesnost je však téměř stejná pro každou testovanou síť.
Takže mezi Theano, Tensorflow a ČTK je zřejmé, že TensorFlow je lepší než Theano. S TensorFlow je doba výpočtu mnohem kratší a CNN je lepší než ostatní.
Další v tomto Keras Python tutoriálu se dozvíme o rozdílu mezi Keras a TensorFlow (Keras vs Tensorflow).
Keras vs Tensorflow
| parametry | Keras | tenzorový tok |
|---|---|---|
| Typ | High-Level API Wrapper | Nízkoúrovňové API |
| Komplexita | Snadné použití, pokud jste Python jazyk | Musíte se naučit syntaxi používání některých funkcí Tensorflow |
| Účel | Rychlé nasazení pro vytvoření modelu se standardními vrstvami | Umožňuje vytvořit libovolný výpočetní graf nebo vrstvy modelu |
| Tools | Používá jiný nástroj pro ladění API, jako je TFDBG | Můžete použít vizualizační nástroje Tensorboard |
| Naše projekty | Velké aktivní komunity | Velké aktivní komunity a široce sdílené zdroje |
Výhody Kerasu
Rychlé nasazení a snadné pochopení
Keras velmi rychle vytváří síťový model. Pokud chcete vytvořit jednoduchý síťový model s několika řádky, Python Keras vám s tím může pomoci. Podívejte se na příklad Keras níže:
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'))
Díky přátelskému rozhraní API můžeme snadno pochopit proces. Psaní kódu s jednoduchou funkcí a bez nutnosti nastavovat více parametrů.
Podpora velké komunity
Existuje mnoho komunit AI, které používají Keras pro svůj rámec Deep Learning. Mnoho z nich zveřejňuje své kódy i návody pro širokou veřejnost.
Mít více backendů
Jako backend s Keras si můžete vybrat Tensorflow, CNTK a Theano. Pro různé projekty si můžete vybrat jiný backend v závislosti na vašich potřebách. Každý backend má svou jedinečnou výhodu.
Víceplatformní a snadné nasazení modelu
S řadou podporovaných zařízení a platforem můžete Keras nasadit na jakékoli zařízení, jako je
- iOS s CoreML
- Android s Tensorflow Android,
- Webový prohlížeč s podporou .js
- Cloudový motor
- Raspberry Pi
Podpora více GPU
Keras můžete trénovat na jednom GPU nebo používat více GPU najednou. Protože Keras má vestavěnou podporu pro datový paralelismus, může zpracovávat velké objemy dat a urychlit čas potřebný k jejich trénování.
Nevýhody Kerasu
Nelze zpracovat nízkoúrovňové API
Keras zpracovává pouze API na vysoké úrovni, které běží na jiném frameworku nebo backendovém enginu, jako je Tensorflow, Theano nebo CNTK. Není to tedy příliš užitečné, pokud si chcete vytvořit vlastní abstraktní vrstvu pro výzkumné účely, protože Keras již má předkonfigurované vrstvy.
Instalace Keras
V této části se podíváme na různé dostupné metody instalace Keras
Přímá instalace nebo virtuální prostředí
Který je lepší? Přímá instalace do aktuálního pythonu nebo použití virtuálního prostředí? Pokud máte mnoho projektů, doporučuji použít virtuální prostředí. Chcete vědět proč? Je to proto, že různé projekty mohou používat různé verze knihovny keras.
Mám například projekt, který potřebuje Python 3.5 pomocí OpenCV 3.3 se starším backendem Keras-Theano, ale v jiném projektu musím používat Keras s nejnovější verzí a Tensorflow jako backend s Python Podpora 3.6.6
Nechceme, aby se knihovna Keras dostala do konfliktu, že? Takže používáme virtuální prostředí k lokalizaci projektu s konkrétním typem knihovny nebo můžeme použít jinou platformu, jako je Cloud Service, aby za nás provedla naše výpočty, např. Amazon Webová služba.
Instalace Keras na Amazon Webová služba (AWS)
Amazon Web Service je platforma, která nabízí služby a produkty Cloud Computing pro výzkumné pracovníky nebo pro jakékoli jiné účely. AWS pronajímá svůj hardware, sítě, databázi atd., abychom je mohli používat přímo z internetu. Jednou z populárních služeb AWS pro účely hlubokého učení je Amazon Machine Image Deep Learning Service nebo DL
Podrobné pokyny, jak používat AWS, naleznete zde konzultace
Poznámka k AMI: K dispozici budete mít následující AMI
AWS Deep Learning AMI je virtuální prostředí v AWS EC2 Service, které pomáhá výzkumníkům nebo praktikům pracovat s Deep Learning. DLAMI nabízí od malých CPU až po vysoce výkonné multi GPU motory s předkonfigurovanými CUDA, cuDNN a přichází s řadou rámců hlubokého učení.
Pokud jej chcete používat okamžitě, měli byste si vybrat Deep Learning AMI, protože je dodáván s předinstalovanými oblíbenými frameworky pro hluboké učení.
Ale pokud chcete vyzkoušet vlastní rámec hlubokého učení pro výzkum, měli byste si nainstalovat Deep Learning Base AMI, protože přichází se základními knihovnami, jako jsou CUDA, cuDNN, ovladače GPU a další potřebné knihovny, které lze provozovat s vaším prostředím hlubokého učení.
Jak nainstalovat Keras Amazon SageMaker
Amazon SageMaker je platforma pro hluboké učení, která vám pomůže se školením a nasazením sítě hlubokého učení s nejlepším algoritmem.
Pro začátečníka je to zdaleka nejjednodušší metoda použití Kerasu. Níže je uveden postup, jak nainstalovat Keras Amazon SageMaker:
Krok 1) Otevřete Amazon SageMaker
V prvním kroku otevřete Amazon Sagemaker konzole a klikněte na Vytvořit instanci notebooku.
Krok 2) Zadejte podrobnosti
- Zadejte název notebooku.
- Vytvořte roli IAM. Vytvoří roli AMI Amazon IAM role ve formátu AmazonSageMaker-Executionrole-RRRRMMDD|HHmmSS.
- Nakonec zvolte Vytvořit instanci poznámkového bloku. Po několika okamžicích Amazon Sagemaker spustí instanci notebooku.
Pozor: Pokud chcete přistupovat ke zdrojům ze svého VPC, nastavte přímý přístup k internetu jako povolený. Jinak tato instance notebooku nebude mít přístup k internetu, takže nebude možné trénovat nebo hostovat modely
Krok 3) Spusťte instanci
Klepnutím na Otevřít spustíte instanci
Krok 4) Začněte kódovat
In Jupyter, Klikněte na Nový> conda_tensorflow_p36 a jste připraveni kódovat
Nainstalujte Keras v Linuxu
Abychom povolili Keras s Tensorflow jako jeho backend enginem, musíme nejprve nainstalovat Tensorflow. Spusťte tento příkaz pro instalaci tensorflow s CPU (bez GPU)
pip install --upgrade tensorflow
pokud chcete povolit podporu GPU pro tensorflow, můžete použít tento příkaz
pip install --upgrade tensorflow-gpu
pojďme se přihlásit Python zda je naše instalace úspěšná zadáním
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 >>>
pokud se neobjeví žádné chybové hlášení, proces instalace je úspěšný
Nainstalujte Keras
Poté, co nainstalujeme Tensorflow, začněme instalovat keras. Zadejte tento příkaz do terminálu
pip install keras
začne instalovat Keras a také všechny jeho závislosti. Měli byste vidět něco takového:
Nyní máme Keras nainstalovaný v našem systému!
Ověření
Než začneme používat Keras, měli bychom zkontrolovat, zda naše Keras používá Tensorflow jako backend otevřením konfiguračního souboru:
gedit ~/.keras/keras.json
měli byste vidět něco takového
{
"floatx": "float32",
"epsilon": 1e-07,
"backend": "tensorflow",
"image_data_format": "channels_last"
}
jak vidíte, „backend“ používá tensorflow. To znamená, že keras používá Tensorflow jako backend, jak jsme očekávali
a nyní jej spusťte na terminálu zadáním
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. >>>
Jak nainstalovat Keras Windows
Než nainstalujeme tenzorový tok a Keras, měli bychom nainstalovat Python, pip a virtualenv. Pokud jste již tyto knihovny nainstalovali, měli byste pokračovat dalším krokem, jinak postupujte takto:
instalovat Python 3 stažením z tohoto https://trials.autocruitment.com
Nainstalujte pip spuštěním tento
Nainstalujte virtualenv pomocí tohoto příkazu
pip3 install –U pip virtualenv
instalovat Microsoft Vizuální C++ 2015 Redistribuovatelná aktualizace 3
- Přejděte na web ke stažení sady Visual Studio https://www.microsoft.com/en-us/download/details.aspx?id=53587
- Vyberte možnost Redistributables and Build Tools
- Stáhněte a nainstalujte Microsoft Vizuální C++ 2015 Redistribuovatelná aktualizace 3
Poté spusťte tento skript
pip3 install virtualenv
Nastavení virtuálního prostředí
To se používá k izolaci pracovního systému od hlavního systému.
virtualenv –-system-site-packages –p python3 ./venv
Aktivujte prostředí
.\venv\Scripts\activate
Po přípravě prostředí zůstává instalace Tensorflow a Keras stejná jako v Linuxu. Dále v tomto tutoriálu Deep learning with Keras se seznámíme se základy Keras pro Deep learning.
Keras Základy pro hluboké učení
Hlavní strukturou v Kerasu je Model, který definuje kompletní graf sítě. Ke stávajícímu modelu můžete přidat další vrstvy a vytvořit tak vlastní model, který potřebujete pro svůj projekt.
Zde je návod, jak vytvořit sekvenční model a několik běžně používaných vrstev v hlubokém učení
1. Sekvenční model
from keras.models import Sequential from keras.layers import Dense, Activation,Conv2D,MaxPooling2D,Flatten,Dropout model = Sequential()
2. Konvoluční vrstva
Tohle je Keras Python příklad konvoluční vrstvy jako vstupní vrstvy se vstupním tvarem 320x320x3, se 48 filtry o velikosti 3×3 a použití ReLU jako aktivační funkce.
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))
jiný typ je
model.add(Conv2D(48, (3, 3), activation='relu'))
3. MaxPooling Vrstva
Pro převzorkování vstupní reprezentace použijte MaxPool2d a zadejte velikost jádra
model.add(MaxPooling2D(pool_size=(2, 2)))
4. Hustá vrstva
přidání Plně připojené vrstvy pouhým zadáním výstupní velikosti
model.add(Dense(256, activation='relu'))
5. Vrstva vynechání
Přidávání vrstvy výpadků s 50% pravděpodobností
model.add(Dropout(0.5))
Kompilace, školení a hodnocení
Poté, co definujeme náš model, začněme je trénovat. Nejprve je nutné zkompilovat síť se ztrátovou funkcí a funkcí optimalizace. To umožní síti měnit váhy a minimalizovat ztráty.
model.compile(loss='mean_squared_error', optimizer='adam')
Nyní začněte trénovat pomocí fit, abyste do modelu vložili trénovací a ověřovací data. To vám umožní trénovat síť v dávkách a nastavovat epochy.
model.fit(X_train, X_train, batch_size=32, epochs=10, validation_data=(x_val, y_val))
Naším posledním krokem je vyhodnocení modelu s testovacími daty.
score = model.evaluate(x_test, y_test, batch_size=32)
Zkusme použít jednoduchou lineární regresi
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()
Po natrénování dat by měl výstup vypadat takto
s počáteční hmotností
Linear regression model is initialized with weights w: 0.37, b: 0.00
a konečná hmotnost
Linear regression model is trained to have weight w: 3.70, b: 0.61
Vylaďte předem vycvičené modely v Kerasu a jak je používat
Proč používáme Fine Tune Models a kdy je používáme
Jemné doladění je úkolem vyladit předem trénovaný model tak, aby se parametry přizpůsobily novému modelu. Když chceme trénovat od nuly na novém modelu, potřebujeme velké množství dat, aby síť našla všechny parametry. Ale v tomto případě použijeme předem trénovaný model, takže parametry jsou již naučené a mají váhu.
Pokud například chceme trénovat vlastní model Keras k vyřešení klasifikačního problému, ale máme jen malé množství dat, můžeme to vyřešit pomocí Přenos učení + Metoda jemného ladění.
Pomocí předem natrénované sítě a závaží nepotřebujeme trénovat celou síť. Potřebujeme pouze natrénovat poslední vrstvu, která se používá k řešení našeho úkolu, jak tomu říkáme metoda jemného ladění.
Příprava modelu sítě
Pro předtrénovaný model můžeme načíst různé modely, které Keras již má ve své knihovně, jako například:
- VGG16
- PočátekV3
- ResNet
- MobileNet
- Xception
- InceptionResNetV2
Ale v tomto procesu použijeme model sítě VGG16 a imageNet jako naši váhu pro model. Pomocí Images from vyladíme síť pro klasifikaci 8 různých typů tříd Kaggle Natural Images Dataset
Architektura modelu VGG16
Nahrávání našich dat do AWS S3 Bucket
Pro náš tréninkový proces použijeme obrázek přírodních obrázků z 8 různých tříd, jako jsou letadla, auto, kočka, pes, květina, ovoce, motorka a člověk. Nejprve musíme nahrát svá data do Amazon Kbelík S3.
Amazon Kbelík S3
Krok 1) Po přihlášení ke svému účtu S3 si vytvořte bucket taktováním Vytvořit kbelík
Krok 2) Nyní vyberte název segmentu a svůj region podle svého účtu. Ujistěte se, že je k dispozici název segmentu. Po tomto kliknutí Vytvořit.
Krok 3) Jak vidíte, váš Bucket je připraven k použití. Ale jak vidíte, přístup není veřejný, je pro vás dobré, pokud si jej chcete ponechat pro sebe. Tento segment můžete změnit pro veřejný přístup ve vlastnostech segmentu
Krok 4) Nyní začnete nahrávat svá tréninková data do vašeho Bucketu. Zde nahraji soubor tar.gz, který se skládá z obrázků pro proces školení a testování.
Krok 5) Nyní klikněte na svůj soubor a zkopírujte jej Odkaz abychom si to mohli stáhnout.
Příprava dat
Potřebujeme generovat naše tréninková data pomocí Keras ImageDataGenerator.
Nejprve si musíte stáhnout pomocí wget s odkazem na váš soubor z S3 Bucket.
!wget https://s3.us-east-2.amazonaws.com/naturalimages02/images.tar.gz !tar -xzf images.tar.gz
Po stažení dat zahájíme tréninkový proces.
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)
Obrazová dataGenerator vytvoří data X_training z adresáře. Podadresář v tomto adresáři bude použit jako třída pro každý objekt. Obrázek bude načten s barevným režimem RGB, s režimem kategorické třídy pro data Y_training, s velikostí dávky 16. Nakonec data zamíchejte.
Podívejme se na naše obrázky náhodně tak, že je vykreslíme pomocí 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()
Poté vytvořte náš síťový model z VGG16 s předem připravenou hmotností imageNet. Tyto vrstvy zmrazíme, aby vrstvy nebyly trénovatelné, což nám pomůže zkrátit dobu výpočtu.
Vytváření našeho modelu z 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())
Jak můžete vidět níže, shrnutí našeho síťového modelu. Ze vstupu z vrstev VGG16 pak přidáme 2 plně připojené vrstvy, které extrahují 1024 funkcí a výstupní vrstvu, která spočítá 8 tříd s aktivací 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
Trénink
# # 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()
výsledky
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
Jak vidíte, naše ztráty výrazně klesly a přesnost je téměř 100%. Pro testování našeho modelu jsme náhodně vybrali obrázky přes internet a vložili je do testovací složky s jinou třídou k testování
Testování našeho modelu
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 náš test je takový, jak je uvedeno níže! Pouze 1 obrázek je předpovězen špatně z testu 14 obrázků!
Neuronová síť pro rozpoznávání obličeje s Keras
Proč potřebujeme uznání
Potřebujeme Rozpoznání, aby nám usnadnilo rozpoznání nebo identifikaci obličeje osoby, typu předmětů, odhadovaného věku osoby z její tváře nebo dokonce poznali výrazy obličeje této osoby.
Možná si uvědomujete, že pokaždé, když se pokusíte označit tvář svého přítele na fotografii, funkce na Facebooku to udělala za vás, tedy označení tváře vašeho přítele, aniž byste jej museli nejprve označit. Toto je rozpoznávání tváře, které používá Facebook, aby nám usnadnil označování přátel.
Jak to tedy funguje? Pokaždé, když označíme tvář našeho přítele, AI Facebooku se to naučí a pokusí se to předpovědět, dokud nedosáhne správného výsledku. Stejný systém, který použijeme k vytvoření vlastního rozpoznávání tváře. Začněme vytvářet vlastní rozpoznávání tváře pomocí hlubokého učení
Model sítě
Použijeme síťový model VGG16, ale s váhou VGGFace.
Architektura modelu VGG16
Co je VGGFace? je to Keras implementace Deep Face Recognition představená Parkhi, Omkar M. et al. "Deep Face Recognition." BMVC (2015). Framework používá jako síťovou architekturu VGG16.
VGGFace si můžete stáhnout z 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()
Jak můžete vidět shrnutí sí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, 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):
uděláme a Přenos učení + Jemné ladění pro rychlejší školení s malými datovými soubory. Nejprve zmrazíme základní vrstvy, aby vrstvy nebyly trénovatelné.
for layer in face_model.layers:
layer.trainable = False
pak přidáme vlastní vrstvu, abychom rozpoznali naše testovací tváře. Přidáme 2 plně propojené vrstvy a výstupní vrstvu s 5 lidmi k detekci.
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)
Podívejme se na přehled naší sí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
Jak můžete vidět výše, po vrstvě pool5 bude sloučena do jediného vektoru prvků, který použije hustá vrstva pro konečné rozpoznání.
Příprava našich tváří
Nyní si připravíme obličeje. Vytvořil jsem adresář složený z 5 slavných lidí
- Jack Ma
- Jason Statham
- Johnny Depp
- Robert Downey Jr
- Rowan Atkinson
Každá složka obsahuje 10 obrázků pro každý proces školení a hodnocení. Je to velmi malé množství dat, ale to je výzva, ne?
K přípravě dat nám pomůže nástroj Keras. Tato funkce bude iterovat ve složce datové sady a poté ji připravit tak, aby ji bylo možné použít při školení.
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,
)
Školení našeho modelu
Začněme náš tréninkový proces sestavením naší sítě s funkcí ztráty a optimalizátorem. Zde používáme sparse_categorical_crossentropy jako naši ztrátovou funkci s pomocí SGD jako našeho optimalizátoru učení.
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
Jak můžete vidět, naše přesnost ověření je až 64 %, což je dobrý výsledek pro malé množství tréninkových dat. Můžeme to zlepšit přidáním další vrstvy nebo přidáním více tréninkových obrázků, aby se náš model mohl dozvědět více o tvářích a dosáhnout větší přesnosti.
Pojďme otestovat náš model testovacím obrázkem
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']
pomocí obrázku Roberta Downeyho Jr. jako našeho testovacího obrázku ukazuje, že předpovídaná tvář je pravdivá!
Predikce pomocí Live Cam!
Co kdybychom otestovali naši dovednost s implementací pomocí vstupu z webové kamery? Pomocí OpenCV s kaskádou Haar Face k nalezení naší tváře a pomocí našeho síťového modelu dokážeme rozpoznat osobu.
Prvním krokem je připravit tváře vás a vašeho přítele. Čím více dat máme, tím lepší je výsledek!
Připravte a trénujte svou síť jako v předchozím kroku, po dokončení školení přidejte tento řádek, abyste získali vstupní obraz z kamery
#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()
Který je lepší? Keras nebo Tensorflow
Keras nabízí jednoduchost při psaní scénáře. Můžeme začít psát a rozumět přímo s Kerasem, protože to není tak těžké pochopit. Je uživatelsky přívětivější a snadno se implementuje, není třeba vytvářet mnoho proměnných pro spuštění modelu. Takže nemusíme rozumět každému detailu v backendovém procesu.
Na druhou stranu, Tensorflow jsou operace na nízké úrovni, které nabízejí flexibilitu a pokročilé operace, pokud chcete vytvořit libovolný výpočetní graf nebo model. Tensorflow také dokáže vizualizovat proces pomocí TensorBoard a specializovaný debugger nástroj.
Pokud tedy chcete začít pracovat s hlubokým učením s ne tak velkou složitostí, použijte Keras. Protože Keras nabízí jednoduchost a uživatelsky přívětivé použití a snadnou implementaci než Tensorflow. Ale pokud chcete napsat svůj vlastní algoritmus v projektu hlubokého učení nebo výzkumu, měli byste místo toho použít Tensorflow.
Shrnutí
Pojďme si tedy shrnout vše, co jsme probrali a udělali v tomto tutoriálu.
- Keras v API na vysoké úrovni, které se používá k usnadnění sítí hlubokého učení pomocí backendového enginu.
- Keras se snadno používá a rozumí s podporou pythonu, takže působí přirozeněji než kdy jindy. Je to dobré pro začátečníky, kteří se chtějí dozvědět o hlubokém učení, a pro výzkumníky, kteří chtějí snadno použitelné API.
- Proces instalace je snadný a můžete použít virtuální prostředí nebo pomocí externí platformy jako je např AWS.
- Keras také přichází s různými druhy síťových modelů, takže nám usnadňuje použití dostupného modelu pro předtrénování a dolaďování vlastního síťového modelu.
- Existuje také mnoho návodů a článků o používání Keras od komunit po celém světě pro účely hlubokého učení.
