Учебник Keras

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

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

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

Установите Python 3, загрузив по этой ссылке

Установите pip, запустив этот

Установите virtualenv с помощью этой команды

pip3 install –U pip virtualenv

Установите распространяемое обновление 3 для Microsoft Visual C ++ 2015

• Перейдите на сайт загрузки Visual Studio https://www.microsoft.com/en-us/download/details.aspx?id=53587.
• Выберите распространяемые и инструменты сборки
• Загрузите и установите распространяемое обновление 3 для Microsoft Visual C ++ 2015

Затем запустите этот скрипт

pip3 install virtualenv

Настройка виртуальной среды

Это используется для изоляции работающей системы с основной системой.

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

Активировать среду

.\venv\Scripts\activate

После подготовки среды установка Tensorflow и Keras остается такой же, как в Linux.

Основы Keras для глубокого обучения

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

model = Sequential()

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

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

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

model.add(Dropout(0.5))

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

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

Тонкая настройка предварительно обученных моделей в Керасе и как их использовать

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

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

источник

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

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

Amazon S3 Bucket

Шаг 1) После входа в свою учетную запись S3 давайте создадим корзину, нажав кнопку « Создать корзину».

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

Шаг 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)

ImageDataGenerator создаст данные X_training из каталога. Подкаталог в этом каталоге будет использоваться как класс для каждого объекта. Изображение будет загружено в цветовом режиме RGB, в режиме категориального класса для данных Y_training с размером пакета 16. Наконец, перемешайте данные.

Давайте посмотрим наши изображения в случайном порядке, построив их с помощью matplotlib

x_batch, y_batch = train_generator.next()

fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows):
    num = np.random.randint(batch_size)
    image = x_batch[num].astype(np.int)
    fig.add_subplot(rows, columns, i)
    plt.imshow(image)
plt.show()

После этого давайте создадим нашу сетевую модель из VGG16 с предварительно обученным весом imageNet. Мы заморозим эти слои, чтобы слои не были обучаемыми, чтобы помочь нам сократить время вычислений.

Создание нашей модели из VGG16

import keras
from keras.models import Model, load_model
from keras.layers import Activation, Dropout, Flatten, Dense
from keras.preprocessing.image import ImageDataGenerator
from keras.applications.vgg16 import VGG16


#Load the VGG model
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(image_size, image_size, 3))

print(base_model.summary())

    # Freeze the layers 
for layer in base_model.layers:
    layer.trainable = False
 
# # Create the model
model = keras.models.Sequential()

# # Add the vgg convolutional base model
model.add(base_model)
 
# # Add new layers
model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dense(1024, activation='relu'))
model.add(Dense(num_class, activation='softmax'))
 
# # Show a summary of the model. Check the number of trainable parameters    
print(model.summary())

Как вы можете видеть ниже, краткое описание нашей сетевой модели. Из входных данных слоев VGG16 мы добавляем 2 полностью подключенных слоя, которые будут извлекать 1024 объекта, и выходной слой, который будет вычислять 8 классов с активацией softmax.

Layer (type)                 Output Shape              Param #   
=================================================================
vgg16 (Model)                (None, 7, 7, 512)         14714688  
_________________________________________________________________
flatten_1 (Flatten)          (None, 25088)             0         
_________________________________________________________________
dense_1 (Dense)              (None, 1024)              25691136  
_________________________________________________________________
dense_2 (Dense)              (None, 1024)              1049600   
_________________________________________________________________
dense_3 (Dense)              (None, 8)                 8200      
=================================================================
Total params: 41,463,624
Trainable params: 26,748,936
Non-trainable params: 14,714,688

Подготовка

# # Compile the model
from keras.optimizers import SGD

model.compile(loss='categorical_crossentropy',
          optimizer=SGD(lr=1e-3),
          metrics=['accuracy'])

# # Start the training process
# model.fit(x_train, y_train, validation_split=0.30, batch_size=32, epochs=50, verbose=2)

# # #save the model
# model.save('catdog.h5')

history = model.fit_generator(
        train_generator,
        steps_per_epoch=train_generator.n/batch_size,
        epochs=10)
        
model.save('fine_tune.h5')

# summarize history for accuracy
import matplotlib.pyplot as plt

