Tutoriel Keras

Qu’est-ce que Keras ?

Keras est une bibliothèque de réseau neuronal Open Source écrite en Python qui s'exécute sur Theano ou Tensorflow. Il est conçu pour être modulaire, rapide et facile à utiliser. Il a été développé par François Chollet, ingénieur chez Google. Keras ne gère pas les calculs de bas niveau. Au lieu de cela, il utilise une autre bibliothèque pour le faire, appelée « Backend.

Keras est un wrapper d'API de haut niveau pour l'API de bas niveau, capable de s'exécuter sur TensorFlow, CNTK ou Theano. L'API Keras de haut niveau gère la façon dont nous créons des modèles, définissons des couches ou configurons plusieurs modèles d'entrée-sortie. À ce niveau, Keras compile également notre modèle avec des fonctions de perte et d'optimisation, un processus de formation avec une fonction d'ajustement. Kéras dans Python ne gère pas les API de bas niveau telles que la création du graphe de calcul, la création de tenseurs ou d'autres variables, car elles ont été gérées par le moteur « backend ».

Qu’est-ce qu’un back-end ?

Backend est un terme en Keras qui effectue tous les calculs de bas niveau tels que les produits tensoriels, les convolutions et bien d'autres choses à l'aide d'autres bibliothèques telles que Tensorflow ou Theano. Ainsi, le « moteur backend » effectuera le calcul et le développement des modèles. Tensorflow est le « moteur backend » par défaut mais nous pouvons le modifier dans la configuration.

Theano, Tensorflow et back-end CNTK

Theano est un projet open source développé par le groupe MILA de l'Université de Montréal, Québec, Canada. C'était le premier framework largement utilisé. C'est un Python Bibliothèque qui aide à la création de tableaux multidimensionnels pour les opérations mathématiques à l'aide de Numpy ou Scipy. Theano peut utiliser des GPU pour des calculs plus rapides, il peut également créer automatiquement des graphiques symboliques pour le calcul des gradients. Sur son site Web, Theano affirme qu'il peut reconnaître des expressions numériquement instables et les calculer avec des algorithmes plus stables, ce qui est très utile pour nos expressions instables.

D’un autre côté, Tensorflow est l’étoile montante du framework d’apprentissage profond. Développé par l'équipe Brain de Google, il s'agit de l'outil d'apprentissage en profondeur le plus populaire. Avec de nombreuses fonctionnalités, les chercheurs contribuent à développer ce cadre à des fins d'apprentissage en profondeur.

Un autre moteur backend pour Keras est The Microsoft Boîte à outils cognitive ou CNTK. Il s'agit d'un cadre d'apprentissage profond open source développé par Microsoft Équipe. Il peut fonctionner sur plusieurs GPU ou sur plusieurs machines pour former un modèle d'apprentissage profond à grande échelle. Dans certains cas, CNTK a été signalé plus rapidement que d'autres frameworks tels que Tensorflow ou Theano. Ensuite, dans ce didacticiel Keras CNN, nous comparerons les backends de Theano, TensorFlow et CNTK.

Comparaison des backends

Nous devons faire un benchmark afin de connaître la comparaison entre ces deux backends. Comme vous pouvez le voir dans La référence de Jeong-Yoon Lee, les performances de 3 backends différents sur différents matériels sont comparées. Et le résultat est que Theano est plus lent que l’autre backend, est-il rapporté 50 fois plus lent, mais la précision est proche les unes des autres.

Une autre test de référence est effectué par Jasmeet Bhatia. Il a signalé que Theano est plus lent que Tensorflow pour certains tests. Mais la précision globale est presque la même pour chaque réseau testé.

Ainsi, entre Theano, Tensorflow et CTK, il est évident que TensorFlow est meilleur que Theano. Avec TensorFlow, le temps de calcul est beaucoup plus court et CNN est meilleur que les autres.

Suivant dans ce Keras Python tutoriel, nous découvrirons la différence entre Keras et TensorFlow (Keras et Tensorflow).

Keras et Tensorflow

Paramètres	Keras	Tensorflow
Type	Wrapper API de haut niveau	API de bas niveau
Complexité	Facile à utiliser si vous Python langue	Vous devez apprendre la syntaxe d'utilisation de certaines fonctions Tensorflow
Interet	Déploiement rapide pour créer un modèle avec des couches standards	Vous permet de créer un graphique informatique arbitraire ou des couches de modèle
Outils	Utilise un autre outil de débogage API tel que TFDBG	Vous pouvez utiliser les outils de visualisation Tensorboard
Communauté	De grandes communautés actives	Grandes communautés actives et ressources largement partagées

