20.8 Création de réseaux de neurones avec Keras et TensorFlow : compilation et entraînement de modèles de Deep Learning
Les progrès de l'intelligence artificielle ces dernières années ont été largement stimulés par le développement des réseaux de neurones profonds (apprentissage profond). Python s'est imposé comme le principal langage de programmation pour créer et entraîner ces modèles, grâce à des bibliothèques comme Keras et TensorFlow. Dans ce chapitre, nous explorerons le processus de compilation et de formation de modèles d'apprentissage profond à l'aide de ces outils puissants.
Présentation de Keras et TensorFlow
Keras est une API de haut niveau permettant de créer et d'entraîner des réseaux de neurones, qui s'exécute sur des frameworks de bas niveau tels que TensorFlow, Theano ou CNTK. TensorFlow, quant à lui, est une bibliothèque open source pour le calcul numérique et l'apprentissage automatique développée par l'équipe Google Brain.
La combinaison de Keras et TensorFlow fournit une plate-forme puissante et flexible pour créer des modèles d'apprentissage profond, permettant aux développeurs de créer des réseaux neuronaux complexes plus facilement et plus rapidement.
Créer un réseau neuronal avec Keras
Pour construire un réseau de neurones dans Keras, nous commençons par définir l'architecture du modèle. Il s’agit de préciser le nombre de couches, le nombre de neurones dans chaque couche et les fonctions d’activation à utiliser. Keras propose deux manières de définir un modèle : en utilisant l'API séquentielle pour les réseaux avec une séquence linéaire de couches, ou l'API fonctionnelle pour les architectures plus complexes et flexibles.
à partir de keras.models, importation séquentielle
à partir de keras.layers importer Dense
# Initialisation du modèle séquentiel
modèle = Séquentiel()
# Ajout du calque d'entrée et du premier calque caché
model.add(Dense(units=64, activation='relu', input_shape=(input_size,)))
# Ajout de la couche de sortie
model.add(Dense(units=num_classes, activation='softmax'))
Compilation de modèles
Après avoir défini l'architecture du modèle, l'étape suivante consiste à compiler le modèle. La compilation est le processus par lequel le modèle est configuré pour la formation. Ici, nous spécifions la fonction de perte, l'optimiseur et les métriques que nous souhaitons suivre pendant l'entraînement.
model.compile(loss='categorical_crossentropy',
optimiseur='adam',
métriques=['précision'])
La fonction de perte détermine la manière dont le modèle mesurera ses performances sur les données d'entraînement. L'optimiseur est l'algorithme qui mettra à jour les poids du réseau pendant l'entraînement. La métrique « précision » est couramment utilisée pour les problèmes de classification.
Formation du modèle
La formation d'un réseau neuronal implique d'alimenter les données d'entrée du modèle et de le laisser ajuster ses poids pour minimiser la fonction de perte. Dans Keras, cela se fait via la méthode fit.
historique = model.fit(x_train, y_train,
batch_size=32,
époques = 10,
validation_data=(x_val, y_val))
La méthode fit reçoit les données d'entraînement (x_train, y_train), la taille du lot (batch_size), le nombre d'époques (epochs) et éventuellement, les données de validation. Une époque est une itération sur l’ensemble de données complet. L'historique d'entraînement, renvoyé par la méthode fit, contient des informations sur la fonction de perte et les mesures de performances à travers les époques.
Évaluation et prédiction
Après la formation, nous évaluons les performances du modèle sur les données de test.
perte, précision = model.evaluate(x_test, y_test)
print(f'Test de précision : {précision}')
Pour faire des prédictions avec le modèle entraîné, nous utilisons la méthode predict.
prédictions = model.predict(x_test)
Réglage précis et régularisation
Pour améliorer les performances du modèle, nous pouvons affiner son architecture ou ses paramètres d'entraînement. Une régularisation, telle que la régularisation Dropout et L1/L2, peut être ajoutée pour éviter le surajustement, qui se produit lorsque le modèle surajuste les données d'entraînement et ne se généralise pas bien aux nouvelles données.
à partir de keras.layers import Dropout
des régularisateurs d'importation keras
# Ajout de la régularisation Dropout et L2 à la couche cachée
model.add(Dense(64, activation='relu', kernel_regularizer=regularizers.l2(0.01)))
modèle.ajouter (Abandon (0.5))
Optimisation des hyperparamètres
Le choix des hyperparamètres, tels que le taux d'apprentissage de l'optimiseur et la taille des lots, peut avoir un impact important sur l'entraînement et les performances du modèle. L'utilisation de techniques d'optimisation d'hyperparamètres telles que la recherche sur grille ou la recherche aléatoire peut aider à trouver la meilleure configuration.
Conclusion
Créez et entraînez des modèles de Deep Learning avec Keraset TensorFlow est un processus itératif qui implique la définition de l'architecture du modèle, sa compilation, sa formation, son évaluation et son optimisation. En maîtrisant ces étapes, les développeurs peuvent créer de puissants réseaux de neurones capables de résoudre un large éventail de problèmes complexes d'apprentissage automatique.
Avec de la pratique et de l'expérience, vous pouvez modifier et améliorer vos modèles pour obtenir des performances encore plus élevées. La puissance de Keras et TensorFlow réside dans leur flexibilité et leur facilité d'utilisation, qui rendent le deep learning accessible à un public plus large.
