Journaliser des Tables

Créez, remplissez et journalisez des W&B Tables pour visualiser et interroger les données structurées de vos runs d’expérience.

Utilisez wandb.Table pour journaliser des données afin de les visualiser et d’effectuer des requêtes avec W&B. Dans ce guide, découvrez comment :

1. Créer des Tables
2. Ajouter des données
3. Récupérer des données
4. Enregistrer des Tables

​

Créer des Tables

Pour définir une Table, spécifiez les colonnes que vous souhaitez afficher pour chaque ligne de données. Chaque ligne peut correspondre à un élément unique de votre jeu de données d’entraînement, à une étape ou une époque particulière pendant l’entraînement, à une prédiction effectuée par votre modèle sur un élément de test, à un objet généré par votre modèle, etc. Chaque colonne a un type fixe : numérique, texte, booléen, image, vidéo, audio, etc. Vous n’avez pas besoin de spécifier le type à l’avance. Donnez un nom à chaque colonne et veillez à n’insérer dans chaque colonne que des données de ce type. Pour un exemple plus détaillé, voir le guide W&B Table.

Utilisez le constructeur wandb.Table de l’une des deux façons suivantes :

1. Liste de lignes :

   Journalisez des colonnes nommées et des lignes de données. Par exemple, l’extrait de code suivant génère un tableau avec deux lignes et trois colonnes :

   wandb.Table(columns=["a", "b", "c"], data=[["1a", "1b", "1c"], ["2a", "2b", "2c"]])
   

2. Pandas DataFrame : Journalisez un DataFrame avec wandb.Table(dataframe=my_df). Les noms de colonnes seront extraits du DataFrame.

​

À partir d’un tableau ou d’un dataframe existants

# supposons qu'un modèle a retourné des prédictions sur quatre images
# avec les champs suivants disponibles :
# - l'identifiant de l'image
# - les pixels de l'image, encapsulés dans un wandb.Image()
# - le label prédit par le modèle
# - le label de vérité terrain
my_data = [
    [0, wandb.Image("img_0.jpg"), 0, 0],
    [1, wandb.Image("img_1.jpg"), 8, 0],
    [2, wandb.Image("img_2.jpg"), 7, 1],
    [3, wandb.Image("img_3.jpg"), 1, 1],
]

# créer un wandb.Table() avec les colonnes correspondantes
columns = ["id", "image", "prediction", "truth"]
test_table = wandb.Table(data=my_data, columns=columns)

​

Ajouter des données

Les Tables sont mutables. À mesure que votre script s’exécute, vous pouvez ajouter plus de données à votre tableau, jusqu’à 200 000 lignes. Il existe deux façons d’ajouter des données à un tableau :

1. Ajouter une ligne : table.add_data("3a", "3b", "3c"). Notez que la nouvelle ligne n’est pas représentée sous forme de liste. Si votre ligne est au format liste, utilisez la notation étoile, *, pour développer la liste en arguments positionnels : table.add_data(*my_row_list). La ligne doit contenir le même nombre d’entrées que le tableau comporte de colonnes.
2. Ajouter une colonne : table.add_column(name="col_name", data=col_data). Notez que la longueur de col_data doit être égale au nombre actuel de lignes du tableau. Ici, col_data peut être une liste ou un tableau NumPy (NDArray).

​

Ajout incrémentiel de données

Cet exemple de code montre comment créer et alimenter un tableau W&B de manière incrémentielle. Vous définissez le tableau avec des colonnes prédéfinies, y compris les scores de confiance pour toutes les étiquettes possibles, puis vous ajoutez les données ligne par ligne pendant l’Inférence. Vous pouvez également ajouter des données aux tableaux de manière incrémentielle lorsque vous reprenez des runs.

# Définir les colonnes du tableau, y compris les scores de confiance pour chaque label
columns = ["id", "image", "guess", "truth"]
for digit in range(10):  # Ajouter des colonnes de score de confiance pour chaque chiffre (0-9)
    columns.append(f"score_{digit}")

# Initialiser le tableau avec les colonnes définies
test_table = wandb.Table(columns=columns)

# Parcourir le jeu de données de test et ajouter les données au tableau ligne par ligne
# Chaque ligne contient l'ID de l'image, l'image, le label prédit, le label réel et les scores de confiance
for img_id, img in enumerate(mnist_test_data):
    true_label = mnist_test_data_labels[img_id]  # Label de référence (ground truth)
    guess_label = my_model.predict(img)  # Label prédit
    test_table.add_data(
        img_id, wandb.Image(img), guess_label, true_label
    )  # Ajouter les données de la ligne au tableau

​

Ajout de données à des runs repris

Vous pouvez mettre à jour de façon incrémentielle un tableau W&B dans des runs repris en chargeant un tableau existant depuis un artifact, en récupérant la dernière ligne de données, puis en ajoutant les métriques mises à jour. Réinitialisez ensuite le tableau pour garantir la compatibilité, puis journalisez de nouveau la version mise à jour dans W&B.

import wandb

# Initialiser un run 
with wandb.init(project="my_project") as run:

    # Charger le tableau existant depuis l'artifact
    best_checkpt_table = run.use_artifact(table_tag).get(table_name)

    # Récupérer la dernière ligne de données du tableau pour la reprise
    best_iter, best_metric_max, best_metric_min = best_checkpt_table.data[-1]

    # Mettre à jour les meilleures métriques si nécessaire

    # Ajouter les données mises à jour au tableau
    best_checkpt_table.add_data(best_iter, best_metric_max, best_metric_min)

    # Réinitialiser le tableau avec ses données mises à jour pour garantir la compatibilité
    best_checkpt_table = wandb.Table(
        columns=["col1", "col2", "col3"], data=best_checkpt_table.data
    )

    # Initialiser le run
    with wandb.init() as run:

        # Enregistrer le tableau mis à jour dans W&B
        run.log({table_name: best_checkpt_table})

