Deep Learning: comprendre et construire des réseaux de neurones

Auteur: Mohamed CHINY Durée necessaire pour le cours de Deep Learning: comprendre et construire des réseaux de neurones Niveau recommandé pour le cours de Deep Learning: comprendre et construire des réseaux de neurones Supports vidéo non disponibles pour ce cours Exercices de renforcement non disponibles pour ce cours Quiz disponible pour ce cours

Leçon 24: Sauvegarder et recharger un modèle de Deep Learning pour une future réutilisation

Toutes les leçons

Deep Learning: comprendre et construire des réseaux de neurones

Leçon 1
Deep Learning et réseaux de neurones: définition, utilité et histoire d'évolution
Leçon 2
Réseaux de neurones artificiels: la base du Deep Learning
Leçon 3
Feed Forward et Backpropagation: les pilliers de l'apprentissage des réseaux de neurones
Leçon 4
TensorFlow, PyTorch et Keras: les piliers actuels du Deep Learning
Leçon 5
Sequential, Input et Dense: construire un réseau de neurones pour la régression avec Keras
Leçon 6
Construire un réseau de neurones pour des données non linéaires avec Keras
Leçon 7
Training Loss et Validation Loss: détecter l'overfitting dans les réseaux de neurones
Leçon 8
Réseaux de neurones appliqués à la classification binaire
Leçon 9
Application des réseaux de neurones à la classification multiclasse sur Iris
Leçon 10
Prévenir l'overfitting grace à la régularisation: principes et techniques fondamentales
Leçon 11
Régularisation L1, L2, Dropout, Batch Normalization et Early Stopping - Mise en pratique
Leçon 12
Convolutional Neural Networks (CNN): réseaux de neurones dédiés aux images
Leçon 13
CNN et MNIST: reconnaissance et classification des chiffres manuscrits
Leçon 14
CNN et CIFAR-10: reconnaissance et classification d'images en couleur
Leçon 15
Recurrent Neural Networks (RNN): Réseaux de neurones dédiés aux séquences
Leçon 16
Apprendre à construire un RNN simple pour la prédiction séquentielle
Leçon 17
Limites des RNN face au vanishing gradient et aux dépendances longues: apports des LSTM et GRU
Leçon 18
LSTM: Long Short-Term Memory - une mémoire longue durée pour les séquences
Leçon 19
Apprentissage séquentiel avec LSTM pour comprendre la dynamique des températures
Leçon 20
GRU: Gated Recurrent Unit - vers une simplification des architectures récurrentes
Leçon 21
Analyse des séries temporelles de consommation électrique domestique par réseaux GRU
Leçon 22
Le mécanisme d'attention et la résolution des limites des RNN
Leçon 23
Transformers: une architecture Deep Learning moderne et flexible
Leçon 24
Sauvegarder et recharger un modèle de Deep Learning pour une future réutilisation

La persistance des modèles Deep Learning: optimiser le temps et les ressources grâce à la sauvegarde

Pourquoi sauvegarder un modèle de Deep Learning?

Lorsqu’on entraîne un modèle de Deep Learning, on investit beaucoup de temps et de ressources (données, puissance de calcul, réglages des hyperparamètres...). Il serait donc inefficace de devoir tout recommencer à chaque utilisation. Sauvegarder le modèle permet de réutiliser les poids déjà appris, de le partager avec d’autres développeurs, ou encore de le déployer dans une application sans relancer l’entraînement.

Dans le cours consacré au Machine Learning, nous avons déjà vu comment utiliser joblib pour les modèles statistiques classiques avec scikit‑learn. Cependant, pour les modèles de Deep Learning, il est préférable d’utiliser les méthodes natives des frameworks (par exemple model.save() et load_model() en Keras, ou torch.save() en PyTorch), car elles garantissent une meilleure compatibilité et une reconstruction correcte de l’architecture et des poids.

Que sauvegarde-t-on exactement en Deep Learning?

Lorsqu’on enregistre un modèle de Deep Learning, on ne se limite pas à une simple fonction ou à des paramètres isolés. La sauvegarde inclut généralement l’architecture du réseau (la structure des couches et leurs connexions), les poids et biais appris pendant l’entraînement, ainsi que parfois l’état de l’optimiseur (utile pour reprendre l’entraînement là où il s’était arrêté).

