Résolution des problèmes courants de YOLO#

Ce guide couvre les problèmes les plus fréquents que tu rencontreras avec Ultralytics YOLO26, classés selon l’étape concernée : installation, entraînement du modèle, prédiction et déploiement. Va directement à la catégorie correspondant à ton erreur ou consulte la FAQ pour obtenir des réponses rapides. Chaque entrée décrit le problème et propose un correctif concret que tu peux appliquer directement.

Problèmes courants#

Erreurs d’installation#

Les erreurs d’installation peuvent avoir différentes causes, comme des versions incompatibles, des dépendances manquantes ou une configuration incorrecte de l’environnement. Commence par vérifier les points suivants :

• Tu utilises Python 3.8 ou une version ultérieure, comme recommandé.
• Vérifie que tu as installé la bonne version de PyTorch (1.8 ou ultérieure).
• Envisage d’utiliser des environnements virtuels pour éviter les conflits.
• Suis étape par étape le guide officiel d’installation.

Voici également des solutions aux problèmes d’installation courants.

Erreurs d’importation ou problèmes de dépendances#

Si tu obtiens des erreurs en important YOLO26 ou si tu rencontres des conflits de dépendances, essaie les étapes suivantes :

• Nouvelle installation : repartir d’une installation propre peut résoudre des problèmes inattendus, surtout après des mises à jour qui modifient la structure ou les fonctionnalités du paquet.
• Mises à jour régulières : utilise la dernière version de la bibliothèque, car les versions plus anciennes peuvent être incompatibles avec les mises à jour récentes.
• Vérification des dépendances : vérifie que toutes les dépendances requises sont correctement installées et que leurs versions sont compatibles.
• Examen des modifications : si tu as installé une ancienne version, consulte la documentation officielle ou le journal des modifications pour comprendre les changements majeurs de structure.

Exécuter YOLO26 sur un GPU#

Si tu as du mal à exécuter YOLO26 sur un GPU, essaie les étapes de dépannage suivantes :

• Vérifier la compatibilité et l’installation de CUDA : vérifie que ton GPU est compatible avec CUDA et que CUDA est correctement installé. Utilise la commande nvidia-smi pour vérifier l’état de ton GPU NVIDIA et la version de CUDA.
• Vérifier l’intégration de PyTorch et CUDA : vérifie que PyTorch peut utiliser CUDA en exécutant import torch; print(torch.cuda.is_available()) dans un terminal Python. Si la commande renvoie 'True', PyTorch est configuré pour utiliser CUDA.
• Activation de l’environnement : vérifie que tu te trouves dans le bon environnement, où tous les paquets nécessaires sont installés.
• Mettre à jour tes paquets : les paquets obsolètes peuvent être incompatibles avec ton GPU. Garde-les à jour.
• Configuration du programme : vérifie que ton code demande l’utilisation du GPU. Tu peux définir l’argument device lors de l’entraînement ou de la prédiction (par exemple, device=0).

import torch

cap = torch.cuda.get_device_capability(0) if torch.cuda.is_available() else (0, 0)
cudnn = torch.backends.cudnn.version() or 0
ok = "not compatible" if cudnn >= 91100 and (cap[0] < 7 or (cap[0] == 7 and cap[1] < 5)) else "should be ok"
print(f"Compute capability: SM {cap[0]}.{cap[1]}, cuDNN: {cudnn} => {ok}")

Problèmes d’entraînement du modèle#

Les problèmes d’entraînement courants et leurs correctifs sont présentés ci-dessous.

Vérification des paramètres de configuration#

Problème : tu ne sais pas si les paramètres de configuration du fichier .yaml sont correctement appliqués pendant l’entraînement du modèle.

Solution : les paramètres du jeu de données et ceux de l’entraînement se trouvent dans des fichiers .yaml différents et sont transmis par des arguments différents de model.train(). Pour vérifier que ces paramètres sont correctement appliqués, suis ces étapes :

• Vérifie que les chemins d’accès à tes fichiers .yaml sont corrects.

• Transmets le fichier .yaml de ton jeu de données (chemins, noms de classes, divisions) avec l’argument data, et un fichier .yaml personnalisé pour les paramètres d’entraînement (par exemple epochs ou lr0) avec l’argument cfg. Les arguments transmis directement à model.train() sont prioritaires par rapport aux deux autres :

  model.train(data="/path/to/your/data.yaml", cfg="/path/to/your/cfg.yaml", batch=4)

Accélérer l’entraînement avec plusieurs GPU#

Problème : l’entraînement est lent sur un seul GPU et tu souhaites l’accélérer en utilisant plusieurs GPU.

