Keras - CoreWeave Docs

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. 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.
WandbEvalCallback : ce callback de base journalise les prédictions du modèle dans W&B Tables afin de les visualiser de manière interactive.

Installer et importer l’intégration Keras

Installez la dernière version de W&B.

pip install -U wandb

Pour utiliser l’intégration Keras, importez les classes requises depuis wandb.integration.keras.

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().

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() ; 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().

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 :

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.

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.

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`

Paramètre	Description
`data_table_columns`	(list) Liste des noms de colonnes de `data_table`
`pred_table_columns`	(list) Liste des noms de colonnes de `pred_table`

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.

`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().

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. Pour une vidéo plus détaillée, regardez Integrate W&B with Keras. Vous pouvez également consulter le Jupyter Notebook Colab. Pour d’autres exemples de scripts, consultez le dépôt d’exemples W&B, notamment un exemple Fashion MNIST et le tableau de bord W&B 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 :

Error("You must call wandb.init() before wandb.config.batch_size")

Pour contourner ce problème :

Lors de la construction de la classe Sequence, ajoutez : wandb.init(group='...').
Dans main, veillez à utiliser if __name__ == "__main__": et placez-y le reste de la logique de votre script.

​Installer et importer l’intégration Keras

​Suivre les expériences avec WandbMetricsLogger

​Référence de WandbMetricsLogger

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

​Référence de WandbModelCheckpoint

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

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

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

​Référence de WandbEvalCallback

​Détails de l’empreinte mémoire

​Personnaliser le callback

​WandbCallback (ancienne version)

​Référence de WandbCallback

​Questions fréquentes

​Utiliser le multiprocessing de Keras avec wandb

Installer et importer l’intégration Keras

Suivre les expériences avec `WandbMetricsLogger`

Référence de `WandbMetricsLogger`

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

Référence de `WandbModelCheckpoint`

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

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

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

Référence de `WandbEvalCallback`

Détails de l’empreinte mémoire

Personnaliser le callback

`WandbCallback` (ancienne version)

Référence de `WandbCallback`

Questions fréquentes

Utiliser le multiprocessing de Keras avec wandb