> ## 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. > Créez, remplissez et journalisez des tableaux W&B pour visualiser et interroger les données structurées issues des runs de vos expériences. # Journaliser des tableaux Utilisez `wandb.Table` pour journaliser des données, puis les visualiser et les interroger avec W\&B. Dans ce guide, vous apprendrez à : 1. [Créer des tableaux](/fr/products/wandb/track/log/log-tables#create-tables) 2. [Ajouter des données](/fr/products/wandb/track/log/log-tables#add-data) 3. [Récupérer des données](/fr/products/wandb/track/log/log-tables#retrieve-data) 4. [Enregistrer des tableaux](/fr/products/wandb/track/log/log-tables#save-tables)

Créer des tableaux

Pour définir un tableau, indiquez les colonnes que vous souhaitez afficher pour chaque ligne de données. Chaque ligne peut correspondre à un élément de votre jeu de données d’entraînement, à une étape ou une époque précise de l’entraînement, à une prédiction de votre modèle sur un élément de test, à un objet généré par votre modèle, etc. Chaque colonne possède un type fixe : numérique, texte, booléen, image, vidéo, audio, etc. Il n’est pas nécessaire de spécifier le type à l’avance. Nommez chaque colonne et veillez à ne transmettre que des données de ce type à l’index de cette colonne. Pour un exemple plus détaillé, consultez le [guide des tableaux W\&B](https://forge.coreweave.com/wandb/stacey/mnist-viz/reports/Guide-to-W-B-Tables--Vmlldzo2NTAzOTk#1.-how-to-log-a-wandb.table). Le constructeur `wandb.Table` s’utilise de deux manières : 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 de deux lignes et trois colonnes : ```python theme={"system"} wandb.Table(columns=["a", "b", "c"], data=[["1a", "1b", "1c"], ["2a", "2b", "2c"]]) ``` 2. **DataFrame Pandas :** Journalisez un DataFrame avec `wandb.Table(dataframe=my_df)`. Les noms de colonnes sont extraits du DataFrame.

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

```python theme={"system"} # supposons qu'un modèle ait renvoyé 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() # - l'étiquette prédite par le modèle # - l'étiquette 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 tableaux sont modifiables. Pendant l'exécution de votre script, vous pouvez y ajouter des données, 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 se présente sous forme de liste, utilisez la notation étoile, `*`, pour décompresser la liste en arguments positionnels : `table.add_data(*my_row_list)`. La ligne doit contenir autant d'entrées que le tableau compte 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 NDArray NumPy.

Ajouter des données de manière incrémentielle

Cet exemple de code montre comment créer et remplir un tableau W\&B de manière incrémentielle. Vous définissez le tableau avec des colonnes prédéfinies, notamment 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 à des tableaux de manière incrémentielle lorsque vous reprenez des runs](#adding-data-to-resumed-runs). ```python theme={"system"} # Définir les colonnes du tableau, y compris les scores de confiance de chaque étiquette columns = ["id", "image", "guess", "truth"] for digit in range(10): # Ajouter une colonne 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, l’étiquette prédite, l’étiquette réelle et les scores de confiance for img_id, img in enumerate(mnist_test_data): true_label = mnist_test_data_labels[img_id] # Étiquette réelle (vérité terrain) guess_label = my_model.predict(img) # Étiquette prédite test_table.add_data( img_id, wandb.Image(img), guess_label, true_label ) # Ajouter la ligne au tableau ```

Ajouter des données aux runs repris

Vous pouvez mettre à jour un tableau W\&B de manière incrémentielle dans des runs repris : chargez un tableau existant depuis un artifact, récupérez la dernière ligne de données, puis ajoutez les métriques mises à jour. Réinitialisez ensuite le tableau pour assurer la compatibilité et journalisez la version mise à jour dans W\&B. ```python theme={"system"} 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 reprendre le run 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: # Journaliser 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 placées dans un tableau, vous pouvez y accéder par colonne ou par ligne : 1. **Itérateur de lignes** : utilisez l’itérateur de lignes du tableau, par exemple `for ndx, row in table.iterrows(): ...`, pour parcourir efficacement les lignes des 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 passer `convert_to="numpy"` afin de convertir la colonne en NDArray NumPy de types primitifs. C’est utile si votre colonne contient des types de médias comme `wandb.Image`, car vous pouvez ainsi 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 des prédictions d’un modèle, enregistrez-le dans W\&B pour visualiser les résultats en direct.

Journaliser un tableau dans un run

Utilisez `wandb.Run.log()` pour enregistrer votre tableau dans le run, comme suit : ```python theme={"system"} 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 journalisé sous la même clé, une nouvelle version du tableau est créée et stockée dans le backend. Vous pouvez ainsi journaliser le même tableau sur plusieurs étapes d’entraînement pour suivre l’amélioration des prédictions du modèle au fil du temps, ou comparer des tableaux entre différents runs, à condition qu’ils soient journalisés sous la même clé. Vous pouvez journaliser jusqu’à 200 000 lignes. Pour journaliser plus de 200 000 lignes, vous pouvez redéfinir la limite avec : `wandb.Table.MAX_ARTIFACT_ROWS = X` Toutefois, cela risque de provoquer des problèmes de performances dans l’interface utilisateur, comme des requêtes plus lentes.

Accéder aux tableaux par programmation

Côté backend, les tableaux sont stockés sous forme d’artifacts. Pour accéder à une version précise, utilisez l’API des artifacts : ```python theme={"system"} with wandb.init() as run: my_table = run.use_artifact("run--:").get("") ``` Pour plus d’informations sur les Artifacts, consultez le [chapitre Artifacts](/fr/products/wandb/artifacts) du Guide du développeur.

Visualiser les tableaux

Tout tableau journalisé de cette manière apparaît dans votre workspace, à la fois sur la Page du run et sur la Page du projet. Pour plus d’informations, voir [Visualiser et analyser des tableaux](/fr/products/wandb/tables/visualize-tables).

Tableaux d’artifacts

Utilisez `artifact.add()` pour journaliser des tableaux dans la section Artifacts de votre run plutôt que dans le workspace. Cette approche est utile si vous disposez d’un jeu de données que vous souhaitez journaliser une seule fois, puis réutiliser comme référence dans vos prochains runs. ```python theme={"system"} 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édiction comme ci-dessus] test_table = wandb.Table(data=data, columns=columns) test_predictions.add(test_table, "my_test_key") run.log_artifact(test_predictions) ``` Consultez ce Colab pour un [exemple détaillé d’utilisation d’artifact.add() avec des données d’image](https://wandb.me/dsviz-nature-colab), ainsi que ce rapport pour découvrir comment utiliser Artifacts et tableaux afin de [gérer les versions de données tabulaires et les dédupliquer](https://wandb.me/TBV-Dedup).

Joindre des tableaux d’artifacts

Vous pouvez joindre des tableaux que vous avez construits localement ou que vous avez 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 une `wandb.Table` dans un artifact, l’objet tableau ou l’ArtifactEntry | | table\_2 | (str, `wandb.Table`, ArtifactEntry) le chemin vers une `wandb.Table` dans un artifact, l’objet tableau ou l’ArtifactEntry | | join\_key | (str, \[str, str]) clé ou clés sur lesquelles effectuer la jointure | Pour joindre deux tableaux que vous avez déjà journalisés dans le contexte d’un artifact, récupérez-les depuis l’artifact, puis joignez-les dans un nouveau tableau. Par exemple, le code suivant montre comment lire un tableau de chansons originales nommé `'original_songs'` et un autre tableau contenant des versions synthétisées de ces mêmes chansons, nommé `'synth_songs'`. Le code joint les deux tableaux sur `"song_id"` et téléverse le tableau obtenu sous la forme d’un nouveau tableau W\&B : ```python theme={"system"} 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 la clé "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 le journaliser dans W&B join_at.add(join_table, "synth_explore") run.log_artifact(join_at) ``` [Lisez ce tutoriel](https://forge.coreweave.com/wandb/stacey/cshanty/reports/Whale2Song-W-B-Tables-for-Audio--Vmlldzo4NDI3NzM) pour voir un exemple montrant comment combiner deux tableaux préalablement stockés dans des objets Artifact distincts.