> ## Documentation Index > Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt > Use this file to discover all available pages before exploring further. # Keras > Utilisez les callbacks Keras de W&B pour suivre les expériences, enregistrer des points de contrôle de vos modèles et visualiser les prédictions pendant l’entraînement. export const ColabLink = ({url}) => Try in Colab ; Utilisez les callbacks Keras de W\&B pour suivre les expériences, journaliser les points de contrôle de vos modèles et visualiser les prédictions du modèle pendant l’entraînement. Grâce à cette intégration, vous pouvez ajouter le suivi des expériences et la gestion des versions des modèles à vos flux de travail d’entraînement Keras sans réécrire votre boucle d’entraînement. Les callbacks Keras sont disponibles dans le module `wandb.integration.keras` à partir de la version `0.13.4` du SDK Python. L’intégration Keras de W\&B fournit les callbacks suivants : * **`WandbMetricsLogger`** : utilisez ce callback pour le [suivi des expériences](/fr/products/wandb/track). Il journalise dans W\&B vos métriques d’entraînement et de validation, ainsi que les métriques système. * **`WandbModelCheckpoint`** : utilisez ce callback pour journaliser les points de contrôle de votre modèle dans W\&B [Artifacts](/fr/products/wandb/artifacts). * **`WandbEvalCallback`** : ce callback de base journalise les prédictions du modèle dans W\&B [Tables](/fr/products/wandb/tables) afin de les visualiser de manière interactive.

Installer et importer l’intégration Keras

Installez la dernière version de W\&B. ```bash theme={"system"} pip install -U wandb ``` Pour utiliser l’intégration Keras, importez les classes requises depuis `wandb.integration.keras`. ```python theme={"system"} import wandb from wandb.integration.keras import WandbMetricsLogger, WandbModelCheckpoint, WandbEvalCallback ``` Les sections suivantes décrivent en détail chaque callback, avec des exemples de code.

Suivre les expériences avec `WandbMetricsLogger`

`wandb.integration.keras.WandbMetricsLogger()` journalise le dictionnaire `logs` de Keras, que les méthodes de callback telles que `on_epoch_end` et `on_batch_end` reçoivent en argument. L’exemple partiel suivant montre comment utiliser `WandbMetricsLogger()` dans un flux de travail Keras. Commencez par compiler le modèle avec l’optimiseur, la fonction de perte et les métriques de votre choix. Initialisez ensuite un run W\&B à l’aide de `wandb.init()`. Enfin, passez le callback `WandbMetricsLogger()` à `model.fit()`. ```python theme={"system"} import wandb from wandb.integration.keras import WandbMetricsLogger import tensorflow as tf model.compile( optimizer = "adam", loss = "categorical_crossentropy", metrics = ["accuracy", tf.keras.metrics.TopKCategoricalAccuracy(k=5, name='top@5_accuracy')] ) # Initialiser un nouveau run W&B with wandb.init(config={"batch_size": 64}) as run: # Transmettre le callback WandbMetricsLogger à model.fit model.fit( X_train, y_train, validation_data=(X_test, y_test), callbacks=[WandbMetricsLogger()] ) ``` L’exemple précédent journalise dans W\&B les métriques d’entraînement et de validation, telles que `loss`, `accuracy` et `top@5_accuracy`, à la fin de chaque époque.

Référence de `WandbMetricsLogger`

| Paramètre | Description | | - | - | | `log_freq` | (`epoch`, `batch` ou un `int`) : si `epoch`, journalise les métriques à la fin de chaque époque. Si `batch`, journalise les métriques à la fin de chaque lot. Si un `int`, journalise les métriques après le nombre de lots indiqué. Valeur par défaut : `epoch`. | | `initial_global_step` | (int) : utilisez cet argument pour journaliser correctement le taux d’apprentissage lorsque vous reprenez l’entraînement à partir d’une valeur initial\_epoch donnée et que vous utilisez un planificateur de taux d’apprentissage. Cette valeur peut se calculer ainsi : step\_size \* initial\_step. Valeur par défaut : 0. |

Créer des points de contrôle d’un modèle avec `WandbModelCheckpoint`