​

Récupérer des données

Une fois les données dans une Table, accédez-y par colonne ou par ligne :

1. Itérateur de lignes : Utilisez l’itérateur de lignes de Table, comme for ndx, row in table.iterrows(): ..., pour parcourir efficacement les lignes de données.
2. Obtenir une colonne : Récupérez une colonne de données avec table.get_column("col_name") . Pour plus de commodité, vous pouvez spécifier convert_to="numpy" pour convertir la colonne en tableau NumPy (NDArray) de valeurs primitives. Cela est utile si votre colonne contient des types de médias comme wandb.Image, afin d’accéder directement aux données sous-jacentes.

​

Enregistrer des tableaux

Après avoir généré un tableau de données dans votre script, par exemple un tableau de prédictions d’un modèle, enregistrez-le dans W&B pour visualiser les résultats en temps réel.

​

Consigner un tableau dans un run

Utilisez wandb.Run.log() pour enregistrer votre tableau dans le run, comme suit :

with wandb.init() as run:
    my_table = wandb.Table(columns=["a", "b"], data=[["1a", "1b"], ["2a", "2b"]])
    run.log({"table_key": my_table})

Chaque fois qu’un tableau est enregistré avec la même clé, une nouvelle version du tableau est créée et stockée dans le back-end. Cela signifie que vous pouvez enregistrer le même tableau à plusieurs étapes de l’entraînement pour voir comment les prédictions du modèle s’améliorent au fil du temps, ou comparer des tableaux entre différents runs, à condition qu’ils soient enregistrés avec la même clé. Vous pouvez enregistrer jusqu’à 200 000 lignes.

Pour enregistrer plus de 200 000 lignes, vous pouvez redéfinir cette limite comme suit :

wandb.Table.MAX_ARTIFACT_ROWS = X

Cependant, cela entraînera probablement des problèmes de performances, comme des requêtes plus lentes, dans l’UI.

​

Accéder aux Tables de façon programmatique

Côté backend, les Tables sont conservées sous forme d’Artifacts. Si vous souhaitez accéder à une version spécifique, vous pouvez le faire avec l’API des Artifacts :

with wandb.init() as run:
    my_table = run.use_artifact("run-<run-id>-<table-name>:<tag>").get("<table-name>")

Pour plus d’informations sur Artifacts, voir le chapitre Artifacts dans le Guide du développeur.

​

Visualiser les Tables

Tout tableau enregistré de cette façon s’affichera dans votre Workspace, à la fois sur la page du run et sur la page du projet. Pour plus d’informations, voir Visualiser et analyser les Tables.

​

Tableaux d’Artifacts

Utilisez artifact.add() pour journaliser des tableaux dans la section Artifacts de votre run plutôt que dans le Workspace. Cela peut être utile si vous avez un jeu de données que vous souhaitez journaliser une seule fois, puis utiliser comme référence pour de futurs runs.

with wandb.init(project="my_project") as run:
    # créer un Artifact wandb pour chaque étape importante
    test_predictions = wandb.Artifact("mnist_test_preds", type="predictions")

    # [construire vos données de prédictions comme indiqué ci-dessus]
    test_table = wandb.Table(data=data, columns=columns)
    test_predictions.add(test_table, "my_test_key")
    run.log_artifact(test_predictions)

Reportez-vous à ce Colab pour un exemple détaillé de artifact.add() avec des données d’images et à ce Report pour voir comment utiliser Artifacts et Tables pour gérer les versions et dédupliquer des données tabulaires.

​

Joindre des tableaux d’Artifact

Vous pouvez joindre des tableaux créés localement ou des tableaux récupérés depuis d’autres Artifacts à l’aide de wandb.JoinedTable(table_1, table_2, join_key).

Arguments	Description
table_1	(str, wandb.Table, ArtifactEntry) le chemin vers un wandb.Table dans un Artifact, l’objet tableau ou ArtifactEntry
table_2	(str, wandb.Table, ArtifactEntry) le chemin vers un wandb.Table dans un Artifact, l’objet tableau ou ArtifactEntry
join_key	(str, [str, str]) clé ou clés sur lesquelles effectuer la jointure

Pour joindre deux tableaux que vous avez enregistrés précédemment dans le contexte d’un Artifact, récupérez-les depuis l’Artifact, puis combinez le résultat dans un nouveau tableau.

Par exemple, l’exemple de code suivant montre comment lire un tableau de chansons originales appelé 'original_songs' et un autre tableau contenant des versions synthétisées de ces mêmes chansons appelé 'synth_songs'. Le code joint les deux tableaux sur "song_id" et téléverse le tableau obtenu en tant que nouveau tableau W&B :

import wandb

with wandb.init(project="my_project") as run:

    # récupérer le tableau des chansons originales
    orig_songs = run.use_artifact("original_songs:latest")
    orig_table = orig_songs.get("original_samples")

    # récupérer le tableau des chansons synthétisées
    synth_songs = run.use_artifact("synth_songs:latest")
    synth_table = synth_songs.get("synth_samples")

    # joindre les tableaux sur "song_id"
    join_table = wandb.JoinedTable(orig_table, synth_table, "song_id")
    join_at = wandb.Artifact("synth_summary", "analysis")

    # ajouter le tableau à l'artifact et enregistrer dans W&B
    join_at.add(join_table, "synth_explore")
    run.log_artifact(join_at)

Lire ce tutoriel pour voir comment combiner deux tableaux précédemment enregistrés dans différents objets Artifact.