> ## 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.
# Settings
export const GitHubLink = ({url, compact = false}) =>
{compact ? "View source" : <>
GitHub source
}
;
Classe wandb.Settings
Paramètres du SDK W\&B.
Cette classe gère les paramètres de configuration du SDK W\&B,
en garantissant la sûreté des types et la validation de tous les paramètres. Les paramètres sont accessibles
sous forme d’attributs et peuvent être initialisés par programmation, au moyen de variables
d’environnement (`WANDB_ prefix`) ou à l’aide de fichiers de configuration.
Les paramètres sont répartis en trois catégories :
1. Paramètres publics : options de configuration principales que les utilisateurs peuvent modifier sans risque pour adapter
le comportement de W\&B à leurs besoins.
2. Paramètres internes : paramètres préfixés par 'x\_' qui régissent le comportement bas niveau du SDK.
Ces paramètres sont principalement destinés à un usage interne et au débogage. Bien qu’ils puissent être modifiés,
ils ne font pas partie de l’API publique et peuvent changer sans préavis dans de futures
versions.
3. Paramètres calculés : paramètres en lecture seule dérivés automatiquement d’autres paramètres ou
de l’environnement.
Les paramètres sont chargés à partir de plusieurs sources. Lorsqu’un même paramètre est fourni
par plusieurs sources, c’est la dernière source de la liste qui l’emporte. De la priorité la plus faible
à la plus élevée :
1. Valeurs par défaut définies dans ce modèle `Settings`.
2. Fichiers de configuration (`~/.config/wandb/settings`, ou le fichier `settings` situé dans
le répertoire indiqué par la variable d’environnement `WANDB_CONFIG_DIR`).
3. Variables d’environnement (celles préfixées par `WANDB_`, par exemple `WANDB_MODE`).
4. Valeurs détectées dans l’environnement d’exécution, comme le nom d’hôte, le
chemin du programme ou du script en cours d’exécution, l’exécutable Python, l’image Docker et
les informations du notebook Jupyter.
5. Paramètres SageMaker, en cas d’exécution dans un environnement Amazon SageMaker.
6. Le paramètre `settings` de `wandb.setup()`.
7. Le paramètre `settings` de `wandb.init()`.
8. Certains paramètres de `wandb.init()` (par exemple, `mode=` remplace le
paramètre `mode`).
```python theme={"system"}
*,
allow_media_symlink: bool = False,
allow_offline_artifacts: bool = True,
allow_val_change: bool = False,
anonymous: object = object(),
api_key: str | None = None,
azure_account_url_to_access_key: dict[str, str] | None = None,
app_url_override: str | None = None,
base_url: str = 'https://api.wandb.ai',
code_dir: str | None = None,
config_paths: collections.abc.Sequence[str] | None = None,
console: Literal['auto', 'off', 'wrap', 'redirect', 'wrap_raw', 'wrap_emu'] = 'auto',
console_multipart: bool = False,
console_chunk_max_bytes: int = 0,
console_chunk_max_seconds: int = 0,
capture_loggers: dict[str, str] | None = None,
credentials_file: str = ,
disable_code: bool = False,
disable_git: bool = False,
disable_git_fork_point: bool = True,
disable_job_creation: bool = True,
docker: str | None = None,
email: str | None = None,
entity: str | None = None,
organization: str | None = None,
force: bool = False,
fork_from: wandb.sdk.lib.run_moment.RunMoment | None = None,
git_commit: str | None = None,
git_remote: str = 'origin',
git_remote_url: str | None = None,
git_root: str | None = None,
heartbeat_seconds: int = 30,
host: str | None = None,
http_proxy: str | None = None,
https_proxy: str | None = None,
identity_token_file: str | None = None,
ignore_globs: collections.abc.Sequence[str] = (),
init_timeout: float = 90.0,
finish_timeout: float = 0.0,
finish_timeout_raises: bool = False,
insecure_disable_ssl: bool = False,
job_name: str | None = None,
job_source: Optional[Literal['repo', 'artifact', 'image']] = None,
label_disable: bool = False,
launch: bool = False,
launch_config_path: str | None = None,
login_timeout: float | None = None,
mode: Literal['online', 'offline', 'shared', 'disabled', 'dryrun', 'run'] = 'online',
notebook_name: str | None = None,
program: str | None = None,
program_abspath: str | None = None,
program_relpath: str | None = None,
project: str | None = None,
quiet: bool = False,
reinit: Union[Literal['default', 'return_previous', 'finish_previous', 'create_new'], bool] = 'default',
relogin: bool = False,
resume: Optional[Literal['allow', 'must', 'never', 'auto']] = None,
resume_from: wandb.sdk.lib.run_moment.RunMoment | None = None,
resumed: bool = False,
root_dir: str = ,
run_group: str | None = None,
run_id: str | None = None,
run_job_type: str | None = None,
run_name: str | None = None,
run_notes: str | None = None,
run_tags: tuple[str, ...] | None = None,
sagemaker_disable: bool = False,
save_code: bool | None = None,
settings_system: str | None = None,
stop_fn: collections.abc.Callable[[], None] | None = None,
max_end_of_run_history_metrics: int = 10,
max_end_of_run_summary_metrics: int = 10,
show_colors: bool | None = None,
show_emoji: bool | None = None,
show_errors: bool = True,
show_info: bool = True,
show_warnings: bool = True,
silent: bool = False,
stop_on_fatal_error: bool = False,
strict: bool | None = None,
summary_timeout: int = 60,
summary_warnings: int = 5,
sweep_id: str | None = None,
sweep_param_path: str | None = None,
symlink: bool = ,
sync_tensorboard: bool | None = None,
table_raise_on_max_row_limit_exceeded: bool = False,
use_dot_wandb: bool | None = None,
username: str | None = None,
x_cli_only_mode: bool = False,
x_disable_meta: bool = False,
x_disable_stats: bool = False,
x_disable_viewer: bool = False,
x_disable_machine_info: bool = False,
x_executable: str | None = None,
x_extra_http_headers: dict[str, str] | None = None,
x_file_stream_max_bytes: int | None = None,
x_file_stream_max_line_bytes: int | None = None,
x_file_stream_transmit_interval: float | None = None,
x_file_stream_no_gzip: bool = True,
x_file_stream_retry_max: int | None = None,
x_file_stream_retry_wait_min_seconds: float | None = None,
x_file_stream_retry_wait_max_seconds: float | None = None,
x_file_stream_timeout_seconds: float | None = None,
x_file_transfer_retry_max: int | None = None,
x_file_transfer_retry_wait_min_seconds: float | None = None,
x_file_transfer_retry_wait_max_seconds: float | None = None,
x_file_transfer_timeout_seconds: float | None = None,
x_files_dir: str | None = None,
x_flow_control_custom: bool | None = None,
x_flow_control_disabled: bool | None = None,
x_graphql_retry_max: int | None = None,
x_graphql_retry_wait_min_seconds: float | None = None,
x_graphql_retry_wait_max_seconds: float | None = None,
x_graphql_timeout_seconds: float | None = None,
x_internal_check_process: float = 8.0,
x_jupyter_name: str | None = None,
x_jupyter_path: str | None = None,
x_jupyter_root: str | None = None,
x_label: str | None = None,
x_live_policy_rate_limit: int | None = None,
x_live_policy_wait_time: int | None = None,
x_log_level: int = 20,
x_network_buffer: int | None = None,
x_primary: bool = True,
x_proxies: dict[str, str] | None = None,
x_runqueue_item_id: str | None = None,
x_save_requirements: bool = True,
x_server_side_derived_summary: bool = False,
x_server_side_expand_glob_metrics: bool = True,
x_service_transport: str | None = None,
x_service_wait: float = 30.0,
x_skip_transaction_log: bool = False,
x_start_time: float | None = None,
x_stats_pid: int = 55150,
x_stats_sampling_interval: float = 15.0,
x_stats_neuron_monitor_config_path: str | None = None,
x_stats_dcgm_exporter: str | None = None,
x_stats_open_metrics_endpoints: dict[str, str] | None = None,
x_stats_open_metrics_filters: dict[str, dict[str, str]] | collections.abc.Sequence[str] | None = None,
x_stats_open_metrics_http_headers: dict[str, str] | None = None,
x_stats_disk_paths: collections.abc.Sequence[str] | None = ('/',),
x_stats_cpu_count: int | None = None,
x_stats_cpu_logical_count: int | None = None,
x_stats_gpu_count: int | None = None,
x_stats_gpu_type: str | None = None,
x_stats_gpu_device_ids: collections.abc.Sequence[int] | None = None,
x_stats_buffer_size: int = 0,
x_stats_coreweave_metadata_base_url: str = 'http://169.254.169.254',
x_stats_coreweave_metadata_endpoint: str = '/api/v2/cloud-init/meta-data',
x_stats_track_process_tree: bool = False,
x_stats_no_cgroup: bool = False,
x_sync: bool = False,
x_sync_dir_suffix: str = '',
x_update_finish_state: bool = True
```
Arguments
Indique s’il faut créer des liens symboliques vers les fichiers multimédias dans le répertoire du run.
Si true, les fichiers multimédias sont liés au répertoire du run par lien symbolique
ou lien physique au lieu d’être copiés. Cela peut accélérer la
journalisation et réduire l’utilisation du disque. En revanche, toute suppression ou modification
des fichiers originaux avant leur téléversement vers le serveur W\&B sera
répercutée dans les données téléversées.
Indicateur permettant de synchroniser les artifacts de tableau en mode hors ligne.
Pour revenir à l’ancien comportement, définissez cette valeur sur False.
Indicateur permettant de modifier les valeurs de `Config` après leur définition.
Obsolète ; sera supprimé.
La clé API W\&B.
Mappage des URL de comptes Azure vers leurs clés d’accès correspondantes pour l’intégration Azure.
Valeur de remplacement de l’URL « app » de l’interface W\&B.
L’`app_url` est normalement calculée à partir de `base_url`, mais ce paramètre permet
de la définir explicitement.
La variable d’environnement correspondante est WANDB\_APP\_URL.
L’URL du backend W\&B pour la synchronisation des données.
Répertoire contenant le code à suivre par W\&B.
Chemins des fichiers à partir desquels charger la configuration dans l’objet `Config`.
Type de capture de la console à appliquer.
Valeurs possibles :
* "auto" - Sélectionne automatiquement la méthode de capture de la console en fonction de
l’environnement système et des paramètres.
* "off" - Désactive la capture de la console.
* "redirect" - Redirige les descripteurs de fichiers de bas niveau pour capturer la sortie.
* "wrap" - Redéfinit les méthodes d’écriture de sys.stdout/sys.stderr. Est
mappé vers "wrap\_raw" ou "wrap\_emu" selon l’état du système.
* "wrap\_raw" - Identique à "wrap", mais capture directement la sortie brute au lieu de
passer par un émulateur. Dérivé du paramètre `wrap` ; ne doit pas être défini manuellement.
* "wrap\_emu" - Identique à "wrap", mais capture la sortie via un émulateur.
Dérivé du paramètre `wrap` ; ne doit pas être défini manuellement.
Active la journalisation de la console en plusieurs parties.
Si True, le SDK écrit la sortie de la console dans des fichiers horodatés
du répertoire `logs/` au lieu d’un unique fichier `output.log`.
Chaque partie est téléversée dès sa fermeture, ce qui permet aux utilisateurs de consulter
les journaux en direct pendant l’exécution du run. La fréquence de rotation est
contrôlée par `console_chunk_max_bytes` et/ou `console_chunk_max_seconds`.
Si les deux limites valent `0`, tous les journaux sont téléversés en une seule fois à la fin du run.
Remarque : les fragments téléversés sont immuables ; les séquences de contrôle du terminal
qui modifient les lignes précédentes (par exemple, les barres de progression utilisant des retours chariot)
n’affectent que le fragment en cours.
Seuil de rotation basé sur la taille pour les journaux de console en plusieurs parties, en octets.
Démarre un nouveau fichier journal de console lorsque la partie en cours atteint cette
taille. N’a d’effet que si `console_multipart` vaut `True`.
Peut être combiné avec `console_chunk_max_seconds` ; la première limite
atteinte déclenche la rotation. Une valeur de `0` désactive la
limite basée sur la taille.
Seuil de rotation basé sur la durée pour les journaux de console en plusieurs parties, en secondes.
Démarre un nouveau fichier journal de console une fois ce nombre de secondes écoulé
depuis le début de la partie en cours. Nécessite que `console_multipart` vaille
`True`. Peut être combiné avec `console_chunk_max_bytes` ; la première limite
atteinte ferme la partie. Une valeur de `0` désactive la limite
basée sur la durée.
Noms des loggers Python à capturer dans l’onglet Logs du run.
Mappage associant un nom de logger à un niveau de journalisation minimum. Lorsque ce paramètre est défini, wandb installe un
logging.Handler sur chaque logger nommé et le supprime à la fin du run.
Les enregistrements de journal émis par ces loggers sont publiés dans le run en tant que sortie de console,
comme pour la capture de stdout/stderr.
Les enregistrements de journal sont formatés comme avec `logging.basicConfig()`, par exemple
`INFO:my_module:Some message.` Ce format n’est pas personnalisable pour le moment.
Pour capturer tous les journaux, transmettez le nom du logger racine, à savoir 'root'.
Ce paramètre est indépendant du paramètre `console` : les deux peuvent être actifs
simultanément.
Exemple :
```python theme={"system"}
wandb.init(
settings=wandb.Settings(
console="off",
capture_loggers={
"my_app": "INFO",
"my_app.training": "ERROR",
},
),
)
```
Chemin du fichier dans lequel écrire les jetons d’accès temporaires.
Indique s’il faut désactiver la capture du code.
Indique s’il faut désactiver la capture de l’état git.
Indique s’il faut désactiver la déduction du point de bifurcation à partir des branches distantes.
Si la valeur est True, le SDK utilise le dernier commit de la branche upstream,
si elle est définie. Sinon, la génération du patch de diff est ignorée.
Si la valeur est False, le SDK essaie d’utiliser le dernier commit de la branche upstream,
si elle est définie.
Sinon, il recherche le commit le plus proche parmi toutes les branches distantes.
Cela peut nuire aux performances pour les dépôts comportant de nombreuses branches upstream.
Indique s’il faut désactiver la création d’un artifact de job pour W\&B Launch.
L’image Docker utilisée pour exécuter le script.
L’adresse e-mail de l’utilisateur.
L’entity W\&B, par exemple un utilisateur ou une équipe.
L’organisation W\&B.
Indique s’il faut transmettre l’option `force` à `wandb.login()`.
Spécifie le point d’une exécution précédente d’un run à partir duquel forker.
Le point est défini par l’ID du run, une métrique et sa valeur.
Actuellement, seule la métrique '\_step' est prise en charge.
Le hash du commit git à associer au run.
Le dépôt distant git à associer au run.
L’URL du dépôt git distant.
Répertoire racine du dépôt git.
Nom d’hôte de la machine qui exécute le script.
Serveurs proxy personnalisés pour les requêtes http vers W\&B.
Serveurs proxy personnalisés pour les requêtes https vers W\&B.
Chemin du fichier contenant un jeton d’identité (JWT) pour l’authentification.
Motifs glob Unix, relatifs à `files_dir`, désignant les fichiers à exclure du téléversement.
Délai d’attente, en secondes, pour la fin de l’appel `wandb.init` avant expiration.
Délai d’attente, en secondes, du téléversement des données à la fin d’un run.
Définir ce paramètre permet de limiter les coûts liés à des téléversements lents vers W\&B à la fin d’un
run, au prix d’un run marqué comme planté et auquel il peut
manquer certaines données. Par défaut, `run.finish()` bloque jusqu’à ce que toutes
les données soient téléversées.
Si cette valeur est supérieure à zéro, W\&B renonce à téléverser les
données d’un run après ce nombre de secondes à la fin du run, ce qui débloque votre
script. Au bout d’un certain temps, le run passe à l’état Crashed ou Failed dans l’interface utilisateur. Toutes
les données non téléversées restent stockées sur le disque et peuvent être téléversées avec `wandb
sync`.
Utilisez le paramètre `finish_timeout_raises` pour lever une erreur en plus
d’afficher un message d’avertissement.
Les runs arrêtés par `wandb.teardown()` (qui s’exécute automatiquement à la fin
d’un script dans un hook atexit) respectent également ce paramètre.
Indique s’il faut lever une TimeoutError lorsque finish\_timeout expire.
Associé au paramètre `finish_timeout`, ce paramètre amène `run.finish()`
à lever une TimeoutError à l’expiration du délai, en plus d’afficher un message.
Notez que `run.finish()` est appelé implicitement lorsqu’un Run est utilisé comme gestionnaire
de contexte :
with wandb.init() as run:
... # run.finish() s’exécute à la fin du bloc `with`
En revanche, `wandb.teardown()` ne lève pas d’erreur (puisqu’il s’exécute
de toute façon à la fin d’un script).
Indique s’il faut désactiver la vérification SSL (option non sécurisée).
Nom du job Launch qui exécute le script.
Type de source pour Launch.
Indique s’il faut désactiver les fonctionnalités d’étiquetage automatique.
Chemin vers le fichier de configuration de Launch.
Délai d’attente, en secondes, des opérations de connexion avant expiration.
Mode de fonctionnement de la journalisation W\&B et de la synchronisation.
Nom du notebook en cas d’exécution dans un environnement de type Jupyter.
Chemin vers le script qui a créé le run, s’il est disponible.
Chemin absolu, depuis le répertoire racine du dépôt, vers le script qui a
créé le run.
Le répertoire racine du dépôt est le répertoire qui contient le
répertoire .git, s’il existe. Sinon, il s’agit du répertoire de travail actuel.
Chemin relatif vers le script qui a créé le run.
ID du projet W\&B.
Indicateur permettant de masquer les sorties non essentielles.
Comportement à adopter lorsque `wandb.init()` est appelé alors qu’un run est actif.
Options :
* "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é. 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 anciennes qui reposent sur le run global
ne fonctionneront pas.
Peut également être un booléen, mais cette utilisation est obsolète. False équivaut à
"return\_previous", et True équivaut à "finish\_previous".
Indicateur permettant de forcer une nouvelle tentative de connexion.
Spécifie le comportement de reprise du run.
Options :
* "must" : reprend un run existant ayant le même ID. Si aucun run de ce type n’existe,
une erreur se produit.
* "allow" : tente de reprendre un run existant ayant le même ID. Si aucun n’est
trouvé, un nouveau run est créé.
* "never" : démarre toujours un nouveau run. Si un run ayant le même ID existe déjà,
une erreur se produit.
* "auto" : reprend automatiquement le run en échec le plus récent sur la même
machine.
Spécifie le point d’une exécution précédente d’un run à partir duquel reprendre.
Le point est défini par l’ID du run, une métrique et sa valeur.
Actuellement, seule la métrique '\_step' est prise en charge.
Répertoire racine servant de base à tous les chemins liés au run.
Il sert notamment à déterminer le répertoire wandb et le répertoire du run.
Identifiant de groupe pour des runs liés.
Sert à regrouper les runs dans l’interface utilisateur.
L’ID du run.
Type de job exécuté (par exemple, entraînement, évaluation).
Nom lisible du run.
Notes ou description supplémentaires du run.
Tags à associer au run pour faciliter son organisation et son filtrage.
Indicateur permettant de désactiver les fonctionnalités propres à SageMaker.
Indique s’il faut enregistrer le code associé au run.
Chemin du fichier de paramètres à l’échelle du système.
Callback à exécuter pour arrêter le run.
Un run peut être arrêté depuis l’interface web, ou après une erreur fatale
(si un paramètre le configure).
Par défaut, pour arrêter un run, W\&B envoie un SIGINT au thread principal.
Définissez ce callback pour redéfinir ce comportement, par exemple pour utiliser un autre
signal ou effectuer une autre action avant l’interruption.
Le callback s’exécute dans un thread distinct, peu après la demande
d’arrêt, mais pas immédiatement.
Nombre maximum de sparklines d’historique à afficher à la fin d’un run.
Nombre maximum de métriques de synthèse à afficher à la fin d’un run.
Indique s’il faut afficher les messages d’erreur.
Indique s’il faut afficher les messages d’information.
Indique s’il faut afficher les messages d’avertissement.
Indicateur permettant de masquer toute sortie.
Indique s’il faut arrêter le run après une erreur fatale.
Lorsque W\&B rencontre une erreur irrécupérable lors du téléversement de données, il affiche
un message et interrompt le téléversement, tout en vous permettant de continuer à journaliser des données.
C’est généralement le comportement souhaité : vos métriques d’entraînement sont stockées sur le disque
et peuvent être récupérées avec `wandb sync`, même si elles n’ont pas été téléversées.
Ce comportement n’est pas utile si vos fichiers sont supprimés après l’entraînement.
Dans ce cas, définir ce paramètre sur True arrête le run après une erreur fatale,
comme si vous aviez cliqué sur le bouton d’arrêt dans l’interface web.
Indique s’il faut activer le mode strict pour la validation et la vérification des erreurs.
Délai d’attente, en secondes, des opérations de synthèse avant expiration.
Identifiant du sweep auquel appartient ce run.
Chemin de la configuration des paramètres du sweep.
Indique s’il faut utiliser des liens symboliques (True par défaut, sauf sous Windows).
Indique s’il faut synchroniser les journaux TensorBoard avec W\&B.
Indique s’il faut lever une exception en cas de dépassement de la limite de lignes d’un tableau.
Indique s’il faut utiliser un répertoire masqué `.wandb` ou visible `wandb` pour les données du run.
Si True, le SDK utilise `.wandb`. Si False, `wandb`.
Si non défini, la valeur par défaut est `.wandb` s’il existe déjà, sinon `wandb`.
Nom d’utilisateur.
Indicateur permettant de désactiver la collecte des métadonnées système.
Indicateur permettant de désactiver la collecte des métriques système.
En-têtes supplémentaires à ajouter à toutes les requêtes HTTP sortantes.
Libellé à attribuer aux métriques système et aux journaux de console collectés pour le run.
Il sert à regrouper les données dans l’interface et permet de distinguer les données
provenant de différents processus dans une tâche d’entraînement distribuée.
Détermine s’il faut enregistrer les fichiers internes et les métadonnées de wandb.
Dans un environnement distribué, cela permet d’éviter que les processus secondaires écrasent des fichiers
lorsque seuls les métriques système et les journaux sont nécessaires,
puisque le processus principal assure l’essentiel de la journalisation.
Indicateur permettant d’enregistrer le fichier des dépendances (requirements).
Indicateur permettant de déléguer au serveur le calcul automatique de la synthèse à partir de l’historique.
Cela ne désactive pas les mises à jour de la synthèse fournies par l’utilisateur.
Délai d’attente, en secondes, du démarrage du service interne wandb-core.
Indique s’il faut ne pas enregistrer les événements du run dans le journal de transactions.
Ne s’applique qu’aux runs en ligne. Permet de réduire la quantité de
données écrites sur le disque.
À utiliser avec prudence, car cela supprime les garanties de
récupérabilité.
Intervalle d’échantillonnage du moniteur système, en secondes.
Points de terminaison OpenMetrics `/metrics` à surveiller pour collecter les métriques système.
Filtre à appliquer aux métriques collectées depuis les points de terminaison OpenMetrics `/metrics`.
Deux formats sont pris en charge :
* `{"metric regex pattern, including endpoint name as prefix": {"label": "label value regex pattern"}}`
* `("metric regex pattern 1", "metric regex pattern 2", ...)`
En-têtes HTTP à ajouter aux requêtes OpenMetrics.
Chemins système dont l’utilisation du disque doit être surveillée.
Nombre de CPU du système.
S’il est défini, remplace la valeur détectée automatiquement dans les métadonnées du run.
Nombre de CPU logiques.
S’il est défini, remplace la valeur détectée automatiquement dans les métadonnées du run.
Nombre de périphériques GPU.
S’il est défini, remplace la valeur détectée automatiquement dans les métadonnées du run.
Type de périphérique GPU.
S’il est défini, remplace la valeur détectée automatiquement dans les métadonnées du run.
Indices des périphériques GPU à surveiller.
S’il n’est pas défini, le moniteur système capture les métriques de tous les GPU.
Suppose une indexation à partir de 0, conforme à l’énumération des périphériques CUDA/ROCm.
Surveille l’utilisation des ressources de l’ensemble de l’arborescence de processus, à partir de `x_stats_pid`.
Lorsque la valeur est `True`, le moniteur système agrège le RSS, le pourcentage de CPU et le nombre de threads
du processus dont le PID est `x_stats_pid` et de tous ses descendants.
Cette option peut avoir un impact sur les performances et est désactivée par défaut.
Désactive la prise en compte des limites de CPU et de mémoire cgroup v2 dans le calcul des pourcentages des métriques système.
Suffixe à ajouter au nom du répertoire du run (sync\_dir).
Cette valeur est définie dans wandb.init() pour éviter les conflits de nommage.
Si elle est définie, elle est ajoutée au nom par défaut, précédée d’un tiret.
Indique si ce processus peut mettre à jour l’état final du run sur le serveur.
Définissez-le sur False lors d’un entraînement distribué, lorsque seul le processus principal doit déterminer l’état final.
Propriétés
L’URL de l’interface W\&B, généralement [https://wandb.ai](https://wandb.ai).
Elle diffère de `base_url` (par exemple [https://api.wandb.ai](https://api.wandb.ai)), qui
sert à accéder aux API W\&B par programmation.
L’URL du notebook Colab, en cas d’exécution dans Colab.
Aucune description fournie.
Chemin absolu du répertoire local où sont stockés les fichiers du run.
Aucune description fournie.
Le répertoire de stockage des fichiers journaux.
Le chemin du fichier à utiliser pour les journaux internes.
Le chemin du lien symbolique vers le fichier journal interne du run le plus récent.
Le chemin du lien symbolique vers le fichier journal du processus utilisateur du run le plus récent.
Le chemin du fichier à utiliser pour les journaux du processus utilisateur.
L’URL W\&B où le projet peut être consulté.
Le chemin du fichier de reprise.
Le mode du run. Valeurs possibles : « run » ou « offline-run ».
L’URL W\&B où le run peut être consulté.
Le chemin du fichier de paramètres du workspace.
L’URL W\&B où le sweep peut être consulté.
Le répertoire de stockage des fichiers du run.
Chemin du fichier journal binaire des transactions, en mode ajout uniquement.
Chemin du lien symbolique vers le fichier journal des transactions du run le plus récent.
La spécification temporelle du run.
Chemin complet du répertoire wandb.