> ## 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.
# Initialiser des runs
> Initialisez des runs W&B avec wandb.init() pour commencer à suivre vos expériences, y compris la gestion de runs simultanés dans un même processus.
Initialisez un run W\&B avec [`wandb.init()`](/fr/products/wandb/ref/python/functions/init).
Par défaut, W\&B prend en charge un seul run actif par processus Python. Si vous appelez `wandb.init()` alors qu’un run est déjà actif, W\&B renvoie ce run actif ou le termine avant d’en créer un nouveau. Ce comportement dépend de l’environnement et de la configuration `reinit`.
Pour gérer plusieurs runs actifs dans un même processus, consultez [Plusieurs runs dans un même processus](/fr/products/wandb/runs/initialize-run#multiple-runs-in-one-process).
W\&B recommande d’utiliser un gestionnaire de contexte (bloc `with`) pour appeler `wandb.init()`. Vous avez ainsi la garantie que W\&B termine le run et téléverse ses données à la sortie du bloc.
Un seul run par processus
L’exemple suivant initialise un run :
```python title="basic.py" theme={"system"}
import wandb
with wandb.init(entity="nico", project="awesome-project") as run:
# Placez ici votre logique d’entraînement
```
La commande produit une sortie semblable à celle-ci :
```bash theme={"system"}
🚀 View run exalted-darkness-6 at:
https://wandb.ai/nico/awesome-project/runs/pgbn9y21
Find logs at: wandb/run-20241106_090747-pgbn9y21/logs
```
Dans cet exemple, W\&B journalise le run `exalted-darkness-6` dans le projet `awesome-project` de l’entity `nico`. W\&B attribue au run l’ID unique `pgbn9y21`.
Plusieurs runs dans un même processus
Utilisez le paramètre `reinit` dans `wandb.init()` ou `wandb.Settings` pour gérer plusieurs runs dans un même processus Python. Vous pouvez par exemple garder un run principal actif tout en créant des runs secondaires de courte durée pour d’autres tâches.
Voici quelques cas d’usage courants :
* Créer des runs secondaires pour des évaluations ou des sous-tâches pendant qu’un run principal reste actif.
* Exécuter plusieurs sous-expériences à partir d’un seul script.
* Journaliser différentes tâches ou périodes dans des runs distincts depuis un même processus.
**Exigences**
Pour gérer plusieurs runs dans un même processus Python, vous devez disposer de la version `v0.19.10` ou ultérieure du SDK Python W\&B.
Options de `reinit`
Utilisez le paramètre `reinit` pour contrôler ce qui se passe lorsque vous appelez `wandb.init()` alors qu’un autre run est actif. Le tableau suivant compare les options disponibles et leurs cas d’utilisation courants. Pour la définition complète du paramètre, consultez la [documentation de référence de `wandb.init()`](/fr/products/wandb/ref/python/functions/init).
| Option | Comportement | Crée un nouveau run ? | À utiliser lorsque |
| - | - | - | - |
| `create_new` | Crée un nouveau run sans terminer les runs actifs existants. W\&B n’attribue pas le nouveau run à la variable globale `wandb.run`. Conservez chaque objet run renvoyé et utilisez-le explicitement. Voir [Gérer plusieurs runs actifs dans un même processus](/fr/products/wandb/runs/initialize-run#example-multiple-runs-in-one-process). | Oui | Vous avez besoin de plusieurs runs actifs dans un même processus, par exemple un run principal qui reste actif pendant que vous créez et terminez des runs secondaires. |
| `finish_previous` | Termine les runs actifs avant de créer un nouveau run. Il s’agit du comportement par défaut en dehors des environnements de notebook. | Oui | Les runs s’exécutent les uns après les autres, et chaque tâche ou phase doit disposer de son propre run. |
| `return_previous` | Renvoie le run non terminé le plus récent au lieu d’en créer un nouveau. Il s’agit du comportement par défaut dans les environnements de notebook. | Non | Les appels successifs à `wandb.init()` doivent continuer à utiliser le run actif. |
W\&B ne prend pas en charge le mode `create_new` pour les [intégrations W\&B](/fr/products/wandb/integrations) qui reposent sur un run global unique, comme Hugging Face Trainer, les callbacks Keras et PyTorch Lightning. Si vous utilisez ces intégrations, exécutez chaque sous-expérience dans un processus distinct.
* Utilisez `wandb.init()` en passant directement l’argument `reinit` :
```python theme={"system"}
import wandb
with wandb.init(reinit="") as run:
# Votre code ici
```
* Utilisez `wandb.init()` et passez un objet `wandb.Settings` au paramètre `settings`. Spécifiez `reinit` dans l’objet `Settings` :
```python theme={"system"}
import wandb
with wandb.init(settings=wandb.Settings(reinit="")) as run:
# Votre code ici
```
* Utilisez `wandb.setup()` pour définir l’option `reinit` de manière globale pour tous les runs du processus en cours. Cette approche est utile si vous souhaitez configurer le comportement une seule fois et l’appliquer à tous les appels `wandb.init()` suivants dans ce processus.
```python theme={"system"}
import wandb
with wandb.setup(wandb.Settings(reinit="")) as run:
# Votre code ici
```
* Spécifiez la valeur souhaitée pour `reinit` dans la variable d’environnement `WANDB_REINIT`. Une fois la variable d’environnement définie, l’option `reinit` s’applique aux appels `wandb.init()`.
```bash theme={"system"}
export WANDB_REINIT=""
```
L’extrait de code suivant montre, dans les grandes lignes, comment configurer W\&B pour créer un nouveau run à chaque appel de `wandb.init()` :
```python theme={"system"}
import wandb
wandb.setup(wandb.Settings(reinit="create_new"))
with wandb.init() as experiment_results_run:
# Ce run sert à journaliser les résultats de chaque expérience.
# Considérez-le comme un run parent qui regroupe les résultats
with wandb.init() as run:
# La fonction do_experiment() journalise des métriques détaillées
# dans le run fourni et renvoie les métriques de résultat que
# vous souhaitez suivre séparément.
experiment_results = do_experiment(run)
# Après chaque expérience, journalisez ses résultats dans un run
# parent. Chaque point des graphiques du run parent correspond
# aux résultats d’une expérience.
experiment_results_run.log(experiment_results)
```
Exemple : processus simultanés
Supposons que vous souhaitiez créer un processus principal qui reste ouvert pendant toute la durée d'exécution du script, tout en lançant périodiquement des processus secondaires de courte durée sans terminer le processus principal. Ce modèle peut par exemple être utile si vous souhaitez entraîner un modèle dans le run principal, mais calculer des évaluations ou effectuer d'autres tâches dans des runs distincts.
Pour ce faire, utilisez `reinit="create_new"` et initialisez plusieurs runs. Dans cet exemple, supposons que « Run A » soit le processus principal qui reste ouvert tout au long du script, tandis que « Run B1 » et « Run B2 » sont des runs secondaires de courte durée destinés à des tâches comme l'évaluation.
Le flux de travail général pourrait se présenter ainsi :
1. Initialisez le processus principal Run A avec `wandb.init()` et journalisez les métriques d'entraînement.
2. Initialisez Run B1 (avec `wandb.init()`), journalisez des données, puis terminez-le.
3. Journalisez d'autres données dans Run A.
4. Initialisez Run B2, journalisez des données, puis terminez-le.
5. Continuez à journaliser dans Run A.
6. Pour finir, terminez Run A.
L'exemple de code Python suivant illustre ce flux de travail :
```python theme={"system"}
import wandb
def train(name: str) -> None:
"""Perform one training iteration in its own W&B run.
Using a 'with wandb.init()' block with `reinit="create_new"` ensures that
this training sub-run can be created even if another run (like our primary
tracking run) is already active.
"""
with wandb.init(
project="my_project",
name=name,
reinit="create_new"
) as run:
# Dans un vrai script, exécutez vos étapes d’entraînement dans ce bloc.
run.log({"train_loss": 0.42}) # Remplacez par vos propres métriques
def evaluate_loss_accuracy() -> (float, float):
"""Returns the current model's loss and accuracy.
Replace this placeholder with your real evaluation logic.
"""
return 0.27, 0.91 # Valeurs de métriques d’exemple
# Créer un run « principal » qui reste actif sur plusieurs étapes d’entraînement et d’évaluation.
with wandb.init(
project="my_project",
name="tracking_run",
reinit="create_new"
) as tracking_run:
# 1) Premier entraînement dans un sous-run nommé 'training_1'
train("training_1")
loss, accuracy = evaluate_loss_accuracy()
tracking_run.log({"eval_loss": loss, "eval_accuracy": accuracy})
# 2) Nouvel entraînement dans un sous-run nommé 'training_2'
train("training_2")
loss, accuracy = evaluate_loss_accuracy()
tracking_run.log({"eval_loss": loss, "eval_accuracy": accuracy})
# Le run 'tracking_run' se termine automatiquement à la sortie de ce bloc 'with'.
```
Retenez trois points clés de l’exemple précédent :
1. `reinit="create_new"` crée un nouveau run chaque fois que vous appelez `wandb.init()`.
2. Vous conservez une référence à chaque run. `wandb.run` ne pointe pas automatiquement vers le nouveau run créé avec `reinit="create_new"`. Stockez les nouveaux runs dans des variables telles que `run_a`, `run_b1`, etc., puis appelez `.log()` ou `.finish()` sur ces objets si nécessaire.
3. Vous pouvez terminer les sous-runs à tout moment tout en gardant le run principal ouvert jusqu’à.
4. Terminez vos runs avec `run.finish()` lorsque vous avez fini d’y journaliser des données. Vous avez ainsi la garantie que toutes les données sont téléversées et que le run est correctement fermé.