Solution : augmenter la taille du lot peut accélérer l’entraînement, mais il est essentiel de tenir compte de la capacité mémoire du GPU. Pour accélérer l’entraînement avec plusieurs GPU, suis ces étapes :

• Vérifie que tu disposes de plusieurs GPU.

• Définis l’argument device sur une liste d’indices de GPU, par exemple device=[0,1,2,3].

• Augmente la taille du lot en conséquence pour utiliser pleinement les différents GPU sans dépasser les limites de mémoire.

• Modifie ta commande d’entraînement pour utiliser plusieurs GPU :

  # Ajuste la taille du lot et les autres paramètres au besoin pour optimiser la vitesse d’entraînement
  model.train(data="/path/to/your/data.yaml", batch=32, device=[0, 1, 2, 3])

Paramètres à surveiller en continu#

Problème : tu souhaites savoir quels paramètres surveiller en continu pendant l’entraînement, en plus de la perte.

Solution : même si la perte est une métrique essentielle à surveiller, il est également important de suivre d’autres métriques pour optimiser les performances du modèle. Voici quelques métriques clés à surveiller pendant l’entraînement :

• Précision
• Rappel
• Précision moyenne (mAP)

Tu peux consulter ces métriques dans les journaux d’entraînement ou utiliser des outils comme TensorBoard ou Weights & Biases pour les visualiser. Un arrêt anticipé fondé sur ces métriques peut t’aider à obtenir de meilleurs résultats.

Outils de suivi de la progression de l’entraînement#

Problème : tu cherches des recommandations d’outils pour suivre la progression de l’entraînement.

Solution : pour suivre et visualiser la progression de l’entraînement, tu peux envisager d’utiliser les outils suivants :

• TensorBoard : TensorBoard est un outil populaire pour visualiser les métriques d’entraînement, notamment la perte, la précision et bien d’autres. Tu peux l’intégrer à ton processus d’entraînement YOLO26.
• Comet : Comet propose une vaste boîte à outils pour le suivi et la comparaison des expériences. Cet outil te permet de suivre les métriques, les hyperparamètres et même les poids du modèle. L’intégration aux modèles YOLO est également simple et te donne une vue d’ensemble complète du cycle de tes expériences.
• Plateforme Ultralytics : la plateforme Ultralytics offre un environnement spécialisé pour le suivi des modèles YOLO, avec une plateforme unique pour gérer les métriques, les jeux de données et même collaborer avec ton équipe. Conçue spécialement pour YOLO, elle propose des options de suivi plus personnalisées.

Comment vérifier si l’entraînement s’effectue sur le GPU#

Problème : la valeur de 'device' dans les journaux d’entraînement est 'null' et tu ne sais pas si l’entraînement s’effectue sur le GPU.

Solution : la valeur 'null' de 'device' signifie généralement que le processus d’entraînement est configuré pour sélectionner automatiquement un GPU disponible, ce qui est le comportement par défaut. Pour entraîner le modèle sur un GPU spécifique, définis l’argument device au démarrage de l’entraînement. device est un argument d’entraînement ; le définir dans le fichier .yaml de ton jeu de données n’aura donc aucun effet :

from ultralytics import YOLO

# Charger un modèle
model = YOLO("yolo26n.pt")

# Utilise le GPU 0 ; device=[0, 1] pour plusieurs GPU, device="cpu" pour le CPU
model.train(data="path/to/data.yaml", device=0)

Surveille le dossier 'runs' pour consulter les journaux et les métriques et suivre efficacement la progression de l’entraînement.

Points clés pour un entraînement efficace du modèle#

Voici quelques points à garder à l’esprit si tu rencontres des problèmes liés à l’entraînement du modèle.

Format du jeu de données et étiquettes

• Importance : la base de tout modèle d’apprentissage automatique repose sur la qualité et le format des données utilisées pour l’entraîner.
• Recommandation : vérifie que ton jeu de données personnalisé et les étiquettes associées respectent le format attendu. Il est essentiel de vérifier que les annotations sont exactes et de grande qualité. Des annotations incorrectes ou médiocres peuvent perturber le processus d’apprentissage du modèle et entraîner des résultats imprévisibles.

Convergence du modèle

• Importance : obtenir la convergence du modèle garantit que celui-ci a suffisamment appris à partir des données d’entraînement.
• Recommandation : lorsque tu entraînes un modèle « à partir de zéro », il est essentiel de veiller à ce qu’il atteigne un niveau de convergence satisfaisant. Cela peut nécessiter une durée d’entraînement plus longue, avec davantage d’époques, que lors de l’ajustement fin d’un modèle existant.

