Tutorial Keras : exemple de deep learning avec Keras et Python

Keras est une bibliothèque open source pour la création d’applications de deep learning. Keras est écrit en Python et fournit une interface commune pour différents backends de deep learning tels que TensorFlow et Theano. Le Deep Learning fait partie du machine learning et se base sur les réseau de neurones artificiels.

Keras vise à simplifier l’entrée dans le deep learning. Au cours de ce tutoriel Keras, nous expliquerons, à l’aide d’un exemple simple, comment fonctionne cette bibliothèque.

Backup Cloud par Acronis
Protégez vos appareils et réduisez les temps d'arrêt
  • Sauvegarde automatique et restauration facile
  • Gestion et planification intuitives
  • Protection contre les menaces basée sur l'IA

Préparer son système avant d’utiliser Keras

La meilleure façon de préparer votre système à l’utilisation de Keras est d’installer le logiciel Anaconda. Il s’agit d’une plateforme gratuite pour la data science. Livrée avec une installation Python3, elle contient des bibliothèques et des outils utiles.

Installer Anaconda et Python

Les explications et le code ci-dessous se réfèrent à macOS. En principe, le code devrait également fonctionner sous d’autres systèmes d’exploitation. Cependant, vous devrez peut-être faire quelques ajustements, surtout si vous utilisez Windows.

Si vous êtes familier avec la ligne de commande et que vous avez installé le logiciel Homebrew gratuit pour la gestion des paquets sur votre Mac, utilisez-le pour installer Anaconda. Pour ce faire, ouvrez une ligne de commande (« Terminal.App » sur le Mac), copiez la ligne de code suivante dans Terminal et exécutez-la :

brew cask install anaconda

Si vous ne connaissez pas Homebrew, ou si vous souhaitez installer Anaconda sous Windows ou Linux, veuillez télécharger le package d’installation adapté à votre système à partir de la page suivante : version « Individual » d’Anaconda.

Tester l’installation d’Anaconda et Python

Pour vous assurer que Anaconda et Python sont correctement installés, exécutez les commandes suivantes sur la ligne de commande :

Pour afficher la version du gestionnaire de paquets Conda : 

conda –version

Pour afficher la version de l’interpréteur Python : 

python --version

Si vous recevez le message d’erreur « Command not found » pendant la frappe, vous devrez peut-être définir le chemin d’accès aux binaires d’Anaconda. Lisez la section suivante pour en savoir plus. Si les tests ont fonctionné, sautez cette étape.

Créer le chemin pour les binaires d’Anaconda

La variable d’environnement "PATH" contient des informations sur l’emplacement de certains utilitaires dans le système de fichiers. Dans la variable d’environnement, les chemins sont séparés par un double point. Vous pouvez ajouter d’autres chemins, présentés ici pour la version 3 d’Anaconda :

export PATH=/usr/local/anaconda3/bin:"$PATH"

Vous devez stocker cette ligne de code dans votre système pour que le chemin soit réellement actif. Selon le système et le shell utilisé (bash, zsh, etc.), le fichier dans lequel la modification est effectuée diffère. Nous le montrons ici à titre d’exemple pour Bash sous macOS.

Exécutez les lignes de code suivantes sur la ligne de commande pour ajuster la variable de chemin dans le fichier ".bash_profile"

Chemin variable pour étendre l’installation Anaconda

echo -n 'export PATH=/usr/local/anaconda3/bin:"$PATH"' >> "$HOME/.bash_profile"

Télécharger le fichier .bash_profile

source "$HOME/.bash_profile"
Conseil

Utilisez la commande 'cat "$HOME/.bash_profile"' sur la ligne de commande pour afficher le fichier ‘.bash_profile’ existant.

Répétez ensuite les tests :

Affichage de la version du gestionnaire du paquet Conda

conda –version

Afficher la version de l’interpréteur Python

python --version

Vous devriez maintenant voir les numéros de version. Si c’est le cas, vous pouvez continuer à suivre les étapes suivantes.

Mettre à jour son installation Anaconda et Python

