> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Options de configuration d’un balayage

> Référence de toutes les clés de configuration d’un W&B Sweep, notamment method, metric, parameters, early termination et command.

Une configuration de balayage se compose de paires clé-valeur imbriquées. Utilisez les clés de premier niveau de votre configuration de balayage pour définir les caractéristiques de votre recherche, comme les paramètres à explorer (clé [`parameter`](./sweep-config-keys#parameters)), la méthode de recherche dans l’espace des paramètres (clé [`method`](./sweep-config-keys#method)), entre autres.

Le tableau suivant répertorie les clés de configuration de balayage de premier niveau, avec une brève description. Voir les sections correspondantes pour plus d’informations sur chaque clé.

| Clés de premier niveau                | Description                                                                                                      |
| ------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| `program`                             | (requis) Script d’entraînement à exécuter                                                                        |
| `entity`                              | L’entité de ce balayage                                                                                          |
| `project`                             | Le projet de ce balayage                                                                                         |
| `description`                         | Description textuelle du balayage                                                                                |
| `name`                                | Le nom du balayage, affiché dans l’interface W\&B.                                                               |
| [`method`](#method)                   | (requis) La stratégie de recherche                                                                               |
| [`metric`](#metric)                   | La métrique à optimiser (utilisée uniquement par certaines stratégies de recherche et certains critères d’arrêt) |
| [`parameters`](#parameters)           | (requis) Les bornes des paramètres à explorer                                                                    |
| [`early_terminate`](#early_terminate) | Tout critère d’arrêt anticipé                                                                                    |
| [`command`](#command)                 | Structure de la commande permettant d’invoquer le script d’entraînement et de lui transmettre des arguments      |
| `run_cap`                             | Nombre maximal de runs pour ce balayage                                                                          |

Voir la structure de [Sweep configuration](./sweep-config-keys) pour plus d’informations sur l’organisation de votre configuration de balayage.

<div id="metric">
  ## `metric`
</div>

Utilisez la clé de configuration de niveau supérieur `metric` du balayage pour spécifier le nom, l'objectif et la métrique cible à optimiser.

| Clé      | Description                                                                                                                                                                                                                                                                                                         |
| -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `name`   | Nom de la métrique à optimiser.                                                                                                                                                                                                                                                                                     |
| `goal`   | `minimize` ou `maximize` (`minimize` par défaut).                                                                                                                                                                                                                                                                   |
| `target` | Valeur cible de la métrique en cours d'optimisation. Le balayage ne crée plus de nouveaux runs lorsqu'un run atteint la valeur cible que vous avez spécifiée. Les agents actifs qui exécutent déjà un run au moment où celui-ci atteint la cible attendent la fin du run avant d'arrêter de créer de nouveaux runs. |

<div id="parameters">
  ## `parameters`
</div>

Dans votre fichier YAML ou votre script Python, spécifiez `parameters` comme clé de premier niveau. Dans la clé `parameters`, indiquez le nom d'un hyperparamètre que vous souhaitez optimiser. Les hyperparamètres courants incluent : le taux d'apprentissage, la taille de lot, les époques, les optimiseurs, etc. Pour chaque hyperparamètre que vous définissez dans votre configuration de balayage, spécifiez une ou plusieurs contraintes de recherche.

Le tableau suivant présente les contraintes de recherche d'hyperparamètres prises en charge. En fonction de votre hyperparamètre et de votre cas d'utilisation, utilisez l'une des contraintes de recherche ci-dessous pour indiquer à votre agent de balayage où rechercher (dans le cas d'une distribution) ou quoi rechercher/utiliser (`value`, `values`, etc.).

| Contrainte de recherche | Description                                                                                                                                                                          |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `values`                | Spécifie toutes les valeurs valides pour cet hyperparamètre. Compatible avec `grid`.                                                                                                 |
| `value`                 | Spécifie l'unique valeur valide pour cet hyperparamètre. Compatible avec `grid`.                                                                                                     |
| `distribution`          | Spécifiez une [distribution](#distribution-options-for-random-and-bayesian-search) de probabilité. Voir la note sous ce tableau pour plus d'informations sur les valeurs par défaut. |
| `probabilities`         | Spécifie la probabilité de sélectionner chaque élément de `values` lors de l'utilisation de `random`.                                                                                |
| `min`, `max`            | (`int`or `float`) Valeurs minimale et maximale. Si `int`, pour les hyperparamètres distribués selon `int_uniform`. Si `float`, pour les hyperparamètres distribués selon `uniform`.  |
| `mu`                    | (`float`) Paramètre de moyenne pour les hyperparamètres distribués selon `normal` ou `lognormal`.                                                                                    |
| `sigma`                 | (`float`) Paramètre d'écart-type pour les hyperparamètres distribués selon `normal` ou `lognormal`.                                                                                  |
| `q`                     | (`float`) Pas de quantification pour les hyperparamètres quantifiés.                                                                                                                 |
| `parameters`            | Imbrique d'autres paramètres dans un paramètre de niveau racine.                                                                                                                     |

<Note>
  W\&B définit les distributions suivantes selon les conditions ci-dessous si aucune [distribution](#distribution-options-for-random-and-bayesian-search) n'est spécifiée :

  * `categorical` si vous spécifiez `values`
  * `int_uniform` si vous spécifiez `max` et `min` comme entiers
  * `uniform` si vous spécifiez `max` et `min` comme nombres à virgule flottante
  * `constant` si vous affectez un ensemble à `value`
</Note>

<div id="method">
  ## `method`
</div>

Spécifiez la stratégie de recherche d'hyperparamètres à l'aide de la clé `method`. Vous avez le choix entre trois stratégies de recherche d'hyperparamètres : recherche sur grille, aléatoire et recherche bayésienne.

<div id="grid-search">
  #### Recherche sur grille
</div>

Parcourez chaque combinaison possible de valeurs d’hyperparamètre. La recherche sur grille choisit, à chaque itération, parmi un ensemble prédéfini de valeurs d’hyperparamètre, sans information préalable. La recherche sur grille peut être coûteuse en ressources de calcul.

La recherche sur grille s’exécute indéfiniment si elle explore un espace de recherche continu.

<div id="random-search">
  #### Recherche aléatoire
</div>

Choisissez, à chaque itération, un ensemble aléatoire de valeurs d'hyperparamètres, sans information préalable, selon une distribution. La recherche aléatoire s'exécute indéfiniment, sauf si vous arrêtez le processus depuis la ligne de commande, dans votre script Python ou dans [application W\&B](/fr/models/sweeps/visualize-sweep-results/).

Spécifiez l'espace de distribution avec la clé de métrique si vous choisissez la recherche aléatoire (`method: random`).

<div id="bayesian-search">
  #### Recherche bayésienne
</div>

Contrairement à la recherche [aléatoire](#random-search) et à la recherche [sur grille](#grid-search), les modèles bayésiens prennent des décisions éclairées. L’optimisation bayésienne s’appuie sur un modèle probabiliste pour déterminer quelles valeurs utiliser, via un processus itératif qui teste des valeurs sur une fonction de substitution avant d’évaluer la fonction objectif. La recherche bayésienne est efficace pour un petit nombre de paramètres continus, mais elle passe mal à l’échelle. Pour en savoir plus sur la recherche bayésienne, voir le [Bayesian Optimization Primer](https://web.archive.org/web/20240209053347/https://static.sigopt.com/b/20a144d208ef255d3b981ce419667ec25d8412e2/static/pdf/SigOpt_Bayesian_Optimization_Primer.pdf).

La recherche bayésienne se poursuit indéfiniment, à moins que vous n’arrêtiez le processus depuis la ligne de commande, dans votre script Python ou dans [l’application W\&B](/fr/models/sweeps/visualize-sweep-results/).

<div id="distribution-options-for-random-and-bayesian-search">
  ### Options de distribution pour la recherche aléatoire et la recherche bayésienne
</div>

Dans la clé `parameter`, imbriquez le nom de l'hyperparamètre. Ensuite, spécifiez la clé `distribution` et indiquez une distribution pour la valeur.

Le tableau suivant répertorie les distributions prises en charge par W\&B.

| Valeur de la clé `distribution` | Description                                                                                                                                                                                          |
| ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `constant`                      | Distribution constante. Vous devez spécifier la valeur constante (`value`) à utiliser.                                                                                                               |
| `categorical`                   | Distribution catégorielle. Vous devez spécifier toutes les valeurs valides (`values`) pour cet hyperparamètre.                                                                                       |
| `int_uniform`                   | Distribution uniforme discrète sur les entiers. Vous devez spécifier `max` et `min` sous forme d'entiers.                                                                                            |
| `uniform`                       | Distribution uniforme continue. Vous devez spécifier `max` et `min` sous forme de nombres à virgule flottante.                                                                                       |
| `q_uniform`                     | Distribution uniforme quantifiée. Renvoie `round(X / q) * q`, où `X` suit une distribution uniforme. `q` a pour valeur par défaut `1`.                                                               |
| `log_uniform`                   | Distribution log-uniforme. Renvoie une valeur `X` comprise entre `exp(min)` et `exp(max)` telle que le logarithme népérien soit uniformément distribué entre `min` et `max`.                         |
| `log_uniform_values`            | Distribution log-uniforme. Renvoie une valeur `X` comprise entre `min` et `max` telle que `log(`X`)` soit uniformément distribué entre `log(min)` et `log(max)`.                                     |
| `q_log_uniform`                 | Distribution log-uniforme quantifiée. Renvoie `round(X / q) * q`, où `X` est `log_uniform`. `q` a pour valeur par défaut `1`.                                                                        |
| `q_log_uniform_values`          | Distribution log-uniforme quantifiée. Renvoie `round(X / q) * q`, où `X` est `log_uniform_values`. `q` a pour valeur par défaut `1`.                                                                 |
| `inv_log_uniform`               | Distribution log-uniforme inverse. Renvoie `X`, où `log(1/X)` est uniformément distribué entre `min` et `max`.                                                                                       |
| `inv_log_uniform_values`        | Distribution log-uniforme inverse. Renvoie `X`, où `log(1/X)` est uniformément distribué entre `log(1/max)` et `log(1/min)`.                                                                         |
| `normal`                        | Distribution normale. La valeur renvoyée suit une distribution normale de moyenne `mu` (par défaut `0`) et d'écart-type `sigma` (par défaut `1`).                                                    |
| `q_normal`                      | Distribution normale quantifiée. Renvoie `round(X / q) * q`, où `X` est `normal`. `q` a pour valeur par défaut `1`.                                                                                  |
| `log_normal`                    | Distribution log-normale. Renvoie une valeur `X` telle que le logarithme népérien `log(X)` suive une distribution normale de moyenne `mu` (par défaut `0`) et d'écart-type `sigma` (par défaut `1`). |
| `q_log_normal`                  | Distribution log-normale quantifiée. Renvoie `round(X / q) * q`, où `X` est `log_normal`. `q` a pour valeur par défaut `1`.                                                                          |

<div id="early_terminate">
  ## `early_terminate`
</div>

Utilisez l’arrêt anticipé (`early_terminate`) pour interrompre les runs peu performants. En cas d’arrêt anticipé, W\&B arrête le run en cours avant d’en créer un nouveau avec un nouvel ensemble de valeurs d’hyperparamètres.

<Note>
  Vous devez spécifier un algorithme d’arrêt si vous utilisez `early_terminate`. Imbriquez la clé `type` dans `early_terminate` au sein de votre configuration de balayage.
</Note>

<div id="stopping-algorithm">
  ### Algorithme d'arrêt
</div>

<Note>
  W\&B prend actuellement en charge l'algorithme d'arrêt [Hyperband](https://arxiv.org/abs/1603.06560).
</Note>

L'optimisation des hyperparamètres avec [Hyperband](https://arxiv.org/abs/1603.06560) détermine si un programme doit s'arrêter ou continuer à une ou plusieurs itérations prédéfinies, appelées *brackets*.

Lorsqu'un run W\&B atteint un bracket, le balayage compare la métrique de ce run à toutes les valeurs de métrique précédemment enregistrées. Le balayage met fin au run si la valeur de sa métrique est trop élevée (lorsque l'objectif est la minimisation) ou si la métrique du run est trop faible (lorsque l'objectif est la maximisation).

Les brackets sont basés sur le nombre d'itérations enregistrées. Le nombre de brackets correspond au nombre de fois où vous enregistrez la métrique que vous optimisez. Les itérations peuvent correspondre à des étapes, des époques ou à quelque chose entre les deux. La valeur numérique du compteur d'étapes n'est pas utilisée dans les calculs des brackets.

<Note>
  Spécifiez `min_iter` ou `max_iter` pour créer une planification de brackets.
</Note>

| Clé        | Description                                                                                                                                          |
| ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| `min_iter` | Spécifiez l'itération du premier bracket                                                                                                             |
| `max_iter` | Spécifiez le nombre maximal d'itérations.                                                                                                            |
| `s`        | Spécifiez le nombre total de brackets (requis pour `max_iter`)                                                                                       |
| `eta`      | Spécifiez le multiplicateur de la planification des brackets (valeur par défaut : `3`).                                                              |
| `strict`   | Activez le mode 'strict', qui élague agressivement les runs et suit de plus près l'article original sur Hyperband. La valeur par défaut est `false`. |

<Note>
  Hyperband vérifie quels [runs](/fr/models/ref/python/experiments/run) arrêter toutes les quelques minutes. L'horodatage de fin du run peut différer des brackets spécifiés si votre run est court ou si vos itérations sont courtes.
</Note>

<div id="command">
  ## `command`
</div>

Modifiez le format et le contenu à l’aide de valeurs imbriquées dans la clé `command`. Vous pouvez inclure directement des composants fixes, comme des noms de fichiers.

<Note>
  Sur les systèmes Unix, `/usr/bin/env` garantit que le système d’exploitation choisit le bon interpréteur Python en fonction de l’environnement.
</Note>

W\&B prend en charge les macros suivantes pour les composants variables de la commande :

| Command macro              | Description                                                                                                                                                                                                |
| -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `${env}`                   | `/usr/bin/env` sur les systèmes Unix, omis sous Windows.                                                                                                                                                   |
| `${interpreter}`           | Est remplacé par `python`.                                                                                                                                                                                 |
| `${program}`               | Nom de fichier du script d’entraînement spécifié par la clé `program` de la configuration du balayage.                                                                                                     |
| `${args}`                  | Hyperparamètres et leurs valeurs sous la forme `--param1=value1 --param2=value2`.                                                                                                                          |
| `${args_no_boolean_flags}` | Hyperparamètres et leurs valeurs sous la forme `--param1=value1`, sauf que les paramètres booléens prennent la forme `--boolean_flag_param` quand ils sont à `True` et sont omis quand ils sont à `False`. |
| `${args_no_hyphens}`       | Hyperparamètres et leurs valeurs sous la forme `param1=value1 param2=value2`.                                                                                                                              |
| `${args_json}`             | Hyperparamètres et leurs valeurs encodés en JSON.                                                                                                                                                          |
| `${args_json_file}`        | Chemin d’accès à un fichier contenant les hyperparamètres et leurs valeurs encodés en JSON.                                                                                                                |
| `${envvar}`                | Permet de transmettre des variables d’environnement. `${envvar:MYENVVAR}` \_\_ est remplacé par la valeur de la variable d’environnement MYENVVAR. \_\_                                                    |
