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 :

  1. Format SavedModel (recommandé)
  2. Format HDF5 (.h5)
  3. 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

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

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}%")

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}%")

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')

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')

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])

Bonnes pratiques pour l'enregistrement et le chargement des modèles

  1. Déploiement en production: Prioriser l'utilisation du format SavedModel
  2. Partage multiplateforme: le format HDF5 est plus universel
  3. Récupération après une interruption d'entraînement: Utiliser des callbacks de checkpoint pour enregistrer périodiquement
  4. Gestion des objets personnalisés:
    model.save('custom_model', save_format='tf')
  5. 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

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')
Autres extensions