Résoudre les problèmes courants de YOLO#

Ce guide couvre les problèmes les plus courants que tu peux rencontrer avec Ultralytics YOLO26, regroupés selon l'étape où ils surviennent : installation, entraînement du modèle, prédiction et déploiement. Accède directement à la catégorie correspondant à ton erreur ou consulte la FAQ pour obtenir rapidement des réponses. Chaque entrée décrit le problème et fournit une solution concrète 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 que tu effectues les opérations suivantes :

• Tu utilises Python 3.8 ou une version ultérieure, comme recommandé.
• Vérifie que la version correcte de PyTorch (1.8 ou ultérieure) est installée.
• Envisage d'utiliser des environnements virtuels pour éviter les conflits.
• Suis pas à pas le guide d'installation officiel.

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, notamment après des mises à jour qui modifient la structure ou les fonctionnalités du paquet.
• Mise à jour régulière : utilise la dernière version de la bibliothèque, car les anciennes versions peuvent ne pas être compatibles 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 changements : si tu as installé une ancienne version, consulte la documentation officielle ou le journal des modifications pour comprendre les changements structurels majeurs.

Exécuter YOLO26 sur un GPU#

Si tu rencontres des difficultés pour 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 ta 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 l'environnement correct, où tous les paquets nécessaires sont installés.
• Mettre tes paquets à jour : les paquets obsolètes peuvent ne pas être compatibles avec ton GPU. Maintiens-les à jour.
• Configuration du programme : vérifie que ton code demande bien 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 courants d'entraînement et leurs solutions 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 de configuration du fichier .yaml doivent être appliqués lors de l'utilisation de la fonction model.train(). Pour t'assurer que ces paramètres sont correctement appliqués, suis les étapes suivantes :

• Vérifie que le chemin vers ton fichier de configuration .yaml est correct.

