> ## 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.

# Journaliser des tableaux

> Créez et journalisez des tableaux W&B à l’aide du SDK Python, avec différents modes de journalisation : immuable, mutable et incrémentiel.

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](/fr/products/wandb/runs) 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](/fr/products/wandb/ref/python/data-types) spécifique à W\&B, journalisé en tant qu’objet [artifact](/fr/products/wandb/artifacts).

Pour [créer et journaliser des objets tableau](#create-and-log-a-new-table), 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](#table-logging-modes). Le mode détermine la manière dont le tableau est journalisé et mis à jour au cours de vos expériences de ML.

<Note>
  Le mode `INCREMENTAL` est pris en charge à partir de la version v0.70.0 du serveur W\&B.
</Note>

<h2 id="create-and-log-a-table">
  Créer et journaliser un tableau
</h2>

1. Initialisez un nouveau run avec `wandb.init()`.
2. Créez un objet Table avec la classe [`wandb.Table`](/fr/products/wandb/ref/python/data-types/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](#logging-modes).
3. 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"]` :

```python theme={"system"}
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})
```

<h2 id="logging-modes">
  Modes de journalisation
</h2>

Le paramètre `log_mode` de [`wandb.Table`](/fr/products/wandb/ref/python/data-types/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<br />- 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<br />- Enrichir les résultats avec de nouvelles informations | - Capturer les modifications du tableau<br />- 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<br /> - Tâches d’entraînement de longue durée<br />- Traiter de grands datasets par lots<br />- Surveiller les résultats en cours | - Afficher les mises à jour dans l’interface pendant l’entraînement<br />- 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é.

<h3 id="mutable-mode">
  Mode MUTABLE
</h3>

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.

<Note>
  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.
</Note>

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.

<Note>
  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.
</Note>

```python theme={"system"}
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`](#INCREMENTAL-mode).

<h3 id="incremental-mode">
  Mode `INCREMENTAL`
</h3>

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.

<Note>
  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.
</Note>

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`).

<Note>
  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.
</Note>

```python theme={"system"}
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.

```python theme={"system"}
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.

<h2 id="examples">
  Exemples
</h2>

<h3 id="enriching-evaluation-results-with-mutable">
  Enrichir les résultats d’évaluation avec MUTABLE
</h3>

```python theme={"system"}
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})
```

<h3 id="resuming-runs-with-incremental-tables">
  Reprendre des runs avec des tableaux INCREMENTAL
</h3>

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

```python theme={"system"}
# 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()
```

<Note>
  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")`.
</Note>

<h3 id="training-with-incremental-batch-training">
  Entraînement par lots en mode INCREMENTAL
</h3>

```python theme={"system"}

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)
```