Підручник Keras: що таке Keras? Як встановити в Python [Приклад]

Що таке Керас?

Керас це бібліотека нейронної мережі з відкритим вихідним кодом, написана в Python який працює поверх Theano або Tensorflow. Він розроблений як модульний, швидкий і простий у використанні. Його розробив Франсуа Шолле, інженер Google. Keras не обробляє низькорівневі обчислення. Натомість для цього використовується інша бібліотека, яка називається «Backend.

Keras — це високорівнева оболонка API для низькорівневого API, здатна працювати поверх TensorFlow, CNTK або Theano. Keras High-Level API керує тим, як ми створюємо моделі, визначаємо шари або налаштовуємо кілька моделей введення-виведення. На цьому рівні Keras також компілює нашу модель із функціями втрат і оптимізатора, навчальний процес із функцією підгонки. Керас в Python не обробляє API низького рівня, як-от створення обчислювального графіка, створення тензорів або інших змінних, оскільки це було оброблено механізмом «backend».

Що таке бекенд?

Бекенд — це термін у Keras, який виконує всі обчислення низького рівня, такі як тензорні добутки, згортки та багато іншого, за допомогою інших бібліотек, таких як Tensorflow або Theano. Отже, «серверний механізм» виконуватиме обчислення та розробку моделей. Tensorflow є «серверним двигуном» за замовчуванням, але ми можемо змінити його в конфігурації.

Theano, Tensorflow і CNTK Backend

Theano — це проект із відкритим вихідним кодом, розроблений групою MILA з Монреальського університету, Квебек, Канада. Це був перший широко використовуваний фреймворк. Це а Python бібліотека, яка допомагає в багатовимірних масивах для математичних операцій за допомогою Numpy або Scipy. Theano може використовувати графічні процесори для швидшого обчислення, він також може автоматично будувати символічні графіки для обчислення градієнтів. На своєму веб-сайті Theano стверджує, що він може розпізнавати чисельно нестабільні вирази та обчислювати їх за допомогою більш стабільних алгоритмів, це дуже корисно для наших нестабільних виразів.

З іншого боку, Tensorflow є висхідною зіркою в структурі глибокого навчання. Розроблений командою Google Brain, це найпопулярніший інструмент глибокого навчання. З багатьма функціями, і дослідники допомагають розробити цю структуру для цілей глибокого навчання.

Ще один серверний механізм для Keras — The Microsoft Cognitive Toolkit або CNTK. Це платформа глибокого навчання з відкритим кодом, розроблена Microsoft Команда. Він може працювати на кількох графічних процесорах або на кількох машинах для навчання моделі глибокого навчання у великому масштабі. У деяких випадках повідомлялося, що CNTK швидше, ніж інші фреймворки, такі як Tensorflow або Theano. Далі в цьому підручнику Keras CNN ми порівняємо серверні програми Theano, TensorFlow і CNTK.

Порівняння бекендів

Нам потрібно провести порівняльний тест, щоб порівняти ці два сервери. Як ви бачите в Еталон Чон-Юн Лі, порівнюється продуктивність 3 різних серверних модулів на різному обладнанні. Повідомляється, що в результаті Theano працює повільніше, ніж інший бекенд 50 раз повільніше, але точність близька один до одного.

Інший еталонний тест виконується Джасміт Бхатія. Він повідомив, що Theano повільніше, ніж Tensorflow для деяких тестів. Але загальна точність майже однакова для кожної перевіреної мережі.

Отже, між Theano, Tensorflow і CTK очевидно, що TensorFlow кращий за Theano. З TensorFlow час обчислення набагато коротший, а CNN кращий за інші.

Далі в цьому Керасі Python навчальний посібник, ми дізнаємося про різницю між Keras і TensorFlow (Keras проти Tensorflow).

Keras проти Tensorflow