Avant de commencer un nouveau projet, il est conseillé de mettre à jour les bibliothèques sous-jacentes. La plateforme Anaconda est livrée avec le gestionnaire de paquets « conda ». Utilisez les commandes conda suivantes pour appliquer les mises à jour disponibles :

Installation de mises à jour pour le gestionnaire de paquets Conda

conda update conda

Installer les mises à jour Anaconda

conda update anaconda

Vérifiez les numéros de version des paquets Keras Deep Learning installés

Keras est écrit en Python et s’appuie sur une variété d’autres modules Python. Exécutez le bloc de code suivant sur la ligne de commande pour afficher les numéros de version des logiciels de deep learning de Keras les plus couramment utilisés :

python << EOF
print()
# scipy
import scipy
print(‘scipy: %s’ % scipy.__version__)
# numpy
import numpy
print(‘numpy: %s’ % numpy.__version__)
# matplotlib
import matplotlib
print(‘matplotlib: %s’ % matplotlib.__version__)
# pandas
import pandas
print(‘pandas: %s’ % pandas.__version__)
# statsmodels
import statsmodels
print(‘statsmodels: %s’ % statsmodels.__version__)
# scikit-learn
import sklearn
print(‘sklearn: %s’ % sklearn.__version__)
print()
EOF

Installer Keras sur son système

Après avoir préparé le système, il s’agit maintenant d’installer Keras. Pour ce faire, exécutez les lignes de code suivantes sur la ligne de commande :

Installer TensorFlow 

pip install tensorflow

Installer Keras 

pip install keras

Comme précédemment, vérifiez ensuite la version de Keras installée. Utilisez pour cela la ligne de code suivante :

python -c "import keras; print(keras.__version__)"

Si l’installation de Keras remonte à un certain temps, vous devez vérifier les mises à jour disponibles et les installer. La ligne de code suivante le fait pour vous. Copiez-le comme d’habitude, et exécutez le code sur la ligne de commande :

pip install --upgrade keras

Exemple de deep learning facile avec Keras

L’équipe Keras a publié une liste d’exemples Keras avec licence gratuite sur GitHub. Nous traiterons les exemples ‘mnist_cnn.py’ pour illustrer ce tutoriel Keras. Le code crée un « convolutional Neural Network » (CNN ou ConvNet) et le forme sur les données de formation.

Pour les données de formation et de test, le script de l’exemple Keras utilise l’ensemble de données de MNIST. Il s’agit d’une importante collection de petites images de 28 x 28 pixels chacune. Chaque image contient un numéro écrit à la main. L’ensemble de données MNIST est la norme pour la reconnaissance des formes et est livré avec Keras.

Si vous êtes curieux, vous pouvez consulter les données relatives à la formation et aux tests. Pour ce faire, copiez le bloc de code suivant et exécutez-le sur la ligne de commande. Chaque fois que vous l’exécuterez, vous verrez l’un des écrans de formation.

python << EOF
# Télécharger Keras 
import keras
# Télécharger les données de formation et de test MNIST 
from keras.datasets import mnist
# Télécharger la bibliothèque pour la présentation graphique 
import matplotlib.pyplot as plt
# Télécharger la fonction de sélection aléatoire des images
from random import randint
# Télécharger les ensembles de données 
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
# Afficher les images 
plt.figure()
plt.imshow(train_images[randint(1, len(train_images) - 1)])
plt.grid(False)
plt.show()
EOF

Dans ce qui suit, nous allons apprendre au réseau de neurones à attribuer correctement les nombres manuscrits. La formation du réseau est exigeante sur le plan informatique. Ne soyez donc pas surpris si votre ordinateur cesse de fonctionner correctement, c’est normal. Si vous utilisez un appareil mobile, assurez-vous que la batterie est suffisamment chargée ou branchez l’appareil.

Nous allons d’abord créer un dossier de test sur le bureau, puis passer à ce dossier et y créer un script Python vide. Utilisez les lignes de code suivantes ; copiez-les et exécutez-les sur la ligne de commande :

