Keras est une bi­blio­thèque open source pour la création d’ap­pli­ca­tions de deep learning. Keras est écrit en Python et fournit une interface commune pour dif­fé­rents backends de deep learning tels que Ten­sor­Flow et Theano. Le Deep Learning fait partie du machine learning et se base sur les réseau de neurones ar­ti­fi­ciels.

Keras vise à sim­pli­fier l’entrée dans le deep learning. Au cours de ce tutoriel Keras, nous ex­pli­que­rons, à l’aide d’un exemple simple, comment fonc­tionne cette bi­blio­thèque.

Backup Cloud par Acronis
Protégez vos appareils et réduisez les temps d'arrêt
  • Sau­ve­garde au­to­ma­tique et res­tau­ra­tion facile
  • Gestion et pla­ni­fi­ca­tion in­tui­tives
  • Pro­tec­tion 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’uti­li­sa­tion de Keras est d’installer le logiciel Anaconda. Il s’agit d’une pla­te­forme gratuite pour la data science. Livrée avec une ins­tal­la­tion Python3, elle contient des bi­blio­thèques et des outils utiles.

Installer Anaconda et Python

Les ex­pli­ca­tions et le code ci-dessous se réfèrent à macOS. En principe, le code devrait également fonc­tion­ner sous d’autres systèmes d’ex­ploi­ta­tion. Cependant, vous devrez peut-être faire quelques ajus­te­ments, 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 con­nais­sez pas Homebrew, ou si vous souhaitez installer Anaconda sous Windows ou Linux, veuillez té­lé­char­ger le package d’ins­tal­la­tion adapté à votre système à partir de la page suivante : version « In­di­vi­dual » d’Anaconda.

Tester l’ins­tal­la­tion d’Anaconda et Python

Pour vous assurer que Anaconda et Python sont cor­rec­te­ment installés, exécutez les commandes suivantes sur la ligne de commande :

Pour afficher la version du ges­tion­naire de paquets Conda : 

conda –version

Pour afficher la version de l’in­ter­pré­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 fonc­tionné, sautez cette étape.

Créer le chemin pour les binaires d’Anaconda

La variable d’en­vi­ron­ne­ment "PATH" contient des in­for­ma­tions sur l’em­pla­ce­ment de certains uti­li­taires dans le système de fichiers. Dans la variable d’en­vi­ron­ne­ment, 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éel­le­ment actif. Selon le système et le shell utilisé (bash, zsh, etc.), le fichier dans lequel la mo­di­fi­ca­tion 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’ins­tal­la­tion Anaconda

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

Té­lé­char­ger 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 ges­tion­naire du paquet Conda

conda –version

Afficher la version de l’in­ter­pré­teur Python

python --version

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

Mettre à jour son ins­tal­la­tion Anaconda et Python

Avant de commencer un nouveau projet, il est conseillé de mettre à jour les bi­blio­thèques sous-jacentes. La pla­te­forme Anaconda est livrée avec le ges­tion­naire de paquets « conda ». Utilisez les commandes conda suivantes pour appliquer les mises à jour dis­po­nibles :

Ins­tal­la­tion de mises à jour pour le ges­tion­naire 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 cou­ram­ment 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 main­te­nant d’installer Keras. Pour ce faire, exécutez les lignes de code suivantes sur la ligne de commande :

Installer Ten­sor­Flow 

pip install tensorflow

Installer Keras 

pip install keras

Comme pré­cé­dem­ment, 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’ins­tal­la­tion de Keras remonte à un certain temps, vous devez vérifier les mises à jour dis­po­nibles 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 trai­te­rons les exemples ‘mnist_cnn.py’ pour illustrer ce tutoriel Keras. Le code crée un « con­vo­lu­tio­nal 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 im­por­tante col­lec­tion 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 re­con­nais­sance 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é­cu­te­rez, 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 cor­rec­te­ment les nombres ma­nus­crits. La formation du réseau est exigeante sur le plan in­for­ma­tique. Ne soyez donc pas surpris si votre or­di­na­teur cesse de fonc­tion­ner cor­rec­te­ment, c’est normal. Si vous utilisez un appareil mobile, assurez-vous que la batterie est suf­fi­sam­ment 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 sau­ve­gar­der.

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. En­re­gis­trez 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’in­ter­pré­teur Python, entrez les lignes de code suivantes sur la ligne de commande :

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

Vous devriez main­te­nant voir quelques in­for­ma­tions sur le statut. Ensuite, le script com­men­cera à former ConvNet, en vous montrant les progrès réalisés à chaque époque. Après l’exécution du script, ConvNet est formé et dis­po­nible pour la clas­si­fi­ca­tion des nombres ma­nus­crits.

Note

Utilisez uni­que­ment un éditeur de code / éditeur de « texte clair » pour en­re­gis­trer le code. Vous ne devez en aucun cas utiliser un logiciel de trai­te­ment de texte tel que Word, Ope­nOf­fice ou Li­breOf­fice.

# 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])
Aller au menu principal