Journaliser des tableaux - CoreWeave Docs

Visualisez et journalisez des données tabulaires avec les tableaux W&B. Un tableau W&B est une grille de données à deux dimensions dans laquelle chaque colonne contient un seul type de données. Chaque ligne représente un ou plusieurs points de données journalisés dans un run W&B. Les tableaux W&B prennent en charge les types primitifs et numériques, ainsi que les listes imbriquées, les dictionnaires et les types de médias enrichis. Un tableau W&B est un type de données spécifique à W&B, journalisé en tant qu’objet artifact. Pour créer et journaliser des objets tableau, utilisez le SDK Python W&B. Lors de la création d’un objet tableau, vous indiquez ses colonnes, ses données et un mode. Le mode détermine la manière dont le tableau est journalisé et mis à jour au cours de vos expériences de ML.

Le mode INCREMENTAL est pris en charge à partir de la version v0.70.0 du serveur W&B.

Créer et journaliser un tableau

Initialisez un nouveau run avec wandb.init().
Créez un objet Table avec la classe wandb.Table. Indiquez les colonnes et les données du tableau dans les paramètres columns et data, respectivement. Il est recommandé de définir le paramètre facultatif log_mode sur l’un des trois modes suivants : IMMUTABLE (par défaut), MUTABLE ou INCREMENTAL. Pour plus d’informations, consultez la section suivante, Modes de journalisation des tableaux.
Journalisez le tableau dans W&B avec run.log().

L’exemple suivant montre comment créer et journaliser un tableau comportant deux colonnes, a et b, et deux lignes de données, ["a1", "b1"] et ["a2", "b2"] :

import wandb

# Démarrer un nouveau run
with wandb.init(project="table-demo") as run:

    # Créer un objet Table avec deux colonnes et deux lignes de données
    my_table = wandb.Table(
        columns=["a", "b"],
        data=[["a1", "b1"], ["a2", "b2"]],
        log_mode="IMMUTABLE"
        )

    # Journaliser le tableau dans W&B
    run.log({"Table Name": my_table})

Modes de journalisation

Le paramètre log_mode de wandb.Table détermine la manière dont un tableau est journalisé et mis à jour au cours de vos expériences de ML. Le paramètre log_mode accepte l’une des trois valeurs suivantes : IMMUTABLE, MUTABLE et INCREMENTAL. Chaque mode a des implications différentes sur la façon dont un tableau est journalisé, sur la manière dont il peut être modifié et sur son rendu dans la W&B App. Le tableau suivant décrit les trois modes de journalisation, leurs principales différences et les cas d’usage courants de chacun :

Mode	Définition	Cas d’usage	Avantages
`IMMUTABLE`	Une fois qu’un tableau est journalisé dans W&B, vous ne pouvez plus le modifier.	- Stocker des données tabulaires générées à la fin d’un run pour une analyse ultérieure	- Surcoût minimal lorsqu’il est journalisé à la fin d’un run - Rendu de toutes les lignes dans l’interface
`MUTABLE`	Après avoir journalisé un tableau dans W&B, vous pouvez remplacer le tableau existant par un nouveau.	- Ajouter des colonnes ou des lignes à des tableaux existants - Enrichir les résultats avec de nouvelles informations	- Capturer les modifications du tableau - Rendu de toutes les lignes dans l’interface
`INCREMENTAL`	Ajouter des lots de nouvelles lignes à un tableau tout au long de l’expérience de machine learning.	- Ajouter des lignes à des tableaux par lots - Tâches d’entraînement de longue durée - Traiter de grands datasets par lots - Surveiller les résultats en cours	- Afficher les mises à jour dans l’interface pendant l’entraînement - Possibilité de parcourir les incréments un par un

Les sections suivantes présentent des exemples d’extraits de code pour chaque mode, ainsi que les considérations à prendre en compte pour choisir le mode adapté.

Mode MUTABLE

Le mode MUTABLE met à jour un tableau existant en le remplaçant par un nouveau. Il est utile lorsque vous souhaitez ajouter de nouvelles colonnes et de nouvelles lignes à un tableau existant dans le cadre d’un processus non itératif. Dans l’interface utilisateur, le rendu du tableau affiche toutes les lignes et colonnes, y compris celles ajoutées après la journalisation initiale.

En mode MUTABLE, l’objet tableau est remplacé chaque fois que vous journalisez le tableau. L’écrasement d’un tableau par un nouveau est coûteux en ressources de calcul et peut être lent pour les tableaux volumineux.

L’exemple suivant montre comment créer un tableau en mode MUTABLE, le journaliser, puis y ajouter de nouvelles colonnes. L’objet tableau est journalisé trois fois : une première fois avec les données initiales, une deuxième fois avec les scores de confiance et une dernière fois avec les prédictions finales.