Selon le framework utilisé, on peut aussi conserver des hyperparamètres ou des métadonnées liées au modèle. Cette approche garantit que le modèle peut être rechargé et utilisé immédiatement sans perte d’information ni besoin de réentraîner.

Entraînement et sauvegarde d’un modèle avec Keras sur le dataset MNIST

Dans ce premier code, nous allons construire et entraîner un modèle de Deep Learning, puis l’enregistrer afin de pouvoir le réutiliser plus tard sans devoir recommencer l’entraînement. Pour illustrer cette démarche, nous utiliserons le célèbre dataset MNIST, composé d’images de chiffres manuscrits.

Je propose ce code:
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical

(X_train,y_train),(X_test,y_test) = mnist.load_data()
X_train = X_train
   .reshape(-1,28*28).astype("float32")/255
X_test = X_test
   .reshape(-1,28*28).astype("float32")/255
y_train = to_categorical(y_train,10)
y_test = to_categorical(y_test,10)

model = Sequential([
   Dense(128, activation="relu", input_shape=(784,)),
   Dense(64, activation="relu"),
   Dense(10, activation="softmax")
])

model.compile(
   optimizer="adam",
   loss="categorical_crossentropy",
   metrics=["accuracy"]
)

model.fit(
   X_train, y_train, epochs=5,
   batch_size=32, validation_split=0.1
)

# Sauvegarde du modèle
model.save("mnist_model.h5")
Dans la pratique, il est généralement mieux de traiter le dataset MNIST avec des réseaux CNN comme on l'a vu dans cet exemple, car ceux‑ci exploitent la structure spatiale des images. Toutefois, l’objectif de cette leçon n’est pas d’optimiser les performances, mais de montrer la démarche de sauvegarde et de rechargement d’un modèle en Deep Learning.
Le format .h5 correspond au standard HDF5 (Hierarchical Data Format), largement utilisé pour stocker des données scientifiques et adopté par Keras/TensorFlow pour enregistrer les modèles de Deep Learning.

Lorsqu’on exécute l’instruction model.save("mnist_model.h5"), Keras crée un fichier qui contient à la fois l’architecture du réseau, les poids appris pendant l’entraînement, ainsi que la configuration de l’optimiseur si nécessaire. Ce fichier permet de recharger le modèle complet plus tard, sans avoir à redéfinir manuellement les couches ou relancer l’entraînement.

Dans le script dédié à la prédiction, je propose d’utiliser le code suivant, qui permet de recharger le modèle sauvegardé puis de l’appliquer sur un exemple du dataset afin d’obtenir une classe prédite:
from tensorflow.keras.models import load_model
from tensorflow.keras.datasets import mnist
import numpy as np

# Chargement du modèle
model = load_model("mnist_model.h5")

(_,_),(X_test,y_test) = mnist.load_data()
X_test = X_test.
   reshape(-1,28*28).astype("float32")/255

sample = X_test[0].reshape(1, -1)
prediction = model.predict(sample)
predicted_class = np.argmax(prediction)

print("Prédiction:", predicted_class)
On commence par importer importer la fonction load_model depuis le module tensorflow.keras.models:
from tensorflow.keras.models import load_model
Cette importation permet de recharger un modèle de Deep Learning précédemment sauvegardé.

La partie la plus importante pour nous consiste à recharger le modèle:
model = load_model("mnist_model.h5")
Cette instruction recharge le modèle sauvegardé dans le fichier mnist_model.h5. Concrètement, cette commande reconstruit automatiquement l’architecture du réseau, restaure les poids appris et remet en place la configuration nécessaire pour que le modèle soit immédiatement utilisable. Grâce à cela, on peut directement effectuer des prédictions ou reprendre l’entraînement sans avoir à redéfinir ni réentraîner le modèle depuis zéro.
La sauvegarde d’un modèle est particulièrement utile lorsque l’on souhaite le déployer dans un environnement réel, par exemple à travers une API ou une application web. En enregistrant le modèle, on évite de réentraîner à chaque fois et on peut l’intégrer directement dans un service qui répond aux requêtes des utilisateurs en temps réel.
         
         
         
         
         
         
         
         
         
         
         
Leçon 24
Sauvegarder et recharger un modèle de Deep Learning pour une future réutilisation