Pour créer un dossier « keras-test » sur le bureau

mkdir "$HOME/Desktop/keras-test/" && cd "$HOME/Desktop/keras-test/"

Pour créer un script Python vide

touch keras-test.py

Ensuite, vous devez copier le script dans le fichier « keras-test.py » et le sauvegarder.

Une fois le dossier test créé, l’étape suivante consiste à créer le script d’exemple Keras. Pour ce faire, copiez le code à la fin de cet article et collez-le dans un document texte vide. Enregistrez le document dans le dossier « keras-test » qui vient d’être créé sur le bureau dans le fichier « keras-test.py » jusqu’à présent vide. Enfin, pour exécuter le script d’exemple Keras à l’aide de l’interpréteur Python, entrez les lignes de code suivantes sur la ligne de commande :

cd "$HOME/Desktop/keras-test/" && python keras-test.py

Vous devriez maintenant voir quelques informations sur le statut. Ensuite, le script commencera à former ConvNet, en vous montrant les progrès réalisés à chaque époque. Après l’exécution du script, ConvNet est formé et disponible pour la classification des nombres manuscrits.

Note

Utilisez uniquement un éditeur de code / éditeur de « texte clair » pour enregistrer le code. Vous ne devez en aucun cas utiliser un logiciel de traitement de texte tel que Word, OpenOffice ou LibreOffice.

# Enregistrez le code dans le fichier « keras-test.py » dans le dossier « keras-test »
from __future__ import print_function
# Télécharger Keras 
import keras
# Télécharger les dossiers de formation et de test MNIST
from keras.datasets import mnist
# Télécharger le modèle séquentiel 
from keras.models import Sequential
# Télécharger les couches des cellules neuronales 
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K
# Nombre de caractéristiques de données différentes : chiffres 0-9
num_classes = 10
# Nombre de laissez-passer pour la formation du réseau de neurones
epochs = 12
# Nombre de données utilisées lors d’un passage
batch_size = 128
# Dimensions des images d’entrée (28 x 28 pixels par image)
img_rows, img_cols = 28, 28
# Télécharger les formations et les tests 
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
if K.image_data_format() == ‘channels_first’:
    train_images = train_images.reshape(train_images.shape[0], 1, img_rows, img_cols)
    test_images = test_images.reshape(test_images.shape[0], 1, img_rows, img_cols)
    input_shape = (1, img_rows, img_cols)
else:
    train_images = train_images.reshape(train_images.shape[0], img_rows, img_cols, 1)
    test_images = test_images.reshape(test_images.shape[0], img_rows, img_cols, 1)
    input_shape = (img_rows, img_cols, 1)
# Définir le type de données en nombre décimal 
train_images = train_images.astype(‘float32’)
test_images = test_images.astype(‘float32’)
# Normaliser les données des images
train_images /= 255
test_images /= 255
print(‘train_images shape:’, train_images.shape)
print(train_images.shape[0], ‘train samples’)
print(test_images.shape[0], ‘test samples’)
# Convertir les vecteurs de classe en matrices de classe binaires
train_labels = keras.utils.to_categorical(train_labels, num_classes)
test_labels = keras.utils.to_categorical(test_labels, num_classes)
# Créer un modèle
model = Sequential()
# Ajouter des couches au modèle
model.add(Conv2D(32, kernel_size=(3, 3),
                 activation=‘relu’,
                 input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation=‘relu’))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation=‘relu’))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation=‘softmax’))
# Compiler le modèle
model.compile(loss=keras.losses.categorical_crossentropy,
              optimizer=keras.optimizers.Adadelta(),
              metrics=[‘accuracy’])
# Former le modèle
model.fit(train_images, train_labels,
          batch_size=batch_size,
          epochs=epochs,
          verbose=1,
          validation_data=(test_images, test_labels))
# Évaluer le modèle
score = model.evaluate(test_images, test_labels, verbose=0)
print(‘Test loss:’, score[0])
print(‘Test accuracy:’, score[1])
Cet article vous a-t-il été utile ?