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

> Exportez ou mettez à jour les données que vous avez enregistrées dans W&B

# Exporter et mettre à jour des données

<h2 id="export-data">
  Exporter des données
</h2>

Utilisez l’API publique pour exporter ou mettre à jour les données que vous avez enregistrées dans W\&B. Avant d’utiliser cette API, journalisez des données depuis votre script. Pour plus de détails, consultez le [Démarrage rapide](/fr/products/wandb/quickstart).

**Cas d’utilisation de l’API publique**

* **Exporter des données** : récupérez un dataframe pour effectuer une analyse personnalisée dans un Jupyter Notebook. Une fois les données explorées, vous pouvez synchroniser vos constats en créant un nouveau run d’analyse et en y journalisant les résultats, par exemple : `wandb.init(job_type="analysis")`
* **Mettre à jour des runs existants** : vous pouvez mettre à jour les données journalisées associées à un run W\&B. Par exemple, vous pourriez vouloir mettre à jour la configuration d’un ensemble de runs pour y ajouter des informations supplémentaires, comme l’architecture ou un hyperparamètre qui n’avait pas été journalisé à l’origine.

Voir la [documentation de référence générée](/fr/products/wandb/ref/python/public-api) pour plus de détails sur les fonctions disponibles.

<h3 id="export-run-data">
  Exporter les données d’un run
</h3>

Téléchargez les données d’un run terminé ou actif. Cette fonctionnalité sert notamment à télécharger un dataframe pour effectuer une analyse personnalisée dans un notebook Jupyter, ou à appliquer une logique personnalisée dans un environnement automatisé.

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