параметри	Керас	Тензорний потік
тип	Високорівнева оболонка 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 ми можемо легко зрозуміти процес. Написання коду за допомогою простої функції без необхідності встановлювати кілька параметрів.

Велика підтримка спільноти

Є багато спільнот ШІ, які використовують Keras для своєї системи Deep Learning. Багато з них публікують свої коди, а також навчальні посібники для широкої публіки.

Майте кілька серверних програм

Ви можете вибрати Tensorflow, CNTK і Theano як серверну частину з Keras. Залежно від ваших потреб ви можете вибрати різний бекенд для різних проектів. Кожен бекенд має свої унікальні переваги.

Кросплатформенність і просте розгортання моделі

Завдяки різноманітності підтримуваних пристроїв і платформ ви можете розгорнути Keras на будь-якому пристрої, наприклад

• iOS з CoreML
• Android з Tensorflow Android,
• Веб-браузер із підтримкою .js
• Хмарний двигун
• Raspberry Pi

Підтримка кількох графічних процесорів

Ви можете навчити Keras на одному графічному процесорі або використовувати кілька графічних процесорів одночасно. Оскільки 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 Service, яке допомагає дослідникам і практикам працювати з глибоким навчанням. DLAMI пропонує механізми від невеликих процесорів до потужних механізмів із декількома графічними процесорами з попередньо налаштованими CUDA, cuDNN, а також поставляється з різними фреймворками глибокого навчання.

Якщо ви хочете використовувати його миттєво, вам слід вибрати Deep Learning AMI, оскільки він постачається з попередньо встановленими популярними фреймворками глибокого навчання.

Але якщо ви хочете спробувати спеціальну структуру глибокого навчання для дослідження, вам слід встановити Deep Learning Base AMI, оскільки вона постачається з фундаментальними бібліотеками, такими як CUDA, cuDNN, драйвери графічних процесорів та іншими бібліотеками, необхідними для роботи у вашому середовищі глибокого навчання.

Як встановити Keras на Amazon SageMaker

Amazon SageMaker — це платформа глибокого навчання, яка допоможе вам у навчанні та розгортанні мережі глибокого навчання за допомогою найкращого алгоритму.

Для початківців це, безумовно, найпростіший спосіб використання Keras. Нижче описано процес встановлення Keras Amazon SageMaker:

Крок 1) Відкрийте Amazon SageMaker

На першому кроці відкрийте Amazon Шалфейник консолі та натисніть «Створити екземпляр блокнота».

Крок 2) Введіть дані

1. Введіть назву свого блокнота.
2. Створіть роль IAM. Це створить роль AMI Amazon Роль IAM у форматі AmazonSageMaker-Executionrole-РРРРММДД|ГГХМСС.
3. Нарешті виберіть «Створити екземпляр блокнота». Через кілька хвилин Amazon Sagemaker запускає екземпляр блокнота.

Примітка:: якщо ви хочете отримати доступ до ресурсів зі свого VPC, увімкніть прямий доступ до Інтернету. Інакше цей екземпляр блокнота не матиме доступу до Інтернету, тому неможливо навчати або розміщувати моделі

Крок 3) Запустіть примірник

Натисніть «Відкрити», щоб запустити екземпляр

Крок 4) Почніть кодування

In JupyterНатисніть New> conda_tensorflow_p36, і ви готові до кодування

Встановіть Keras у Linux

Щоб увімкнути Keras із Tensorflow як серверним механізмом, нам потрібно спочатку встановити Tensorflow. Виконайте цю команду, щоб установити tensorflow із ЦП (без графічного процесора)

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

як бачите, «сервер» використовує 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 фільтрами розміром 3x3 і використанням 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 і як ними користуватися

Чому ми використовуємо моделі Fine Tune і коли ми їх використовуємо

Тонка настройка — це завдання налаштувати попередньо навчену модель таким чином, щоб параметри адаптувалися до нової моделі. Коли ми хочемо навчитися з нуля на новій моделі, нам потрібна велика кількість даних, щоб мережа могла знайти всі параметри. Але в цьому випадку ми будемо використовувати попередньо навчену модель, тому параметри вже вивчені та мають вагу.