Avantages de Keras

Déploiement rapide et facile à comprendre

Keras est très rapide pour créer un modèle de réseau. Si vous souhaitez créer un modèle de réseau simple avec quelques lignes, Python Keras peut vous aider. Regardez l'exemple Keras ci-dessous :

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

Grâce à la convivialité de l'API, nous pouvons facilement comprendre le processus. Écrire le code avec une fonction simple et pas besoin de définir plusieurs paramètres.

Support de grande communauté

De nombreuses communautés d'IA utilisent Keras pour leur cadre de Deep Learning. Beaucoup d’entre eux publient leurs codes ainsi que des tutoriels destinés au grand public.

Avoir plusieurs backends

Vous pouvez choisir Tensorflow, CNTK et Theano comme backend avec Keras. Vous pouvez choisir un backend différent pour différents projets en fonction de vos besoins. Chaque backend a son propre avantage unique.

Déploiement multiplateforme et facile du modèle

Avec une variété d'appareils et de plates-formes pris en charge, vous pouvez déployer Keras sur n'importe quel appareil comme

• iOS avec CoreML
• Android avec Tensorflow Android,
• Navigateur Web avec prise en charge .js
• Moteur cloud
• Raspberry Pi

Prise en charge de plusieurs GPU

Vous pouvez entraîner Keras sur un seul GPU ou utiliser plusieurs GPU à la fois. Parce que Keras dispose d'une prise en charge intégrée du parallélisme des données, ce qui lui permet de traiter de gros volumes de données et d'accélérer le temps nécessaire à leur formation.

Inconvénients du Keras

Impossible de gérer l'API de bas niveau

Keras ne gère que les API de haut niveau qui s'exécutent sur d'autres frameworks ou moteurs backend tels que Tensorflow, Theano ou CNTK. Ce n'est donc pas très utile si vous souhaitez créer votre propre couche abstraite à des fins de recherche car Keras dispose déjà de couches préconfigurées.

Installation de Keras

Dans cette section, nous examinerons les différentes méthodes disponibles pour installer Keras

Installation directe ou environnement virtuel

Quel est le meilleur? Installation directe sur le python actuel ou utilisation d'un environnement virtuel ? Je suggère d'utiliser un environnement virtuel si vous avez de nombreux projets. Vous voulez savoir pourquoi ? En effet, différents projets peuvent utiliser une version différente d'une bibliothèque keras.

Par exemple, j'ai un projet qui nécessite Python 3.5 en utilisant OpenCV 3.3 avec l'ancien backend Keras-Theano mais dans l'autre projet, je dois utiliser Keras avec la dernière version et un Tensorflow comme backend avec Python Prise en charge de 3.6.6

Nous ne voulons pas que les bibliothèques Keras entrent en conflit, n'est-ce pas ? Nous utilisons donc un environnement virtuel pour localiser le projet avec un type spécifique de bibliothèque ou nous pouvons utiliser une autre plateforme telle que Cloud Service pour effectuer notre calcul à notre place, comme Amazon Service Web.

Installation de Keras sur Amazon Services Web (AWS)

Amazon Web Service est une plate-forme qui propose des services et des produits Cloud Computing destinés aux chercheurs ou à toute autre fin. AWS loue son matériel, son réseau, sa base de données, etc. afin que nous puissions l'utiliser directement depuis Internet. L'un des services AWS les plus populaires à des fins d'apprentissage en profondeur est le Amazon Service d'apprentissage profond d'image machine ou DL

Pour des instructions détaillées sur l'utilisation d'AWS, reportez-vous à ceci tutoriel

Note sur l'AMI : Vous disposerez de l'AMI suivante

AWS Deep Learning AMI est un environnement virtuel dans le service AWS EC2 qui aide les chercheurs ou les praticiens à travailler avec le Deep Learning. DLAMI propose des moteurs de petits processeurs jusqu'à des moteurs multi-GPU haute puissance avec CUDA, cuDNN préconfigurés et est livré avec une variété de cadres d'apprentissage en profondeur.

Si vous souhaitez l'utiliser instantanément, vous devez choisir Deep Learning AMI car elle est préinstallée avec les frameworks d'apprentissage profond populaires.

