Comment configurer le suivi avec Weights & Biases (étape par étape)

Comment configurer la surveillance avec Weights & Biases (étape par étape)

Si vous gérez des expériences d’apprentissage automatique et que vous enregistrez encore tout dans des feuilles de calcul ou des fichiers texte éparpillés, vous manquez sérieusement quelque chose—la configuration de la surveillance de weights & biases vous fera économiser des dizaines d’heures douloureuses et de nuits blanches à lutter avec des données expérimentales désorganisées.

Ce que vous allez construire et pourquoi c’est important

Nous mettons en place la surveillance de weights & biases pour suivre, visualiser et déboguer les sessions d’entraînement d’apprentissage automatique de manière efficace—plus de métriques perdues ni de suppositions sur les hyperparamètres qui ont fait grimper votre modèle.

Conditions préalables

• Python 3.8+ (Weights & Biases est assez tolérant mais restez sur 3.8 ou une version ultérieure pour la compatibilité)
• pip installé, de préférence version 23.0+ (les mises à jour corrigent souvent les bugs liés aux dépendances de paquets)
• Créez un compte Weights & Biases gratuit à https://wandb.ai
• Connaissance de base des scripts d’entraînement en apprentissage automatique (TensorFlow, PyTorch ou sklearn fonctionnent)
• Connaissance des outils de ligne de commande (le CLI de weights & biases est indispensable)

Configuration étape par étape

Étape 1 : Installer le package Python Weights & Biases

pip install wandb

Ceci est le seul package dont vous avez besoin pour surveiller vos sessions d’apprentissage automatique. Il s’intègre dans votre code et vous offre des tableaux de bord en direct, le suivi des métriques et la gestion des artefacts.

Pourquoi ? Parce que le client de wandb gère tout ce qui concerne le téléchargement, la synchronisation et la liaison avec le serveur automatiquement. Cela vous évite les tracas de l’enregistrement manuel.

Pièges courants : Si vous recevez un conflit de version ou un problème de dépendance échoué, mettez à jour pip et setuptools :

pip install --upgrade pip setuptools

Étape 2 : Connectez-vous à votre compte Wandb

wandb login

Cette commande vous demandera votre clé API. Rendez-vous dans les paramètres de votre compte sur https://wandb.ai/settings et copiez votre clé API. Collez-la lorsque le CLI vous le demande.

Pourquoi ? Vous devez authentifier votre outil CLI avec votre projet cloud afin que vos sessions soient liées à votre compte utilisateur et à vos projets.

Attention : Si vous collez par accident des espaces blancs ou appuyez trop tôt sur entrer, wandb refusera votre clé et affichera une erreur cryptique concernant l’échec de l’authentification.

Étape 3 : Initialiser Wandb dans votre script d’entraînement

import wandb

# Commencer une nouvelle session
wandb.init(project="my-ml-project", entity="your-username")

# Exemple : Enregistrer les hyperparamètres
config = wandb.config
config.learning_rate = 0.001
config.batch_size = 32

Insérer ce fragment au début de votre boucle principale d’entraînement permet à wandb de capturer tout ce qui se passe dans cette session.

Pourquoi ? L’étape d’initialisation crée un nouvel objet de session côté serveur, vous permettant d’enregistrer des métriques et des artefacts en temps réel. Sans cela, vous ne verrez aucune donnée dans votre espace de travail.

Erreur courante : Si vous oubliez d’appeler wandb.init(), vos appels à wandb.log() ne feront rien et cela peut échouer silencieusement. Assurez-vous toujours de vérifier cela.

Étape 4 : Enregistrer les métriques et les hyperparamètres pendant l’entraînement

for epoch in range(num_epochs):
 # Entraînez votre modèle ici
 train_loss = compute_train_loss()
 val_loss = compute_val_loss()
 
 # Enregistrer les métriques dans wandb
 wandb.log({
 "epoch": epoch,
 "train_loss": train_loss,
 "val_loss": val_loss
 })

Ce fragment doit être à l’intérieur de votre boucle principale d’entraînement. wandb.log() envoie les données au serveur de manière asynchrone.

Pourquoi ? L’enregistrement vous permet de suivre la performance du modèle étape par étape. Vous pouvez repérer le surapprentissage ou les plateaux et ajuster les hyperparamètres en conséquence.

Erreur typique : Ne pas envoyer les journaux assez souvent, ce qui entraîne des données de session incomplètes si votre tâche échoue. Assurez-vous que wandb.log() soit appelé après chaque mise à jour significative (généralement chaque époque ou lot).

Étape 5 : Enregistrer les artefacts des modèles pour le suivi des versions

# Enregistrer le checkpoint de votre modèle localement
torch.save(model.state_dict(), "model.pt")

# Télécharger le checkpoint en tant qu’artefact dans wandb
artifact = wandb.Artifact('model', type='model')
artifact.add_file("model.pt")
wandb.log_artifact(artifact)

Les artefacts wandb vous permettent de suivre les versions des modèles, des ensembles de données ou d’autres résultats. Cela rend votre entraînement reproductible et débogable.

