20.4. Créer des réseaux de neurones avec Keras et TensorFlow
Le développement de réseaux neuronaux est devenu plus accessible grâce à l'introduction de bibliothèques de haut niveau telles que Keras, qui fonctionne sur TensorFlow, une puissante bibliothèque d'apprentissage automatique. Dans ce chapitre, nous explorerons comment construire des modèles séquentiels dans Keras, permettant la création de réseaux de neurones profonds de manière simplifiée et efficace.
Présentation de Keras
Keras est une API de réseau neuronal de haut niveau écrite en Python capable de s'exécuter sur TensorFlow, CNTK ou Theano. Il a été développé en mettant l’accent sur l’expérimentation rapide et la productivité, permettant de transformer les idées en résultats dans un délai minimal. La simplicité et la facilité d'utilisation de Keras en ont fait l'un des outils les plus populaires parmi les scientifiques des données et les ingénieurs en apprentissage automatique.
Modèles séquentiels dans Keras
Un modèle séquentiel dans Keras est une pile linéaire de couches. Il s’agit du type de modèle le plus simple et convient à la plupart des problèmes d’apprentissage profond. Avec lui, vous pouvez créer un réseau neuronal en ajoutant des couches les unes après les autres de manière séquentielle.
Installer Keras et TensorFlow
Avant de commencer à créer un modèle, vous devez installer Keras et TensorFlow. Cela peut être facilement fait en utilisant pip, le gestionnaire de packages Python :
pip installer tensorflow
pip installer keras
Après l'installation, vous pouvez importer Keras et vérifier la version de TensorFlow pour vous assurer que tout est correctement configuré :
importer Tensorflow en tant que TF
importer des keras
imprimer(tf.__version__)
imprimer(keras.__version__)
Créer un modèle séquentiel
Pour créer un modèle séquentiel dans Keras, vous commencez par importer la classe Sequential et ajouter des couches à l'aide de la méthode add(). Créons un modèle simple pour la classification d'images :
à partir de keras.models, importation séquentielle
à partir de keras.layers, importez Dense, Flatten, Conv2D, MaxPooling2D
# Initialiser le modèle séquentiel
modèle = Séquentiel()
# Ajouter une couche convolutionnelle
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
# Ajouter une couche de pooling
modèle.add(MaxPooling2D((2, 2)))
# Aplatir la sortie pour fournir une entrée aux couches denses
model.add(Aplatir())
# Ajouter une couche dense (entièrement connectée)
model.add(Dense(100, activation='relu'))
# Ajouter une couche de sortie
model.add(Dense(10, activation='softmax'))
Ce modèle se compose d'une couche convolutive suivie d'une couche de regroupement, d'une couche d'aplatissement et de deux couches denses. La dernière couche dense utilise la fonction d'activation softmax pour obtenir des probabilités de classification pour chacune des 10 classes possibles.
Compiler le modèle
Après avoir construit le modèle, vous devez le compiler. Cela se fait à l'aide de la méthode compile(), où vous définissez la fonction de perte, l'optimiseur et les métriques d'évaluation :
model.compile(optimizer='adam',
perte='categorical_crossentropy',
métriques=['précision'])
La fonction de perte categorical_crossentropy est couramment utilisée dans les problèmes de classification multiclasse. L'optimiseur adam est un choix populaire en raison de son efficacité et de son ajustement automatique du taux d'apprentissage.
Formation du modèle
Une fois le modèle compilé, vous pouvez l'entraîner à l'aide de la méthode fit(). Vous devrez fournir les données d'entraînement, les étiquettes, le nombre d'époques et la taille du lot :
history = model.fit (train_data, train_labels, époques = 10, batch_size = 32)
L'objet history contient des informations sur le processus de formation, telles que la perte et la précision à chaque époque, qui peuvent être utilisées pour l'analyse et le réglage du modèle.
Évaluer et enregistrer le modèle
Après l'entraînement, vous pouvez évaluer les performances du modèle sur les données de test à l'aide de la méthode evaluate() :
test_loss, test_acc = model.evaluate(test_data, test_labels)
print('Précision du test :', test_acc)
Si vous êtes satisfait des performances du modèle, vous pouvez le sauvegarder à l'aide de la méthode save(), vous permettant de le charger plus tard pour faire des prédictions ou continuer l'entraînement :
modèle.save('mon_modèle.h5')
Conclusion
La création de réseaux neuronaux avec Keras et TensorFlow est un processus simple et efficace. L'API séquentielle de Keras vous permet de créer des modèles couche par couche, tandis que TensorFlow offre la robustesse et l'évolutivité nécessaires pour entraîner des modèles complexes. Avec la couverturecapable de compiler, former, évaluer et enregistrer facilement des modèles, Keras est un outil indispensable pour toute personne intéressée par l'apprentissage en profondeur avec Python.
