> ## Documentation Index > Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt > Use this file to discover all available pages before exploring further. > Créez, remplissez et journalisez des W&B Tables pour visualiser et interroger les données structurées de vos runs d’expérience. # Journaliser des Tables 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](./log-tables#create-tables) 2. [Ajouter des données](./log-tables#add-data) 3. [Récupérer des données](./log-tables#retrieve-data) 4. [Enregistrer des Tables](./log-tables#save-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](https://wandb.ai/stacey/mnist-viz/reports/Guide-to-W-B-Tables--Vmlldzo2NTAzOTk#1.-how-to-log-a-wandb.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 : ```python theme={null} 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
```python theme={null} # 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](#adding-data-to-resumed-runs). ```python theme={null} # 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. ```python theme={null} 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 : ```python theme={null} 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 : ```python theme={null} with wandb.init() as run: my_table = run.use_artifact("run--:").get("") ``` Pour plus d’informations sur Artifacts, voir le [chapitre Artifacts](/fr/models/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](/fr/models/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. 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. ```python theme={null} 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](https://wandb.me/dsviz-nature-colab) et à ce Report pour voir [comment utiliser Artifacts et Tables pour gérer les versions et dédupliquer des données tabulaires](https://wandb.me/TBV-Dedup).
### 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 : ```python theme={null} 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](https://wandb.ai/stacey/cshanty/reports/Whale2Song-W-B-Tables-for-Audio--Vmlldzo4NDI3NzM) pour voir comment combiner deux tableaux précédemment enregistrés dans différents objets Artifact.