Керас Учебник

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

Keras — это библиотека нейронных сетей с открытым исходным кодом, написанная на Python который работает поверх Theano или Tensorflow. Он спроектирован как модульный, быстрый и простой в использовании. Его разработал Франсуа Шолле, инженер Google. Keras не обрабатывает низкоуровневые вычисления. Вместо этого он использует для этого другую библиотеку, называемую «Backend.

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

Что такое бэкэнд?

Бэкенд — это термин в Keras, который выполняет все низкоуровневые вычисления, такие как тензорные произведения, свертки и многое другое, с помощью других библиотек, таких как Tensorflow или Theano. Итак, «бэкэнд-движок» будет выполнять вычисления и разработку моделей. Tensorflow — это «бэкэнд-движок» по умолчанию, но мы можем изменить его в конфигурации.

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.

Сравнение бэкэндов

Нам нужно провести тест, чтобы сравнить эти два бэкэнда. Как вы можете видеть в Эталон Чон-Юна Ли, сравнивается производительность 3 разных бэкендов на разном оборудовании. Сообщается, что в результате Theano работает медленнее, чем другой бэкэнд. 50 раз медленнее, но по точности близки друг к другу.

Еще один продукт контрольный тест выполняется Джасмит Бхатия. Он сообщил, что Theano в некоторых тестах медленнее, чем Tensorflow. Но общая точность почти одинакова для каждой протестированной сети.

Итак, между Theano, Tensorflow и CTK очевидно, что TensorFlow лучше, чем Theano. С TensorFlow время вычислений намного короче, а CNN лучше, чем другие.

Далее в этом Керасе Python учебник, мы узнаем о разнице между Keras и TensorFlow (Керас против Тензорного потока).

Керас против Тензорного потока

Параметры	Keras	Tensorflow
Тип	Высокоуровневая оболочка API	Низкоуровневый API
Многогранность	Легко использовать, если вы Python язык	Вам необходимо изучить синтаксис использования некоторых функций Tensorflow.
Цель	Быстрое развертывание для создания модели со стандартными слоями	Позволяет создавать произвольный вычислительный график или слои модели.
Инструменты	Использует другой инструмент отладки API, такой как TFDBG.	Вы можете использовать инструменты визуализации Tensorboard.
Сообщество	Большие активные сообщества	Большие активные сообщества и широко используемые ресурсы.

Преимущества Кераса

Быстрое развертывание и простота понимания

Керас очень быстро создает сетевую модель. Если вы хотите создать простую сетевую модель из нескольких строк, Python Керас может помочь вам в этом. Посмотрите на пример 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 для своей среды глубокого обучения. Многие из них публикуют свои коды, а также учебные пособия для широкой публики.

Иметь несколько бэкэндов

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

Кроссплатформенность и простота развертывания модели

Благодаря множеству поддерживаемых устройств и платформ вы можете развернуть Keras на любом устройстве, например

• iOS с CoreML
• Android с Тензорным потоком Android,
• Веб-браузер с поддержкой .js
• Облачный движок
• Raspberry Pi

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

Вы можете обучать Keras на одном графическом процессоре или использовать несколько графических процессоров одновременно. Потому что Keras имеет встроенную поддержку параллелизма данных, поэтому он может обрабатывать большие объемы данных и ускорять время, необходимое для их обучения.

Недостатки Кераса

Невозможно обработать низкоуровневый API

Keras обрабатывает только API высокого уровня, который работает поверх другой платформы или внутреннего механизма, такого как Tensorflow, Theano или CNTK. Так что это не очень полезно, если вы хотите создать свой собственный абстрактный слой для исследовательских целей, поскольку в Keras уже есть предварительно настроенные слои.

Установка Кераса

В этом разделе мы рассмотрим различные способы установки Keras.

Прямая установка или виртуальная среда

Какая из них лучше? Прямая установка на текущий Python или использование виртуальной среды? Я предлагаю использовать виртуальную среду, если у вас много проектов. Хотите знать, почему? Это связано с тем, что разные проекты могут использовать разные версии библиотеки keras.

Например, у меня есть проект, который требует Python 3.5 с использованием OpenCV 3.3 со старым бэкэндом Keras-Theano, но в другом проекте мне приходится использовать Keras с последней версией и Tensorflow в качестве бэкэнда с Python Поддержка 3.6.6

Мы не хотим, чтобы библиотеки Keras конфликтовали друг с другом, верно? Поэтому мы используем виртуальную среду для локализации проекта с помощью библиотеки определенного типа или можем использовать другую платформу, такую ​​​​как Cloud Service, чтобы выполнять наши вычисления за нас, например Amazon Веб-сервис.

Установка Кераса на Amazon Веб-сервис (AWS)

Amazon Веб-сервис — это платформа, которая предлагает услуги и продукты облачных вычислений для исследователей или любых других целей. AWS арендует свое оборудование, сети, базу данных и т. д., чтобы мы могли использовать их непосредственно из Интернета. Одним из популярных сервисов AWS для целей глубокого обучения является Amazon Служба глубокого обучения машинного образа или DL

Подробные инструкции по использованию AWS см. здесь. учебник

Примечание относительно AMI: вам будут доступны следующие AMI.

AWS Deep Learning AMI — это виртуальная среда в сервисе AWS EC2, которая помогает исследователям и практикам работать с глубоким обучением. DLAMI предлагает от небольших процессоров до мощных модулей с несколькими графическими процессорами с предварительно настроенными CUDA, cuDNN и различными платформами глубокого обучения.

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

Но если вы хотите попробовать собственную среду глубокого обучения для исследований, вам следует установить Deep Learning Base AMI, поскольку он поставляется с фундаментальными библиотеками, такими как CUDA, cuDNN, драйверы графических процессоров и другими необходимыми библиотеками для работы в вашей среде глубокого обучения.

