> ## 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 métriques de synthèse

> Suivez et personnalisez des métriques de synthèse uniques, comme la meilleure précision ou la perte minimale, sur un run W&B à l’aide de run.summary.

Outre les valeurs qui évoluent au fil de l’entraînement, il est souvent important de suivre des valeurs qui résument un modèle ou une étape de prétraitement. Stockez ces informations dans l’attribut `summary` d’un run. L’attribut summary d’un run prend en charge les tableaux NumPy, les tenseurs PyTorch et les tenseurs TensorFlow. W\&B enregistre les tableaux NumPy, les tenseurs PyTorch et les tenseurs TensorFlow dans un fichier binaire.

La dernière valeur journalisée avec `wandb.Run.log()` est automatiquement définie comme dictionnaire de synthèse du run. Toute modification d’un dictionnaire de métriques de synthèse entraîne la perte de la valeur précédente.

Vous pouvez journaliser une métrique de synthèse pendant qu’un run est actif ou une fois qu’il est terminé.

<Tabs>
  <Tab title="Pendant un run">
    L’extrait de code suivant montre comment fournir une métrique de synthèse personnalisée à W\&B :

    ```python theme={"system"}
    import wandb
    import random

    # Projet dans lequel le run est enregistré
    project = "summary-demo"
    entity = "<your-entity>" # Remplacez par le nom de votre entity W&B

    # Dictionnaire des hyperparamètres
    config = {
        'epochs' : 10,
        'lr' : 0.01
    }

    with wandb.init(entity=entity, project=project, config=config) as run:
        offset = random.random() / 5
        print(f"lr: {config['lr']}")

        # Simuler un run d’entraînement
        for epoch in range(2, config['epochs']):
            acc = 1 - 2**-config['epochs'] - random.random() / config['epochs'] - offset
            loss = 2**-config['epochs'] + random.random() / config['epochs'] + offset
            print(f"epoch={config['epochs']}, accuracy={acc}, loss={loss}")
            run.log({"accuracy": acc, "loss": loss})

            if epoch % 5 == 0:
                run.summary["best_accuracy"] = acc
                run.summary["best_loss"] = loss
    ```
  </Tab>

  <Tab title="Après un run">
    Une fois l’entraînement terminé, vous pouvez mettre à jour l’attribut summary d’un run W\&B existant. Pour ce faire, utilisez l’[API publique de W\&B](/fr/products/wandb/ref/python/public-api) :

    ```python theme={"system"}
    api = wandb.Api()
    run = api.run("entity/project/run_id")
    run.summary["tensor"] = np.random.random(1000)
    run.summary.update()
    ```
  </Tab>
</Tabs>

L’image suivante montre à quoi pourraient ressembler les métriques de synthèse si vous copiez et exécutez l’extrait de code ci-dessus :

<Frame>
  <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/_media/summary_demo.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=1a1f14924f6c1d0cacf79c2f348dbd76" alt="Synthèse du run" width="3120" height="2970" data-path="products/wandb/_media/summary_demo.png" />
</Frame>

<h2 id="customize-summary-metrics">
  Personnaliser les métriques de synthèse
</h2>

Les métriques de synthèse personnalisées permettent de capturer dans votre `run.summary` les performances du modèle à la meilleure étape de l’entraînement. Par exemple, vous pouvez capturer la précision maximale ou la perte minimale plutôt que la valeur finale.

Par défaut, la synthèse utilise la valeur finale de l’historique. Pour personnaliser les métriques de synthèse, passez l’argument `summary` à `define_metric`. Il accepte les valeurs suivantes :

* `"min"`
* `"max"`
* `"mean"`
* `"best"`
* `"last"`
* `"none"`

Vous ne pouvez utiliser `"best"` que si vous définissez également l’argument facultatif `objective` sur `"minimize"` ou `"maximize"`.

L’exemple suivant ajoute à la synthèse les valeurs minimale et maximale de la perte et de la précision :

```python theme={"system"}
import wandb
import random

random.seed(1)

with wandb.init() as run:
    # Valeurs min et max de la perte dans la synthèse
    run.define_metric("loss", summary="min")
    run.define_metric("loss", summary="max")

    # Valeurs min et max de la précision dans la synthèse
    run.define_metric("acc", summary="min")
    run.define_metric("acc", summary="max")

    for i in range(10):
        log_dict = {
            "loss": random.uniform(0, 1 / (i + 1)),
            "acc": random.uniform(1 / (i + 1), 1),
        }
        run.log(log_dict)
```

<h2 id="view-summary-metrics">
  Afficher les métriques de synthèse
</h2>

Accédez à la synthèse d’un run dans la W\&B App, pendant l’exécution d’un run, à partir d’un run existant ou depuis le système de fichiers local.