• Assure-toi de transmettre le chemin vers ton fichier .yaml en tant qu'argument data lors de l'appel à model.train(), comme indiqué ci-dessous :

  model.train(data="/path/to/your/data.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 veux accélérer le processus 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 les étapes suivantes :

• Vérifie que plusieurs GPU sont disponibles.

• 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 afin d'utiliser pleinement les différents GPU sans dépasser les limites de mémoire.

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

  # Adjust the batch size and other settings as needed to optimize training speed
  model.train(data="/path/to/your/data.yaml", batch=32, device=[0, 1, 2, 3])

Paramètres de suivi continu#

Problème : tu veux savoir quels paramètres doivent être surveillés en continu pendant l'entraînement, en plus de la perte.

Solution : bien que la perte soit une mesure 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 accéder à ces métriques à partir des journaux d'entraînement ou en utilisant des outils comme TensorBoard ou Weights & Biases pour la visualisation. La mise en place d'un arrêt précoce basé 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 recherches 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 très utilisé pour visualiser les métriques d'entraînement, notamment la perte, l'exactitude, etc. Tu peux l'intégrer à ton processus d'entraînement YOLO26.
• Comet : Comet fournit une boîte à outils complète pour suivre et comparer les expériences. Il te permet de suivre les métriques, les hyperparamètres et même les poids du modèle. Son intégration aux modèles YOLO est également simple et te donne une vue d'ensemble complète du cycle de ton expérience.
• Ultralytics Platform : Ultralytics Platform fournit un environnement spécialisé pour suivre les modèles YOLO et te propose une plateforme centralisée pour gérer les métriques, les jeux de données et même collaborer avec ton équipe. Grâce à son orientation dédiée à YOLO, elle offre des options de suivi plus personnalisées.

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

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

Solution : lorsque la valeur 'device' est 'null', cela signifie généralement que le processus d'entraînement est configuré pour sélectionner automatiquement un GPU disponible, ce qui correspond au 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 ton .yaml de jeu de données n'a donc aucun effet :

from ultralytics import YOLO

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

# Use GPU 0; device=[0, 1] for multiple GPUs, device="cpu" for 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 essentiels pour un entraînement efficace du modèle#

Voici quelques éléments à 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 de machine learning réside dans la qualité et le format des données sur lesquelles il est entraîné.
• Recommandation : assure-toi que ton jeu de données personnalisé et les étiquettes qui lui sont associées respectent le format attendu. Il est essentiel de vérifier que les annotations sont exactes et de haute 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 : parvenir à 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 « from scratch », il est essentiel de t'assurer qu'il atteint 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'affinage d'un modèle existant.

Taux d'apprentissage et taille du lot

• Importance : ces hyperparamètres jouent un rôle essentiel pour déterminer 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 spécifique. Des paramètres qui ne correspondent pas 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 de prédiction du modèle.
• 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 développer un biais en faveur de la classe la plus représentée. Ce biais peut apparaître dans la matrice de confusion, où le modèle peut 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 un point de départ solide pour l'entraînement du 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 « from scratch » nécessite un entraînement ou des ajustements supplémentaires.

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

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

Obtenir les prédictions des cadres englobants avec ton modèle YOLO26 personnalisé#

Problème : lors de l'exécution de prédictions avec un modèle YOLO26 personnalisé, le format et la visualisation des coordonnées des cadres englobants posent problème.

Solution :

• Format des coordonnées : YOLO26 fournit les coordonnées des cadres englobants en valeurs de pixels absolues. Pour les convertir en coordonnées relatives (comprises entre 0 et 1), tu dois les diviser par les dimensions de l'image. Par exemple, supposons que la taille de ton image soit de 640x640. Tu dois alors procéder comme suit :

  # Convert absolute coordinates to relative coordinates
  x1 = x1 / 640  # Divide x-coordinates by image width
  x2 = x2 / 640
  y1 = y1 / 640  # Divide y-coordinates by image height
  y2 = y2 / 640

• Nom du fichier : pour obtenir le nom du fichier de l'image sur laquelle tu effectues la prédiction, accède directement au chemin du fichier image depuis l'objet de résultat 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 certains objets dans les résultats de prédiction lors de l'exécution de YOLO26 avec la bibliothèque Ultralytics.

Solution : pour détecter certaines classes, utilise l'argument classes afin de spécifier les classes à inclure dans la sortie. Par exemple, pour détecter uniquement les voitures (en supposant que 'cars' possède 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 : tu ne comprends pas bien 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 cadres englobants prédits par rapport aux cadres de vérité terrain réels, 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'un cadre englobant peut être géométriquement exact (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 des aspects distincts des performances d'un modèle, ce qui reflète la nécessité de disposer de métriques d'évaluation différentes selon les tâches.

Extraire les dimensions des objets dans YOLO26#

Problème : tu as des difficultés à récupérer la longueur et la hauteur des objets détectés dans YOLO26, notamment lorsque plusieurs objets sont détectés dans une image.

Solution : pour récupérer les dimensions du cadre englobant, utilise d'abord le modèle Ultralytics YOLO26 pour prédire les objets dans une image. Extrais ensuite les informations de largeur et de hauteur des cadres englobants à 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 de 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 entre les GPU.

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 les initialisations par défaut inattendues, spécifie directement le GPU lors du déploiement et de la prédiction. Utilise ensuite des outils pour surveiller l'utilisation du GPU et de la mémoire afin d'identifier les anomalies en temps réel. Vérifie également que tu utilises la dernière version du framework ou de la bibliothèque.

Problèmes de conversion ou d'exportation du modèle#

Problème : lors de la conversion ou de l'exportation de modèles de machine learning vers différents formats ou plateformes, tu peux 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 effectue 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 provoquer des erreurs inattendues lors de la conversion.
• Réinitialisation de l'environnement : si tu utilises un environnement interactif comme Jupyter ou Colab, envisage de le redémarrer après des modifications ou installations importantes. Repartir sur une session propre 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 recommandations spécifiques 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 trouver des problèmes similaires signalés par d'autres utilisateurs. Les mainteneurs ou la communauté ont peut-être proposé des solutions ou des contournements dans les fils de discussion.
• Mettre à jour régulièrement : vérifie que tu utilises 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.
• Tester progressivement : avant d'effectuer une conversion complète, teste le processus avec un modèle ou un jeu de données plus petit afin d'identifier rapidement les problèmes potentiels.

Communauté et assistance#

Obtiens de l'aide et partage des solutions sur ces canaux et avec ces ressources.

Forums et canaux pour obtenir de l'aide#

Problèmes GitHub : Le dépôt Ultralytics sur GitHub possède un onglet Problèmes où tu peux poser des questions, signaler des bugs et suggérer de nouvelles fonctionnalités. La communauté et les mainteneurs y sont actifs, et c'est un excellent endroit pour obtenir de l'aide sur des problèmes spécifiques.

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 fournit une présentation complète de YOLO26, ainsi que des guides d'installation, d'utilisation et de résolution des problèmes.

Conclusion#

La plupart des problèmes liés à YOLO26 sont dus à quelques causes récurrentes : incompatibilités de versions, formatage du jeu de données et configuration du GPU. Lorsqu'une erreur n'est pas traitée ici, consulte l'onglet GitHub Issues ou pose ta question sur le serveur Discord : il y a de fortes chances que quelqu'un ait déjà trouvé une solution. Pour les problèmes plus approfondis liés à l'entraînement, consulte le guide Conseils pour l'entraînement des modèles afin d'obtenir des conseils pratiques pour améliorer les résultats de tes projets de vision par ordinateur.

FAQ#