Utilisez le callback `WandbModelCheckpoint` pour enregistrer périodiquement le modèle Keras (format `SavedModel`) ou les poids du modèle, et les téléverser dans W\&B en tant que `wandb.Artifact` afin d’assurer la gestion des versions des modèles. Ce callback hérite de [`tf.keras.callbacks.ModelCheckpoint()`](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/ModelCheckpoint) ; c’est donc le callback parent qui gère la logique de création des points de contrôle. Ce callback enregistre : * Le modèle ayant obtenu les meilleures performances selon la valeur surveillée (`monitor`). * Le modèle à la fin de chaque époque, quelles que soient les performances. * Le modèle à la fin de l’époque ou après un nombre fixe de lots d’entraînement. * Uniquement les poids du modèle, ou le modèle complet. * Le modèle au format `SavedModel` ou au format `.h5`. Utilisez ce callback conjointement avec `WandbMetricsLogger()`. ```python theme={"system"} import wandb from wandb.integration.keras import WandbMetricsLogger, WandbModelCheckpoint # Initialiser un nouveau run W&B with wandb.init(config={"bs": 12}) as run: # Passer le callback WandbModelCheckpoint à model.fit model.fit( X_train, y_train, validation_data=(X_test, y_test), callbacks=[ WandbMetricsLogger(), WandbModelCheckpoint("models"), ], ) ```

Référence de `WandbModelCheckpoint`

| Paramètre | Description | | | - | - | - | | `filepath` | (str) : chemin où enregistrer le fichier du modèle. | | | `monitor` | (str) : nom de la métrique à surveiller. | | | `verbose` | (int) : mode de verbosité, 0 ou 1. Le mode 0 est silencieux et le mode 1 affiche des messages lorsque le callback effectue une action. | | | `save_best_only` | (Boolean) : si `save_best_only=True`, seul le dernier modèle ou celui jugé le meilleur est enregistré, selon les critères définis par les attributs `monitor` et `mode`. | | | `save_weights_only` | (Boolean) : si True, seuls les poids du modèle sont enregistrés. | | | `mode` | (`auto`, `min` ou `max`) : pour `val_acc`, définissez-le sur `max`, pour `val_loss`, sur `min`, et ainsi de suite. | | | `save_freq` | ("epoch" ou int) : avec "epoch", le callback enregistre le modèle après chaque époque. Avec un entier, il enregistre le modèle tous les N lots, N étant la valeur indiquée. Si vous surveillez des métriques de validation telles que `val_acc` ou `val_loss`, `save_freq` doit être défini sur "epoch", car ces métriques ne sont disponibles qu’à la fin d’une époque. | | | `options` | (str) : objet `tf.train.CheckpointOptions` facultatif si `save_weights_only` est true, ou objet `tf.saved_model.SaveOptions` facultatif si `save_weights_only` est false. | | | `initial_value_threshold` | (float) : valeur initiale (en virgule flottante) considérée comme la « meilleure » pour la métrique à surveiller. | |

Journaliser des points de contrôle toutes les `N` époques

Par défaut (`save_freq="epoch"`), le callback crée un point de contrôle et le téléverse en tant qu’artifact à la fin de chaque époque. Pour créer un point de contrôle après un nombre donné de lots, définissez `save_freq` sur un entier. Pour créer un point de contrôle toutes les `N` époques, calculez la cardinalité du dataloader `train` et passez-la à `save_freq` : ```python theme={"system"} WandbModelCheckpoint( filepath="models/", save_freq=int((trainloader.cardinality()*N).numpy()) ) ```

Journaliser efficacement des points de contrôle sur une architecture TPU

Lors de la création de points de contrôle sur des TPU, vous pouvez rencontrer le message d’erreur `UnimplementedError: File system scheme '[local]' not implemented`. Cette erreur se produit parce que le répertoire du modèle (`filepath`) doit utiliser le chemin d’un bucket de stockage cloud (`gs://bucket-name/...`), et ce bucket doit être accessible depuis le serveur TPU. Pour contourner ce problème, W\&B utilise le chemin local pour créer les points de contrôle, puis les téléverse en tant qu’artifact. ```python theme={"system"} checkpoint_options = tf.saved_model.SaveOptions(experimental_io_device="/job:localhost") WandbModelCheckpoint( filepath="models/", options=checkpoint_options, ) ```

Visualiser les prédictions du modèle avec `WandbEvalCallback`

