Commencer

Obtiens des informations visuelles grâce à l’intégration de YOLO26 avec TensorBoard

Comprendre et régler finement les modèles de vision par ordinateur, comme Ultralytics YOLO26, devient plus simple lorsqu’on examine de plus près leur processus d’entraînement. La visualisation de l’entraînement des modèles permet de mieux comprendre leurs schémas d’apprentissage, leurs indicateurs de performance et leur comportement général. L’intégration de YOLO26 à TensorBoard facilite la visualisation et l’analyse, et permet d’ajuster le modèle plus efficacement et en meilleure connaissance de cause.

Ce guide explique comment utiliser TensorBoard avec YOLO26. Tu découvriras différentes visualisations, du suivi des métriques à l’analyse des graphes de modèles. Ces outils t’aideront à mieux comprendre les performances de ton modèle YOLO26.

TensorBoard#

TensorBoard, l’outil de visualisation de TensorFlow, est largement utilisé pour les expériences d’apprentissage automatique. TensorBoard propose divers outils de visualisation pour surveiller les modèles d’apprentissage automatique. Ces outils permettent notamment de suivre des indicateurs clés comme la fonction de perte et la précision, de visualiser les graphes des modèles et d’afficher l’évolution des histogrammes des poids et des biais. L’outil permet également de projeter les plongements dans des espaces de plus faible dimension et d’afficher des données multimédias.

Entraîner YOLO26 avec TensorBoard#

L’utilisation de TensorBoard pendant l’entraînement des modèles YOLO26 est simple et présente des avantages considérables.

Installation#

Pour installer le package requis, exécute :

Installation
# Install YOLO26 and TensorBoard
pip install ultralytics tensorboard

TensorBoard est une dépendance facultative. Après l’installation, active le rappel une seule fois avec yolo settings tensorboard=True ; le paramètre restera activé pour les prochains entraînements.

Pour obtenir des instructions détaillées et des bonnes pratiques concernant l’installation, consulte notre guide d’installation de YOLO26. Si tu rencontres des difficultés lors de l’installation des paquets requis pour YOLO26, consulte notre guide des problèmes courants pour trouver des solutions et des conseils.

Configurer TensorBoard pour Google Colab#

Lorsque tu utilises Google Colab, configure TensorBoard avant de lancer ton code d’entraînement :

Configurer TensorBoard pour Google Colab
%load_ext tensorboard
%tensorboard --logdir path/to/runs

Utilisation#

Activer ou désactiver TensorBoard

Par défaut, la journalisation de TensorBoard est désactivée. Tu peux l’activer ou la désactiver à l’aide de la commande yolo settings.

# Enable TensorBoard logging
yolo settings tensorboard=True

# Disable TensorBoard logging
yolo settings tensorboard=False
Utilisation
from ultralytics import YOLO

# Charger un modèle préentraîné
model = YOLO("yolo26n.pt")

# Entraîner le modèle
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

Après avoir exécuté l’extrait de code d’utilisation ci-dessus, tu peux t’attendre à obtenir la sortie suivante :

TensorBoard: Start with 'tensorboard --logdir runs/detect/train', view at http://localhost:6006/

Cette sortie indique que TensorBoard surveille maintenant activement ta session d’entraînement YOLO26. Tu peux accéder au tableau de bord TensorBoard à l’adresse localhost:6006 pour consulter les indicateurs d’entraînement en temps réel et les performances du modèle. Dans Google Colab, TensorBoard s’affiche dans la même cellule que celle où tu as exécuté les commandes de configuration de TensorBoard.

Pour en savoir plus sur le processus d’entraînement des modèles, consulte notre guide d’entraînement des modèles YOLO26. Si tu souhaites en apprendre davantage sur la journalisation, les points de contrôle, les graphiques et la gestion des fichiers, consulte notre guide d’utilisation de la configuration.

Comprendre TensorBoard pour l’entraînement de YOLO26#

Cette section présente les principales fonctionnalités et composantes de TensorBoard dans le contexte de l’entraînement de YOLO26. Les trois sections clés de TensorBoard sont les séries temporelles, les scalaires et les graphes.

Séries temporelles#

La fonctionnalité Séries temporelles de TensorBoard offre une vue dynamique et détaillée de différents indicateurs d’entraînement des modèles YOLO26 au fil du temps. Elle met l’accent sur l’évolution et les tendances des indicateurs d’un cycle d’entraînement à l’autre. Voici un exemple de ce que tu peux voir.

Visualisation des métriques d’entraînement en séries temporelles dans TensorBoard

Principales fonctionnalités des séries temporelles dans TensorBoard#

  • Filtrer les balises et épingler les cartes : cette fonctionnalité permet de filtrer certaines métriques et d’épingler des cartes pour les comparer et y accéder rapidement. Elle est particulièrement utile pour se concentrer sur des aspects précis du processus d’entraînement.

  • Cartes de métriques détaillées : les séries temporelles répartissent les métriques en différentes catégories, comme le taux d’apprentissage (lr), les métriques d’entraînement (train) et de validation (val), chacune étant représentée par une carte distincte.

  • Affichage graphique : chaque carte de la section Séries temporelles présente un graphique détaillé d’une métrique donnée pendant l’entraînement. Cette représentation visuelle aide à repérer les tendances, les schémas et les anomalies dans le processus d’entraînement.

  • Analyse approfondie : les séries temporelles fournissent une analyse approfondie de chaque métrique. Par exemple, elles affichent les différents segments du taux d’apprentissage et indiquent ainsi comment ses ajustements influent sur la courbe d’apprentissage du modèle.