api = wandb.Api()
run = api.run("<entity>/<project>/<run_id>")
```

Les attributs les plus couramment utilisés d’un objet run sont les suivants :

| Attribut | Signification |
| - | - |
| `run.config` | Un dictionnaire contenant les informations de configuration du run, comme les hyperparamètres d'un run d'entraînement ou les méthodes de prétraitement d'un run qui crée un artifact de jeu de données. Considérez-les comme les entrées du run. |
| `run.history()` | Une liste de dictionnaires destinée à stocker les valeurs qui évoluent pendant l'entraînement du modèle, comme la perte. La commande `run.log()` ajoute des éléments à cet objet. |
| `run.summary` | Un dictionnaire d'informations qui synthétise les résultats du run. Il peut s'agir de scalaires comme la précision et la perte, ou de fichiers volumineux. Par défaut, `run.log()` affecte à la synthèse la valeur finale d'une série temporelle journalisée. Le contenu de la synthèse peut également être défini directement. Considérez la synthèse comme les sorties du run. |

Vous pouvez également modifier ou mettre à jour les données de runs antérieurs. Par défaut, une même instance d’un objet api met en cache toutes les requêtes réseau. Si votre cas d’usage nécessite des informations en temps réel dans un script en cours d’exécution, appelez `api.flush()` pour obtenir des valeurs à jour.

<h3 id="querying-multiple-runs">
  Interroger plusieurs runs
</h3>

<Tabs>
  <Tab title="DataFrame et CSV">
    Cet exemple de script trouve un projet et génère un fichier CSV des runs contenant leur nom, leurs configurations et leurs statistiques de synthèse. Remplacez `<entity>` et `<project>` respectivement par votre entity W\&B et le nom de votre projet.

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

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

    summary_list, config_list, name_list = [], [], []
    for run in runs:
        # .summary contient les clés/valeurs de sortie pour
        # des métriques comme la précision.
        #  Nous appelons ._json_dict pour omettre les fichiers volumineux
        summary_list.append(run.summary._json_dict)

        # .config contient les hyperparamètres.
        #  Nous supprimons les valeurs spéciales qui commencent par _.
        config_list.append({k: v for k, v in run.config.items() if not k.startswith("_")})

        # .name est le nom lisible du run.
        name_list.append(run.name)

    runs_df = pd.DataFrame(
        {"summary": summary_list, "config": config_list, "name": name_list}
    )

    runs_df.to_csv("project.csv")

    run.finish()
    ```
  </Tab>

  <Tab title="Style MongoDB">
    L’API W\&B permet également d’interroger les runs d’un projet avec api.runs(). Le cas d’usage le plus courant consiste à exporter les données des runs pour une analyse personnalisée. L’interface de requête est identique à [celle de MongoDB](https://www.mongodb.com/docs/manual/reference/mql/query-predicates/).

    ```python theme={"system"}
    runs = api.runs(
        "username/project",
        {"$or": [{"config.experiment_name": "foo"}, {"config.experiment_name": "bar"}]},
    )
    print(f"Found {len(runs)} runs")
    ```
  </Tab>
</Tabs>

L’appel à `api.runs` renvoie un objet `Runs` itérable qui se comporte comme une liste. Par défaut, l’objet charge les runs séquentiellement, par lots de 50, au fur et à mesure des besoins, mais vous pouvez modifier le nombre de runs chargés par page avec l’argument nommé `per_page`.

`api.runs` accepte également un argument nommé `order`. L’ordre par défaut est `-created_at`. Pour trier les résultats par ordre croissant, indiquez `+created_at`. Vous pouvez aussi trier selon des valeurs de configuration ou de synthèse, par exemple `summary.val_acc` ou `config.experiment_name`.

<h3 id="error-handling">
  Gestion des erreurs
</h3>

Si des erreurs surviennent lors de la communication avec les serveurs W\&B, une exception `wandb.CommError` est levée. Vous pouvez inspecter l’exception d’origine via l’attribut `exc`.

<h3 id="get-a-runs-name-and-id-during-an-active-run">
  Obtenir le nom et l’ID d’un run pendant son exécution
</h3>

Après avoir appelé `wandb.init()`, vous pouvez accéder depuis votre script à l’ID aléatoire du run ou à son nom lisible, comme suit :

* ID unique du run (hachage de 8 caractères) : `run.id`
* Nom aléatoire du run (lisible) : `run.name`

Si vous cherchez comment attribuer des identifiants utiles à vos runs, voici nos recommandations :

* **ID du run** : conservez le hachage généré. Cet identifiant doit être unique parmi les runs de votre projet.
* **Nom du run** : choisissez un nom court, lisible et de préférence unique, afin de pouvoir distinguer les différentes courbes de vos graphiques.
* **Notes du run** : c’est l’endroit idéal pour décrire brièvement ce que fait votre run. Vous pouvez les définir avec `wandb.init(notes="your notes here")`
* **Tags du run** : utilisez les tags du run pour suivre des informations de manière dynamique, et appliquez des filtres dans l’interface utilisateur pour n’afficher dans votre tableau que les runs qui vous intéressent. Vous pouvez définir des tags depuis votre script, puis les modifier dans l’interface utilisateur, aussi bien dans le tableau des runs que dans l’onglet Vue d’ensemble de la page du run. Consultez les instructions détaillées [ici](/fr/products/wandb/runs/tags).

<h2 id="public-api-examples">
  Exemples d’utilisation de l’API publique
</h2>

<h3 id="read-metrics-from-a-run">
  Lire les métriques d’un run
</h3>

Cet exemple affiche l’horodatage et la précision journalisés avec `run.log({"accuracy": acc})` pour un run enregistré dans `"<entity>/<project>/<run_id>"`.

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

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
if run.state == "finished":
    for i, row in run.history().iterrows():
        print(row["_timestamp"], row["accuracy"])
```

<h3 id="read-specific-metrics-from-a-run">
  Lire des métriques spécifiques d’un run
</h3>

Pour récupérer des métriques spécifiques d’un run, utilisez l’argument `keys`. Par défaut, `run.history()` renvoie 500 échantillons. Les steps journalisés qui ne contiennent pas une métrique donnée apparaissent dans le dataframe de sortie avec la valeur `NaN`. L’argument `keys` indique à l’API d’échantillonner plus fréquemment les steps qui contiennent les clés de métriques indiquées.

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

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
if run.state == "finished":
    for i, row in run.history(keys=["accuracy"]).iterrows():
        print(row["_timestamp"], row["accuracy"])
```

<h3 id="compare-two-runs">
  Comparer deux runs
</h3>

Ce code affiche les paramètres de configuration qui diffèrent entre `run1` et `run2`.

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

api = wandb.Api()

# remplacez <entity>, <project> et <run_id> par vos propres valeurs
run1 = api.run("<entity>/<project>/<run_id>")
run2 = api.run("<entity>/<project>/<run_id>")


df = pd.DataFrame([run1.config, run2.config]).transpose()

df.columns = [run1.name, run2.name]
print(df[df[run1.name] != df[run2.name]])
```

Sorties :

```
              c_10_sgd_0.025_0.01_long_switch base_adam_4_conv_2fc
batch_size                                 32                   16
n_conv_layers                               5                    4
optimizer                             rmsprop                 adam
```

<h3 id="update-metrics-for-a-run-after-the-run-has-finished">
  Mettre à jour les métriques d’un run une fois celui-ci terminé
</h3>

Cet exemple définit la précision d’un run précédent à `0.9` :

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

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
run.summary["accuracy"] = 0.9
run.summary.update()
```

<h3 id="rename-a-metric-in-a-completed-run">
  Renommer une métrique dans un run terminé
</h3>

Cet exemple renomme une colonne de synthèse dans vos tableaux.

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

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
run.summary["new_name"] = run.summary["old_name"]
del run.summary["old_name"]
run.summary.update()
```

<Note>
  Le renommage d’une colonne ne s’applique qu’aux tableaux. Les graphiques continueront de se référer aux métriques par leur nom d’origine.
</Note>

<h3 id="update-config-for-an-existing-run">
  Mettre à jour la configuration d’un run existant
</h3>

Cet exemple met à jour l’un de vos paramètres de configuration.

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

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
run.config["key"] = updated_value
run.update()
```

Pour plus d’informations, consultez [Configurer des expériences](/fr/products/wandb/track/config#existing-run).

<h3 id="export-system-resource-consumptions-to-a-csv-file">
  Exporter la consommation des ressources système vers un fichier CSV
</h3>

L’extrait de code ci-dessous permet de trouver la consommation des ressources système d’un run, puis de l’enregistrer dans un fichier CSV.

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

run = wandb.Api().run("<entity>/<project>/<run_id>")
system_metrics = run.history(stream="events")
system_metrics.to_csv("sys_metrics.csv")
```

<h3 id="get-unsampled-metric-data">
  Obtenir les données de métriques non échantillonnées
</h3>

Lorsque vous récupérez des données depuis l'historique, elles sont échantillonnées par défaut à 500 points. Pour obtenir l'ensemble des points de données journalisés, utilisez `run.scan_history()`. Voici un exemple qui télécharge tous les points de données `loss` journalisés dans l'historique.

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

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
history = run.scan_history()
losses = [row["loss"] for row in history]
```

<h3 id="get-paginated-data-from-history">
  Obtenir des données paginées depuis l’historique
</h3>

Pour récupérer l’historique complet et non échantillonné d’un run, utilisez `run.scan_history()`. L’historique non échantillonné contient tous les enregistrements d’historique du run. À l’inverse, la vue échantillonnée renvoyée par `run.history()` peut omettre certains enregistrements.

Le paramètre `page_size` définit le nombre maximum d’enregistrements d’historique récupérés par requête API. Sa valeur par défaut est `1000`. Si les requêtes sont lentes ou expirent, essayez une taille de page plus petite. Des pages plus petites réduisent le risque d’expiration, mais nécessitent davantage de requêtes API.

Le paramètre `keys` permet, indépendamment, de filtrer les métriques renvoyées.

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

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
run.scan_history(keys=sorted(cols), page_size=100)
```

<h3 id="export-metrics-from-all-runs-in-a-project-to-a-csv-file">
  Exporter les métriques de tous les runs d’un projet vers un fichier CSV
</h3>

Ce script récupère les runs d’un projet et génère un dataframe ainsi qu’un fichier CSV répertoriant les runs avec leurs noms, leurs configurations et leurs statistiques de synthèse. Remplacez `<entity>` et `<project>` respectivement par votre entity W\&B et le nom de votre projet.

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

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

summary_list, config_list, name_list = [], [], []
for run in runs:
    # .summary contient les clés/valeurs de sortie
    #  des métriques telles que la précision.
    #  On appelle ._json_dict pour exclure les fichiers volumineux
    summary_list.append(run.summary._json_dict)

    # .config contient les hyperparamètres.
    #  On supprime les valeurs spéciales commençant par _.
    config_list.append({k: v for k, v in run.config.items() if not k.startswith("_")})

    # .name est le nom lisible du run.
    name_list.append(run.name)

runs_df = pd.DataFrame(
    {"summary": summary_list, "config": config_list, "name": name_list}
)

runs_df.to_csv("project.csv")
```

<h3 id="get-the-starting-time-for-a-run">
  Obtenir l’heure de début d’un run
</h3>

Cet extrait de code récupère l’heure de création du run.

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

api = wandb.Api()

run = api.run("entity/project/run_id")
start_time = run.created_at
```

<h3 id="upload-files-to-a-finished-run">
  Téléverser des fichiers dans un run terminé
</h3>

L’extrait de code ci-dessous téléverse le fichier sélectionné dans un run terminé.

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

api = wandb.Api()

run = api.run("entity/project/run_id")
run.upload_file("file_name.extension")
```

<h3 id="download-a-file-from-a-run">
  Télécharger un fichier depuis un run
</h3>

Cet exemple recherche le fichier "model-best.h5" associé au run d’ID uxte44z7 dans le projet cifar, puis l’enregistre localement.

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

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
run.file("model-best.h5").download()
```

<h3 id="download-all-files-from-a-run">
  Télécharger tous les fichiers d’un run
</h3>

Ce code récupère tous les fichiers associés à un run et les enregistre en local.

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

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
for file in run.files():
    file.download()
```

<h3 id="get-runs-from-a-specific-sweep">
  Obtenir les runs d’un sweep spécifique
</h3>

Cet extrait télécharge tous les runs associés à un sweep donné.

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

api = wandb.Api()

sweep = api.sweep("<entity>/<project>/<sweep_id>")
sweep_runs = sweep.runs
```

<h3 id="get-the-best-run-from-a-sweep">
  Obtenir le meilleur run d’un sweep
</h3>

L’extrait de code suivant récupère le meilleur run d’un sweep donné.

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

api = wandb.Api()

sweep = api.sweep("<entity>/<project>/<sweep_id>")
best_run = sweep.best_run()
```

Le `best_run` est le run qui obtient la meilleure métrique, telle que définie par le paramètre `metric` de la configuration du sweep.

<h3 id="download-the-best-model-file-from-a-sweep">
  Télécharger le fichier du meilleur modèle d’un sweep
</h3>

Cet extrait télécharge le fichier de modèle ayant la meilleure précision de validation dans un sweep dont les runs ont enregistré leurs fichiers de modèle dans `model.h5`.

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

api = wandb.Api()

sweep = api.sweep("<entity>/<project>/<sweep_id>")
runs = sorted(sweep.runs, key=lambda run: run.summary.get("val_acc", 0), reverse=True)
val_acc = runs[0].summary.get("val_acc", 0)
print(f"Best run {runs[0].name} with {val_acc}% val accuracy")

runs[0].file("model.h5").download(replace=True)
print("Best model saved to model-best.h5")
```

<h3 id="delete-all-files-with-a-given-extension-from-a-run">
  Supprimer d’un run tous les fichiers ayant une extension donnée
</h3>

Cet extrait supprime d’un run les fichiers ayant une extension donnée.

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

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")

extension = ".png"
files = run.files()
for file in files:
    if file.name.endswith(extension):
        file.delete()
```

<h3 id="download-system-metrics-data">
  Télécharger les données des métriques système
</h3>

Cet extrait génère un dataframe contenant toutes les métriques de consommation des ressources système d’un run, puis l’enregistre dans un fichier CSV.

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

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
system_metrics = run.history(stream="events")
system_metrics.to_csv("sys_metrics.csv")
```

<h3 id="update-summary-metrics">
  Mettre à jour les métriques de synthèse
</h3>

Vous pouvez transmettre un dictionnaire pour mettre à jour les métriques de synthèse.

```python theme={"system"}
summary.update({"key": val})
```

<h3 id="get-the-command-that-ran-the-run">
  Obtenir la commande qui a lancé le run
</h3>

Chaque run capture la commande qui l’a lancé et l’affiche sur la page d’aperçu du run. Pour récupérer cette commande depuis l’API, vous pouvez exécuter :

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

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")

meta = json.load(run.file("wandb-metadata.json").download())
program = ["python"] + [meta["program"]] + meta["args"]
```