Taux d’apprentissage et taille du lot

• Importance : ces hyperparamètres jouent un rôle déterminant dans la manière dont le modèle met à jour ses poids pendant l’entraînement.
• Recommandation : évalue régulièrement si le taux d’apprentissage et la taille du lot choisis sont optimaux pour ton jeu de données. Des paramètres qui ne sont pas adaptés aux caractéristiques du jeu de données peuvent nuire aux performances du modèle.

Répartition des classes

• Importance : la répartition des classes dans ton jeu de données peut influencer les tendances du modèle en matière de prédiction.
• Recommandation : évalue régulièrement la répartition des classes dans ton jeu de données. En cas de déséquilibre entre les classes, le modèle risque de favoriser la classe la plus représentée. Ce biais peut apparaître dans la matrice de confusion, où le modèle risque de prédire principalement la classe majoritaire.

Vérification croisée avec des poids préentraînés

• Importance : L’utilisation de poids préentraînés peut fournir une base solide pour l’entraînement d’un modèle, en particulier lorsque les données sont limitées.
• Recommandation : À titre de diagnostic, envisage d’entraîner ton modèle avec les mêmes données, mais en l’initialisant avec des poids préentraînés. Si cette approche produit une matrice de confusion bien formée, cela peut indiquer que le modèle entraîné « from scratch » nécessite un entraînement supplémentaire ou des ajustements.

Problèmes liés aux prédictions du modèle#

Les problèmes courants rencontrés lors des prédictions du modèle et leurs solutions sont présentés ci-dessous.

Obtenir des prédictions de boîtes englobantes avec ton modèle personnalisé YOLO26#

Problème : Lors de l’exécution de prédictions avec un modèle personnalisé YOLO26, le format et la visualisation des coordonnées des boîtes englobantes posent problème.

Solution :

• Format des coordonnées : YOLO26 fournit les coordonnées des boîtes englobantes en valeurs de pixels absolues. Pour les convertir en coordonnées relatives (comprises entre 0 et 1), divise-les par les dimensions de l’image. Par exemple, supposons que ton image mesure 640x640. Tu procéderais alors ainsi :

  # Convertis les coordonnées absolues en coordonnées relatives
  x1 = x1 / 640  # Divise les coordonnées x par la largeur de l’image
  x2 = x2 / 640
  y1 = y1 / 640  # Divise les coordonnées y par la hauteur de l’image
  y2 = y2 / 640

• Nom du fichier : Pour obtenir le nom du fichier de l’image sur laquelle tu effectues une prédiction, lis le chemin du fichier image dans l’attribut path de chaque objet de résultat (par exemple result.path) dans ta boucle de prédiction.

Filtrer les objets dans les prédictions YOLO26#

Problème : Tu rencontres des difficultés pour filtrer et afficher uniquement des objets spécifiques dans les résultats de prédiction lors de l’exécution de YOLO26 avec la bibliothèque Ultralytics.

Solution : Pour détecter des classes spécifiques, utilise l’argument classes afin de préciser les classes à inclure dans la sortie. Par exemple, pour détecter uniquement les voitures (en supposant que « voitures » correspond à l’indice de classe 2) :

yolo segment predict model=yolo26n-seg.pt source='path/to/car.mp4' show=True classes=2

Comprendre les métriques de précision dans YOLO26#

Problème : Confusion quant à la différence entre la précision des boîtes, la précision des masques et la précision de la matrice de confusion dans YOLO26.

Solution : La précision des boîtes mesure l’exactitude des boîtes englobantes prédites par rapport aux boîtes de vérité terrain, en utilisant l’IoU (intersection sur union) comme métrique. La précision des masques évalue la concordance entre les masques de segmentation prédits et les masques de vérité terrain pour la classification des objets pixel par pixel. La précision de la matrice de confusion, quant à elle, porte sur l’exactitude globale de la classification pour toutes les classes et ne tient pas compte de l’exactitude géométrique des prédictions. Il est important de noter qu’une boîte englobante peut être géométriquement exacte (vrai positif), même si la classe prédite est incorrecte, ce qui entraîne des différences entre la précision des boîtes et celle de la matrice de confusion. Ces métriques évaluent différents aspects des performances d’un modèle, ce qui montre la nécessité de métriques d’évaluation différentes selon les tâches.

Extraire les dimensions des objets dans YOLO26#

Problème : Difficulté à récupérer la longueur et la hauteur des objets détectés dans YOLO26, en particulier lorsque plusieurs objets sont détectés dans une image.