Mais si vous souhaitez essayer un cadre d'apprentissage profond personnalisé pour la recherche, vous devez installer l'AMI Deep Learning Base car elle est livrée avec des bibliothèques fondamentales telles que CUDA, cuDNN, des pilotes GPU et d'autres bibliothèques nécessaires pour fonctionner avec votre environnement d'apprentissage profond.

Comment installer Keras sur Amazon SageMaker

Amazon SageMaker est une plateforme d'apprentissage en profondeur pour vous aider à former et à déployer un réseau d'apprentissage en profondeur avec le meilleur algorithme.

En tant que débutant, c'est de loin la méthode la plus simple pour utiliser Keras. Vous trouverez ci-dessous un processus permettant d'installer Keras sur Amazon SageMaker :

Étape 1) Ouvrez Amazon SageMaker

Dans la première étape, ouvrez le Amazon Faiseur de sauge console et cliquez sur Créer une instance de notebook.

Étape 2) Entrez les détails

1. Entrez le nom de votre bloc-notes.
2. Créez un rôle IAM. Cela créera un rôle AMI Amazon Rôle IAM sous la forme de AmazonSageMaker-Executionrole-AAAAMMJJ|HHmmSS.
3. Enfin, choisissez Créer une instance de notebook. Après quelques instants, Amazon Sagemaker lance une instance de notebook.

Note: Si vous souhaitez accéder aux ressources de votre VPC, définissez l'accès Internet direct comme activé. Sinon, cette instance de notebook n'aura pas d'accès Internet, il est donc impossible de former ou d'héberger des modèles

Étape 3) Lancez l'instance

Cliquez sur Ouvrir pour lancer l'instance

Étape 4) Commencez à coder

In Jupyter, Cliquez sur Nouveau> conda_tensorflow_p36 et vous êtes prêt à coder

Installer Keras sous Linux

Pour activer Keras avec Tensorflow comme moteur backend, nous devons d'abord installer Tensorflow. Exécutez cette commande pour installer tensorflow avec CPU (pas de GPU)

pip install --upgrade tensorflow

si vous souhaitez activer la prise en charge GPU pour tensorflow, vous pouvez utiliser cette commande

pip install --upgrade tensorflow-gpu

vérifions Python pour voir si notre installation réussit en tapant

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

s'il n'y a pas de message d'erreur, le processus d'installation est réussi

Installer Keras

Après avoir installé Tensorflow, commençons à installer keras. Tapez cette commande dans le terminal

pip install keras

il commencera à installer Keras ainsi que toutes ses dépendances. Vous devriez voir quelque chose comme ceci :

Nous avons maintenant Keras installé dans notre système !

Vérification

Avant de commencer à utiliser Keras, nous devons vérifier si nos Keras utilisent Tensorflow comme backend en ouvrant le fichier de configuration :

gedit ~/.keras/keras.json

tu devrais voir quelque chose comme ça

{
    "floatx": "float32",
    "epsilon": 1e-07,
    "backend": "tensorflow",
    "image_data_format": "channels_last"
}

comme vous pouvez le voir, le « backend » utilise tensorflow. Cela signifie que les keras utilisent Tensorflow comme backend comme prévu

et maintenant exécutez-le sur le terminal en tapant

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.
>>> 

Comment installer Keras sur Windows

Avant d'installer Tensorflow et Keras, nous devrions installer Python, pip et virtualenv. Si vous avez déjà installé ces bibliothèques, vous devez passer à l'étape suivante, sinon procédez comme suit :

Installer Python 3 en téléchargeant à partir de ceci lien

Installez pip en exécutant ceci.

Installez virtualenv avec cette commande

pip3 install –U pip virtualenv

Installer Microsoft Visuel C++ Mise à jour redistribuable 2015 3

• Accédez au site de téléchargement de Visual Studio https://www.microsoft.com/en-us/download/details.aspx?id=53587
• Sélectionnez les redistribuables et les outils de construction
• Téléchargez et installez le Microsoft Visuel C++ Mise à jour redistribuable 2015 3

Ensuite, exécutez ce script

pip3 install virtualenv

Configurer l'environnement virtuel

Ceci est utilisé pour isoler le système de travail avec le système principal.

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

Activer l'environnement

.\venv\Scripts\activate

Après avoir préparé l'environnement, l'installation de Tensorflow et Keras reste la même que celle de Linux. Ensuite, dans ce didacticiel Deep Learning avec Keras, nous découvrirons les principes fondamentaux de Keras pour le Deep Learning.

