> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-automation-updates-docs-2928-docs-2829.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Ajoutez W&B à votre script Python ou à votre notebook Jupyter.
# Ajoutez W&B (wandb) à votre code
Ce guide fournit des recommandations pour intégrer W\&B à votre script d’entraînement Python ou à votre notebook afin d’optimiser la recherche d’hyperparamètres. En suivant ces recommandations, vous pouvez utiliser les balayages W\&B pour explorer les valeurs d’hyperparamètres, journaliser les métriques d’entraînement et de validation, et identifier la configuration qui permet d’obtenir de bonnes performances du modèle.
Ce guide s’adresse aux praticiens du machine learning qui disposent déjà d’un script d’entraînement Python et souhaitent ajouter la prise en charge des balayages d’hyperparamètres. Les sections suivantes présentent un exemple de script d’entraînement, puis montrent comment le mettre à jour pour qu’il fonctionne avec les balayages W\&B.
## Script d’entraînement original
Supposons que vous disposiez d’un script Python qui entraîne un modèle (voir le code ci-dessous). Votre objectif est de trouver les hyperparamètres qui maximisent la précision de validation (`val_acc`).
Dans votre script Python, vous définissez deux fonctions : `train_one_epoch` et `evaluate_one_epoch`. La fonction `train_one_epoch` simule l’entraînement sur une époque et renvoie la précision et la perte d’entraînement. La fonction `evaluate_one_epoch` simule l’évaluation du modèle sur l’ensemble de données de validation et renvoie la précision et la perte de validation.
Vous définissez un dictionnaire de configuration nommé `config` qui contient des valeurs d’hyperparamètres telles que le taux d’apprentissage, la taille de lot et le nombre d’époques. Les valeurs de ce dictionnaire de configuration contrôlent le processus d’entraînement.
Ensuite, vous définissez une fonction appelée `main` qui reproduit une boucle d’entraînement classique. À chaque époque, le script calcule la précision et la perte sur les ensembles de données d’entraînement et de validation.
Ce code est un script d’entraînement fictif. Il n’entraîne pas réellement de modèle, mais simule le processus d’entraînement en générant des valeurs aléatoires de précision et de perte. L’objectif de ce code est de montrer comment intégrer W\&B dans votre script d’entraînement.
```python theme={null}
import random
import numpy as np
def train_one_epoch(epoch, lr, batch_size):
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
# variable de configuration avec les valeurs des hyperparamètres
config = {"lr": 0.0001, "batch_size": 16, "epochs": 5}
def main():
lr = config["lr"]
batch_size = config["batch_size"]
epochs = config["epochs"]
for epoch in np.arange(1, epochs):
train_acc, train_loss = train_one_epoch(epoch, lr, batch_size)
val_acc, val_loss = evaluate_one_epoch(epoch)
print("epoch: ", epoch)
print("training accuracy:", train_acc, "training loss:", train_loss)
print("validation accuracy:", val_acc, "validation loss:", val_loss)
if __name__ == "__main__":
main()
```
La section suivante montre comment ajouter W\&B à votre script Python afin de suivre les hyperparamètres et les métriques pendant l’entraînement. Vous souhaitez utiliser W\&B pour trouver les meilleurs hyperparamètres afin de maximiser la précision de validation (`val_acc`).
## Ajoutez W\&B à votre script d'entraînement
Cette section montre comment modifier le script d'entraînement original afin que l'agent de balayage puisse transmettre des valeurs d'hyperparamètre à chaque run et que W\&B puisse enregistrer les métriques obtenues. La manière d'intégrer W\&B à votre script Python ou notebook dépend de la façon dont vous gérez les Sweeps.
Pour utiliser le W\&B Python SDK afin de démarrer, d'arrêter et de gérer les Sweeps, suivez les instructions de l'onglet **Python script or notebook**. Pour utiliser le W\&B CLI à la place, suivez les instructions de l'onglet **CLI**.
Créez un fichier de configuration YAML pour votre sweep. Ce fichier contient les hyperparamètres que vous voulez explorer avec le sweep. Dans l’exemple suivant, le sweep fait varier les hyperparamètres `batch_size`, `epochs` et `lr` à chaque exécution.
```yaml theme={null}
# config.yaml
program: train.py
method: random
name: sweep
metric:
goal: maximize
name: val_acc
parameters:
batch_size:
values: [16, 32, 64]
lr:
min: 0.0001
max: 0.1
epochs:
values: [5, 10, 15]
```
Pour plus d'informations, voir [Définir la configuration du sweep](/fr/models/sweeps/define-sweep-configuration).
Vous devez fournir le nom de votre script Python pour la clé `program`
dans votre fichier YAML.
Ensuite, ajoutez ce qui suit à l'exemple de code :
1. Importez le SDK Python de W\&B (`wandb`) et PyYAML (`yaml`). Utilisez PyYAML pour lire votre fichier de configuration YAML.
2. Chargez le fichier de configuration.
3. Utilisez [`wandb.init()`](/fr/models/ref/python/functions/init) pour démarrer un processus d'arrière-plan afin de synchroniser et d'enregistrer les données en tant que [W\&B Run](/fr/models/ref/python/experiments/run). Passez l'objet config au paramètre config.
4. Définissez les valeurs des hyperparamètres à partir de `wandb.Run.config` au lieu d'utiliser des valeurs codées en dur.
5. Enregistrez la métrique que vous souhaitez optimiser avec [`wandb.Run.log()`](/fr/models/ref/python/experiments/run.md/#method-runlog). Vous devez enregistrer la métrique définie dans votre configuration. Dans le dictionnaire de configuration (`sweep_configuration` dans cet exemple), vous définissez le sweep de manière à maximiser la valeur `val_acc`.
```python theme={null}
import wandb
import yaml
import random
import numpy as np
def train_one_epoch(epoch, lr, batch_size):
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():
# Configurez vos hyperparamètres par défaut
with open("./config.yaml") as file:
config = yaml.load(file, Loader=yaml.FullLoader)
with wandb.init(config=config) as run:
for epoch in np.arange(1, run.config['epochs']):
train_acc, train_loss = train_one_epoch(epoch, run.config['lr'], run.config['batch_size'])
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,
}
)
# Appelez la fonction principale.
main()
```
Après avoir mis à jour votre script d'entraînement, initialisez et démarrez le sweep depuis votre CLI :
1. Initialisez le sweep avec la commande [`wandb sweep`](/fr/models/ref/cli/wandb-sweep). Fournissez le nom du fichier YAML. Si vous le souhaitez, définissez l'option `--project` sur le nom du projet :
```bash theme={null}
wandb sweep --project sweep-demo-cli config.yaml
```
Cela renvoie un ID de sweep. Pour plus d'informations, voir [Initialiser les sweeps](/fr/models/sweeps/initialize-sweeps).
2. Copiez l'ID du sweep et remplacez `[SWEEP-ID]` dans la commande suivante pour démarrer le job du sweep avec la commande [`wandb agent`](/fr/models/ref/cli/wandb-agent). Remplacez `[YOUR-ENTITY]` par le nom de votre entité W\&B. Si vous le souhaitez, définissez `--count` pour limiter le nombre de runs que l'agent lance (cet exemple le définit sur cinq) :
```bash theme={null}
wandb agent --count 5 [YOUR-ENTITY]/sweep-demo-cli/[SWEEP-ID]
```
L'agent de sweep exécute votre script d'entraînement de façon répétée, chaque fois avec une combinaison différente de valeurs d'hyperparamètres issues de votre configuration YAML, et journalise les résultats dans W\&B. Pour plus d'informations, voir [Démarrer des jobs de sweep](/fr/models/sweeps/start-sweep-agents).
Suivez ces étapes pour ajouter W\&B à votre script Python :
1. Créez un dictionnaire dans lequel les paires clé-valeur définissent une [configuration de sweep](/fr/models/sweeps/define-sweep-configuration). La configuration du sweep définit les hyperparamètres que vous souhaitez voir W\&B explorer, ainsi que la métrique que vous souhaitez optimiser. En reprenant l’exemple précédent, faites varier les hyperparamètres `batch_size`, `epochs` et `lr` à chaque sweep. Pour maximiser la précision de validation, définissez `goal` de la métrique sur `maximize` et son `name` sur `val_acc`.
2. Passez le dictionnaire de configuration du sweep à [`wandb.sweep()`](/fr/models/ref/python/functions/sweep). Cela initialise le sweep et renvoie un ID de sweep (`sweep_id`). Pour plus d'informations, voir [Initialize sweeps](/fr/models/sweeps/initialize-sweeps).
3. En haut de votre script, importez le SDK Python de W\&B (`wandb`).
4. Dans votre fonction `main`, utilisez [`wandb.init()`](/fr/models/ref/python/functions/init) pour générer un processus en arrière-plan afin de synchroniser et d’enregistrer les données sous forme de [W\&B Run](/fr/models/ref/python/experiments/run). Passez le nom du projet comme paramètre à la méthode `wandb.init()`. Si vous ne fournissez pas de nom de projet, W\&B utilise le nom de projet par défaut.
5. Récupérez les valeurs des hyperparamètres à partir de l’objet `wandb.Run.config`. Cela vous permet d’utiliser les valeurs d’hyperparamètres définies dans le dictionnaire de configuration du sweep au lieu de valeurs codées en dur.
6. Enregistrez dans W\&B la métrique que vous optimisez à l’aide de [`wandb.Run.log()`](/fr/models/ref/python/experiments/run.md/#method-runlog). Vous devez enregistrer la métrique définie dans votre configuration. Par exemple, si vous définissez la métrique à optimiser comme `val_acc`, vous devez enregistrer `val_acc`. Si vous n’enregistrez pas la métrique, W\&B ne peut pas effectuer l’optimisation. Dans le dictionnaire de configuration (`sweep_configuration` dans cet exemple), vous définissez le sweep pour maximiser la valeur `val_acc`.
7. Démarrez le sweep avec [`wandb.agent()`](/fr/models/ref/python/functions/agent). Fournissez l’ID du sweep et le nom de la fonction exécutée par le sweep (`function=main`), puis définissez le nombre maximal de runs sur quatre (`count=4`).
En combinant le tout, votre script pourrait ressembler à ce qui suit :
```python theme={null}
import wandb # Importer le SDK Python W&B
import numpy as np
import random
import argparse
def train_one_epoch(epoch, lr, batch_size):
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=None):
# Lorsqu'il est appelé par l'agent de balayage, args est None,
# on utilise donc le projet issu de la configuration du sweep
project = args.project if args else None
with wandb.init(project=project) as run:
# Récupère les valeurs des hyperparamètres depuis l'objet `wandb.Run.config`
lr = run.config["lr"]
batch_size = run.config["batch_size"]
epochs = run.config["epochs"]
# Exécute la boucle d'entraînement et consigne les valeurs de performances dans W&B
for epoch in np.arange(1, epochs):
train_acc, train_loss = train_one_epoch(epoch, lr, batch_size)
val_acc, val_loss = evaluate_one_epoch(epoch)
run.log(
{
"epoch": epoch,
"train_acc": train_acc,
"train_loss": train_loss,
"val_acc": val_acc, # Métrique optimisée
"val_loss": val_loss,
}
)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--project", type=str, default="sweep-example", help="W&B project name")
args = parser.parse_args()
# Définir un dictionnaire de configuration du sweep
sweep_configuration = {
"method": "random",
"name": "sweep",
# Métrique à optimiser
# Par exemple, pour maximiser la précision de validation,
# définissez "goal": "maximize" et le nom de la variable
# à optimiser, ici "val_acc"
"metric": {
"goal": "maximize",
"name": "val_acc"
},
"parameters": {
"batch_size": {"values": [16, 32, 64]},
"epochs": {"values": [5, 10, 15]},
"lr": {"max": 0.1, "min": 0.0001},
},
}
# Initialiser le sweep en transmettant le dictionnaire de configuration
sweep_id = wandb.sweep(sweep=sweep_configuration, project=args.project)
# Démarrer le job de sweep
wandb.agent(sweep_id, function=main, count=4)
```
Lorsque vous exécutez ce script, W\&B lance le sweep, exécute la fonction `main` jusqu'à quatre fois avec différentes combinaisons d'hyperparamètres et journalise les métriques de chaque run afin de vous permettre de comparer les résultats dans l'application W\&B.
**Journal des métriques dans W\&B lors d’un balayage**
Vous devez journaliser la métrique que vous définissez et que vous optimisez, à la fois dans votre configuration de balayage et avec `wandb.Run.log()`. Par exemple, si vous définissez `val_acc` comme métrique à optimiser dans votre configuration de balayage, vous devez également journaliser `val_acc` dans W\&B. Si vous ne journalisez pas cette métrique, W\&B ne peut pas effectuer l’optimisation.
```python theme={null}
with wandb.init() as run:
val_loss, val_acc = train()
run.log(
{
"val_loss": val_loss,
"val_acc": val_acc
}
)
```
L’exemple suivant montre une journalisation incorrecte de la métrique dans W\&B. La métrique optimisée dans la configuration de balayage est `val_acc`, mais le code journalise `val_acc` dans un dictionnaire imbriqué sous la clé `validation`. Vous devez journaliser la métrique directement, et non dans un dictionnaire imbriqué.
```python theme={null}
with wandb.init() as run:
val_loss, val_acc = train()
run.log(
{
"validation": {
"val_loss": val_loss,
"val_acc": val_acc
}
}
)
```