Наприклад, якщо ми хочемо навчити нашу власну модель Keras вирішувати проблему класифікації, але у нас є лише невелика кількість даних, ми можемо вирішити це за допомогою Трансферне навчання + Метод тонкої настройки.

Використовуючи попередньо підготовлену мережу та ваги, нам не потрібно тренувати всю мережу. Нам просто потрібно навчити останній рівень, який використовується для вирішення нашого завдання, як ми називаємо це методом тонкої настройки.

Підготовка моделі мережі

Для попередньо навченої моделі ми можемо завантажити різноманітні моделі, які вже є у бібліотеці Keras, наприклад:

• VGG16
• Початок V3
• ResNet
• MobileNet
• Xception
• InceptionResNetV2

Але в цьому процесі ми будемо використовувати модель мережі VGG16 і imageNet як нашу вагу для моделі. Ми точно налаштуємо мережу для класифікації 8 різних типів класів за допомогою зображень із Набір даних природних зображень Kaggle

Архітектура моделі VGG16

джерело

Завантаження наших даних у сегмент AWS S3

Для нашого навчального процесу ми будемо використовувати зображення природних зображень із 8 різних класів, таких як літаки, машини, кішки, собаки, квіти, фрукти, мотоцикли та людини. По-перше, нам потрібно завантажити наші дані Amazon S3 Відро.

Amazon S3 Ківш

Крок 1) Після входу в обліковий запис S3 давайте створимо відро за тактуванням Створити відро

Крок 2) Тепер виберіть назву сегмента та свій регіон відповідно до свого облікового запису. Переконайтеся, що назва сегмента доступна. Після цього натисніть Створити.

Крок 3) Як бачите, ваш Bucket готовий до використання. Але, як бачите, доступ не є публічним, це добре для вас, якщо ви хочете зберегти його приватним для себе. Ви можете змінити це відро для загального доступу у властивостях відра

Крок 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)

Дані зображенняGenerator зробить дані 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, щоб полегшити нам позначення друзів.

Отже, як це працює? Щоразу, коли ми позначаємо обличчя нашого друга, штучний інтелект Facebook вивчатиме це та намагатиметься передбачити, доки не отримає правильний результат. Цю ж систему ми будемо використовувати для створення власного розпізнавання обличчя. Давайте почнемо створювати наше власне розпізнавання обличчя за допомогою глибокого навчання

Модель мережі

Ми будемо використовувати мережеву модель VGG16, але з вагою VGGFace.

Архітектура моделі VGG16

Що таке VGGFace? це реалізація Keras Deep Face Recognition, представлена ​​Паркхі, Омкар М. та ін. «Глибоке розпізнавання обличчя». 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 відомих людей

• Джек Ма
• Джейсон Стетхем
• Джонні Депп
• Роберт Дауні-молодший
• Роуен Аткінсон

Кожна папка містить 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.

Підсумки

Отже, давайте підсумуємо все, що ми обговорили та зробили в цьому підручнику.

• Keras у API високого рівня, який використовується для полегшення мереж глибокого навчання за допомогою механізму серверної обробки.
• Keras простий у використанні та зрозумілий завдяки підтримці Python, тому він виглядає більш природним, ніж будь-коли. Це добре для початківців, які хочуть дізнатися про глибоке навчання, і для дослідників, які хочуть простий у використанні API.
• Процес встановлення простий, і ви можете використовувати віртуальне середовище або зовнішню платформу, наприклад AWS.
• Keras також постачається з різними видами мережевих моделей, тому нам легше використовувати доступну модель для попереднього навчання та точного налаштування нашої власної моделі мережі.
• Крім того, є багато навчальних посібників і статей про використання Keras від кодів спільнот по всьому світу для глибокого навчання.