Fondamentaux de Keras pour l'apprentissage profond

La structure principale de Keras est le modèle qui définit le graphe complet d'un réseau. Vous pouvez ajouter davantage de couches à un modèle existant pour créer un modèle personnalisé dont vous avez besoin pour votre projet.

Voici comment créer un modèle séquentiel et quelques couches couramment utilisées en apprentissage profond

1. Modèle séquentiel

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

model = Sequential()

2. Couche convolutive

C'est un Keras Python exemple de couche convolutive comme couche d'entrée avec la forme d'entrée de 320x320x3, avec 48 filtres de taille 3×3 et utilise ReLU comme fonction d'activation.

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

un autre type est

model.add(Conv2D(48, (3, 3), activation='relu'))

3. MaxPooling Couche

Pour sous-échantillonner la représentation d'entrée, utilisez MaxPool2d et spécifiez la taille du noyau

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

4. Couche dense

ajouter une couche entièrement connectée en spécifiant simplement la taille de sortie

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

5. Couche d'abandon

Ajout d'une couche d'abandon avec une probabilité de 50 %

model.add(Dropout(0.5))

Compiler, former et évaluer

Après avoir défini notre modèle, commençons à les former. Il est nécessaire de compiler d'abord le réseau avec la fonction de perte et la fonction d'optimisation. Cela permettra au réseau de modifier les poids et de minimiser les pertes.

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

Maintenant, pour commencer la formation, utilisez fit pour alimenter le modèle en données de formation et de validation. Cela vous permettra de former le réseau par lots et de définir les époques.

model.fit(X_train, X_train, batch_size=32, epochs=10, validation_data=(x_val, y_val))

Notre dernière étape consiste à évaluer le modèle avec les données de test.

score = model.evaluate(x_test, y_test, batch_size=32)

Essayons d'utiliser une régression linéaire simple

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

Après avoir entraîné les données, le résultat devrait ressembler à ceci

avec le poids initial

Linear regression model is initialized with weights w: 0.37, b: 0.00

et poids final

Linear regression model is trained to have weight w: 3.70, b: 0.61

Affiner les modèles pré-entraînés dans Keras et comment les utiliser

Pourquoi nous utilisons les modèles Fine Tune et quand nous les utilisons

Le réglage fin est une tâche consistant à peaufiner un modèle pré-entraîné de telle sorte que les paramètres s'adaptent au nouveau modèle. Lorsque l’on veut s’entraîner à partir de zéro sur un nouveau modèle, nous avons besoin d’une grande quantité de données, afin que le réseau puisse retrouver tous les paramètres. Mais dans ce cas, nous utiliserons un modèle pré-entraîné donc les paramètres sont déjà appris et auront un poids.

Par exemple, si nous voulons entraîner notre propre modèle Keras pour résoudre un problème de classification mais que nous ne disposons que d'une petite quantité de données, nous pouvons résoudre ce problème en utilisant un Transfert d'apprentissage + Méthode de réglage fin.

En utilisant un réseau et des poids pré-entraînés, nous n'avons pas besoin de former l'ensemble du réseau. Nous avons juste besoin de former la dernière couche utilisée pour résoudre notre tâche, ce que nous appelons la méthode de réglage fin.

Préparation du modèle de réseau

Pour le modèle pré-entraîné, nous pouvons charger une variété de modèles que Keras a déjà dans sa bibliothèque, tels que :

• VGG16
• CréationV3
• ResNet
• Réseau mobile
• Xception
• CréationResNetV2

Mais dans ce processus, nous utiliserons le modèle de réseau VGG16 et imageNet comme poids pour le modèle. Nous allons affiner un réseau pour classer 8 types différents de classes à l'aide d'images de Ensemble de données d'images naturelles Kaggle

Architecture du modèle VGG16

source

Téléchargement de nos données sur le compartiment AWS S3

Pour notre processus de formation, nous utiliserons une image d'images naturelles provenant de 8 classes différentes telles que les avions, la voiture, le chat, le chien, la fleur, le fruit, la moto et la personne. Tout d'abord, nous devons télécharger nos données sur Amazon Seau S3.

Amazon Compartiment S3

Étape 1) Après vous être connecté à votre compte S3, créons un bucket en pointant Créer Bucket

Étape 2) Choisissez maintenant un nom de compartiment et votre région en fonction de votre compte. Assurez-vous que le nom du compartiment est disponible. Après ce clic Créer.