Pourquoi ? Les artefacts facilitent les workflows collaboratifs et l’intégration avec l’intégration continue/livraison continue. Vous pouvez comparer les modèles et même revenir à des checkpoints précédents facilement.

Attention : Oublier d’appeler wandb.log_artifact() signifie que vos fichiers enregistrés n’apparaîtront pas dans le tableau de bord du projet. De plus, les artefacts volumineux peuvent échouer silencieusement si les quotas de stockage sont atteints — vérifiez les limites d’utilisation de votre projet.

Étape 6 : Visualiser les résultats dans le tableau de bord Wandb

Ouvrez https://wandb.ai et naviguez jusqu’à votre projet. Vous verrez des graphiques en direct se mettre à jour avec vos métriques, hyperparamètres et artefacts enregistrés.

Pourquoi ? La visualisation est la fonctionnalité clé qui rend la mise en place de la surveillance par weights & biases vraiment précieuse—voir les tendances de vos métriques vous aide à comprendre le comportement du modèle en temps réel.

Avertissement : Si vos métriques n’apparaissent pas, vérifiez que votre wandb.init() a le bon nom de projet et que vous êtes connecté au bon compte (entité). Vérifiez également que votre connexion réseau permet les connexions cloud (parfois, les pare-feu d’entreprise bloquent cela).

Étape 7 : Intégration avancée – Automatiser les exécutions Wandb avec CI/CD

# Extrait d'un workflow GitHub Actions

name: Exécuter l'entraînement et enregistrer sur W&B

on: [push]

jobs:
 train:
 runs-on: ubuntu-latest
 steps:
 - uses: actions/checkout@v2
 - name: Configurer Python
 uses: actions/setup-python@v2
 with:
 python-version: 3.9
 - name: Installer les dépendances
 run: pip install wandb torch
 - name: Connexion à Wandb
 run: echo ${{ secrets.WANDB_API_KEY }} | wandb login
 - name: Exécuter le script d'entraînement
 run: python train.py

Ce script montre un workflow CI automatisé avec GitHub exécutant votre entraînement et poussant les résultats vers wandb automatiquement.

Pourquoi ? Les équipes de niveau production ont besoin d’une surveillance qui s’intègre dans les pipelines — les exécutions manuelles sont fastidieuses et sujettes aux erreurs.

Problèmes potentiels : Vous devez conserver votre clé API Wandb en toute sécurité comme une variable d’environnement secrète (ne jamais l’engager). Oublier cela signifie que les tâches CI échouent silencieusement l’authentification.

Les pièges dont personne ne vous parle

• Quotas et limites : Votre niveau gratuit de Wandb vous permet d’enregistrer à peu près quelques milliers de sessions par mois avant d’atteindre les limites de bande passante ou de stockage d’artefacts. Si vous exécutez 10K+ époques ou de grands ensembles de données, attendez-vous à une réduction de débit. Vous ne recevrez pas d’avertissements explicites immédiatement ; vérifiez simplement votre quota de projet.

  Solution : Nettoyez régulièrement les anciennes sessions et archivez les grands artefacts à l’extérieur.

• Latence entre l’enregistrement et le rafraîchissement du tableau de bord : Wandb télécharge de manière asynchrone, donc parfois vos dernières métriques apparaissent quelques secondes trop tard, ce qui est frustrant si vous déboguez à un niveau de granularité de lot.

  Solution : Ajoutez `wandb.log(…, commit=True)` pour envoyer des données à des points critiques.

• Incohérences de l’environnement : Wandb surveille les versions des paquets de votre environnement Python. Si votre code s’exécute dans un environnement Docker ou distant sans listes de paquets exactes (requirements.txt), votre expérience pourrait ne pas être reproductible malgré les métriques enregistrées.
  Solution : Fixez et enregistrez toujours les versions des paquets.
• Problèmes réseau dans des environnements restreints : Les serveurs d’entreprise et académiques bloquent souvent par défaut les téléchargements de télémétrie de Wandb, provoquant des échecs silencieux ou des suspensions indéfinies.
  Solution : Utilisez le mode hors ligne local (`wandb.init(mode=”offline”)`) et synchronisez plus tard, ou ajoutez des domaines à la liste blanche sur les pare-feu.
• Enregistrement de trop de données : Enregistrer chaque métrique de batch peut gonfler vos sessions et ralentir votre interface utilisateur. Utilisez des statistiques de synthèse ou échantillonnez à intervalles.
  Solution : Enregistrez au niveau de l’époque ou tous les N lots, pas chaque lot.

Exemple complet de code fonctionnel

import wandb
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# Jeu de données fictif
X = torch.randn(100, 10)
y = torch.randint(0, 2, (100,))

dataset = TensorDataset(X, y)
loader = DataLoader(dataset, batch_size=16, shuffle=True)

# Classificateur binaire simple
class SimpleModel(nn.Module):
 def __init__(self):
 super().__init__()
 self.fc = nn.Linear(10, 2)
 def forward(self, x):
 return self.fc(x)

