> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-docs-2516.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# init()
export const GitHubLink = ({url, compact = false}) =>
{compact ? "voir la source" : <>
Source GitHub
}
;
## fonction wandb.init()
Démarrez un nouveau run pour suivre et journaliser dans W\&B.
Dans un pipeline d'entraînement ML, vous pouvez ajouter `wandb.init()` au début de
votre script d'entraînement ainsi que de votre script d'évaluation, et chacun d'eux sera
suivi en tant que run dans W\&B.
`wandb.init()` lance un nouveau processus en arrière-plan pour journaliser des données dans un run, et
synchronise également les données avec [https://wandb.ai](https://wandb.ai) par défaut, afin que vous puissiez voir vos résultats
en temps réel. Une fois que vous avez fini de journaliser des données, appelez `run.finish()` pour
mettre fin au run, ou utilisez le run comme gestionnaire de contexte pour l'appeler 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 terminera lorsque votre script s'arrêtera.
Les ID du run ne doivent contenir aucun des caractères spéciaux suivants `/ \ # ? % :`
```python theme={null}
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
```
## Arguments
Le nom d’utilisateur ou d’équipe auquel les runs sont enregistrés. L’entité doit déjà exister. Veillez donc à créer votre compte ou votre équipe dans l’interface utilisateur avant de commencer à enregistrer des runs. Si elle n’est pas spécifiée, le run utilisera votre entité par défaut. Pour modifier l’entité par défaut, accédez à vos paramètres et mettez à jour « Default location to create new projects » sous « Default team ».
Le nom du projet dans lequel ce run sera enregistré. S’il n’est pas spécifié, nous utilisons une heuristique pour déduire le nom du projet à partir du système, par exemple en vérifiant la racine Git ou le fichier de programme actuel. Si nous ne pouvons pas déduire le nom du projet, `"uncategorized"` sera utilisé par défaut.
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 cela n’affecte pas 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 qu’un run a été supprimé. Pour un nom descriptif court, utilisez 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, nous générons un nom aléatoire de deux mots, ce qui permet de faire facilement le lien entre les runs dans 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 vous recommandons d’utiliser le champ `config`.
Une description détaillée du run, semblable à un message de commit Git. Utilisez cet argument pour capturer tout contexte ou détail susceptible de vous aider à vous rappeler ultérieurement l’objectif ou la configuration de ce run.
Une liste de tags permettant d’étiqueter ce run dans l’interface utilisateur. Les tags sont utiles pour organiser les runs ou ajouter des identifiants temporaires tels que « référence » ou « production ». Vous pouvez facilement ajouter ou supprimer des tags, ou filtrer les runs par tag dans l’interface utilisateur. Lors de la reprise d’un run, les tags fournis ici remplaceront tous les tags existants. Pour ajouter des tags à un run repris sans remplacer les tags actuels, utilisez `run.tags += ("new_tag",)` après avoir appelé `run = wandb.init()`.
Définit `wandb.config`, un objet de type dictionnaire destiné à 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 apparaît dans l’interface utilisateur, sur une page d’aperçu, ce qui vous permet de regrouper, filtrer et trier les runs selon ces paramètres. Les clés ne doivent pas contenir de points (`.`) et les valeurs doivent être inférieures à 10 Mo. Si un dictionnaire, `argparse.Namespace` ou `absl.flags.FLAGS` est fourni, les paires clé-valeur sont chargées directement dans `wandb.config`. Si une chaîne est fournie, 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 remplacée. Pour suivre des variables qui évoluent pendant l’entraînement, telles qu’un taux d’apprentissage, envisagez plutôt d’utiliser `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 les runs individuels dans le cadre d’une expérience plus vaste. Cela est utile dans des cas tels que 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 Grouping vous permet de gérer collectivement les runs associés dans l’interface utilisateur, ce qui facilite leur regroupement et l’examen des résultats comme une expérience unifiée.
Spécifiez 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 attribuer aux runs des types de job comme "train" et "eval". La définition de types de job vous permet de filtrer et de regrouper facilement des runs similaires dans l'interface utilisateur, afin de faciliter les comparaisons directes.
Indique comment les données du run sont gérées, avec les options suivantes :
* `"online"` (par défaut) : Active la synchronisation en direct avec W\&B lorsqu’une connexion réseau
est disponible, avec des mises à 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. Assurez-vous que le dossier du run
est conservé pour permettre une synchronisation future.
* `"disabled"` : Désactive toutes les fonctionnalités W\&B, ce qui rend les méthodes du run
sans effet. Généralement utilisé pour les tests afin de contourner les opérations W\&B.
* `"shared"` : (Il s’agit d’une fonctionnalité expérimentale.) Permet à plusieurs processus,
éventuellement sur des machines différentes, de journaliser simultanément dans le même run.
Dans 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
à l’aide du 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 pourra pas continuer. Si `False` (par défaut), le script peut continuer sans connexion et basculer en mode hors ligne si l’utilisateur n’est pas connecté.
Forme abrégée du 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"
sinon.
* `"return_previous"` : renvoie le run créé le plus récemment
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`.
Pour cette raison, certaines intégrations plus anciennes qui s’appuient 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 :
* `"allow"` : Si un run avec l’`id` spécifié existe, il reprendra
à partir de la dernière étape ; sinon, un nouveau run sera créé.
* `"never"` : Si un run avec l’`id` spécifié existe, une erreur sera
générée. Si aucun run correspondant n’est trouvé, un nouveau run sera créé.
* `"must"` : Si un run avec l’`id` spécifié existe, il reprendra
à partir de la dernière étape. Si aucun run n’est trouvé, une erreur sera généré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. Utiliser `"auto"` à la place.
* `False` : Obsolète. Utiliser 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émarrera toujours un nouveau run.
Spécifie un point dans un run précédent à partir duquel reprendre un run, en utilisant le format `{run_id}?_step={step}`. Cela permet aux utilisateurs de tronquer l’historique enregistré pour un run à une étape intermédiaire et de reprendre l’enregistrement à 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 utilisés ensemble : un seul peut être utilisé à la fois. Notez que cette fonctionnalité est en bêta et pourra changer à l’avenir.
Spécifie un point d’un run précédent à partir duquel créer un nouveau run, au format `{id}?_step={step}`. Cela crée un nouveau run qui reprend la journalisation à 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` ; une erreur est générée s’ils sont identiques. `resume`, `resume_from` et `fork_from` ne peuvent pas être utilisés ensemble : un seul peut être utilisé à la fois. Notez que cette fonctionnalité est en bêta et peut évoluer à l’avenir.
Active l’enregistrement du script principal ou du notebook dans W\&B, ce qui favorise 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 modifier cette valeur par défaut pour l’activer sur 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 pertinents pour les consulter dans l’interface W\&B.
Active la journalisation automatique des vidéos de l’environnement lors de l’utilisation d’OpenAI Gym.
Spécifie 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 se produit lors de l'initialisation du run.
* `AuthenticationError`: Si l'utilisateur ne fournit pas d'identifiants valides.
* `CommError`: En cas de problème de communication avec le serveur WandB.
* `UsageError`: Si l'utilisateur fournit des arguments non valides.
* `KeyboardInterrupt`: Si l'utilisateur interrompt le run.
## Exemples
`wandb.init()` renvoie un objet `Run`. Utilisez l'objet run pour journaliser des données,
enregistrer des Artifacts et gérer le cycle de vie du run.
```python theme={null}
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 # Exemple de précision
loss = 0.05 # Exemple de perte
run.log({"accuracy": acc, "loss": loss})
```