Importance des séries temporelles pour l’entraînement de YOLO26#

La section Séries temporelles est essentielle pour analyser en profondeur la progression de l’entraînement du modèle YOLO26. Elle te permet de suivre les métriques en temps réel afin de repérer et de résoudre rapidement les problèmes. Elle offre également une vue détaillée de l’évolution de chaque métrique, ce qui est essentiel pour affiner le modèle et améliorer ses performances.

Valeurs scalaires#

Dans TensorBoard, les scalaires servent à représenter et à analyser des indicateurs simples, comme la fonction de perte et la précision, pendant l’entraînement des modèles YOLO26. Ils donnent une vue claire et concise de l’évolution de ces indicateurs à chaque cycle d’entraînement, ce qui permet d’évaluer l’efficacité et la stabilité de l’apprentissage du modèle. Voici un exemple de ce que tu peux voir.

Tableau de bord des scalaires TensorBoard affichant les métriques d’entraînement de YOLO

Principales fonctionnalités des scalaires dans TensorBoard#

  • Étiquettes du taux d’apprentissage (lr) : ces étiquettes montrent les variations du taux d’apprentissage au fil de différentes phases (par ex., lr/pg0, lr/pg1, lr/pg2). Elles t’aident à comprendre l’effet des ajustements du taux d’apprentissage sur le processus d’entraînement.

  • Balises de métriques : Les scalaires incluent des indicateurs de performance tels que :

    • metrics/mAP50(B) : précision moyenne moyenne à 50 % d’intersection sur l’union (IoU), un indicateur essentiel pour évaluer la précision de la détection d’objets.

    • metrics/mAP50-95(B) : précision moyenne calculée sur une plage de seuils IoU, pour une évaluation plus complète de la précision.

    • metrics/precision(B) : la précision des détections, c’est-à-dire la proportion de prédictions positives correctes.

    • metrics/recall(B) : indicateur important pour les modèles pour lesquels manquer une détection est coûteux, le rappel mesure la capacité à détecter toutes les instances pertinentes.

    • Pour en savoir plus sur les différentes métriques, consulte notre guide sur les métriques de performance.

  • Balises d’entraînement et de validation (train, val) : Ces balises affichent les métriques propres aux jeux de données d’entraînement et de validation, ce qui permet de comparer les performances du modèle sur différents jeux de données.

Importance du suivi des scalaires#

L’observation des métriques scalaires est essentielle pour affiner le modèle YOLO26. Les variations de ces métriques, comme les pics ou les motifs irréguliers dans les graphiques de perte, peuvent mettre en évidence des problèmes potentiels tels que le surapprentissage, le sous-apprentissage ou des paramètres de taux d’apprentissage inadaptés. En surveillant attentivement ces scalaires, tu peux prendre des décisions éclairées pour optimiser le processus d’entraînement et faire en sorte que le modèle apprenne efficacement et atteigne les performances souhaitées.

Différence entre les scalaires et les séries temporelles#

Dans TensorBoard, les scalaires et les séries temporelles servent tous deux à suivre des métriques, mais répondent à des besoins légèrement différents. Les scalaires permettent de tracer des métriques simples, comme la perte et la précision, sous forme de valeurs scalaires. Ils donnent une vue d’ensemble de l’évolution de ces métriques à chaque époque d’entraînement. La section des séries temporelles de TensorBoard propose quant à elle une chronologie plus détaillée des différentes métriques. Elle est particulièrement utile pour suivre leur évolution et leurs tendances au fil du temps, et fournit ainsi un aperçu plus approfondi des spécificités du processus d’entraînement.

Graphes#

La section Graphes de TensorBoard visualise le graphe de calcul du modèle YOLO26 et montre la circulation des opérations et des données dans le modèle. Elle aide à comprendre la structure du modèle, à vérifier que toutes les couches sont correctement reliées et à repérer d’éventuels goulots d’étranglement dans le flux de données. Voici un exemple de ce que tu peux voir.

Visualisation du graphe de calcul TensorBoard pour un modèle YOLO

Les graphes sont particulièrement utiles pour déboguer le modèle, notamment dans les architectures complexes courantes des modèles d’apprentissage profond comme YOLO26. Ils aident à vérifier les connexions entre les couches et la conception globale du modèle.

Résumé#

Ce guide a pour objectif de t’aider à utiliser TensorBoard avec YOLO26 pour visualiser et analyser l’entraînement des modèles de machine learning. Il explique comment les principales fonctionnalités de TensorBoard peuvent éclairer les métriques d’entraînement et les performances du modèle pendant les sessions d’entraînement de YOLO26.