`WandbEvalCallback()` est une classe de base abstraite qui permet de créer des callbacks Keras, principalement pour visualiser les prédictions du modèle et, accessoirement, les datasets. Ce callback abstrait ne dépend ni du dataset ni de la tâche. Pour l’utiliser, héritez de la classe de callback de base `WandbEvalCallback()` et implémentez les méthodes `add_ground_truth` et `add_model_prediction`. `WandbEvalCallback()` est une classe utilitaire qui fournit des méthodes pour : * Créer des instances `wandb.Table()` pour les données et les prédictions. * Journaliser les Tables de données et de prédictions en tant que `wandb.Artifact()`. * Journaliser le tableau de données lors de `on_train_begin`. * Journaliser le tableau de prédictions lors de `on_epoch_end`. L’exemple suivant utilise `WandbClfEvalCallback` pour une tâche de classification d’images. Ce callback d’exemple journalise les données de validation (`data_table`) dans W\&B, effectue l’inférence, puis journalise les prédictions (`pred_table`) dans W\&B à la fin de chaque époque. ```python theme={"system"} import wandb from wandb.integration.keras import WandbMetricsLogger, WandbEvalCallback # Implémenter votre callback de visualisation des prédictions du modèle class WandbClfEvalCallback(WandbEvalCallback): def __init__( self, validation_data, data_table_columns, pred_table_columns, num_samples=100 ): super().__init__(data_table_columns, pred_table_columns) self.x = validation_data[0] self.y = validation_data[1] def add_ground_truth(self, logs=None): for idx, (image, label) in enumerate(zip(self.x, self.y)): self.data_table.add_data(idx, wandb.Image(image), label) def add_model_predictions(self, epoch, logs=None): preds = self.model.predict(self.x, verbose=0) preds = tf.argmax(preds, axis=-1) table_idxs = self.data_table_ref.get_index() for idx in table_idxs: pred = preds[idx] self.pred_table.add_data( epoch, self.data_table_ref.data[idx][0], self.data_table_ref.data[idx][1], self.data_table_ref.data[idx][2], pred, ) # ... # Initialiser un nouveau run W&B with wandb.init(config={"hyper": "parameter"}) as run: # Ajouter les callbacks à Model.fit model.fit( X_train, y_train, validation_data=(X_test, y_test), callbacks=[ WandbMetricsLogger(), WandbClfEvalCallback( validation_data=(X_test, y_test), data_table_columns=["idx", "image", "label"], pred_table_columns=["epoch", "idx", "image", "label", "pred"], ), ], ) ```

Référence de `WandbEvalCallback`

Détails de l’empreinte mémoire

W\&B journalise le `data_table` lors de l’appel de la méthode `on_train_begin`. Une fois que W\&B l’a téléversé en tant qu’artifact W\&B, vous obtenez une référence à ce tableau, accessible via la variable de classe `data_table_ref`. `data_table_ref` est une liste 2D que vous pouvez indexer sous la forme `self.data_table_ref[idx][n]`, où `idx` est le numéro de ligne et `n` le numéro de colonne. Voir l’exemple d’utilisation ci-dessous.

Personnaliser le callback