L’exemple suivant utilise une fonction fictive load_eval_data() pour charger les données et une fonction fictive model.predict() pour effectuer des prédictions. Remplacez-les par vos propres fonctions de chargement de données et de prédiction.

import wandb
import numpy as np

with wandb.init(project="mutable-table-demo") as run:

    # Créer un objet tableau en mode de journalisation MUTABLE
    table = wandb.Table(columns=["input", "label", "prediction"],
                        log_mode="MUTABLE")

    # Charger les données et générer des prédictions
    inputs, labels = load_eval_data() # Fonction fictive
    raw_preds = model.predict(inputs) # Fonction fictive

    for inp, label, pred in zip(inputs, labels, raw_preds):
        table.add_data(inp, label, pred)

    # Étape 1 : journaliser les données initiales 
    run.log({"eval_table": table})  # Journaliser le tableau initial

    # Étape 2 : ajouter les scores de confiance (p. ex. softmax maximal)
    confidences = np.max(raw_preds, axis=1)
    table.add_column("confidence", confidences)
    run.log({"eval_table": table})  # Ajouter les informations de confiance

    # Étape 3 : ajouter les prédictions post-traitées
    # (p. ex. sorties seuillées ou lissées)
    post_preds = (confidences > 0.7).astype(int)
    table.add_column("final_prediction", post_preds)
    run.log({"eval_table": table})  # Mise à jour finale avec une colonne supplémentaire

Si vous souhaitez uniquement ajouter de nouveaux lots de lignes (sans colonnes) de manière incrémentielle, comme dans une boucle d’entraînement, utilisez plutôt le mode INCREMENTAL.

Mode `INCREMENTAL`

En mode incrémentiel, vous journalisez des lots de lignes dans un tableau au cours de l’expérience de machine learning. Ce mode est idéal pour surveiller des jobs de longue durée ou pour travailler avec de grands tableaux qu’il serait inefficace de journaliser à chaque mise à jour pendant le run. Dans l’interface utilisateur, le tableau s’enrichit des nouvelles lignes au fur et à mesure de leur journalisation, ce qui vous permet de consulter les données les plus récentes sans attendre la fin du run. Vous pouvez également parcourir les incréments pour afficher le tableau à différents moments.

Les workspaces de run de la W&B App sont limités à 100 incréments. Si vous journalisez plus de 100 incréments, seuls les 100 plus récents sont affichés dans le workspace du run.

L’exemple suivant crée un tableau en mode INCREMENTAL, le journalise, puis y ajoute de nouvelles lignes. Notez que le tableau est journalisé une fois par étape d’entraînement (step).

L’exemple suivant utilise des fonctions fictives : get_training_batch() pour charger les données, train_model_on_batch() pour entraîner le modèle et predict_on_batch() pour générer des prédictions. Remplacez-les par vos propres fonctions de chargement de données, d’entraînement et de prédiction.

import wandb

with wandb.init(project="incremental-table-demo") as run:

    # Créer un tableau en mode de journalisation INCREMENTAL
    table = wandb.Table(columns=["step", "input", "label", "prediction"],
                        log_mode="INCREMENTAL")

    # Boucle d’entraînement
    for step in range(get_num_batches()): # Fonction fictive
        # Charger les données du lot
        inputs, labels = get_training_batch(step) # Fonction fictive

        # Entraîner et prédire
        train_model_on_batch(inputs, labels) # Fonction fictive
        predictions = predict_on_batch(inputs) # Fonction fictive

        # Ajouter les données du lot au tableau
        for input_item, label, prediction in zip(inputs, labels, predictions):
            table.add_data(step, input_item, label, prediction)

        # Journaliser le tableau de manière incrémentielle
        run.log({"training_table": table}, step=step)

La journalisation incrémentielle est généralement moins coûteuse en calcul que la journalisation d’un nouveau tableau à chaque fois (log_mode=MUTABLE). Toutefois, la W&B App risque de ne pas afficher toutes les lignes du tableau si vous journalisez un grand nombre d’incréments. Si vous souhaitez mettre à jour et consulter les données de votre tableau pendant l’exécution de votre run, tout en disposant de l’ensemble des données pour l’analyse, utilisez plutôt deux tableaux : l’un avec le mode de journalisation INCREMENTAL et l’autre avec le mode de journalisation IMMUTABLE. L’exemple suivant montre comment combiner les modes de journalisation INCREMENTAL et IMMUTABLE pour y parvenir.

import wandb

