> ## 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.
> Utilisez un objet semblable à un dictionnaire pour enregistrer la configuration de votre expérience
# Configurer Experiments
export const ColabLink = ({url}) =>
Essayer sur Colab
;
Utilisez la propriété `config` d'un run pour enregistrer votre configuration d'entraînement :
* hyperparamètre
* paramètres d'entrée, comme le nom du jeu de données ou le type de modèle
* toute autre variable indépendante pour vos expériences.
La propriété `wandb.Run.config` facilite l'analyse de vos expériences et la reproduction de votre travail par la suite. Vous pouvez regrouper vos données selon les valeurs de configuration dans l'application W\&B, comparer les configurations de différents runs W\&B et évaluer l'effet de chaque configuration d'entraînement sur les résultats. La propriété `config` est un objet de type dictionnaire qui peut être construit à partir de plusieurs objets de type dictionnaire.
Pour enregistrer les métriques de sortie ou des variables dépendantes comme la perte et l'accuracy, utilisez `wandb.Run.log()` plutôt que `wandb.Run.config`.
## Configurer la configuration d’une expérience
Les configurations sont généralement définies au début d’un script d’entraînement. Toutefois, les flux de travail de machine learning peuvent varier, donc vous n’êtes pas obligé de définir une configuration au début de votre script d’entraînement.
Utilisez des tirets (`-`) ou des caractères de soulignement (`_`) au lieu de points (`.`) dans les noms de variables de votre configuration.
Utilisez la syntaxe d’accès au dictionnaire `["key"]["value"]` plutôt que la syntaxe d’accès par attribut `config.key.value` si votre script accède à des clés de `wandb.Run.config` sous la racine.
Les sections suivantes présentent différents scénarios courants pour définir la configuration de vos expériences.
### Définir la configuration à l'initialisation
Passez un dictionnaire au début de votre script lorsque vous appelez l'API `wandb.init()` pour créer un processus en arrière-plan chargé de synchroniser et de journaliser les données dans un run W\&B.
L'extrait de code suivant montre comment définir un dictionnaire Python avec des valeurs de configuration et comment passer ce dictionnaire en argument lorsque vous initialisez un run W\&B.
```python theme={null}
import wandb
# Définir un objet dictionnaire de configuration
config = {
"hidden_layer_sizes": [32, 64],
"kernel_sizes": [3],
"activation": "ReLU",
"pool_sizes": [2],
"dropout": 0.5,
"num_classes": 10,
}
# Passer le dictionnaire de configuration lors de l'initialisation de W&B
with wandb.init(project="config_example", config=config) as run:
...
```
Si vous passez un dictionnaire imbriqué comme `config`, W\&B aplatit les noms en utilisant des points.
Accédez aux valeurs du dictionnaire comme à celles de tout autre dictionnaire en Python :
```python theme={null}
# Accéder aux valeurs avec la clé comme index
hidden_layer_sizes = run.config["hidden_layer_sizes"]
kernel_sizes = run.config["kernel_sizes"]
activation = run.config["activation"]
# Méthode get() du dictionnaire Python
hidden_layer_sizes = run.config.get("hidden_layer_sizes")
kernel_sizes = run.config.get("kernel_sizes")
activation = run.config.get("activation")
```
Tout au long du Guide du développeur et des exemples, nous copions les valeurs de configuration dans des variables distinctes. Cette étape est facultative. Cela est fait pour plus de lisibilité.
### Définir la configuration avec argparse
Vous pouvez définir votre configuration avec un objet argparse. [argparse](https://docs.python.org/3/library/argparse.html), abréviation de « analyseur d’arguments », est un module de la bibliothèque standard de Python 3.2 et versions ultérieures qui facilite l’écriture de scripts tirant parti de toute la flexibilité et de la puissance des arguments en ligne de commande.
Cela est utile pour suivre les résultats de scripts lancés en ligne de commande.
Le script Python suivant montre comment créer un objet parser afin de définir et de renseigner la configuration de votre expérience. Les fonctions `train_one_epoch` et `evaluate_one_epoch` sont fournies pour simuler une boucle d’entraînement à des fins de démonstration :
```python theme={null}
# config_experiment.py
import argparse
import random
import numpy as np
import wandb
# Code de démonstration pour l'entraînement et l'évaluation
def train_one_epoch(epoch, lr, bs):
acc = 0.25 + ((epoch / 30) + (random.random() / 10))
loss = 0.2 + (1 - ((epoch - 1) / 10 + random.random() / 5))
return acc, loss
def evaluate_one_epoch(epoch):
acc = 0.1 + ((epoch / 20) + (random.random() / 10))
loss = 0.25 + (1 - ((epoch - 1) / 10 + random.random() / 6))
return acc, loss
def main(args):
# Démarrer un Run W&B
with wandb.init(project="config_example", config=args) as run:
# Accéder aux valeurs du dictionnaire de configuration et les stocker
# dans des variables pour plus de lisibilité
lr = run.config["learning_rate"]
bs = run.config["batch_size"]
epochs = run.config["epochs"]
# Simuler l'entraînement et la journalisation des valeurs vers W&B
for epoch in np.arange(1, epochs):
train_acc, train_loss = train_one_epoch(epoch, lr, bs)
val_acc, val_loss = evaluate_one_epoch(epoch)
run.log(
{
"epoch": epoch,
"train_acc": train_acc,
"train_loss": train_loss,
"val_acc": val_acc,
"val_loss": val_loss,
}
)
if __name__ == "__main__":
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter
)
parser.add_argument("-b", "--batch_size", type=int, default=32, help="Batch size")
parser.add_argument(
"-e", "--epochs", type=int, default=50, help="Number of training epochs"
)
parser.add_argument(
"-lr", "--learning_rate", type=int, default=0.001, help="Learning rate"
)
args = parser.parse_args()
main(args)
```
### Définissez la configuration au fil de votre script
Vous pouvez ajouter d’autres paramètres à votre objet de configuration au fil de votre script. L’extrait de code suivant montre comment ajouter de nouvelles paires clé-valeur à votre objet de configuration :
```python theme={null}
import wandb
# Définir un objet dictionnaire de configuration
config = {
"hidden_layer_sizes": [32, 64],
"kernel_sizes": [3],
"activation": "ReLU",
"pool_sizes": [2],
"dropout": 0.5,
"num_classes": 10,
}
# Passer le dictionnaire de configuration lors de l'initialisation de W&B
with wandb.init(project="config_example", config=config) as run:
# Mettre à jour la configuration après l'initialisation de W&B
run.config["dropout"] = 0.2
run.config.epochs = 4
run.config["batch_size"] = 32
```
Vous pouvez mettre à jour plusieurs valeurs à la fois :
```python theme={null}
run.config.update({"lr": 0.1, "channels": 16})
```
### Définissez la configuration une fois votre run terminé
Utilisez l’[API publique de W\&B](/fr/models/ref/python/public-api/) pour mettre à jour la configuration d’un run terminé.
Vous devez fournir à l’API votre entité, le nom du projet et l’ID du run. Vous trouverez ces informations dans l’objet Run ou dans la [W\&B App](/fr/models/track/workspaces/) :
```python theme={null}
with wandb.init() as run:
...
# Trouvez les valeurs suivantes dans l'objet Run s'il a été initié depuis le
# script ou le notebook actuel, ou copiez-les depuis l'interface de l'application W&B.
username = run.entity
project = run.project
run_id = run.id
# Notez que api.run() renvoie un type d'objet différent de wandb.init().
api = wandb.Api()
api_run = api.run(f"{username}/{project}/{run_id}")
api_run.config["bar"] = 32
api_run.update()
```
## Mettre en avant les valeurs de configuration
Épinglez des clés de configuration dans la section **References**, en haut de la page d’aperçu d’un run.
Utilisez [`wandb.Run.pin_config_keys`](/fr/models/ref/python/experiments/run#method-run-pin_config_keys) pour épingler une ou plusieurs clés de configuration avec le SDK Python.
Par exemple, si vous utilisez un tableau de bord Grafana pour surveiller des runs d’entraînement, ajoutez l’URL du tableau de bord à votre configuration et épinglez la clé `grafana_url` :
```python theme={null}
config = {
"hidden_layer_sizes": [32, 64],
"kernel_sizes": [3],
"activation": "ReLU",
"pool_sizes": [2],
"dropout": 0.5,
"num_classes": 10,
"grafana_url": "[Grafana dashboard](https://my-grafana-instance.com/)"
}
with wandb.init(config=config) as run:
# Ajouter la clé de configuration "grafana_url" à la section References.
run.pin_config_keys(["grafana_url"])
```
## `absl.FLAGS`
Vous pouvez également transmettre des flags [`absl`](https://abseil.io/docs/python/guides/flags).
```python theme={null}
flags.DEFINE_string("model", None, "model to run") # nom, défaut, aide
run.config.update(flags.FLAGS) # ajoute les flags absl à la configuration
```
## Configurations basées sur des fichiers
Si vous placez un fichier nommé `config-defaults.yaml` dans le même répertoire que votre script de run, le run détecte automatiquement les paires clé-valeur définies dans le fichier et les transmet à `wandb.Run.config`.
L’extrait de code suivant montre un exemple de fichier YAML `config-defaults.yaml` :
```yaml theme={null}
batch_size:
desc: Size of each mini-batch
value: 32
```
Vous pouvez surcharger les valeurs par défaut chargées automatiquement depuis `config-defaults.yaml` en définissant de nouvelles valeurs dans l’argument `config` de `wandb.init()`. Par exemple :
```python theme={null}
import wandb
# Surcharger config-defaults.yaml en passant des valeurs personnalisées
with wandb.init(config={"epochs": 200, "batch_size": 64}) as run:
...
```
Pour charger un fichier de configuration autre que `config-defaults.yaml`, utilisez l’argument `--configs command-line` et indiquez le chemin du fichier :
```bash theme={null}
python train.py --configs other-config.yaml
```
### Exemple d’utilisation de configurations basées sur des fichiers
Supposons que vous disposiez d’un fichier YAML contenant des métadonnées sur le run, ainsi que d’un dictionnaire d’hyperparamètres dans votre script Python. Vous pouvez enregistrer les deux dans l’objet `config` imbriqué :
```python theme={null}
hyperparameter_defaults = dict(
dropout=0.5,
batch_size=100,
learning_rate=0.001,
)
config_dictionary = dict(
yaml=my_yaml_file,
params=hyperparameter_defaults,
)
with wandb.init(config=config_dictionary) as run:
...
```
## Afficher les valeurs de configuration dans la W\&B App
Consultez vos valeurs de configuration dans la section **Config** de l’onglet **Vue d’ensemble** d’un run. Elles sont également disponibles dans la section **References** si vous les épinglez.
1. Accédez à votre projet dans la W\&B App.
2. Cliquez sur le run dont vous souhaitez consulter les valeurs de configuration.
3. Sélectionnez l’onglet **Vue d’ensemble**.
4. Faites défiler jusqu’à la section **Config**.
5. (Facultatif) Cliquez sur **View raw data** pour afficher les valeurs de configuration au format JSON.
Le format JSON brut est utile lorsque vous écrivez des expressions pour créer ou transformer des graphiques en courbes à partir de valeurs de configuration, de métriques enregistrées ou de valeurs de synthèse. Voir [Expressions](/fr/models/app/features/panels/line-plot/reference#expressions) pour plus de détails.
## Flags de TensorFlow v1
Vous pouvez transmettre directement les flags TensorFlow à l’objet `wandb.Run.config`.
```python theme={null}
with wandb.init() as run:
run.config.epochs = 4
flags = tf.app.flags
flags.DEFINE_string("data_dir", "/tmp/data")
flags.DEFINE_integer("batch_size", 128, "Batch size.")
run.config.update(flags.FLAGS) # ajouter les flags TensorFlow à la configuration
```