Étape 3) Comme vous pouvez le constater, votre Bucket est prêt à être utilisé. Mais comme vous pouvez le voir, l'accès n'est pas public, c'est bien pour vous si vous souhaitez le garder privé pour vous-même. Vous pouvez modifier ce bucket pour l'accès public dans les propriétés du bucket.

Étape 4) Vous commencez maintenant à télécharger vos données d'entraînement sur votre bucket. Ici, je vais télécharger le fichier tar.gz qui contient des images pour le processus de formation et de test.

Étape 5) Cliquez maintenant sur votre fichier et copiez le Lien afin que nous puissions le télécharger.

Préparation des données

Nous devons générer nos données de formation à l'aide de Keras ImageDataGenerator.

Vous devez d’abord télécharger en utilisant wget avec le lien vers votre fichier depuis S3 Bucket.

!wget https://s3.us-east-2.amazonaws.com/naturalimages02/images.tar.gz		
!tar -xzf images.tar.gz

Après avoir téléchargé les données, commençons le processus de formation.

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)

Les données d'imageGenerator créera une donnée X_training à partir d'un répertoire. Le sous-répertoire de ce répertoire sera utilisé comme classe pour chaque objet. L'image sera chargée avec le mode couleur RVB, avec le mode classe catégorielle pour les données Y_training, avec une taille de lot de 16. Enfin, mélangez les données.

Voyons nos images au hasard en les traçant avec 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()

Après cela, créons notre modèle de réseau à partir de VGG16 avec le poids pré-entraîné imageNet. Nous allons geler ces couches afin qu'elles ne puissent pas être entraînées afin de nous aider à réduire le temps de calcul.

Créer notre modèle à partir de 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())

Comme vous pouvez le voir ci-dessous, le résumé de notre modèle de réseau. À partir d'une entrée des couches VGG16, nous ajoutons ensuite 2 couches entièrement connectées qui extrairont 1024 fonctionnalités et une couche de sortie qui calculera les 8 classes avec l'activation 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

Entraînement

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

Résultats

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

Comme vous pouvez le constater, nos pertes ont été considérablement réduites et la précision est proche de 100 %. Pour tester notre modèle, nous avons sélectionné des images au hasard sur Internet et les avons placées dans le dossier de test avec une classe différente à tester.

Tester notre modèle

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

Et notre test est comme indiqué ci-dessous ! Une seule image est prédite fausse sur un test de 1 images !

Réseau neuronal de reconnaissance faciale avec Keras

Pourquoi nous avons besoin de reconnaissance

Nous avons besoin de reconnaissance pour nous permettre de reconnaître ou d'identifier plus facilement le visage d'une personne, le type d'objet, l'âge estimé d'une personne à partir de son visage, ou même de connaître les expressions faciales de cette personne.

Peut-être réalisez-vous qu'à chaque fois que vous essayez de marquer le visage de votre ami sur une photo, la fonctionnalité de Facebook l'a fait pour vous, c'est-à-dire qu'elle marque le visage de votre ami sans que vous ayez besoin de le marquer au préalable. Il s'agit de la reconnaissance faciale appliquée par Facebook pour nous permettre de marquer plus facilement nos amis.

Alors, comment ça marche? Chaque fois que nous marquons le visage de notre ami, l'IA de Facebook l'apprendra et tentera de le prédire jusqu'à obtenir le bon résultat. Le même système que nous utiliserons pour créer notre propre reconnaissance faciale. Commençons à créer notre propre reconnaissance faciale à l'aide du Deep Learning

Modèle de réseau

Nous utiliserons un modèle de réseau VGG16 mais avec un poids VGGFace.

Architecture du modèle VGG16

Qu’est-ce que VGGFace ? il s'agit de l'implémentation Keras de la reconnaissance faciale profonde introduite par Parkhi, Omkar M. et al. « Reconnaissance faciale profonde. » BMVC (2015). Le framework utilise VGG16 comme architecture réseau.

Vous pouvez télécharger le VGGFace depuis 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()

Comme vous pouvez le voir le résumé du réseau

_________________________________________________________________
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):

nous ferons un Transfert d'apprentissage + Réglage fin pour rendre la formation plus rapide avec de petits ensembles de données. Tout d’abord, nous allons geler les couches de base afin qu’elles ne puissent pas être entraînées.

for layer in face_model.layers:
    layer.trainable = False

