> ## 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.
> Ajoutez W&B à votre script Python ou à votre Jupyter Notebook.
# Ajouter 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 pourrez utiliser W\&B Sweeps pour explorer différentes valeurs d’hyperparamètres, journaliser les métriques d’entraînement et de validation, et identifier la configuration qui offre les meilleures 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 y ajouter la prise en charge des sweeps d’hyperparamètres. Les sections suivantes présentent un exemple de script d’entraînement, puis expliquent comment l’adapter pour qu’il fonctionne avec W\&B Sweeps.
Script d’entraînement d’origine
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 le jeu 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 pilotent le processus d’entraînement.
Vous définissez ensuite 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 jeux de données d’entraînement et de validation.
Ce code est un script d’entraînement fictif. Il n'entraîne aucun modèle, mais simule le processus d’entraînement en générant des valeurs aléatoires de précision et de perte. Il a pour but de montrer comment intégrer W\&B dans votre script d’entraînement.
```python theme={"system"}
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 config contenant 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 pour suivre les hyperparamètres et les métriques pendant l’entraînement. L’objectif est d’utiliser W\&B pour trouver les hyperparamètres qui maximisent la précision de validation (`val_acc`).
Ajouter W\&B à votre script d’entraînement
Cette section explique comment modifier le script d’entraînement d’origine pour que l’agent de sweep puisse transmettre des valeurs d’hyperparamètres à chaque run et que W\&B puisse enregistrer les métriques obtenues. La manière d’intégrer W\&B dans votre script Python ou votre notebook dépend de la façon dont vous gérez les sweeps.
Si vous utilisez le SDK Python W\&B pour démarrer, arrêter et gérer les sweeps, suivez les instructions de l’onglet **Script Python ou notebook**. Si vous préférez utiliser la CLI W\&B, suivez les instructions de l’onglet **CLI**.
Créez un fichier de configuration YAML contenant votre configuration de sweep. Ce fichier définit les hyperparamètres que le sweep doit explorer. Dans l’exemple suivant, le sweep fait varier les hyperparamètres `batch_size`, `epochs` et `lr` à chaque run.
```yaml theme={"system"}
# 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 de sweep](/fr/products/wandb/sweeps/define-sweep-configuration).
Vous devez indiquer le nom de votre script Python comme valeur de la clé `program`
dans votre fichier YAML.
Ajoutez ensuite les éléments suivants à l’exemple de code :
1. Importez le SDK Python W\&B (`wandb`) et PyYAML (`yaml`). Utilisez PyYAML pour lire votre fichier de configuration YAML.
2. Lisez le fichier de configuration.
3. Utilisez [`wandb.init()`](/fr/products/wandb/ref/python/functions/init) pour démarrer un processus en arrière-plan qui synchronise et journalise les données sous forme de [run W\&B](/fr/products/wandb/ref/python/experiments/run). Passez l’objet de configuration 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. Journalisez la métrique à optimiser avec [`wandb.Run.log()`](/fr/products/wandb/ref/python/experiments/run#method-runlog). Vous devez journaliser la métrique définie dans votre configuration. Dans le dictionnaire de configuration (ici, `sweep_configuration`), le sweep est défini de manière à maximiser la valeur `val_acc`.
```python theme={"system"}
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():
# Configurer les 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,
}
)
# Appeler la fonction main.
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/products/wandb/ref/cli/wandb-sweep) en indiquant le nom du fichier YAML. Vous pouvez également définir l'option `--project` sur le nom du projet :
```bash theme={"system"}
wandb sweep --project sweep-demo-cli config.yaml
```
Cette commande renvoie un ID de sweep. Pour plus d'informations, voir [Initialiser des sweeps](/fr/products/wandb/sweeps/initialize-sweeps).
2. Copiez l'ID du sweep et remplacez `[SWEEP-ID]` dans la commande suivante pour démarrer le job de sweep avec la commande [`wandb agent`](/fr/products/wandb/ref/cli/wandb-agent). Remplacez `[YOUR-ENTITY]` par le nom de votre entity W\&B. Vous pouvez également définir `--count` pour limiter le nombre de runs que l'agent tente d'exécuter (ici, cinq) :
```bash theme={"system"}
wandb agent --count 5 [YOUR-ENTITY]/sweep-demo-cli/[SWEEP-ID]
```
L'agent de sweep exécute votre script d'entraînement de manière répétée, chaque fois avec une combinaison différente de valeurs d'hyperparamètres tirées de votre configuration YAML, et journalise les résultats dans W\&B. Pour plus d'informations, voir [Démarrer des jobs de sweep](/fr/products/wandb/sweeps/start-sweep-agents).
Suivez ces étapes pour ajouter W\&B à votre script Python :
1. Créez un objet dictionnaire dont les paires clé-valeur définissent une [configuration de sweep](/fr/products/wandb/sweeps/define-sweep-configuration). La configuration de sweep définit les hyperparamètres que W\&B doit explorer, ainsi que la métrique à optimiser. Dans la continuité de 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 le `goal` de la métrique sur `maximize` et son `name` sur `val_acc`.
2. Transmettez le dictionnaire de configuration de sweep à [`wandb.sweep()`](/fr/products/wandb/ref/python/functions/sweep). Cette fonction initialise le sweep et renvoie un ID de sweep (`sweep_id`). Pour plus d'informations, voir [Initialiser des sweeps](/fr/products/wandb/sweeps/initialize-sweeps).
3. En haut de votre script, importez le SDK Python W\&B (`wandb`).
4. Dans votre fonction `main`, utilisez [`wandb.init()`](/fr/products/wandb/ref/python/functions/init) pour lancer un processus en arrière-plan chargé de synchroniser et de journaliser les données sous la forme d'un [W\&B Run](/fr/products/wandb/ref/python/experiments/run). Transmettez le nom du projet en paramètre à la méthode `wandb.init()`. Si vous ne transmettez 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`. Vous pouvez ainsi utiliser les valeurs d'hyperparamètres définies dans le dictionnaire de configuration de sweep plutôt que des valeurs codées en dur.
6. Journalisez dans W\&B la métrique que vous optimisez à l'aide de [`wandb.Run.log()`](/fr/products/wandb/ref/python/experiments/run#method-runlog). Vous devez journaliser la métrique définie dans votre configuration. Par exemple, si vous définissez `val_acc` comme métrique à optimiser, vous devez journaliser `val_acc`. Si vous ne journalisez pas la métrique, W\&B ne peut pas effectuer l'optimisation. Dans le dictionnaire de configuration (`sweep_configuration` dans cet exemple), le sweep est défini de façon à maximiser la valeur `val_acc`.
7. Lancez le sweep avec [`wandb.agent()`](/fr/products/wandb/ref/python/functions/agent). Fournissez l'ID du sweep et le nom de la fonction exécutée par le sweep (`function=main`), puis fixez le nombre maximum de runs à quatre (`count=4`).
Une fois tous ces éléments réunis, votre script pourrait ressembler à ceci :
```python theme={"system"}
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):
# Lorsque la fonction est appelée par l’agent de sweep, args vaut None :
# on utilise donc le projet défini dans 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écuter la boucle d’entraînement et journaliser les métriques 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 à optimiser
"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 le 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 indiquez 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 lui passant le dictionnaire de configuration
sweep_id = wandb.sweep(sweep=sweep_configuration, project=args.project)
# Lancer 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, puis journalise les métriques de chaque run pour vous permettre de comparer les résultats dans l’application W\&B.
**Consigner des métriques dans W\&B lors d’un sweep**
La métrique que vous définissez et que vous cherchez à optimiser doit être à la fois déclarée dans votre configuration de sweep et journalisée avec `wandb.Run.log()`. Par exemple, si vous définissez `val_acc` comme métrique à optimiser dans votre configuration de sweep, vous devez également journaliser `val_acc` dans W\&B. Si vous ne journalisez pas la métrique, W\&B ne peut pas effectuer l’optimisation.
```python theme={"system"}
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 manière incorrecte de journaliser la métrique dans W\&B. La configuration de sweep optimise `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={"system"}
with wandb.init() as run:
val_loss, val_acc = train()
run.log(
{
"validation": {
"val_loss": val_loss,
"val_acc": val_acc
}
}
)
```