Sauvegarde et chargement de modèle TensorFlow
Dans les projets d'apprentissage automatique et d'apprentissage profond, la sauvegarde et le chargement des modèles sont des étapes cruciales.
TensorFlow propose plusieurs façons de sauvegarder et restaurer des modèles, permettant aux développeurs de :
- Sauvegarder les modèles entraînés pour une utilisation ultérieure
- Partager des modèles avec d'autres développeurs
- Reprendre l'entraînement à partir de checkpoints
- Déployer des modèles dans des environnements de production
TensorFlow 2.x prend principalement en charge trois formats d'enregistrement de modèle :
- Format SavedModel (recommandé)
- Format HDF5 (.h5)
- Format Keras hérité
Sauvegarde du modèle complet
Format SavedModel
SavedModel est le format d'enregistrement de modèle recommandé par TensorFlow. Il contient des informations complètes sur le modèle :
Exemple
import tensorflow as tf
# Créer et entraîner un modèle simple
model = tf.keras.Sequential([
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(x_train, y_train, epochs=5)
# Enregistrer au format SavedModel
model.save('my_model') # Remarque : aucune extension de fichier
# Créer et entraîner un modèle simple
model = tf.keras.Sequential([
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(x_train, y_train, epochs=5)
# Enregistrer au format SavedModel
model.save('my_model') # Remarque : aucune extension de fichier
Structure du répertoire après l'enregistrement :
my_model/ ├── assets/ ├── variables/ │ ├── variables.data-00000-of-00001 │ └── variables.index └── saved_model.pb
Format HDF5
HDF5 est un autre format couramment utilisé pour l'enregistrement des modèles :
Exemple
# Enregistrer au format HDF5
model.save('my_model.h5') # Remarque : l'extension .h5
model.save('my_model.h5') # Remarque : l'extension .h5
Différences entre les deux formats
| Fonctionnalité | SavedModel | HDF5 |
|---|---|---|
| Contient des objets personnalisés | Oui | Nécessite une configuration supplémentaire |
| Contient l'état de l'optimiseur | Oui | Optional |
| TensorFlow Serving | Prise en charge native | Non pris en charge |
| Taille du fichier | Plus volumineux | Plus compact |
Chargement du modèle complet
Chargement depuis SavedModel
Exemple
# Charger depuis SavedModel
loaded_model = tf.keras.models.load_model('my_model')
# Vérifier le modèle
loss, acc = loaded_model.evaluate(x_test, y_test, verbose=2)
print(f"Modèle restauré, précision : {100*acc:.1f}%")
loaded_model = tf.keras.models.load_model('my_model')
# Vérifier le modèle
loss, acc = loaded_model.evaluate(x_test, y_test, verbose=2)
print(f"Modèle restauré, précision : {100*acc:.1f}%")
Chargement depuis un fichier HDF5
Exemple
# Charger depuis le fichier HDF5
loaded_model = tf.keras.models.load_model('my_model.h5')
# Vérifier le modèle
loss, acc = loaded_model.evaluate(x_test, y_test, verbose=2)
print(f"Modèle restauré, précision : {100*acc:.1f}%")
loaded_model = tf.keras.models.load_model('my_model.h5')
# Vérifier le modèle
loss, acc = loaded_model.evaluate(x_test, y_test, verbose=2)
print(f"Modèle restauré, précision : {100*acc:.1f}%")
Sauvegarde et chargement sélectifs
Sauvegarde des poids uniquement
Exemple
# Enregistrer les poids
model.save_weights('my_model_weights')
# Enregistrer les poids au format HDF5
model.save_weights('my_model_weights.h5')
model.save_weights('my_model_weights')
# Enregistrer les poids au format HDF5
model.save_weights('my_model_weights.h5')
Chargement des poids
Exemple
# Créer un modèle avec la même architecture
new_model = tf.keras.Sequential([
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(10, activation='softmax')
])
new_model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# Charger les poids
new_model.load_weights('my_model_weights')
# Ou pour les fichiers .h5
new_model.load_weights('my_model_weights.h5')
new_model = tf.keras.Sequential([
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(10, activation='softmax')
])
new_model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# Charger les poids
new_model.load_weights('my_model_weights')
# Ou pour les fichiers .h5
new_model.load_weights('my_model_weights.h5')
Enregistrement des checkpoints pour les boucles d'entraînement personnalisées
Exemple
# Créer un callback de checkpoint
checkpoint_path = "training_1/cp.ckpt"
cp_callback = tf.keras.callbacks.ModelCheckpoint(
filepath=checkpoint_path,
save_weights_only=True,
verbose=1)
# Entraîner le modèle à l'aide du callback
model.fit(x_train, y_train,
époques=10,
callbacks=[cp_callback])
checkpoint_path = "training_1/cp.ckpt"
cp_callback = tf.keras.callbacks.ModelCheckpoint(
filepath=checkpoint_path,
save_weights_only=True,
verbose=1)
# Entraîner le modèle à l'aide du callback
model.fit(x_train, y_train,
époques=10,
callbacks=[cp_callback])
Bonnes pratiques pour l'enregistrement et le chargement des modèles
- Déploiement en production: Prioriser l'utilisation du format SavedModel
- Partage multiplateforme: le format HDF5 est plus universel
- Récupération après une interruption d'entraînement: Utiliser des callbacks de checkpoint pour enregistrer périodiquement
- Gestion des objets personnalisés:
model.save('custom_model', save_format='tf') - Gestion des versions de modèles: Créer différents répertoires pour différentes versions de modèles
Problèmes courants et solutions
Problèmes de sauvegarde des couches/modèles personnalisés
Exemple
# Exemple de couche personnalisée
class CustomLayer(tf.keras.layers.Layer):
def __init__(self, units=32, **kwargs):
super().__init__(**kwargs)
self.units = units
def build(self, input_shape):
self.w = self.add_weight(
shape=(input_shape[-1], self.units),
initializer="random_normal",
trainable=True)
def call(self, inputs):
return tf.matmul(inputs, self.w)
def get_config(self):
config = super().get_config()
config.update({"units": self.units})
return config
# Utiliser une couche personnalisée et enregistrer
model = tf.keras.Sequential([CustomLayer(10)])
model.compile(optimizer='adam', loss='mse')
model.save('custom_model') # La couche personnalisée sera sauvegardée automatiquement
class CustomLayer(tf.keras.layers.Layer):
def __init__(self, units=32, **kwargs):
super().__init__(**kwargs)
self.units = units
def build(self, input_shape):
self.w = self.add_weight(
shape=(input_shape[-1], self.units),
initializer="random_normal",
trainable=True)
def call(self, inputs):
return tf.matmul(inputs, self.w)
def get_config(self):
config = super().get_config()
config.update({"units": self.units})
return config
# Utiliser une couche personnalisée et enregistrer
model = tf.keras.Sequential([CustomLayer(10)])
model.compile(optimizer='adam', loss='mse')
model.save('custom_model') # La couche personnalisée sera sauvegardée automatiquement
Problèmes de compatibilité entre versions
- Essayez d'utiliser la même version de TensorFlow pour sauvegarder et charger les modèles
- Pour les environnements de production, envisagez d'utiliser TensorFlow Serving pour éviter les problèmes de version
Optimisation de la sauvegarde des grands modèles
Exemple
# Utilisez save_weights au lieu de save pour réduire le temps de sauvegarde
model.save_weights('large_model_weights.h5')
model.save_weights('large_model_weights.h5')