> ## 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.
# init()
export const GitHubLink = ({url, compact = false}) =>
{compact ? "View source" : <>
GitHub source
}
;
function wandb.init()
Démarrez un nouveau run pour suivre et consigner des données dans W\&B.
Dans un pipeline d’entraînement ML, vous pouvez ajouter `wandb.init()` au début de
votre script d’entraînement comme de votre script d’évaluation : chacun d’eux
sera alors suivi en tant que run dans W\&B.
`wandb.init()` lance un nouveau processus en arrière-plan qui journalise les données dans un run et
les synchronise par défaut avec [https://wandb.ai](https://wandb.ai), ce qui vous permet de consulter vos résultats
en temps réel. Une fois la journalisation des données terminée, appelez `run.finish()` pour
mettre fin au run, ou utilisez le run comme gestionnaire de contexte pour que cet appel soit effectué automatiquement :
with wandb.init() as run:
... # run.finish() s’exécute à la fin du bloc
Si vous n’appelez pas `run.finish()`, le run se termine à la fin de l’exécution de votre script.
Les ID de run ne doivent contenir aucun des caractères spéciaux suivants : `/ \ # ? % :`
```python theme={"system"}
entity: 'str | None' = None,
project: 'str | None' = None,
dir: 'StrPath | None' = None,
id: 'str | None' = None,
name: 'str | None' = None,
notes: 'str | None' = None,
tags: 'Sequence[str] | None' = None,
config: 'dict[str, Any] | str | None' = None,
config_exclude_keys: 'list[str] | None' = None,
config_include_keys: 'list[str] | None' = None,
allow_val_change: 'bool | None' = None,
group: 'str | None' = None,
job_type: 'str | None' = None,
mode: "Literal['online', 'offline', 'disabled', 'shared'] | None" = None,
force: 'bool | None' = None,
reinit: "bool | Literal[None, 'default', 'return_previous', 'finish_previous', 'create_new']" = None,
resume: "bool | Literal['allow', 'never', 'must', 'auto'] | None" = None,
resume_from: 'str | None' = None,
fork_from: 'str | None' = None,
save_code: 'bool | None' = None,
tensorboard: 'bool | None' = None,
sync_tensorboard: 'bool | None' = None,
monitor_gym: 'bool | None' = None,
settings: 'Settings | dict[str, Any] | None' = None,
anonymous: 'DoNotSet' = DoNotSet
```
Args
Le nom d’utilisateur ou le nom d’équipe sous lequel les runs sont journalisés. L’entity doit déjà exister : veillez donc à créer votre compte ou votre équipe dans l’interface utilisateur avant de commencer à journaliser des runs. Si ce paramètre n’est pas spécifié, le run utilise votre entity par défaut. Pour modifier l’entity par défaut, accédez à vos paramètres et mettez à jour « Default location to create new projects » sous « Default team ».
Le nom du projet sous lequel ce run sera journalisé. S’il n’est pas spécifié, une heuristique permet de déduire le nom du projet à partir du système, par exemple en examinant la racine git ou le fichier du programme en cours. Si le nom du projet ne peut pas être déduit, le projet prend par défaut la valeur `"uncategorized"`.
Le chemin absolu du répertoire où sont stockés les journaux d’expérience et les fichiers de métadonnées. S’il n’est pas spécifié, le répertoire `./wandb` est utilisé par défaut. Notez que ce paramètre n’a aucune incidence sur l’emplacement où les artifacts sont stockés lors de l’appel à `download()`.
Un identifiant unique pour ce run, utilisé pour la reprise. Il doit être unique au sein du projet et ne peut pas être réutilisé une fois le run supprimé. Pour un nom court et descriptif, utilisez plutôt le champ `name` ; pour enregistrer des hyperparamètres à comparer entre les runs, utilisez `config`.
Un nom d’affichage court pour ce run, qui apparaît dans l’interface utilisateur pour vous aider à l’identifier. Par défaut, un nom aléatoire de deux mots est généré afin de faciliter le recoupement des runs entre les tableaux et les graphiques. Des noms de run courts améliorent la lisibilité des légendes de graphiques et des tableaux. Pour enregistrer des hyperparamètres, nous recommandons d’utiliser le champ `config`.
Une description détaillée du run, semblable à un message de commit dans Git. Utilisez cet argument pour consigner tout contexte ou détail susceptible de vous rappeler ultérieurement l’objectif ou la configuration de ce run.
Une liste de tags pour étiqueter ce run dans l’interface utilisateur. Les tags sont utiles pour organiser les runs ou ajouter des identifiants temporaires comme « baseline » ou « production ». Vous pouvez facilement ajouter ou supprimer des tags, ou filtrer par tag dans l’interface utilisateur. Lors de la reprise d’un run, les tags fournis ici remplacent les tags existants. Pour ajouter des tags à un run repris sans écraser les tags actuels, utilisez `run.tags += ("new_tag",)` après l’appel à `run = wandb.init()`.
Définit `wandb.config`, un objet de type dictionnaire permettant de stocker les paramètres d’entrée de votre run, tels que les hyperparamètres du modèle ou les paramètres de prétraitement des données. La configuration s’affiche dans l’interface utilisateur sur une page d’aperçu, ce qui vous permet de grouper, filtrer et trier les runs en fonction de ces paramètres. Les clés ne doivent pas contenir de points (`.`) et les valeurs doivent faire moins de 10 Mo. Si vous fournissez un dictionnaire, `argparse.Namespace` ou `absl.flags.FLAGS`, les paires clé-valeur sont chargées directement dans `wandb.config`. Si vous fournissez une chaîne, elle est interprétée comme le chemin d’un fichier YAML dont les valeurs de configuration sont chargées dans `wandb.config`.
Une liste de clés spécifiques à exclure de `wandb.config`.
Une liste de clés spécifiques à inclure dans `wandb.config`.
Détermine si les valeurs de configuration peuvent être modifiées après leur définition initiale. Par défaut, une exception est levée si une valeur de configuration est écrasée. Pour suivre des variables qui évoluent pendant l’entraînement, comme le taux d’apprentissage, utilisez plutôt `wandb.log()`. Par défaut, cette valeur est `False` dans les scripts et `True` dans les environnements Notebook.
Spécifiez un nom de groupe pour organiser des runs individuels au sein d’une expérience plus vaste. C’est utile, par exemple, pour la validation croisée ou l’exécution de plusieurs tâches qui entraînent et évaluent un modèle sur différents jeux de test. Le regroupement vous permet de gérer collectivement les runs associés dans l’interface utilisateur, ce qui facilite l’affichage et l’examen des résultats comme une seule et même expérience.
Spécifie le type de run, ce qui est particulièrement utile pour organiser les runs au sein d’un groupe dans le cadre d’une expérience plus large. Par exemple, dans un groupe, vous pouvez étiqueter les runs avec des types de job tels que « train » et « eval ». Définir des types de job vous permet de filtrer et de regrouper facilement des runs similaires dans l’interface utilisateur, ce qui facilite les comparaisons directes.
Spécifie la façon dont les données du run sont gérées. Les options suivantes sont disponibles :
* `"online"` (par défaut) : active la synchronisation en direct avec W\&B lorsqu’une connexion
réseau est disponible, avec une mise à jour des visualisations en temps réel.
* `"offline"` : adapté aux environnements isolés du réseau ou hors ligne ; les données
sont enregistrées localement et peuvent être synchronisées ultérieurement. Veillez à conserver le dossier du run
pour permettre cette synchronisation.
* `"disabled"` : désactive toutes les fonctionnalités de W\&B ; les méthodes du run
ne font alors rien. Généralement utilisé lors des tests pour contourner les opérations W\&B.
* `"shared"` : (fonctionnalité expérimentale). Permet à plusieurs processus,
éventuellement sur des machines différentes, de journaliser simultanément dans le même run.
Avec cette approche, vous utilisez un nœud principal et un ou plusieurs nœuds de travail
pour journaliser des données dans le même run. Sur le nœud principal, vous
initialisez un run. Pour chaque nœud de travail, initialisez un run
avec l’ID du run utilisé par le nœud principal.
Détermine si une connexion à W\&B est requise pour exécuter le script. Si `True`, l’utilisateur doit être connecté à W\&B ; sinon, le script ne s’exécute pas. Si `False` (par défaut), le script peut s’exécuter sans connexion et passe en mode hors ligne si l’utilisateur n’est pas connecté.
Raccourci pour le paramètre « reinit ». Détermine le comportement de
`wandb.init()` lorsqu’un run est actif.
* `"default"` : utilise « finish\_previous » dans les notebooks et « return\_previous »
dans les autres cas.
* `"return_previous"` : renvoie le run le plus récemment créé
qui n’est pas encore terminé. Cela ne met pas à jour `wandb.run` ; voir
l’option « create\_new ».
* `"finish_previous"` : termine tous les runs actifs, puis renvoie un nouveau run.
* `"create_new"` : crée un nouveau run sans modifier les autres runs actifs.
Ne met pas à jour `wandb.run` ni les fonctions de premier niveau comme `wandb.log`.
Par conséquent, certaines intégrations plus anciennes qui reposent sur le run global
ne fonctionneront pas.
Contrôle le comportement lors de la reprise d’un run avec l’`id` spécifié.
Les options disponibles sont les suivantes :
* `"allow"` : si un run avec l’`id` spécifié existe, il reprend
à partir de la dernière étape ; sinon, un nouveau run est créé.
* `"never"` : si un run avec l’`id` spécifié existe, une erreur
est levée. Si aucun run correspondant n’est trouvé, un nouveau run est créé.
* `"must"` : si un run avec l’`id` spécifié existe, il reprend
à partir de la dernière étape. Si aucun run n’est trouvé, une erreur est levée.
* `"auto"` : reprend automatiquement le run précédent s’il a planté sur
cette machine ; sinon, démarre un nouveau run.
* `True` : obsolète. Utilisez `"auto"` à la place.
* `False` : obsolète. Utilisez le comportement par défaut (en laissant `resume`
non défini) pour toujours démarrer un nouveau run.
Si `resume` est défini, `fork_from` et `resume_from` ne peuvent pas être
utilisés. Lorsque `resume` n’est pas défini, le système démarre toujours un nouveau run.
Spécifie le moment d’un run précédent à partir duquel reprendre un run, au format `{run_id}?_step={step}`. Cela permet aux utilisateurs de tronquer l’historique journalisé dans un run à une étape intermédiaire et de reprendre la journalisation à partir de cette étape. Le run cible doit se trouver dans le même projet. Si un argument `id` est également fourni, l’argument `resume_from` est prioritaire. `resume`, `resume_from` et `fork_from` ne peuvent pas être combinés : vous ne pouvez en utiliser qu’un seul à la fois. Notez que cette fonctionnalité est en version bêta et susceptible d’évoluer.
Indique le point d’un run précédent à partir duquel créer un nouveau run par fork, au format `{id}?_step={step}`. Le nouveau run ainsi créé reprend la journalisation à partir de l’étape spécifiée dans l’historique du run cible. Le run cible doit appartenir au projet actuel. Si un argument `id` est également fourni, il doit être différent de l’argument `fork_from`, sinon une erreur est levée. `resume`, `resume_from` et `fork_from` sont mutuellement exclusifs : vous ne pouvez en utiliser qu’un seul à la fois. Notez que cette fonctionnalité est en version bêta et susceptible d’évoluer.
Active l’enregistrement du script principal ou du notebook dans W\&B, ce qui facilite la reproductibilité des expériences et permet de comparer le code entre les runs dans l’interface utilisateur. Cette option est désactivée par défaut, mais vous pouvez l’activer par défaut depuis votre page de paramètres.
Obsolète. Utilisez plutôt `sync_tensorboard`.
Active la synchronisation automatique des journaux W\&B depuis TensorBoard ou TensorBoardX et enregistre les fichiers d’événements correspondants pour les afficher dans l’interface W\&B.
Active la journalisation automatique de vidéos de l’environnement lors de l’utilisation d’OpenAI Gym.
Indique un dictionnaire ou un objet `wandb.Settings` contenant des paramètres avancés pour le run.
Aucune description fournie.
Renvoie
Un objet `Run`.
Exceptions levées
* `Error` : si une erreur inconnue ou interne s’est produite lors de l’initialisation du run.
* `AuthenticationError` : si l’utilisateur n’a pas fourni d’identifiants d’authentification valides.
* `CommError` : si un problème de communication avec le serveur WandB est survenu.
* `UsageError` : si l’utilisateur a fourni des arguments non valides.
* `KeyboardInterrupt` : si l’utilisateur interrompt le run.
Exemples
`wandb.init()` renvoie un objet `Run`. Utilisez cet objet run pour journaliser des données,
enregistrer des artifacts et gérer le cycle de vie du run.
```python theme={"system"}
import wandb
config = {"lr": 0.01, "batch_size": 32}
with wandb.init(config=config) as run:
# Journaliser la précision et la perte dans le run
acc = 0.95 # Valeur de précision fictive
loss = 0.05 # Valeur de perte fictive
run.log({"accuracy": acc, "loss": loss})
```
## Related topics
- [init](/fr/products/wandb/weave/reference/typescript-sdk/functions/init.md)