plt.plot(history.history['loss'])
plt.title('loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['loss'], loc='upper left')
plt.show()

Результаты

Epoch 1/10
432/431 [==============================] - 53s 123ms/step - loss: 0.5524 - acc: 0.9474 
Epoch 2/10
432/431 [==============================] - 52s 119ms/step - loss: 0.1571 - acc: 0.9831
Epoch 3/10
432/431 [==============================] - 51s 119ms/step - loss: 0.1087 - acc: 0.9871
Epoch 4/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0624 - acc: 0.9926
Epoch 5/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0591 - acc: 0.9938
Epoch 6/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0498 - acc: 0.9936
Epoch 7/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0403 - acc: 0.9958
Epoch 8/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0248 - acc: 0.9959
Epoch 9/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0466 - acc: 0.9942
Epoch 10/10
432/431 [==============================] - 52s 120ms/step - loss: 0.0338 - acc: 0.9947

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

Тестирование нашей модели

model = load_model('fine_tune.h5')

test_datagen = ImageDataGenerator()
train_generator = train_datagen.flow_from_directory(
                        directory=train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='categorical',
                        color_mode='rgb',
                        shuffle=True)

test_generator = test_datagen.flow_from_directory(
                        directory=test_path, 
                        target_size=(image_size, image_size),
                        color_mode='rgb',
                        shuffle=False,
                        class_mode='categorical',
                        batch_size=1)

filenames = test_generator.filenames
nb_samples = len(filenames)

fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows -1):
    x_batch, y_batch = test_generator.next()

    name = model.predict(x_batch)
    name = np.argmax(name, axis=-1)
    true_name = y_batch
    true_name = np.argmax(true_name, axis=-1)

    label_map = (test_generator.class_indices)
    label_map = dict((v,k) for k,v in label_map.items()) #flip k,v
    predictions = [label_map[k] for k in name]
    true_value = [label_map[k] for k in true_name]

    image = x_batch[0].astype(np.int)
    fig.add_subplot(rows, columns, i)
    plt.title(str(predictions[0]) + ':' + str(true_value[0]))
    plt.imshow(image)
plt.show()

И наш тест, как показано ниже! Только 1 изображение предсказано неправильно из теста из 14 изображений!

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

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

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

Модель сети

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

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

Что такое VGGFace? это реализация Keras Deep Face Recognition, представленная Parkhi, Omkar M. et al. «Глубокое распознавание лица». BMVC (2015). Фреймворк использует VGG16 в качестве сетевой архитектуры.

Вы можете скачать VGGFace из GitHub

from keras.applications.vgg16 import VGG16
from keras_vggface.vggface import VGGFace

face_model = VGGFace(model='vgg16', 
                weights='vggface',
                input_shape=(224,224,3)) 
face_model.summary()

Как вы можете увидеть в сети резюме

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_1 (InputLayer)         (None, 224, 224, 3)       0         
_________________________________________________________________
conv1_1 (Conv2D)             (None, 224, 224, 64)      1792      
_________________________________________________________________
conv1_2 (Conv2D)             (None, 224, 224, 64)      36928     
_________________________________________________________________
pool1 (MaxPooling2D)         (None, 112, 112, 64)      0         
_________________________________________________________________
conv2_1 (Conv2D)             (None, 112, 112, 128)     73856     
_________________________________________________________________
conv2_2 (Conv2D)             (None, 112, 112, 128)     147584    
_________________________________________________________________
pool2 (MaxPooling2D)         (None, 56, 56, 128)       0         
_________________________________________________________________
conv3_1 (Conv2D)             (None, 56, 56, 256)       295168    
_________________________________________________________________
conv3_2 (Conv2D)             (None, 56, 56, 256)       590080    
_________________________________________________________________
conv3_3 (Conv2D)             (None, 56, 56, 256)       590080    
_________________________________________________________________
pool3 (MaxPooling2D)         (None, 28, 28, 256)       0         
_________________________________________________________________
conv4_1 (Conv2D)             (None, 28, 28, 512)       1180160   
_________________________________________________________________
conv4_2 (Conv2D)             (None, 28, 28, 512)       2359808   
_________________________________________________________________
conv4_3 (Conv2D)             (None, 28, 28, 512)       2359808   
_________________________________________________________________
pool4 (MaxPooling2D)         (None, 14, 14, 512)       0         
_________________________________________________________________
conv5_1 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
conv5_2 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
conv5_3 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
pool5 (MaxPooling2D)         (None, 7, 7, 512)         0         
_________________________________________________________________
flatten (Flatten)            (None, 25088)             0         
_________________________________________________________________
fc6 (Dense)                  (None, 4096)              102764544 
_________________________________________________________________
fc6/relu (Activation)        (None, 4096)              0         
_________________________________________________________________
fc7 (Dense)                  (None, 4096)              16781312  
_________________________________________________________________
fc7/relu (Activation)        (None, 4096)              0         
_________________________________________________________________
fc8 (Dense)                  (None, 2622)              10742334  
_________________________________________________________________
fc8/softmax (Activation)     (None, 2622)              0         
=================================================================
Total params: 145,002,878
Trainable params: 145,002,878
Non-trainable params: 0
_________________________________________________________________
Traceback (most recent call last):

мы сделаем Transfer Learning + Fine Tuning, чтобы ускорить обучение с небольшими наборами данных. Во-первых, мы заморозим базовые слои, чтобы они не были обучаемыми.

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

Какой лучше? Керас или Тензорфлоу

Керас предлагает простоту при написании сценария. Мы можем начать писать и понимать непосредственно с Керасом, поскольку это не так сложно понять. Она более удобна и проста в реализации, не требует много переменных для запуска модели. Таким образом, нам не нужно понимать каждую деталь в бэкэнд-процессе.

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

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

Резюме

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

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