<Tabs>
  <Tab title="Aperçu du run">
    1. Accédez à la W\&B App.
    2. Sélectionnez l’onglet **Workspace** dans la barre latérale du projet.
    3. Cliquez sur le run qui a journalisé les valeurs de synthèse. La page du run s’ouvre sur l’onglet **Overview**, affiché par défaut.
    4. Consultez les valeurs de synthèse dans la section **Summary**.

    L’image suivante montre à quoi peuvent ressembler les métriques de synthèse dans l’onglet **Overview** si vous copiez et exécutez l’extrait de code ci-dessus :

    <Frame>
      <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/_media/customize_summary.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=d56df9168cf8eb4a2e696eab0812ea71" alt="Aperçu du run" width="2284" height="2554" data-path="products/wandb/_media/customize_summary.png" />
    </Frame>
  </Tab>

  <Tab title="Tableau des runs">
    1. Accédez à la W\&B App.
    2. Sélectionnez l’onglet **Runs**.
    3. Dans le tableau des runs, les valeurs de synthèse s’affichent dans les colonnes portant le nom de chaque valeur.
  </Tab>

  <Tab title="Pendant un run">
    Utilisez `wandb.Run.summary` pour accéder aux valeurs de synthèse d’un run pendant son exécution. Cet attribut renvoie un dictionnaire de paires clé-valeur.

    L’exemple suivant accède à la synthèse d’un run. Remplacez `"<my-project>"` par le nom de votre projet W\&B :

    ```python theme={"system"}
    import wandb

    with wandb.init(project="<my-project>", config=config) as run:
      run.log({"accuracy": 0.9, "loss": 0.1})

      print(run.summary)  # affiche le dictionnaire de synthèse
    ```
  </Tab>

  <Tab title="Runs existants">
    Utilisez l’API publique de W\&B pour accéder aux métriques de synthèse via la propriété `wandb.Api.Run.summary`.

    L’exemple de code suivant montre une façon de récupérer les valeurs de synthèse journalisées dans un run donné à l’aide de l’API publique de W\&B et de pandas :

    ```python theme={"system"}
    import wandb
    import pandas

    entity = "<your-entity>"
    project = "<your-project>"
    run_name = "<your-run-name>" # Nom du run contenant les valeurs de synthèse

    all_runs = []

    for run in api.runs(f"{entity}/{project_name}"):
        print("Fetching details for run: ", run.id, run.name)
        run_data = {
                  "id": run.id,
                  "name": run.name,
                  "url": run.url,
                  "state": run.state,
                  "tags": run.tags,
                  "config": run.config,
                  "created_at": run.created_at,
                  "system_metrics": run.system_metrics,
                  "summary": run.summary,
                  "project": run.project,
                  "entity": run.entity,
                  "user": run.user,
                  "path": run.path,
                  "notes": run.notes,
                  "read_only": run.read_only,
                  "history_keys": run.history_keys,
                  "metadata": run.metadata,
              }
        all_runs.append(run_data)
      
    # Convertir en DataFrame  
    df = pd.DataFrame(all_runs)

    # Récupérer la ligne en fonction du nom de colonne (run) et la convertir en dictionnaire
    df[df['name']==run_name].summary.reset_index(drop=True).to_dict()
    ```

    Pour accéder aux métriques de synthèse de plusieurs runs d’un projet, itérez sur les runs renvoyés par `api.runs()` :

    ```python theme={"system"}
    import wandb

    api = wandb.Api()
    runs = api.runs("<entity>/<project>")

    for run in runs:
        print(f"Run name: {run.name}")
        print(f"Run ID: {run.id}")
        print(f"Run summary: {dict(run.summary)}")
        print("----------")
    ```

    L’objet JSON suivant présente un exemple de synthèse de run :

    ```shell theme={"system"}
    Run name: clean-oath-11
    Run ID: mt2dasoz
    Run summary: {'_runtime': 3, '_step': 1000, '_timestamp': 1778541534.834642, '_wandb.runtime': 3, 'train/epoch_ndx': 1000, 'train/train_loss': 0.25498124957084656}

    Run name: zesty-snowball-7
    Run ID: qne08r7u
    Run summary: {'_runtime': 3, '_step': 1000, '_timestamp': 1776714833.636171, '_wandb.runtime': 3, 'train/epoch_ndx': 1000, 'train/train_loss': 0.24914199113845825}
    ```
  </Tab>

  <Tab title="Système de fichiers local">
    W\&B stocke les valeurs de synthèse du run dans le fichier `wandb-summary.json` du répertoire du run. Pour lire les valeurs de synthèse en local, ouvrez le fichier `wandb-summary.json`.

    Par défaut, W\&B stocke les répertoires des runs à l’emplacement suivant : `./wandb/run-<timestamp>-<run_id>`.
  </Tab>
</Tabs>


## Related topics

- [Suivre des fichiers CSV avec des expériences](/fr/products/wandb/track/log/working-with-csv.md)