> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-update-reference-docs-60.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# paramètre
export const GitHubLink = ({url, compact = false}) =>
{compact ? "voir la source" : <>
Source GitHub
}
;
## Classe wandb.Settings
Paramètres de configuration du SDK W\&B.
Cette classe gère les paramètres de configuration du SDK W\&B
et garantit la sécurité des types ainsi que la validation de tous les paramètres. Les paramètres sont accessibles
sous forme d'attributs et peuvent être initialisés par programmation, via des variables
d'environnement (préfixe `WANDB_`), et à l'aide de fichiers de configuration.
Les paramètres sont organisés en trois catégories :
1. Paramètres publics : options de configuration principales que les utilisateurs peuvent modifier en toute sécurité pour personnaliser
le comportement de W\&B en fonction de leurs besoins spécifiques.
2. Paramètres internes : paramètres préfixés par « x\_ » qui gèrent le comportement du SDK à bas niveau.
Ces paramètres sont principalement destinés à un usage interne et au débogage. Bien qu'ils puissent être modifiés,
ils ne sont pas considérés comme faisant partie de l'API publique et peuvent changer sans préavis dans les futures
versions.
3. Paramètres calculés : paramètres en lecture seule automatiquement dérivés 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, celle qui apparaît le plus bas dans la liste l'emporte. Par ordre de
priorité croissante :
1. Les valeurs par défaut définies sur ce modèle `Settings`.
2. Les fichiers de configuration (`~/.config/wandb/settings`, ou le fichier `settings` dans
le répertoire désigné par la variable d'environnement `WANDB_CONFIG_DIR`).
3. Les variables d'environnement (celles préfixées par `WANDB_`, par ex. `WANDB_MODE`).
4. Les valeurs détectées à partir de l'environnement d'exécution, telles que le nom d'hôte, le
chemin du programme/script en cours d'exécution, l'exécutable Python, l'image Docker et
les détails du notebook Jupyter.
5. Les paramètres SageMaker, lors d'une 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=` redéfinit le
paramètre `mode`).
```python theme={null}
*,
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 = 32512,
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 si des liens symboliques vers les fichiers multimédias doivent être créés dans le répertoire du run.
Si la valeur est true, les fichiers multimédias seront liés au répertoire du run par des liens symboliques ou physiques au lieu d’être copiés. Cela peut accélérer la journalisation et réduire l’utilisation du disque. Toutefois, toute suppression ou modification des fichiers d’origine 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 artefacts 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 et 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.
Redéfinition de l’URL « app » pour l’interface W\&B.
L’`app_url` est normalement calculée à partir de `base_url`, mais cette option permet de la définir explicitement.
WANDB\_APP\_URL est la variable d’environnement correspondante.
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`.
Le type de capture de console à appliquer.
Les valeurs possibles sont :
* "auto" - Sélectionne automatiquement la méthode de capture de console selon l’environnement et les paramètres du système.
* "off" - Désactive la capture de 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` et ne doit pas être défini manuellement.
* "wrap\_emu" - Identique à "wrap", mais capture la sortie via un émulateur. Dérivé du paramètre `wrap` et ne doit pas être défini manuellement.
Active la journalisation de console multipart.
Lorsque la valeur est True, le SDK écrit la sortie de la console dans des fichiers horodatés sous le répertoire `logs/` au lieu d’un unique fichier `output.log`.
Chaque partie est téléversée dès sa fermeture, offrant aux utilisateurs un accès aux journaux en temps réel pendant que le run est actif. La fréquence de rotation est contrôlée par `console_chunk_max_bytes` et/ou `console_chunk_max_seconds`. Si les deux limites sont définies sur `0`, tous les journaux sont téléversés à 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 ex., les barres de progression utilisant des retours chariot) n’affectent que le fragment actuel.
Seuil de rotation basé sur la taille pour les journaux de console multipart, en octets.
Démarre un nouveau fichier journal de console lorsque la partie actuelle atteint cette taille. N’a d’effet que lorsque `console_multipart` est `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 le temps pour les journaux de console multipart, en secondes.
Démarre un nouveau fichier journal de console après l’écoulement de ce nombre de secondes depuis le début de la partie actuelle. Nécessite que `console_multipart` soit `True`. Peut être utilisé avec `console_chunk_max_bytes` ; la première limite atteinte ferme la partie. Une valeur de `0` désactive la limite basée sur le temps.
Noms des loggers Python à capturer dans l’onglet Logs du run.
Mappage entre les noms de loggers et les niveaux de journalisation minimaux. 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 émis par ces loggers sont publiés dans le run en tant que sortie de console,
de manière similaire à la capture de stdout/stderr.
Les enregistrements sont formatés comme avec `logging.basicConfig()`, par exemple
`INFO:my_module:Some message.` Ce format n’est actuellement pas personnalisable.
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={null}
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 fork à partir des branches distantes.
Lorsqu’il est défini sur True, le SDK utilisera le dernier commit de la branche en amont,
si elle est définie. Sinon, il ignore la génération du patch diff.
Lorsqu’il est défini sur False, le SDK essaiera d’utiliser le dernier commit de la branche en amont,
si elle est définie.
Sinon, il trouvera le commit le plus proche parmi toutes les branches distantes.
Cela peut affecter les performances des dépôts comportant de nombreuses branches en amont.
Indique s’il faut désactiver la création d’un artefact de job pour W\&B Launch.
L’image Docker utilisée pour exécuter le script.
L’adresse e-mail de l’utilisateur.
L’entité W\&B, telle qu’un utilisateur ou une équipe.
L’organisation W\&B.
Indique s’il faut transmettre l’indicateur `force` à `wandb.login()`.
Spécifie un 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 hachage du commit Git à associer au run.
Le dépôt distant Git à associer au run.
L’URL du dépôt distant Git.
Répertoire racine du dépôt Git.
Nom d’hôte de la machine exécutant 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` spécifiant les fichiers à exclure du téléversement.
Durée, en secondes, pendant laquelle attendre la fin de l’appel à `wandb.init` avant l’expiration du délai.
Durée, en secondes, pendant laquelle attendre le téléversement des données à la fin d’une exécution.
La définition de cette valeur peut limiter les coûts liés aux téléversements lents vers W\&B à la fin d’une
exécution, mais l’exécution sera alors marquée comme plantée et certaines données pourraient
être manquantes. 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 abandonne le téléversement des
données d’une exécution après ce nombre de secondes à la fin de celle-ci, ce qui libère votre
script. Après un certain temps, l’exécution 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 exécutions arrêtées par `wandb.teardown()` (qui s’exécute automatiquement à la fin
d’un script via un hook atexit) respectent également ce paramètre.
Indique s’il faut lever une TimeoutError si le délai `finish_timeout` expire.
L’utilisation de ce paramètre avec `finish_timeout` entraîne la levée d’une TimeoutError par `run.finish()`
à l’expiration du délai, en plus de l’affichage d’un message.
Notez que `run.finish()` est appelé implicitement lorsqu’une Run est utilisée comme gestionnaire
de contexte :
with wandb.init() as run:
... # run.finish() s’exécute à la fin du bloc `with`
Cela ne provoque pas la levée d’une erreur par `wandb.teardown()` (puisqu’il s’exécute
de toute façon à la fin d’un script).
Indique s’il faut désactiver de manière non sécurisée la vérification SSL.
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 d’accès au fichier de configuration Launch.
Durée, en secondes, pendant laquelle attendre les opérations de connexion avant expiration du délai.
Mode de fonctionnement de la journalisation et de la synchronisation W\&B.
Nom du notebook en cas d’exécution dans un environnement de type Jupyter.
Chemin d’accès au script qui a créé l’exécution, s’il est disponible.
Chemin absolu depuis le répertoire racine du dépôt jusqu’au script qui
a créé l’exécution.
Le répertoire racine du dépôt est le répertoire contenant 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éé l’exécution.
ID du projet W\&B.
Indicateur permettant de supprimer les sorties non essentielles.
Action à effectuer lorsque `wandb.init()` est appelé alors qu’une exécution est active.
Options :
* "default" : Utiliser "finish\_previous" dans les notebooks et "return\_previous"
dans les autres cas.
* "return\_previous" : Renvoyer l’exécution créée la plus récemment
qui n’est pas encore terminée. Cela ne met pas à jour `wandb.run` ; voir
l’option "create\_new".
* "finish\_previous" : Terminer toutes les exécutions actives, puis renvoyer une nouvelle exécution.
* "create\_new" : Créer une nouvelle exécution sans modifier les autres exécutions actives.
Ne met pas à jour `wandb.run` ni les fonctions de premier niveau comme `wandb.log`.
Par conséquent, certaines intégrations plus anciennes qui dépendent de l’exécution globale
ne fonctionneront pas.
Peut également être une valeur booléenne, 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 portant le même ID. Si aucun run de ce type n’existe,
l’opération échoue.
* "allow" : Tente de reprendre un run existant portant le même ID. Si aucun n’est
trouvé, un nouveau run est créé.
* "never" : Démarre toujours un nouveau run. Si un run portant le même ID existe déjà,
l’opération échoue.
* "auto" : Reprend automatiquement le dernier run en échec sur la même
machine.
Spécifie un point d’une exécution précédente du run à partir duquel reprendre.
Ce 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 à utiliser comme base pour tous les chemins associés au run.
Il permet notamment de déterminer le répertoire wandb et le répertoire du run.
Identifiant de groupe pour les runs associés.
Utilisé pour regrouper les runs dans l’interface utilisateur.
ID du run.
Type de job exécuté (par exemple, entraînement ou évaluation).
Nom lisible du run.
Notes ou description supplémentaires du run.
Tags à associer au run pour l’organisation et le filtrage.
Indicateur permettant de désactiver les fonctionnalités spécifiques à SageMaker.
Indique s’il faut enregistrer le code associé au run.
Chemin vers le fichier de paramètres système.
Fonction de rappel à exécuter pour arrêter le run.
Un run peut être arrêté via l’interface utilisateur web ou après une erreur fatale
(si cela est configuré dans un paramètre).
Par défaut, pour arrêter un run, W\&B envoie un SIGINT au thread principal.
Définissez cette fonction de rappel pour redéfinir ce comportement, par exemple afin d’utiliser un autre
signal ou d’effectuer une autre action avant l’interruption.
La fonction de rappel s’exécute dans un thread distinct. Elle s’exécute peu après qu’un arrêt est
demandé, mais pas immédiatement.
Nombre maximal de graphiques sparkline d’historique à afficher à la fin d’un run.
Nombre maximal 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 supprimer toute sortie.
Indique s’il faut arrêter le run après une erreur fatale.
Lorsqu’une erreur irrécupérable survient pendant le téléversement de données, W\&B affiche
un message et arrête le téléversement, tout en vous permettant de continuer à journaliser des données.
Ce comportement est généralement souhaitable : vos métriques d’entraînement sont stockées sur le disque
et peuvent être récupérées à l’aide de `wandb sync`, même si elles ne sont pas téléversées.
Cela n’est pas utile si vos fichiers sont supprimés après l’entraînement.
Dans ce cas, définir cette valeur 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 utilisateur web.
Indique s’il faut activer le mode strict pour la validation et la vérification des erreurs.
Durée, en secondes, d’attente des opérations de synthèse avant expiration du délai.
Identifiant du sweep auquel appartient ce run.
Chemin vers 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 lorsque la limite du nombre de lignes du tableau est dépassée.
Indique s’il faut utiliser un répertoire caché `.wandb` ou un répertoire visible `wandb` pour les données du run.
Si True, le SDK utilise `.wandb`. Si False, `wandb`.
Si cette option n’est pas définie, `.wandb` est utilisé 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 permet de regrouper les données dans le frontend et de distinguer les données
de différents processus au sein d’une tâche d’entraînement distribuée.
Détermine s’il faut enregistrer les fichiers internes de wandb et les métadonnées.
Dans un environnement distribué, cette option permet d’éviter que les processus secondaires
n’écrasent des fichiers lorsque seules les métriques système et les journaux sont nécessaires,
car le processus principal assure la journalisation principale.
Indicateur permettant d’enregistrer le fichier des exigences.
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 synthèse fournies par l’utilisateur.
Durée d’attente, en secondes, du démarrage du service interne wandb-core.
Indique s’il faut ignorer l’enregistrement des événements du run dans le journal des transactions.
Cela ne concerne que les runs en ligne. Cette option peut être utilisée pour réduire la quantité de
données écrites sur le disque.
À utiliser avec prudence, car elle supprime les garanties de
récupérabilité.
Intervalle d’échantillonnage du moniteur système, en secondes.
Points de terminaison OpenMetrics `/metrics` à surveiller pour les métriques système.
Filtre à appliquer aux métriques collectées depuis les points de terminaison OpenMetrics `/metrics`.
Prend en charge deux formats :
* `{"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 à surveiller pour l’utilisation du disque.
Nombre de CPU du système.
S’il est défini, redéfinit la valeur détectée automatiquement dans les métadonnées du run.
Nombre de CPU logiques.
S’il est défini, redéfinit la valeur détectée automatiquement dans les métadonnées du run.
Nombre de périphériques GPU.
S’il est défini, redéfinit la valeur détectée automatiquement dans les métadonnées du run.
Type de périphérique GPU.
S’il est défini, redéfinit la valeur détectée automatiquement dans les métadonnées du run.
Indices des périphériques GPU à surveiller.
S’ils ne sont pas définis, le moniteur système capture les métriques de tous les GPU.
Suppose une indexation à partir de 0 correspondant à l’énumération des périphériques CUDA/ROCm.
Surveille l’ensemble de l’arborescence des processus pour suivre l’utilisation des ressources à partir de `x_stats_pid`.
Lorsque la valeur est `True`, le moniteur système agrège le RSS, le pourcentage d’utilisation du CPU et le nombre de threads
du processus dont le PID est `x_stats_pid` ainsi que de tous ses descendants.
Cette option peut dégrader les performances et est désactivée par défaut.
Désactive les limites de CPU et de mémoire de cgroup v2 pour les pourcentages des métriques système.
Suffixe à ajouter au nom du répertoire de l’exécution (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, séparée par un tiret.
Indicateur précisant si ce processus peut mettre à jour l’état final de l’exécution sur le serveur.
Définissez cette valeur 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)), utilisée pour 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 vers le répertoire local où sont stockés les fichiers du run.
Aucune description fournie.
Répertoire où stocker les fichiers journaux.
Chemin vers le fichier à utiliser pour les journaux internes.
Chemin vers le lien symbolique du fichier journal interne du run le plus récent.
Chemin vers le lien symbolique du fichier journal du processus utilisateur du run le plus récent.
Chemin vers le fichier à utiliser pour les journaux du processus utilisateur.
L’URL W\&B où le projet peut être consulté.
Chemin vers le fichier de reprise.
Mode du run : « run » ou « offline-run ».
L’URL W\&B où le run peut être consulté.
Chemin vers le fichier de paramètres du workspace.
L’URL W\&B où le sweep peut être consulté.
Répertoire où stocker les fichiers du run.
Chemin vers le fichier journal binaire de transactions en ajout seul.
Chemin vers le lien symbolique du fichier journal de transactions du run le plus récent.
Spécification temporelle du run.
Chemin complet vers le répertoire wandb.