Как установить Keras на Amazon SageMaker

Amazon SageMaker — это платформа глубокого обучения, которая поможет вам в обучении и развертывании сети глубокого обучения с лучшим алгоритмом.

Для новичка это, безусловно, самый простой способ использования Keras. Ниже приведен процесс установки Keras на Amazon МудрецСоздатель:

Шаг 1) Открыть Amazon SageMaker

На первом этапе откройте Amazon Sagemaker консоль и нажмите «Создать экземпляр блокнота».

Шаг 2) Введите данные

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

Внимание: Если вы хотите получить доступ к ресурсам из вашего VPC, включите прямой доступ в Интернет. В противном случае этот экземпляр ноутбука не будет иметь доступа к Интернету, поэтому невозможно будет обучать или размещать модели.

Шаг 3) Запустите экземпляр

Нажмите «Открыть», чтобы запустить экземпляр.

Шаг 4) Начните кодирование

In Jupyter, нажмите «Создать»> conda_tensorflow_p36, и вы готовы к написанию кода.

Установите Керас в Linux

Чтобы включить Keras с Tensorflow в качестве внутреннего движка, нам нужно сначала установить Tensorflow. Запустите эту команду, чтобы установить тензорный поток с процессором (без графического процессора).

pip install --upgrade 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
>>>

если сообщения об ошибке нет, процесс установки прошел успешно

Установить Керас

После установки 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"
}

как видите, «бэкэнд» использует тензорный поток. Это означает, что 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

Прежде чем мы установим Tensorflow и Керас, мы должны установить 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
• Выберите распространяемые файлы и инструменты сборки.
• Загрузите и установите 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. МаксPoolinг Слой

Чтобы уменьшить входное представление, используйте 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 уже имеет в своей библиотеке, например:

• ВГГ16
• НачалоV3
• RESNET
• Мобильная сеть
• Восприятие
• НачалоResNetV2

Но в этом процессе мы будем использовать сетевую модель VGG16 и imageNet в качестве веса модели. Мы настроим сеть для классификации 8 различных типов классов, используя изображения из Набор данных Kaggle Natural Images

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

источник

Загрузка наших данных в корзину AWS S3

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

Amazon Ведро S3

Шаг 1) После входа в свою учетную запись S3 давайте создадим сегмент путем синхронизации Создание Bucket

Шаг 2) Теперь выберите имя сегмента и регион в соответствии с вашей учетной записью. Убедитесь, что имя сегмента доступно. После этого нажмите Создать.

Шаг 3) Как видите, ваше ведро готово к использованию. Но, как вы можете видеть, доступ не является общедоступным, это хорошо для вас, если вы хотите сохранить его конфиденциальным для себя. Вы можете изменить этот сегмент для публичного доступа в свойствах сегмента.

Шаг 4) Теперь вы начинаете загружать данные о тренировках в свое ведро. Сюда я загружу файл tar.gz, состоящий из картинок для процесса обучения и тестирования.

Шаг 5) Теперь нажмите на свой файл и скопируйте Ссылка чтобы мы могли его скачать.

Подготовка данных

Нам нужно сгенерировать данные обучения, используя Keras ImageData.Generator.

Сначала вам необходимо загрузить с помощью 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 изображений!

Нейронная сеть распознавания лиц с Keras

Зачем нам нужно признание

Нам нужно распознавание, чтобы нам было легче распознавать или идентифицировать лицо человека, тип объекта, предполагаемый возраст человека по его лицу или даже узнавать выражение лица этого человека.

Возможно, вы понимаете, что каждый раз, когда вы пытаетесь отметить лицо своего друга на фотографии, функция Facebook делает это за вас, то есть отмечает лицо вашего друга без необходимости предварительно отмечать его. Это распознавание лиц, применяемое Facebook, чтобы нам было проще отмечать друзей.

Итак, как это работает? Каждый раз, когда мы отмечаем лицо нашего друга, ИИ Facebook запоминает его и пытается предсказать его, пока не получит правильный результат. Ту же систему мы будем использовать для создания собственного распознавания лиц. Давайте начнем создавать собственное распознавание лиц с помощью глубокого обучения.

Сетевая модель

Мы будем использовать сетевую модель VGG16, но с весом VGGFace.

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

Что такое VGGFace? это реализация Keras Deep Face Recognition, представленная Паркхи, Омкаром М. и др. «Глубокое распознавание лиц». БМВЦ (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

Как вы можете видеть выше, после слоя пула5 он будет сведен в один вектор признаков, который будет использоваться плотным слоем для окончательного распознавания.

Готовим наши лица

Теперь подготовим наши лица. Я сделал каталог, состоящий из 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 предлагает простоту написания сценария. Мы можем начать писать и понимать непосредственно с помощью Keras, поскольку это не так уж сложно понять. Он более удобен для пользователя и прост в реализации, нет необходимости создавать много переменных для запуска модели. Таким образом, нам не нужно понимать каждую деталь серверного процесса.

С другой стороны, Tensorflow — это низкоуровневые операции, которые предлагают гибкость и расширенные операции, если вы хотите создать произвольный вычислительный график или модель. Tensorflow также может визуализировать процесс с помощью Тензорборд и специализированный инструмент отладчика.

Итак, если вы хотите начать работу с глубоким обучением без особых сложностей, используйте Keras. Потому что Keras предлагает простоту, удобство использования и простоту реализации, чем Tensorflow. Но если вы хотите написать свой собственный алгоритм в проекте глубокого обучения или исследовании, вместо этого вам следует использовать Tensorflow.

Резюме

Итак, давайте подведем итог всему, что мы обсудили и сделали в этом уроке.

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