Pour mieux contrôler le moment où les données et les prédictions sont journalisées, vous pouvez redéfinir les méthodes par défaut du callback. Redéfinissez les méthodes `on_train_begin` ou `on_epoch_end` pour un contrôle plus fin. Pour journaliser les échantillons tous les `N` lots, implémentez la méthode `on_train_batch_end`. Si vous implémentez un callback de visualisation des prédictions du modèle en héritant de `WandbEvalCallback` et que certains points méritent d’être clarifiés ou corrigés, ouvrez une [issue](https://github.com/wandb/wandb/issues).

`WandbCallback` (ancienne version)

`WandbCallback` est l’ancien callback tout-en-un. Pour les nouveaux projets, utilisez plutôt les callbacks dédiés décrits dans les sections précédentes (`WandbMetricsLogger`, `WandbModelCheckpoint` et `WandbEvalCallback`). Utilisez la classe `WandbCallback()` de la bibliothèque W\&B pour enregistrer l’ensemble des métriques et des valeurs de perte suivies dans `model.fit()`. ```python theme={"system"} import wandb from wandb.integration.keras import WandbCallback with wandb.init(config={"hyper": "parameter"}) as run: # code de configuration de votre modèle dans Keras # Passer le callback à model.fit model.fit( X_train, y_train, validation_data=(X_test, y_test), callbacks=[WandbCallback()] ) ``` Vous pouvez regarder la courte vidéo [Get Started with Keras and W\&B in Less Than a Minute](https://www.youtube.com/watch?ab_channel=Weights\&Biases\&v=4FjDIJ-vO_M). Pour une vidéo plus détaillée, regardez [Integrate W\&B with Keras](https://www.youtube.com/watch?v=Bsudo7jbMow\&ab_channel=Weights%26Biases). Vous pouvez également consulter le [Jupyter Notebook Colab](https://colab.research.google.com/github/wandb/examples/blob/master/colabs/keras/Keras_pipeline_with_Weights_and_Biases.ipynb). Pour d’autres exemples de scripts, consultez le [dépôt d’exemples W\&B](https://github.com/wandb/examples), notamment un [exemple Fashion MNIST](https://github.com/wandb/examples/blob/master/examples/keras/keras-cnn-fashion/train.py) et le [tableau de bord W\&B](https://forge.coreweave.com/wandb/wandb/keras-fashion-mnist/runs/5z1d85qs) qu’il génère. La classe `WandbCallback` prend en charge diverses options de configuration de la journalisation : choix d’une métrique à surveiller, suivi des poids et des gradients, journalisation des prédictions sur `training_data` et `validation_data`, etc. Pour plus de détails, consultez la documentation de référence de `keras.WandbCallback`. `WandbCallback` : * Journalise l’historique de toutes les métriques collectées par Keras : la perte et tout ce qui est passé à `keras_model.compile()`. * Définit les métriques de synthèse du run à partir de la « meilleure » étape d’entraînement, telle que définie par les attributs `monitor` et `mode`. Par défaut, il s’agit de l’époque présentant la `val_loss` minimale. Par défaut, `WandbCallback` enregistre le modèle associé à la meilleure `epoch`. * Journalise, en option, les histogrammes des gradients et des paramètres. * Enregistre, en option, les données d’entraînement et de validation afin que wandb puisse les visualiser.

Référence de `WandbCallback`

| Arguments | | | - | - | | `monitor` | (str) nom de la métrique à surveiller. Valeur par défaut : `val_loss`. | | `mode` | (str) l’une des valeurs `{`auto`, `min`, `max`}`. `min` - enregistrer le modèle lorsque la métrique surveillée atteint un minimum `max` - enregistrer le modèle lorsque la métrique surveillée atteint un maximum `auto` - essayer de déterminer automatiquement quand enregistrer le modèle (par défaut). | | `save_model` | True - enregistrer un modèle lorsque la métrique surveillée est meilleure qu’à toutes les époques précédentes False - ne pas enregistrer de modèles | | `save_graph` | (booléen) si True, enregistrer le graphe du modèle dans wandb (True par défaut). | | `save_weights_only` | (booléen) si True, enregistre uniquement les poids du modèle (`model.save_weights(filepath)`). Sinon, enregistre le modèle complet). | | `log_weights` | (booléen) si True, enregistrer les histogrammes des poids des couches du modèle. | | `log_gradients` | (booléen) si True, journaliser les histogrammes des gradients d’entraînement | | `training_data` | (tuple) Même format `(X,y)` que celui transmis à `model.fit`. Requis pour calculer les gradients ; obligatoire si `log_gradients` vaut `True`. | | `validation_data` | (tuple) Même format `(X,y)` que celui passé à `model.fit`. Ensemble de données à visualiser par wandb. Si vous définissez ce champ, wandb effectue un petit nombre de prédictions à chaque époque et enregistre les résultats pour les visualiser ultérieurement. | | `generator` | (generator) Générateur qui renvoie les données de validation que wandb doit visualiser. Ce générateur doit renvoyer des tuples `(X,y)`. Pour que wandb visualise des exemples de données précis, définissez `validate_data` ou `generator`. | | `validation_steps` | (int) si `validation_data` est un générateur, nombre d’étapes pendant lesquelles exécuter le générateur pour couvrir l’ensemble de validation complet. | | `labels` | (list) Si vous visualisez vos données avec wandb et que vous créez un classifieur multiclasse, cette liste d’étiquettes convertit la sortie numérique en chaînes de caractères lisibles. Pour un classifieur binaire, vous pouvez transmettre une liste de deux étiquettes \[`label for false`, `label for true`]. Si `validate_data` et `generator` valent tous deux false, ce paramètre n’a aucun effet. | | `predictions` | (int) nombre de prédictions à effectuer pour la visualisation à chaque époque, avec un maximum de 100. | | `input_type` | (string) type de l’entrée du modèle, pour faciliter la visualisation. Valeurs possibles : (`image`, `images`, `segmentation_mask`). | | `output_type` | (string) type de la sortie du modèle, pour faciliter la visualisation. Valeurs possibles : (`image`, `images`, `segmentation_mask`). | | `log_evaluation` | (boolean) si True, enregistre une Table contenant les données de validation et les prédictions du modèle à chaque époque. Pour plus de détails, voir `validation_indexes`, `validation_row_processor` et `output_row_processor`. | | `class_colors` | (\[float, float, float]) si l’entrée ou la sortie est un masque de segmentation, un tableau contenant un tuple RGB (valeurs entre 0 et 1) pour chaque classe. | | `log_batch_frequency` | (entier) si None, le callback journalise à chaque époque. Si un entier est spécifié, le callback journalise les métriques d’entraînement tous les `log_batch_frequency` lots. | | `log_best_prefix` | (string) si la valeur est None, n’enregistre aucune métrique de synthèse supplémentaire. Si une chaîne est définie, l’ajoute comme préfixe à la métrique surveillée et à l’époque, puis enregistre les résultats comme métriques de synthèse. | | `validation_indexes` | (\[wandb.data\_types.\_TableLinkMixin]) une liste ordonnée de clés d’index à associer à chaque exemple de validation. Si `log_evaluation` vaut True et que vous fournissez `validation_indexes`, aucune Table de données de validation n’est créée. Chaque prédiction est alors associée à la ligne représentée par le `TableLinkMixin`. Pour obtenir une liste de clés de ligne, utilisez `Table.get_index() `. | | `validation_row_processor` | (Callable) une fonction à appliquer aux données de validation, généralement utilisée pour visualiser ces données. La fonction reçoit un `ndx` (int) et un `row` (dict). Si votre modèle a une seule entrée, `row["input"]` contient les données d’entrée de la ligne. Sinon, il contient les noms des emplacements d’entrée. Si votre fonction fit prend une seule cible, `row["target"]` contient les données cibles de la ligne. Sinon, il contient les noms des emplacements de sortie. Par exemple, si vos données d’entrée se composent d’un seul tableau, fournissez `lambda ndx, row: {"img": wandb.Image(row["input"])}` comme processeur pour visualiser les données sous forme d’Image. Ignoré si `log_evaluation` vaut False ou si `validation_indexes` est présent. | | `output_row_processor` | (Callable) identique à `validation_row_processor`, mais appliquée à la sortie du modèle. `row["output"]` contient les résultats produits par le modèle. | | `infer_missing_processors` | (Boolean) Détermine s’il faut inférer `validation_row_processor` et `output_row_processor` lorsqu’ils sont absents. Valeur par défaut : True. Si vous fournissez `labels`, W\&B tente d’inférer des processeurs de type classification le cas échéant. | | `log_evaluation_frequency` | (int) Détermine la fréquence de journalisation des résultats d’évaluation. La valeur par défaut est `0`, ce qui signifie que la journalisation n’a lieu qu’à la fin de l’entraînement. Définissez-la sur 1 pour journaliser à chaque époque, sur 2 pour journaliser une époque sur deux, et ainsi de suite. Sans effet lorsque `log_evaluation` vaut False. |

Questions fréquentes

Utiliser le multiprocessing de Keras avec wandb

Lorsque vous définissez `use_multiprocessing=True`, l’erreur suivante peut se produire : ```python theme={"system"} Error("You must call wandb.init() before wandb.config.batch_size") ``` Pour contourner ce problème : 1. Lors de la construction de la classe `Sequence`, ajoutez : `wandb.init(group='...')`. 2. Dans `main`, veillez à utiliser `if __name__ == "__main__":` et placez-y le reste de la logique de votre script.