Solution : Pour récupérer les dimensions des boîtes englobantes, utilise d’abord le modèle Ultralytics YOLO26 pour prédire les objets dans une image. Extrais ensuite la largeur et la hauteur des boîtes englobantes à partir des résultats de prédiction.

from ultralytics import YOLO

# Load a pretrained YOLO26 model
model = YOLO("yolo26n.pt")

# Specify the source image
source = "https://ultralytics.com/images/bus.jpg"

# Make predictions
results = model.predict(source, save=True, imgsz=320, conf=0.25)

# Extract bounding box dimensions
boxes = results[0].boxes.xywh.cpu()
for box in boxes:
    x, y, w, h = box
    print(f"Width of Box: {w}, Height of Box: {h}")

Difficultés liées au déploiement#

Problèmes de déploiement sur GPU#

Problème : Le déploiement de modèles dans un environnement multi-GPU peut parfois entraîner des comportements inattendus, comme une utilisation imprévue de la mémoire ou des résultats incohérents d’un GPU à l’autre.

Solution : Vérifie l’initialisation du GPU par défaut. Certains frameworks, comme PyTorch, peuvent initialiser les opérations CUDA sur un GPU par défaut avant de passer aux GPU désignés. Pour éviter ces initialisations par défaut inattendues, spécifie directement le GPU lors du déploiement et des prédictions. Utilise ensuite des outils pour surveiller en temps réel l’utilisation du GPU et de la mémoire afin de repérer les anomalies. Vérifie également que tu utilises la dernière version du framework ou de la bibliothèque.

Problèmes de conversion et d’exportation des modèles#

Problème : Lors de la conversion ou de l’exportation de modèles de machine learning vers différents formats ou plateformes, les utilisateurs peuvent rencontrer des erreurs ou des comportements inattendus.

Solution : Consulte les formats pris en charge et les options propres à chaque format dans la documentation du mode Export, puis passe en revue les vérifications suivantes :

• Vérification de compatibilité : Assure-toi d’utiliser des versions de bibliothèques et de frameworks compatibles entre elles. Des versions incompatibles peuvent entraîner des erreurs inattendues lors de la conversion.
• Réinitialisation de l’environnement : Si tu utilises un environnement interactif comme Jupyter ou Colab, pense à le redémarrer après des changements ou des installations importants. Un redémarrage peut parfois résoudre des problèmes sous-jacents.
• Documentation officielle : Consulte toujours la documentation officielle de l’outil ou de la bibliothèque que tu utilises pour la conversion. Elle contient souvent des consignes précises et des bonnes pratiques pour l’exportation des modèles.
• Assistance de la communauté : Consulte le dépôt officiel de la bibliothèque ou du framework pour voir si d’autres utilisateurs ont signalé des problèmes similaires. Les responsables du projet ou la communauté ont peut-être proposé des solutions ou des contournements dans des fils de discussion.
• Mises à jour régulières : Assure-toi d’utiliser la dernière version de l’outil ou de la bibliothèque. Les développeurs publient fréquemment des mises à jour qui corrigent des bogues connus ou améliorent les fonctionnalités.
• Tests progressifs : Avant d’effectuer une conversion complète, teste le processus avec un modèle ou un jeu de données plus petit afin de repérer rapidement les problèmes potentiels.

Communauté et assistance#

Obtiens de l’aide et partage des solutions sur ces canaux et dans ces ressources.

Forums et canaux d’assistance#

Problèmes GitHub : le dépôt Ultralytics sur GitHub comprend un onglet Issues où tu peux poser des questions, signaler des bogues et suggérer de nouvelles fonctionnalités. La communauté et les responsables du dépôt y sont actifs ; c'est un excellent endroit pour obtenir de l'aide sur des problèmes précis.

Serveur Discord Ultralytics : Ultralytics dispose d'un serveur Discord où tu peux échanger avec d'autres utilisateurs et les développeurs.

Documentation et ressources officielles#

Documentation Ultralytics YOLO26 : La documentation officielle offre une présentation complète de YOLO26, ainsi que des guides sur l’installation, l’utilisation et le dépannage.

Conclusion#

La plupart des problèmes liés à YOLO26 ont quelques causes récurrentes : des versions incompatibles, le formatage des jeux de données et la configuration du GPU. Si tu ne trouves pas ici la réponse à une erreur, consulte l’onglet GitHub Issues ou pose ta question sur le serveur Discord : quelqu’un a probablement déjà trouvé une solution. Pour les problèmes plus complexes liés à l’entraînement, consulte le guide Conseils pour l’entraînement des modèles, qui propose des conseils pratiques pour obtenir de meilleurs résultats dans tes projets de vision par ordinateur.

FAQ#