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 :
- Créer des Tables
- Ajouter des données
- Récupérer des données
- Enregistrer 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 :
-
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"]])
-
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 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.
- 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
# 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
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})
- 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.
- 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.
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
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})
Pour enregistrer plus de 200 000 lignes, vous pouvez redéfinir cette limite comme suit :wandb.Table.MAX_ARTIFACT_ROWS = XCependant, 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
with wandb.init() as run:
my_table = run.use_artifact("run-<run-id>-<table-name>:<tag>").get("<table-name>")
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)
Joindre des tableaux d’Artifact
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 |
'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)
