Apprentissage en profondeur avec Keras : formation d'un réseau de neurones avec Keras [avec code]
Publié: 2020-12-24Keras est une bibliothèque Python qui fournit une API pour travailler avec les réseaux de neurones et les frameworks d'apprentissage en profondeur. Keras fournit des fonctions et des modules extrêmement pratiques lorsqu'il s'agit de diverses applications d'apprentissage en profondeur en Python.
À la fin de ce didacticiel, vous aurez les connaissances suivantes :
- Qu'est-ce que Keras ?
- API Keras
- Formation d'un réseau de neurones à Keras
Table des matières
Qu'est-ce que Keras ?
Pour faire du Deep Learning, la bibliothèque la plus utilisée auparavant était Tensorflow 1.x qui était difficile à gérer pour les débutants. Il a fallu beaucoup de codage pour créer un réseau de base à 1 couche. Cependant, avec Keras, le processus complet de création de la structure d'un réseau de neurones, puis de sa formation et de son suivi est devenu extrêmement facile.
Keras est une API de haut niveau qui peut s'exécuter sur les backends Tensorflow, Theano et CNTK. Cela nous donne la possibilité d'exécuter des expériences à l'aide de réseaux de neurones à l'aide d'une API de haut niveau et conviviale. Il est également capable de fonctionner sur des CPU et des GPU.
API Keras
Keras dispose de 10 modules API différents destinés à gérer la modélisation et la formation des réseaux de neurones. Passons en revue chacun d'eux pour comprendre ce que tout Keras a à offrir.
Des modèles
L'API Models fournit la fonctionnalité permettant de créer des réseaux de neurones complexes en ajoutant/supprimant des couches. Le modèle peut être séquentiel, ce qui signifie que les couches seront empilées séquentiellement avec une seule entrée et sortie. Le modèle peut également être fonctionnel, c'est-à-dire avec des modèles entièrement personnalisables. C'est ce qui est le plus utilisé dans l'industrie.

L'API dispose également du module de formation qui fournit des méthodes pour compiler le modèle avec l'optimiseur et la fonction de perte, une méthode pour ajuster le modèle, une méthode pour évaluer et prédire également sur de nouvelles données. De plus, il dispose également de méthodes de formation, de test et de prédiction sur des données de lot. L'API des modèles permet également de sauvegarder et de sérialiser les modèles.
Couches
Les couches sont les éléments constitutifs de tout réseau de neurones. L'API Layers offre un ensemble complet de méthodes pour construire l'architecture du réseau neuronal. L'API Layers a la classe Base Layer qui contient les méthodes nécessaires pour créer des couches personnalisées avec des poids et des initialiseurs personnalisés.
Il contient la classe Layer Activations qui comprend les différentes fonctions d'activation telles que ReLU, Sigmoid, Tanh, Softmax, etc. La classe Layer Weight Initializers propose des méthodes pour initialiser les poids de différentes manières.
Il se compose également de la classe Core Layers qui se compose de classes nécessaires pour ajouter des couches centrales telles que la couche dense, la couche d'activation, la couche d'intégration, etc. La classe Convolution Layer propose diverses méthodes pour ajouter différents types de couches de convolution. La classe Pooling Layers contient les méthodes requises pour différents types de pooling tels que Max Pooling, Average Pooling, Global Max Pooling et Global Average Pooling.
Rappels
Les rappels sont un moyen de suivre le processus de formation du modèle. Lorsque le rappel est activé, diverses actions peuvent être effectuées avant ou après la fin d'une époque ou d'un lot. Avec les rappels, vous pouvez :
- Surveillez les métriques d'entraînement en enregistrant les métriques dans TensorFlow Board
- Enregistrement périodique du modèle sur le disque
- Arrêt précoce au cas où la perte ne diminue pas de manière significative après une certaine époque
- Afficher les états internes et les statistiques d'un modèle pendant la formation
Prétraitement de l'ensemble de données
Les données sont généralement au format brut et se trouvent dans des répertoires organisés et doivent être prétraitées avant d'être introduites dans le modèle pour l'ajustement. La classe Image Data Preprocessing possède de nombreuses fonctions dédiées. Par exemple, les données d'image doivent être dans le tableau numérique pour lequel nous pouvons utiliser la fonction img_to_array. Ou si les images sont présentes dans un répertoire et des sous-dossiers, nous pouvons utiliser la fonction image_dataset_from_directory.
L'API de prétraitement des données a également des classes pour les données de séries chronologiques et les données textuelles.
Optimiseurs
Les optimiseurs sont l'épine dorsale de tout réseau de neurones. Chaque réseau de neurones travaille sur l'optimisation d'une fonction de perte pour trouver les meilleurs poids pour la prédiction. Il existe plusieurs types d'optimiseurs qui suivent des techniques légèrement différentes pour trouver des poids optimaux. Tous ces optimiseurs sont disponibles dans l'API Optimizers - SGD, RMSProp, Adam, Adadelta, Adagrad, Adamax, Nadal, FTRL.
Pertes
Les fonctions de perte doivent être spécifiées lors de la compilation d'un modèle. Cette fonction de perte serait optimisée par l'optimiseur qui était également passé en paramètre dans la méthode de compilation. Les trois principales classes de pertes sont : les pertes probabilistes, les pertes de régression, les pertes charnières.
Métrique
Les métriques sont utilisées dans chaque modèle ML pour quantifier ses performances sur les données de test. Les métriques sont similaires aux fonctions de perte, sauf qu'elles sont utilisées sur les données de test. Il existe de nombreuses mesures de précision disponibles telles que la précision, la précision binaire, la précision catégorielle, etc. Il contient également des mesures probabilistes telles que l'entropie croisée binaire, l'entropie croisée catégorielle, etc. Précision, rappel, etc.
Outre ces métriques de classification, il possède également des métriques de régression telles que l'erreur quadratique moyenne, l'erreur quadratique moyenne racine, l'erreur absolue moyenne, etc.

