Keras Урок: Какво е Keras? Как да инсталирате в Python [Пример]
Евелин Кларк
Какво е Keras?
Keras е библиотека за невронни мрежи с отворен код, написана на Python който работи върху Theano или Tensorflow. Той е проектиран да бъде модулен, бърз и лесен за използване. Разработен е от Франсоа Шоле, инженер на Google. Keras не обработва изчисления на ниско ниво. Вместо това, той използва друга библиотека, за да го направи, наречена „Backend.
Keras е API обвивка на високо ниво за API на ниско ниво, способна да работи върху TensorFlow, CNTK или Theano. Keras High-Level API управлява начина, по който правим модели, дефинираме слоеве или настройваме множество входно-изходни модели. В това ниво Keras също компилира нашия модел с функции за загуба и оптимизиране, процес на обучение с функция за прилягане. Керас в Python не обработва API на ниско ниво, като например създаване на изчислителна графика, създаване на тензори или други променливи, тъй като е обработено от „backend“ двигателя.
Какво е Backend?
Backend е термин в Keras, който извършва всички изчисления на ниско ниво, като тензорни продукти, навивки и много други неща с помощта на други библиотеки като Tensorflow или Theano. Така че „бекенд двигателят“ ще извърши изчислението и разработването на моделите. Tensorflow е „backend engine“ по подразбиране, но можем да го променим в конфигурацията.
Theano, Tensorflow и CNTK Backend
Theano е проект с отворен код, разработен от групата MILA в Университета на Монреал, Квебек, Канада. Това беше първата широко използвана рамка. Това е а Python библиотека, която помага в многомерни масиви за математически операции с помощта на Numpy или Scipy. Theano може да използва GPU за по-бързо изчисление, също така може автоматично да изгражда символни графики за изчисляване на градиенти. На своя уебсайт Theano твърди, че може да разпознава числено нестабилни изрази и да ги изчислява с по-стабилни алгоритми, това е много полезно за нашите нестабилни изрази.
От друга страна, Tensorflow е изгряващата звезда в рамките на дълбокото обучение. Разработен от екипа на Google Brain, той е най-популярният инструмент за дълбоко обучение. С много функции и изследователите допринасят за разработването на тази рамка за целите на задълбочено обучение.
Друг бекенд двигател за Keras е The Microsoft Когнитивен инструментариум или CNTK. Това е рамка за дълбоко обучение с отворен код, разработена от Microsoft Екип. Може да работи на няколко графични процесора или на няколко машини за обучение на модел за дълбоко обучение в огромен мащаб. В някои случаи CNTK се съобщава по-бързо от други рамки като Tensorflow или Theano. След това в този урок на Keras CNN ще сравним бекенда на Theano, TensorFlow и CNTK.
Сравняване на задните части
Трябва да направим бенчмарк, за да разберем сравнението между тези два бекенда. Както можете да видите в Бенчмаркът на Jeong-Yoon Lee, сравнява се производителността на 3 различни бекенда на различен хардуер. И резултатът е, че Theano е по-бавен от другия бекенд, се съобщава 50 пъти по-бавни, но точността е близка една до друга.
Друг бенчмарк тест се извършва от Джасмит Бхатия. Той съобщи, че Theano е по-бавен от Tensorflow за някои тестове. Но общата точност е почти еднаква за всяка мрежа, която е била тествана.
И така, между Theano, Tensorflow и CTK е очевидно, че TensorFlow е по-добър от Theano. С TensorFlow времето за изчисление е много по-кратко и CNN е по-добър от останалите.
Следващият в този Keras Python урок, ще научим за разликата между Keras и TensorFlow (Keras срещу Tensorflow).
Keras срещу Tensorflow
| параметри | Keras | Тензорен поток |
|---|---|---|
| Тип | API обвивка на високо ниво | API на ниско ниво |
| Сложност | Лесен за използване, ако Python език | Трябва да научите синтаксиса за използване на някои от функциите на Tensorflow |
| Цел | Бързо разгръщане за създаване на модел със стандартни слоеве | Позволява ви да направите произволна изчислителна графика или модели на слоеве |
| Инструменти | Използва друг API инструмент за отстраняване на грешки като TFDBG | Можете да използвате инструменти за визуализация на Tensorboard |
| общност | Големи активни общности | Големи активни общности и широко споделени ресурси |
Предимства на Keras
Бързо разгръщане и лесно за разбиране
Keras много бързо прави мрежов модел. Ако искате да направите прост мрежов модел с няколко реда, Python Keras може да ви помогне с това. Вижте примера на Keras по-долу:
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'))
Благодарение на приятелския API, можем лесно да разберем процеса. Писане на кода с проста функция и без необходимост от задаване на множество параметри.
Подкрепа за голяма общност
Има много общности на AI, които използват Keras за своята рамка за дълбоко обучение. Много от тях публикуват своите кодове, както и уроци за широката публика.
Имайте множество бекендове
Можете да изберете Tensorflow, CNTK и Theano като ваш бекенд с Keras. Можете да изберете различен бекенд за различни проекти в зависимост от вашите нужди. Всеки бекенд има свое уникално предимство.
Междуплатформено и лесно внедряване на модела
С разнообразие от поддържани устройства и платформи можете да разположите Keras на всяко устройство като
- iOS с CoreML
- Android с Tensorflow Android,
- Уеб браузър с поддръжка на .js
- Облачен двигател
- Raspberry Pi
Поддръжка на няколко GPU
Можете да тренирате Keras на един GPU или да използвате няколко GPU наведнъж. Тъй като Keras има вградена поддръжка за паралелизъм на данни, така че може да обработва големи обеми данни и да ускорява времето, необходимо за обучението им.
Недостатъци на Keras
Не може да се справи с API на ниско ниво
Keras обработва само API на високо ниво, който работи върху друга рамка или бекенд двигател, като Tensorflow, Theano или CNTK. Така че не е много полезно, ако искате да направите свой собствен абстрактен слой за вашите изследователски цели, защото Keras вече има предварително конфигурирани слоеве.
Инсталиране на Keras
В този раздел ще разгледаме различни налични методи за инсталиране на Keras
Директна инсталация или виртуална среда
Кое е по-добро? Директно инсталиране на текущия Python или използване на виртуална среда? Предлагам да използвате виртуална среда, ако имате много проекти. Искате ли да знаете защо? Това е така, защото различните проекти могат да използват различна версия на библиотека keras.
Например, имам проект, който се нуждае Python 3.5 с помощта на OpenCV 3.3 с по-стар бекенд на Keras-Theano, но в другия проект трябва да използвам Keras с най-новата версия и Tensorflow като бекенд с Python Поддръжка на 3.6.6
Не искаме библиотеката на Keras да влиза в конфликт една с друга, нали? Така че ние използваме виртуална среда, за да локализираме проекта със специфичен тип библиотека или можем да използваме друга платформа, като Cloud Service, за да направи изчисленията си вместо нас, като Amazon Уеб услуга.
Инсталиране на Keras на Amazon Уеб услуга (AWS)
Amazon Уеб услугата е платформа, която предлага услуги и продукти за облачни изчисления за изследователи или всякакви други цели. AWS наема техния хардуер, мрежи, база данни и т.н., за да можем да ги използваме директно от интернет. Една от популярните услуги на AWS за целите на дълбокото обучение е Amazon Machine Image Deep Learning Service или DL
За подробни инструкции как да използвате AWS вижте това настойнически
Бележка за AMI: Ще имате наличен следния AMI
AWS Deep Learning AMI е виртуална среда в услугата AWS EC2, която помага на изследователи или практици да работят с Deep Learning. DLAMI предлага от двигател с малки процесори до мощни двигатели с множество графични процесори с предварително конфигурирани CUDA, cuDNN и се предлага с различни рамки за дълбоко обучение.
Ако искате да го използвате незабавно, трябва да изберете Deep Learning AMI, защото той идва предварително инсталиран с популярни рамки за дълбоко обучение.
Но ако искате да изпробвате персонализирана рамка за задълбочено обучение за изследвания, трябва да инсталирате Deep Learning Base AMI, защото идва с основни библиотеки като CUDA, cuDNN, драйвери на GPU и други необходими библиотеки, които да работят с вашата среда за задълбочено обучение.
Как да инсталирате Keras на Amazon SageMaker
Amazon SageMaker е платформа за задълбочено обучение, която ви помага с обучението и внедряването на мрежа за задълбочено обучение с най-добрия алгоритъм.
Като начинаещ това е най-лесният метод за използване на Keras. По-долу е описан процес за инсталиране на Keras Amazon SageMaker:
Стъпка 1) Отворете Amazon SageMaker
В първата стъпка отворете Amazon Sagemaker конзола и щракнете върху Създаване на екземпляр на бележник.
Стъпка 2) Въведете подробностите
- Въведете името на вашия бележник.
- Създайте IAM роля. Това ще създаде роля на AMI Amazon IAM роля във формата на AmazonSageMaker-Executionrole-ГГГГММДД|ЧЧмСС.
- Накрая изберете Създаване на екземпляр на бележник. След няколко мига, Amazon Sagemaker стартира екземпляр на бележник.
Забележка: Ако искате да получите достъп до ресурси от вашия VPC, задайте директния достъп до интернет като разрешен. В противен случай този екземпляр на преносим компютър няма да има достъп до интернет, така че е невъзможно да се обучават или хостват модели
Стъпка 3) Стартирайте екземпляра
Кликнете върху Отвори, за да стартирате екземпляра
Стъпка 4) Започнете кодирането
In Jupyter, Щракнете върху New> conda_tensorflow_p36 и сте готови да кодирате
Инсталирайте Keras в Linux
За да активираме Keras с Tensorflow като негов бекенд двигател, първо трябва да инсталираме Tensorflow. Изпълнете тази команда, за да инсталирате tensorflow с CPU (без GPU)
pip install --upgrade tensorflow
ако искате да активирате поддръжката на GPU за tensorflow, можете да използвате тази команда
pip install --upgrade tensorflow-gpu
нека се регистрираме Python за да видим дали нашата инсталация е успешна, като напишете
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 >>>
ако няма съобщение за грешка, инсталационният процес е успешен
Инсталирайте Keras
След като инсталираме Tensorflow, нека започнем да инсталираме keras. Въведете тази команда в терминала
pip install keras
ще започне да инсталира Keras, а също и всички негови зависимости. Трябва да видите нещо подобно:
Вече имаме Keras инсталиран в нашата система!
Проверка
Преди да започнем да използваме Keras, трябва да проверим дали нашите Keras използват Tensorflow като бекенд, като отворим конфигурационния файл:
gedit ~/.keras/keras.json
трябва да видите нещо подобно
{
"floatx": "float32",
"epsilon": 1e-07,
"backend": "tensorflow",
"image_data_format": "channels_last"
}
както можете да видите, „backend“ използва tensorflow. Това означава, че keras използва Tensorflow като бекенд, както очаквахме
и сега го стартирайте на терминала, като напишете
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. >>>
Как да инсталирате Keras на Windows
Преди да инсталираме Тензорен поток и Keras, трябва да инсталираме Python, pip и virtualenv. Ако вече сте инсталирали тези библиотеки, трябва да продължите към следващата стъпка, в противен случай направете следното:
Инсталирайте Python 3 чрез изтегляне от това връзка
Инсталирайте pip чрез стартиране това
Инсталирайте virtualenv с тази команда
pip3 install –U pip virtualenv
Инсталирайте Microsoft зрителен C++ Актуализация 2015 за повторно разпространение от 3 г
- Отидете на сайта за изтегляне на Visual Studio https://www.microsoft.com/en-us/download/details.aspx?id=53587
- Изберете Redistributables и Build Tools
- Изтеглете и инсталирайте Microsoft зрителен C++ Актуализация 2015 за повторно разпространение от 3 г
След това стартирайте този скрипт
pip3 install virtualenv
Настройка на виртуална среда
Това се използва за изолиране на работната система от основната система.
virtualenv –-system-site-packages –p python3 ./venv
Активирайте средата
.\venv\Scripts\activate
След подготовката на средата инсталацията на Tensorflow и Keras остава същата като Linux. След това в този урок за задълбочено обучение с Keras ще научим за основите на Keras за задълбочено обучение.
Основи на Keras за дълбоко обучение
Основната структура в Keras е моделът, който дефинира пълната графика на мрежа. Можете да добавите повече слоеве към съществуващ модел, за да изградите персонализиран модел, който ви е необходим за вашия проект.
Ето как да направите последователен модел и няколко често използвани слоя в дълбокото обучение
1. Последователен модел
from keras.models import Sequential from keras.layers import Dense, Activation,Conv2D,MaxPooling2D,Flatten,Dropout model = Sequential()
2. Конволюционен слой
Това е Керас Python пример за конволюционен слой като входен слой с входна форма 320x320x3, с 48 филтъра с размер 3×3 и използване на ReLU като функция за активиране.
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))
друг тип е
model.add(Conv2D(48, (3, 3), activation='relu'))
3. МаксPooling Слой
За да намалите входното представяне, използвайте MaxPool2d и задайте размера на ядрото
model.add(MaxPooling2D(pool_size=(2, 2)))
4. Плътен слой
добавяне на напълно свързан слой само с посочване на изходния размер
model.add(Dense(256, activation='relu'))
5. Отпадащ слой
Добавяне на отпадащ слой с 50% вероятност
model.add(Dropout(0.5))
Компилиране, обучение и оценка
След като дефинираме нашия модел, нека започнем да ги обучаваме. Изисква се първо да се компилира мрежата с функцията за загуба и функцията за оптимизиране. Това ще позволи на мрежата да променя теглата и ще минимизира загубата.
model.compile(loss='mean_squared_error', optimizer='adam')
Сега, за да започнете обучението, използвайте fit, за да подадете данните за обучение и валидиране към модела. Това ще ви позволи да обучавате мрежата на партиди и да задавате епохи.
model.fit(X_train, X_train, batch_size=32, epochs=10, validation_data=(x_val, y_val))
Последната ни стъпка е да оценим модела с данните от теста.
score = model.evaluate(x_test, y_test, batch_size=32)
Нека опитаме да използваме проста линейна регресия
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()
След обучение на данните изходът трябва да изглежда така
с първоначалното тегло
Linear regression model is initialized with weights w: 0.37, b: 0.00
и крайно тегло
Linear regression model is trained to have weight w: 3.70, b: 0.61
Фина настройка на предварително обучени модели в Keras и как да ги използвате
Защо използваме модели за фина настройка и кога ги използваме
Фината настройка е задача за настройване на предварително обучен модел, така че параметрите да се адаптират към новия модел. Когато искаме да обучим от нулата на нов модел, имаме нужда от голямо количество данни, така че мрежата да може да намери всички параметри. Но в този случай ще използваме предварително обучен модел, така че параметрите вече са научени и имат тежест.
Например, ако искаме да обучим нашия собствен модел Keras за решаване на проблем с класификацията, но имаме само малко количество данни, тогава можем да решим това, като използваме Прехвърляне на обучение + Метод за фина настройка.
Използвайки предварително обучена мрежа и тежести, не е необходимо да тренираме цялата мрежа. Просто трябва да обучим последния слой, който се използва за решаване на нашата задача, както го наричаме метод за фина настройка.
Подготовка на мрежов модел
За предварително обучения модел можем да заредим различни модели, които Keras вече има в своята библиотека, като например:
- VGG16
- Начало V3
- ResNet
- MobileNet
- Xception
- InceptionResNetV2
Но в този процес ще използваме мрежов модел VGG16 и imageNet като тегло за модела. Ще настроим фино мрежа, за да класифицираме 8 различни типа класове, използвайки изображения от Kaggle Natural Images Dataset
Архитектура на модела VGG16
Качване на нашите данни в AWS S3 Bucket
За нашия процес на обучение ще използваме картина на природни изображения от 8 различни класа като самолети, кола, котка, куче, цвете, плод, мотоциклет и човек. Първо, трябва да качим нашите данни в Amazon S3 кофа.
Amazon S3 кофа
Стъпка 1) След като влезете във вашия S3 акаунт, нека създадем кофа чрез часовник Създаване на кофа
Стъпка 2) Сега изберете име на кофа и вашия регион според вашия акаунт. Уверете се, че името на кофата е налично. След това щракнете Създаване.
Стъпка 3) Както можете да видите, вашата кофа е готова за използване. Но както можете да видите, достъпът не е публичен, добре е за вас, ако искате да го запазите личен за себе си. Можете да промените тази кофа за публичен достъп в свойствата на кофата
Стъпка 4) Сега започвате да качвате вашите тренировъчни данни в Bucket. Тук ще кача файла tar.gz, който се състои от снимки за процеса на обучение и тестване.
Стъпка 5) Сега щракнете върху вашия файл и копирайте връзка за да можем да го изтеглим.
Подготовка на данните
Трябва да генерираме нашите данни за обучение с помощта на Keras ImageDataGenerator.
Първо трябва да изтеглите с помощта на wget с връзката към вашия файл от S3 Bucket.
!wget https://s3.us-east-2.amazonaws.com/naturalimages02/images.tar.gz !tar -xzf images.tar.gz
След като изтеглите данните, нека започнем процеса на обучение.
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 ще направи X_training данни от директория. Поддиректорията в тази директория ще се използва като клас за всеки обект. Изображението ще бъде заредено с цветовия режим RGB, с режима на категоричен клас за данните за Y_training, с размер на партидата 16. Накрая разбъркайте данните.
Нека да видим нашите изображения на случаен принцип, като ги начертаем с 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()
След това нека създадем нашия мрежов модел от VGG16 с предварително обучено тегло на imageNet. Ние ще замразим тези слоеве, така че слоевете да не могат да се обучават, за да ни помогне да намалим времето за изчисление.
Създаване на нашия модел от 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())
Както можете да видите по-долу, обобщението на нашия мрежов модел. От вход от VGG16 слоеве след това добавяме 2 напълно свързани слоя, които ще извлекат 1024 функции и изходен слой, който ще изчисли 8-те класа с активирането на 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
Обучение
# # 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()
Резултати
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
Както можете да видите, нашите загуби са намалели значително и точността е почти 100%. За тестване на нашия модел произволно избрахме изображения в интернет и ги поставихме в тестовата папка с различен клас за тестване
Тестване на нашия модел
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()
И нашият тест е даден по-долу! Само 1 изображение е предвидено грешно от тест от 14 изображения!
Невронна мрежа за разпознаване на лица с Keras
Защо имаме нужда от Признание
Имаме нужда от разпознаване, за да ни улесни в разпознаването или идентифицирането на лицето на човек, вида на обектите, приблизителната възраст на човек по лицето му или дори да познаваме изражението на лицето на това лице.
Може би осъзнавате, че всеки път, когато се опитате да маркирате лицето на ваш приятел в снимка, функцията във Facebook го е направила вместо вас, която маркира лицето на вашия приятел, без да е необходимо вие да го маркирате първо. Това е разпознаване на лица, прилагано от Facebook, за да ни улесни при тагването на приятели.
И така, как работи? Всеки път, когато маркираме лицето на наш приятел, AI на Facebook ще го научи и ще се опита да го предвиди, докато получи правилния резултат. Същата система ще използваме, за да направим нашето собствено разпознаване на лица. Нека започнем да създаваме наше собствено разпознаване на лица с помощта на Deep Learning
Мрежов модел
Ще използваме мрежов модел VGG16, но с тегло VGGFace.
Архитектура на модела VGG16
Какво е VGGFace? това е изпълнението на Keras на Deep Face Recognition, въведено от Parkhi, Omkar M. et al. „Дълбоко разпознаване на лица.“ BMVC (2015). Рамката използва VGG16 като мрежова архитектура.
Можете да изтеглите VGGFace от 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()
Както можете да видите обобщението на мрежата
_________________________________________________________________ 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):
ще направим а Прехвърляне на обучение + Фина настройка за по-бързо обучение с малки набори от данни. Първо, ще замразим базовите слоеве, така че слоевете да не могат да се тренират.
for layer in face_model.layers:
layer.trainable = False
след това добавяме наш собствен слой, за да разпознаем нашите тестови лица. Ще добавим 2 напълно свързани слоя и изходен слой с 5 души за откриване.
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)
Нека видим обобщението на нашата мрежа
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
Както можете да видите по-горе, след слоя pool5, той ще бъде изравнен в един вектор на характеристиките, който ще бъде използван от плътния слой за окончателното разпознаване.
Подготовка на нашите лица
Сега нека подготвим лицата си. Направих директория, състояща се от 5 известни хора
- Джак Ма
- Джейсън Стейтъм
- Джони Деп
- Робърт Дауни-младши
- Rowan Atkinson
Всяка папка съдържа 10 снимки за всеки процес на обучение и оценка. Това е много малко количество данни, но това е предизвикателството, нали?
Ще използваме помощта на инструмента Keras, за да ни помогне да подготвим данните. Тази функция ще повтори папката с набор от данни и след това ще я подготви, за да може да се използва в обучението.
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,
)
Обучение на нашия модел
Нека започнем нашия процес на обучение, като компилираме нашата мрежа с функция за загуба и оптимизатор. Тук използваме sparse_categorical_crossentropy като функция за загуба с помощта на SGD като наш оптимизатор на обучение.
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
Както можете да видите, нашата точност на валидиране е до 64%, това е добър резултат за малко количество данни за обучение. Можем да подобрим това, като добавим още слой или добавим повече изображения за обучение, така че нашият модел да може да научи повече за лицата и да постигне повече точност.
Нека тестваме нашия модел с тестова снимка
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']
използвайки снимката на Робърт Дауни младши като наша тестова снимка, тя показва, че прогнозираното лице е вярно!
Прогноза с помощта на Live Cam!
Какво ще кажете, ако тестваме уменията си с прилагането му с вход от уеб камера? Използвайки OpenCV с каскада Haar Face, за да намерим лицето си и с помощта на нашия мрежов модел можем да разпознаем човека.
Първата стъпка е да подготвите лицата на себе си и на вашия приятел. Колкото повече данни имаме, толкова по-добър е резултатът!
Подгответе и обучете вашата мрежа като предишната стъпка, след като обучението приключи, добавете този ред, за да получите входното изображение от камерата
#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()
Кое е по-добро? Keras или Tensorflow
Keras предлага простота при писане на скрипта. Можем да започнем да пишем и разбираме директно с Keras, тъй като не е твърде трудно за разбиране. Той е по-удобен за потребителя и лесен за изпълнение, няма нужда да правите много променливи, за да стартирате модела. Така че не е необходимо да разбираме всеки детайл в процеса на бекенда.
От друга страна, Tensorflow е операциите на ниско ниво, които предлагат гъвкавост и разширени операции, ако искате да направите произволна изчислителна графика или модел. Tensorflow също може да визуализира процеса с помощта на TensorBoard и специализиран инструмент за отстраняване на грешки.
Така че, ако искате да започнете да работите с дълбоко обучение с не толкова голяма сложност, използвайте Keras. Тъй като Keras предлага простота и лесен за използване и лесен за внедряване от Tensorflow. Но ако искате да напишете свой собствен алгоритъм в проект или изследване за дълбоко обучение, трябва да използвате Tensorflow вместо това.
Oбобщение
Така че нека обобщим всичко, което обсъдихме и направихме в този урок.
- Keras в API на високо ниво, който се използва за улесняване на мрежите за дълбоко обучение с помощта на бекенд двигател.
- Keras е лесен за използване и разбиране с поддръжка на Python, така че се чувства по-естествено от всякога. Добре е за начинаещи, които искат да научат за задълбочено обучение, и за изследователи, които искат лесен за използване API.
- Процесът на инсталиране е лесен и можете да използвате виртуална среда или да използвате външна платформа като напр AWS.
- Keras също идва с различни видове мрежови модели, така че ни улеснява да използваме наличния модел за предварително обучение и фина настройка на нашия собствен мрежов модел.
- Освен това има много уроци и статии за използването на Keras от кодове на общности по целия свят за целите на дълбокото обучение.