model = SimpleModel()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Initialiser l'exécution wandb
wandb.init(project="my-ml-project", entity="your-username")
wandb.config.update({
 "epochs": 5,
 "batch_size": 16,
 "learning_rate": 0.001,
})

for epoch in range(wandb.config.epochs):
 running_loss = 0.0
 for inputs, labels in loader:
 optimizer.zero_grad()
 outputs = model(inputs)
 loss = criterion(outputs, labels)
 loss.backward()
 optimizer.step()
 running_loss += loss.item()
 avg_loss = running_loss / len(loader)

 print(f"Époque {epoch+1}, Perte : {avg_loss:.4f}")
 wandb.log({"epoch": epoch + 1, "loss": avg_loss})

# Sauvegarder et télécharger l'artéfact du modèle
torch.save(model.state_dict(), "model.pt")
artifact = wandb.Artifact('simple-model', type='model')
artifact.add_file("model.pt")
wandb.log_artifact(artifact)

wandb.finish()

Que faire ensuite

Une fois que vous avez configuré vos poids & biais pour surveiller et enregistrer avec efficacité, je recommande d’ajouter wandb Sweeps pour automatiser l’ajustement des hyperparamètres. C’est bien mieux que de relancer manuellement des scripts pour chaque combinaison de paramètres et cela vous permet de vous concentrer sur les résultats au lieu d’expériences délicates.

FAQ

Q : Puis-je utiliser weights & biases avec d’autres frameworks que PyTorch ?

A : Absolument. Wandb prend en charge TensorFlow, Keras, Hugging Face Transformers, sklearn, vous l’appelez. Cela enveloppe essentiellement votre boucle d’entraînement et enregistre les données. Vous devez juste insérer des appels similaires à wandb.init() et wandb.log() aux bons endroits.

Q : Comment protéger les identifiants sensibles lors de l’utilisation de wandb dans des pipelines CI ?

A : Conservez votre clé API Wandb dans le système de gestion des secrets de votre fournisseur CI (par exemple, GitHub Secrets, variables CI GitLab). Ne codifiez jamais des clés dans le code source. Ensuite, utilisez des variables d’environnement pour fournir des clés pendant l’exécution CI, comme echo $WANDB_API_KEY | wandb login.

Q : Est-il possible d’exécuter l’enregistrement wandb hors ligne et de synchroniser plus tard ?

A : Oui. Vous pouvez initialiser wandb avec wandb.init(mode="offline"), ce qui met en cache les journaux localement. Plus tard, exécutez wandb sync pour télécharger les données des exécutions passées lorsque l’accès réseau est rétabli. Cela est utile pour les environnements cloisonnés.

Projet et données d’exécution Wandb en un coup d’œil

Pour comprendre pourquoi la configuration de weights & biases pour la surveillance surpasse l’enregistrement traditionnel dans des feuilles de calcul, voici un tableau rapide comparant le suivi manuel typique à la surveillance wandb sur des métriques clés :

Aspect	Enregistrement manuel (Excel/CSV)	Surveillance des Poids & Biais
Visibilité en temps réel	Non (doit attendre l’ouverture des fichiers)	Oui (tableaux de bord en direct se mettant à jour automatiquement)
Suivi des hyperparamètres	Souvent oublié ou incohérent	Automatisé ; toujours lié aux exécutions
Versionnage des artéfacts de modèle	Sauvegardes manuelles de fichiers, pas de métadonnées	Contrôle de version des artéfacts intégré
Collaboration	Envoyer des fichiers par email ou partager des dossiers	Les équipes partagent des projets en temps réel avec un accès basé sur les rôles
Intégration avec CI/CD	Étapes manuelles	Automatisé via des scripts et des APIs
Limites de stockage	Espace disque local	Quotas cloud et options d’archivage

Recommandations personnalisées pour différents profils de développeurs

Si vous êtes un hobbyiste solitaire ayant des modèles petits sur votre ordinateur portable, commencez par configurer wandb localement avec le mode hors ligne activé pour ne pas vous soucier des problèmes de réseau. L’interface utilisateur et l’enregistrement donneront à vos expériences un sens de l’organisation qu’aucune feuille de calcul ne peut égaler.

Si vous êtes un data scientist équilibrant plusieurs modèles et collaborateurs, investissez du temps à intégrer les exécutions wandb avec les dépôts Git de votre équipe et l’infrastructure cloud. Automatisez votre enregistrement et vos artéfacts – faites-moi confiance, personne ne veut demander une nouvelle exportation CSV.

Pour les ingénieurs ML construisant des pipelines de production, intégrez les sweeps wandb et l’automatisation CI/CD dès le début de votre processus. Vous voudrez un état d’expérience constant, des options de restauration, et une surveillance intégrée dans les cycles de publication pour éviter de déboguer des trous noirs des semaines plus tard.

Données à partir du 21 mars 2026. Sources : Poids & Biais Site Officiel, Documentation Poids & Biais

Articles Connexes

• Sécurité des réseaux de bots IA
• Gouvernance de la sécurité des bots IA
• Grammarly est-elle IA ? Comment l’outil d’écriture utilise l’intelligence artificielle

🕒 Published: March 27, 2026