with wandb.init(project="combined-logging-example") as run:

    # Créer un tableau incrémentiel pour des mises à jour efficaces pendant l'entraînement
    incr_table = wandb.Table(columns=["step", "input", "prediction", "label"],
                            log_mode="INCREMENTAL")

    # Boucle d'entraînement
    for step in range(get_num_batches()):
        # Traiter le lot
        inputs, labels = get_training_batch(step)
        predictions = model.predict(inputs)

        # Ajouter les données au tableau incrémentiel
        for inp, pred, label in zip(inputs, predictions, labels):
            incr_table.add_data(step, inp, pred, label)

        # Journaliser la mise à jour incrémentielle (suffixe -incr pour la distinguer du tableau final)
        run.log({"table-incr": incr_table}, step=step)

    # À la fin de l'entraînement, créer un tableau immuable complet contenant toutes les données
    # Utilisation du mode IMMUTABLE par défaut pour conserver l'intégralité du jeu de données
    final_table = wandb.Table(columns=incr_table.columns, data=incr_table.data, log_mode="IMMUTABLE")
    run.log({"table": final_table})

Dans cet exemple, incr_table est journalisé de manière incrémentielle (avec log_mode="INCREMENTAL") pendant l’entraînement. Vous pouvez ainsi journaliser et visualiser les mises à jour du tableau au fur et à mesure du traitement des nouvelles données. À la fin de l’entraînement, un tableau immuable (final_table) est créé à partir de toutes les données du tableau incrémentiel. Ce tableau immuable est journalisé afin de conserver le dataset complet pour des analyses ultérieures et vous permet de visualiser toutes les lignes dans la W&B App.

Exemples

Enrichir les résultats d’évaluation avec MUTABLE

import wandb
import numpy as np

with wandb.init(project="mutable-logging") as run:

    # Étape 1 : journaliser les prédictions initiales
    table = wandb.Table(columns=["input", "label", "prediction"], log_mode="MUTABLE")
    inputs, labels = load_eval_data()
    raw_preds = model.predict(inputs)

    for inp, label, pred in zip(inputs, labels, raw_preds):
        table.add_data(inp, label, pred)

    run.log({"eval_table": table})  # Journaliser les prédictions brutes

    # Étape 2 : ajouter les scores de confiance (par ex. softmax maximal)
    confidences = np.max(raw_preds, axis=1)
    table.add_column("confidence", confidences)
    run.log({"eval_table": table})  # Ajouter les scores de confiance

    # Étape 3 : ajouter les prédictions post-traitées
    # (par ex. sorties seuillées ou lissées)
    post_preds = (confidences > 0.7).astype(int)
    table.add_column("final_prediction", post_preds)
    run.log({"eval_table": table})

Reprendre des runs avec des tableaux INCREMENTAL

Vous pouvez continuer à journaliser dans un tableau incrémentiel lorsque vous reprenez un run :

# Démarrer ou reprendre un run
resumed_run = wandb.init(project="resume-incremental", id="your-run-id", resume="must")

# Créer le tableau incrémentiel ; inutile d’y reporter les données du tableau journalisé précédemment
# Les incréments continueront d’être ajoutés à l’artifact Table.
table = wandb.Table(columns=["step", "metric"], log_mode="INCREMENTAL")

# Poursuivre la journalisation
for step in range(resume_step, final_step):
    metric = compute_metric(step)
    table.add_data(step, metric)
    resumed_run.log({"metrics": table}, step=step)

resumed_run.finish()

Les incréments sont journalisés dans un nouveau tableau si vous désactivez les synthèses pour une clé utilisée par le tableau incrémentiel, avec wandb.Run.define_metric("<table_key>", summary="none") ou wandb.Run.define_metric("*", summary="none").

Entraînement par lots en mode INCREMENTAL

with wandb.init(project="batch-training-incremental") as run:

    # Créer un tableau incrémentiel
    table = wandb.Table(columns=["step", "input", "label", "prediction"], log_mode="INCREMENTAL")

    # Boucle d’entraînement simulée
    for step in range(get_num_batches()):
        # Charger les données du lot
        inputs, labels = get_training_batch(step)

        # Entraîner le modèle sur ce lot
        train_model_on_batch(inputs, labels)

        # Exécuter l’inférence du modèle
        predictions = predict_on_batch(inputs)

        # Ajouter les données au tableau
        for input_item, label, prediction in zip(inputs, labels, predictions):
            table.add_data(step, input_item, label, prediction)

        # Journaliser de manière incrémentielle l’état actuel du tableau
        run.log({"training_table": table}, step=step)

​Créer et journaliser un tableau

​Modes de journalisation

​Mode MUTABLE

​Mode INCREMENTAL

​Exemples

​Enrichir les résultats d’évaluation avec MUTABLE

​Reprendre des runs avec des tableaux INCREMENTAL

​Entraînement par lots en mode INCREMENTAL

Créer et journaliser un tableau

Modes de journalisation

Mode MUTABLE

Mode `INCREMENTAL`

Exemples

Enrichir les résultats d’évaluation avec MUTABLE

Reprendre des runs avec des tableaux INCREMENTAL

Entraînement par lots en mode INCREMENTAL