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.