VGG16 – Tutoriel Simple Et Détaillé pour la Reconnaissance D’Image

Dans ce tutoriel, nous allons voir comment charger et utiliser le modèle VGG16 de la librairie Keras.

Ce modèle est utilisé dans la vision par ordinateur (Computer Vision). Il a notamment remporté le concours ILSVRC (ImageNet Large Scale Visual Recognition Challenge) en 2014.

Nous expliquerons en détails dans un prochain article en quoi consiste ce modèle, en attendant, nous vous proposons d’explorer l’implémentation de ce modèle.

Vous pouvez directement télécharger le code sur github ou bien suivre, ici, le tutoriel.

source: machinelearningmastery

Charger le modèle

On utilise la librairie Keras pour charger le modèle VGG16, il faut donc l’avoir préalablement installé.

Keras Application comporte plusieurs modèles de Deep Learning. Ces modèles sont mis à disposition avec des poids pré-entraînés.

Charger un modèle sur Keras permet de charger automatiquement les poids pré-entraînés sur lesquels le modèle sera indexé, c’est ce qu’on appelle du Transfert Learning.

Dans Keras Application, VGG16 a été entraînés sur plus d’un million d’images provenant de la base de données ImageNet.

Ce réseau de neurones peut classer les images en 1000 classes d’objets, tels que des voitures, des souris, des crayons et de nombreux animaux.

Grâce au Transfert Learning, on peut directement utiliser ce réseau de neurones. C’est un gain de temps considérable étant donné que, sans Keras, il faudrait plusieurs heures pour entraîner soi-même ce modèle à partir d’ImageNet.

On charge donc le modèle:

from keras.applications.vgg16 import VGG16
model = VGG16()

Chargement et pré-traitement de l’image

Dans cet exemple, on utilise VGG16 sur une image d’ours polaire.

La taille de l’image d’entrée par défaut de VGG-16 est de 224×224. On redimensionne donc notre image.

from keras.preprocessing.image import load_img
image = load_img('/ice-bear-hans-jurgen-mager-unsplash.jpg', target_size=(224, 224))

Petit rappel: Un modèle de Machine Learning ne prend toujours que des numériques en entrée.

C’est pour cela qu’il faut que nous convertissons notre image en matrice de pixels. Pour ce faire on transforme notre image en numpy.array avec la fonction: img_to_array().

from keras.preprocessing.image import img_to_array
image = img_to_array(image)

La dimension de l’image d’entrée par défaut de VGG16 est (None,224,224,3).

On ajoute donc une autre dimension a notre matrice.

image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2]))

Ensuite, nous devons traiter les pixels de l’image de la même manière que les données d’entraînement d’ImageNet ont été préparées. 

Expliqué plus précisément, dans le papier de recherche de Karen Simonyan et Andrew Zisserman :

Le seul pré-traitement que nous faisons est de soustraire à chaque pixel la valeur RVB moyenne des données d’entraînement. »

Heureusement, Keras fournit une fonction appelée preprocess_input() pour réaliser ce pré-traitement (encore appelé preprocessing).

from keras.applications.vgg16 import preprocess_input
image = preprocess_input(image)

Faire la prédiction

Enfin, on peut faire une prédiction sur notre image avec le modèle.

prediction = model.predict(image)

Allez, encore un dernier traitement pour décoder notre prédiction et nous pourrons voir le résultat de notre algorithme !

from keras.applications.vgg16 import decode_predictions
label = decode_predictions(prediction)
label = label[0][0]
print('%s (%.2f%%)' % (label[1], label[2]*100))

On obtient: ice_bear (99.95%)

Selon VGG16, l’image à une probabilité de 99.95% de contenir un ours polaire. Plutôt bien, non ?

En fait, VGG16 ne retourne pas une seul prédiction mais la liste des 1000 classes sur lequel il a été pré-entraîné.

Il associe le nom de chacune de ces classes à la probabilité que cette classe soit dans l’image.

Voici le code pour afficher le top 3 des classes que VGG-16 a prédit dans notre image:

labels = decode_predictions(prediction)
print('%s (%.2f%%)' % (labels[0][0][1], labels[0][0][2]*100))
print('%s (%.2f%%)' % (labels[0][1][1], labels[0][1][2]*100))
print('%s (%.2f%%)' % (labels[0][2][1], labels[0][2][2]*100))

On obtient:

• ice_bear (99.95%)
• weasel (0.03%)
• otter (0.01%)

Et voilà, vous avez pu voir comment utiliser VGG16 ! J’espère que cet article vous a plu.

Si vous avez des questions, direction la section commentaire ! 🙂