Lisez aussi: Le quoi de Keras et TensorFlow
Applications Keras
La classe Keras Applications comprend des modèles prédéfinis ainsi que des poids pré-formés. Ces modèles préformés sont utilisés pour le processus d'apprentissage par transfert. Ces modèles pré-entraînés sont différents selon l'architecture, le nombre de couches, les poids entraînables, etc. Certains d'entre eux sont Xception, VGG16, Resnet50, MobileNet, etc.
Formation d'un réseau de neurones avec Keras
Considérons un ensemble de données simple tel que MNIST qui est disponible dans la classe des ensembles de données de Keras. Nous allons créer un simple réseau de neurones convolutifs séquentiels pour classer les images manuscrites des chiffres 0-9.
#Chargement du jeu de données depuis keras.datasets importer mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() |
Normaliser l'ensemble de données en divisant chaque pixel par 255. De plus, il est nécessaire de transformer les images en 4 dimensions avant de les alimenter à un modèle CNN.
x_train = x_train.astype( 'float32' ) x_test = x_test.astype( 'float32' ) x_train /= 255 x_test /= 255 x_train = X_train.reshape(X_train.forme[ 0 ], 28 , 28 , 1 ) x_test = X_test.reshape(X_test.shape[ 0 ], 28 , 28 , 1 ) |
Nous devons étiqueter les classes avant de les alimenter au modèle. Nous le ferons en utilisant la classe Utils de Keras.
de l' importation de keras.utils vers_categorical
|
Nous pouvons maintenant commencer à créer le modèle à l'aide de l'API séquentielle.
depuis keras.models import séquentiel de keras.layers import Conv2D, MaxPool2D, Dense, Flatten, Dropout model = Sequential() model.add(Conv2D(filters= 32 , kernel_size=( 5 , 5 ), activation= 'relu' , input_shape=x_train.shape[ 1 :])) model.add(MaxPool2D(pool_size=( 2 , 2 ))) model.add(Dropout(rate= 0.25 )) model.add(Conv2D(filters= 64 , kernel_size=( 3 , 3 ), activation= 'relu' )) model.add(MaxPool2D(pool_size=( 2 , 2 ))) model.add(Dropout(rate= 0.25 )) model.add(Aplatir()) model.add(Dense( 256 , activation= 'relu' )) model.add(Dropout(rate= 0.5 )) model.add(Dense( 10 , activation= 'softmax' )) |
Dans le code ci-dessus, nous déclarons un modèle séquentiel, puis y ajoutons plusieurs couches. La couche convolutive, suivie d'une couche Max Pooling, puis d'une couche d'abandon pour la régularisation. Plus tard, nous aplatissons la sortie à l'aide de la couche d'aplatissement et la dernière couche est une couche dense entièrement connectée avec 10 nœuds.
Ensuite, nous devons le compiler en passant la fonction de perte, l'optimiseur et la métrique.
modèle.compile( loss= 'categorical_crossentropy' , optimiseur= 'adam' , metrics=[ 'précision' ] ) |
Nous devons maintenant ajouter des images augmentées à partir des images d'origine pour augmenter l'ensemble d'apprentissage et la précision du modèle. Nous le ferons en utilisant la fonction ImageDataGenerator.
à partir de keras.preprocessing.image importer ImageDataGenerator datagen = ImageDataGenerator( rotation_range= 10 , zoom_range= 0.1 , width_shift_range= 0.1 , height_shift_range= 0.1 ) |
Maintenant que le modèle est compilé et que les images sont augmentées, nous pouvons commencer le processus de formation. Comme nous avons utilisé un générateur de données d'image ci-dessus, nous utiliserons la méthode fit_generator plutôt que juste fit.

époques = 3 taille_lot = 32 history = model.fit_generator( datagen.flow(x_train, y_train, batch_size=batch_size), epochs=epochs, validation_data=(x_test, y_test), steps_per_epoch=x_train.shape[ 0 ]//batch_size ) |
Le résultat du processus de formation est le suivant :
3Maintenant, le modèle est formé et peut être évalué en l'exécutant sur des données de test invisibles.
Lecture connexe : Apprentissage en profondeur et réseaux de neurones avec Keras
Avant que tu partes
Dans ce didacticiel, nous avons vu à quel point Keras est bien structuré et facilite la construction d'un réseau de neurones complexe. Keras est maintenant enveloppé sous Tensorflow 2.x, ce qui lui donne encore plus de fonctionnalités. Essayez d'autres exemples de ce type et explorez les fonctions et fonctionnalités de Keras.
Si vous souhaitez en savoir plus sur l'apprentissage automatique, consultez le diplôme PG en apprentissage automatique et IA de IIIT-B & upGrad, conçu pour les professionnels en activité et offrant plus de 450 heures de formation rigoureuse, plus de 30 études de cas et missions, IIIT- Statut B Alumni, plus de 5 projets de synthèse pratiques et aide à l'emploi avec les meilleures entreprises.