Pour approfondir ces fonctionnalités et découvrir des stratégies efficaces pour les utiliser, consulte la documentation officielle de TensorBoard de TensorFlow et son dépôt GitHub.

FAQ#

  • L’utilisation de TensorBoard avec YOLO26 met à ta disposition plusieurs outils de visualisation essentiels pour entraîner efficacement les modèles :

    • Suivi des métriques en temps réel : Suis en direct les métriques clés telles que la perte, la précision, la précision positive et le rappel.
    • Visualisation du graphe du modèle : Comprends et débogue l’architecture du modèle en visualisant les graphes de calcul.

    Ces outils te permettent d’effectuer des ajustements éclairés pour améliorer les performances de ton modèle YOLO26. Pour plus de détails sur les fonctionnalités de TensorBoard, consulte le guide TensorBoard de TensorFlow.

  • Pour suivre les métriques d’entraînement avec TensorBoard pendant l’entraînement d’un modèle YOLO26, suis les étapes suivantes :

    1. Installe TensorBoard et YOLO26 : Exécute pip install ultralytics tensorboard.
    2. Active la journalisation TensorBoard : Exécute yolo settings tensorboard=True. Pendant l’entraînement, YOLO26 écrit les métriques dans le répertoire d’exécution.
    3. Démarre TensorBoard : Lance TensorBoard avec tensorboard --logdir path/to/runs en lui indiquant le répertoire d’exécution de l’entraînement (par exemple, runs/detect/train).

    Le tableau de bord TensorBoard, accessible à l’adresse localhost:6006, fournit des informations en temps réel sur différentes métriques d’entraînement. Pour approfondir les configurations d’entraînement, consulte notre guide de configuration de YOLO26.

  • Lors de l’entraînement de modèles YOLO26, TensorBoard te permet de visualiser un ensemble de métriques importantes, notamment :

    • Perte (entraînement et validation) : Indique les performances du modèle pendant l’entraînement et la validation.
    • Précision/Précision positive/Rappel : indicateurs de performance clés pour évaluer la précision de la détection.
    • Taux d’apprentissage : Suis les variations du taux d’apprentissage pour comprendre leur impact sur la dynamique de l’entraînement.
    • mAP (moyenne de la précision moyenne) : Permet d’évaluer de manière complète la précision de la détection d’objets à différents seuils d’IoU.

    Ces visualisations sont essentielles pour suivre les performances du modèle et effectuer les optimisations nécessaires. Pour en savoir plus sur ces métriques, consulte notre guide des métriques de performance.

  • Oui, tu peux utiliser TensorBoard dans un environnement Google Colab pour entraîner des modèles YOLO26. Voici une configuration rapide :

    Configurer TensorBoard pour Google Colab
    %load_ext tensorboard
    %tensorboard --logdir path/to/runs

    Ensuite, exécute le script d’entraînement YOLO26 :

    from ultralytics import YOLO
    
    # Charger un modèle préentraîné
    model = YOLO("yolo26n.pt")
    
    # Entraîner le modèle
    results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

    TensorBoard visualise la progression de l’entraînement dans Colab et fournit des informations en temps réel sur des indicateurs comme la fonction de perte et la précision.

Commentaires6

Pose une question, partage tes résultats ou aide quelqu’un d’autre.

  1. HoseinHashemiGitHub

    I found enabling tensorboard from within the YOLO training script more comfortable reducing CLI commands.

    from ultralytics import settings
    settings.update({"tensorboard": True})
    1. Glenn JocherUltralytics

      Yes, that’s supported—settings.update({"tensorboard": True}) is a nice way to enable logging from Python (it persists in your Ultralytics settings across runs), and you can disable it later with settings.update({"tensorboard": False}); details on where logs are written and how to view them are in the TensorBoard integration guide (feel free to drop any follow-up questions here so the team can see them).

    1. Glenn JocherUltralytics(modifié)

      @ruslanraupoff to forward TensorBoard from Docker, map the port using -p 6006:6006 when running your container and start TensorBoard with tensorboard --logdir /path/to/runs. Yes, you can use YOLO CLI for training; enable TensorBoard logging once with yolo settings tensorboard=True and the logs are saved in the run directory under runs/ for TensorBoard visualization. See our Docker Quickstart for setup details.

      1
    1. Glenn JocherUltralytics(modifié)

      @lauravchrobak hi there!

      Thank you for pointing that out. It seems like the code snippet got truncated. Here's the complete usage example for integrating YOLO26 with TensorBoard. First enable the setting once:

      yolo settings tensorboard=True
      from ultralytics import YOLO
      
      # Load a pre-trained model
      model = YOLO("yolo26n.pt")
      
      # Train the model
      results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

      After starting the training code, start TensorBoard on the run directory printed in the log to visualize the training metrics:

      tensorboard --logdir runs/detect/train

      You can then access the TensorBoard dashboard at http://localhost:6006/ to monitor your training progress in real-time.

      For more detailed guidance, you can visit our TensorBoard integration documentation.

      If you encounter any issues, please ensure you are using the latest version of the Ultralytics package. If the problem persists, providing a minimum reproducible example would be very helpful. You can find more information on how to create one here.

      Happy training! 🚀