puis nous ajoutons notre propre calque pour reconnaître nos visages de test. Nous ajouterons 2 couches entièrement connectées et une couche de sortie avec 5 personnes à détecter.

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)

Voyons le résumé de notre réseau

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

Comme vous pouvez le voir ci-dessus, après la couche pool5, elle sera aplatie en un seul vecteur de caractéristiques qui sera utilisé par la couche dense pour la reconnaissance finale.

Préparer nos visages

Maintenant, préparons nos visages. J'ai créé un annuaire composé de 5 personnes célèbres

• Jack Ma
• Jason Statham
• Johnny Depp
• Robert Downey Jr
• Rowan Atkinson

Chaque dossier contient 10 images, pour chaque processus de formation et d'évaluation. Il s’agit d’une très petite quantité de données, mais c’est là le défi, n’est-ce pas ?

Nous utiliserons l'aide de l'outil Keras pour nous aider à préparer les données. Cette fonction parcourra le dossier de l'ensemble de données, puis le préparera afin qu'il puisse être utilisé dans la formation.

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

Former notre modèle

Commençons notre processus de formation en compilant notre réseau avec fonction de perte et optimiseur. Ici, nous utilisons sparse_categorical_crossentropy comme fonction de perte, avec l'aide de SGD comme optimiseur d'apprentissage.

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

Comme vous pouvez le constater, la précision de notre validation atteint 64 %, ce qui est un bon résultat pour une petite quantité de données d'entraînement. Nous pouvons améliorer cela en ajoutant plus de calques ou en ajoutant plus d'images d'entraînement afin que notre modèle puisse en apprendre davantage sur les visages et obtenir plus de précision.

Testons notre modèle avec une image test

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

en utilisant la photo de Robert Downey Jr. comme photo de test, cela montre que le visage prédit est vrai !

Prédiction en utilisant Live Cam !

Et si nous testions nos compétences en l’implémentant avec une entrée provenant d’une webcam ? En utilisant OpenCV avec la cascade Haar Face pour trouver notre visage et avec l'aide de notre modèle de réseau, nous pouvons reconnaître la personne.

La première étape consiste à préparer votre visage et celui de vos amis. Plus nous avons de données, meilleur est le résultat !

Préparez et entraînez votre réseau comme à l'étape précédente. Une fois la formation terminée, ajoutez cette ligne pour obtenir l'image d'entrée de la caméra.

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

Quel est le meilleur? Keras ou Tensorflow

Keras offre la simplicité lors de l'écriture du script. On peut commencer à écrire et comprendre directement avec Keras car ce n'est pas trop difficile à comprendre. Il est plus convivial et facile à mettre en œuvre, pas besoin de créer de nombreuses variables pour exécuter le modèle. Nous n’avons donc pas besoin de comprendre tous les détails du processus backend.

D'un autre côté, Tensorflow correspond aux opérations de bas niveau qui offrent une flexibilité et des opérations avancées si vous souhaitez créer un graphique ou un modèle de calcul arbitraire. Tensorflow peut également visualiser le processus à l'aide de Tableau Tenseur et un outil de débogage spécialisé.

Donc, si vous souhaitez commencer à travailler avec le deep learning sans trop de complexité, utilisez Keras. Parce que Keras offre une simplicité et une convivialité à utiliser et facile à mettre en œuvre que Tensorflow. Mais si vous souhaitez écrire votre propre algorithme dans un projet ou une recherche d'apprentissage en profondeur, vous devez plutôt utiliser Tensorflow.

Résumé

Résumons donc tout ce dont nous avons discuté et fait dans ce tutoriel.

• Keras dans une API de haut niveau utilisée pour faciliter les réseaux d'apprentissage en profondeur à l'aide d'un moteur backend.
• Keras est facile à utiliser et à comprendre avec le support Python, ce qui le rend plus naturel que jamais. C'est bon pour les débutants qui souhaitent en savoir plus sur l'apprentissage profond et pour les chercheurs qui souhaitent une API facile à utiliser.
• Le processus d'installation est simple et vous pouvez utiliser un environnement virtuel ou utiliser une plateforme externe telle que AWS.
• Keras est également livré avec différents types de modèles de réseau, ce qui nous permet d'utiliser plus facilement le modèle disponible pour pré-entraîner et affiner notre propre modèle de réseau.
• En outre, il existe de nombreux didacticiels et articles sur l'utilisation de Keras provenant de codes de communautés du monde entier à des fins d'apprentissage en profondeur.