Dépannage des problèmes courants avec YOLO

Introduction

Ce guide sert d'aide complète pour résoudre les problèmes courants rencontrés lors de l'utilisation de YOLO26 dans tes projets Ultralytics. Naviguer à travers ces problèmes peut être un jeu d'enfant avec les bons conseils, garantissant que tes projets restent sur la bonne voie sans retards inutiles.

Problèmes courants

Erreurs d'installation

Les erreurs d'installation peuvent survenir pour diverses raisons, telles que des versions incompatibles, des dépendances manquantes ou des configurations d'environnement incorrectes. D'abord, vérifie que tu fais bien ce qui suit :

• Tu utilises Python 3.8 ou une version ultérieure, comme recommandé.
• Assure-toi d'avoir installé la bonne version de PyTorch (1.8 ou ultérieure).
• Envisage d'utiliser des environnements virtuels pour éviter les conflits.
• Suis le guide d'installation officiel étape par étape.

De plus, voici quelques problèmes d'installation courants rencontrés par les utilisateurs, accompagnés de leurs solutions respectives :

• Erreurs d'importation ou problèmes de dépendances - Si tu obtiens des erreurs lors de l'importation de YOLO26, ou si tu rencontres des problèmes liés aux dépendances, envisage les étapes de dépannage suivantes :

  • Installation propre : Parfois, commencer par une nouvelle installation peut résoudre des problèmes inattendus. Surtout avec des bibliothèques comme Ultralytics, où les mises à jour peuvent introduire des changements dans la structure de l'arborescence des fichiers ou dans les fonctionnalités.

  • Mise à jour régulière : Assure-toi d'utiliser la dernière version de la bibliothèque. Les anciennes versions peuvent ne pas être compatibles avec les récentes mises à jour, ce qui pourrait entraîner des conflits ou des problèmes potentiels.

  • Vérification des dépendances : Vérifie que toutes les dépendances requises sont correctement installées et qu'elles sont dans les versions compatibles.

  • Examen des changements : Si tu as initialement cloné ou installé une version antérieure, sois conscient que des mises à jour importantes peuvent affecter la structure ou les fonctionnalités de la bibliothèque. Référe-toi toujours à la documentation officielle ou aux journaux de modifications pour comprendre les changements majeurs.

  • N'oublie pas que garder tes bibliothèques et tes dépendances à jour est crucial pour une expérience fluide et sans erreur.

• Exécuter YOLO26 sur GPU - Si tu as du mal à exécuter YOLO26 sur GPU, considère les étapes de dépannage suivantes :

  • Vérifier la compatibilité et l'installation de CUDA : Assure-toi que ton GPU est compatible avec CUDA et que CUDA est correctement installé. Utilise la commande nvidia-smi pour vérifier le statut de ton GPU NVIDIA et la version de CUDA.

  • Vérifier l'intégration de PyTorch et CUDA : Assure-toi que PyTorch peut utiliser CUDA en exécutant import torch; print(torch.cuda.is_available()) dans un terminal Python. S'il renvoie 'True', PyTorch est configuré pour utiliser CUDA.

  • Vérifier la compatibilité du GPU : La prise en charge des architectures GPU antérieures à Turing et une capacité de calcul (SM) < 7.5 a été abandonnée depuis cuDNN 9.11.0. Donc, si tu as un GPU plus ancien - comme une 1080Ti - tu devras peut-être utiliser une version de PyTorch construite avec une ancienne version de CUDA/cuDNN. Tu peux vérifier cela en exécutant 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}")

  • Activation de l'environnement : Assure-toi d'être dans l'environnement correct où tous les packages nécessaires sont installés.

  • Mettre à jour tes packages : Des packages obsolètes peuvent ne pas être compatibles avec ton GPU. Garde-les à jour.

  • Configuration du programme : Vérifie si le programme ou le code spécifie l'utilisation du GPU. Dans YOLO26, cela peut se trouver dans les paramètres ou la configuration.

Problèmes d'entraînement de modèle

Cette section abordera les problèmes courants rencontrés lors de l'entraînement ainsi que leurs explications et solutions respectives.

Vérification des paramètres de configuration

Problème : Tu n'es pas sûr que les paramètres de configuration dans le fichier .yaml soient appliqués correctement lors de 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 ces étapes :

• Confirme que le chemin vers ton fichier de configuration .yaml est correct.

• Assure-toi de passer le chemin vers ton fichier .yaml en tant qu'argument data lors de l'appel de 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 souhaites accélérer le processus en utilisant plusieurs GPU.

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

• Assure-toi d'avoir plusieurs GPU disponibles.

• Modifie ton fichier de configuration .yaml pour spécifier le nombre de GPU à utiliser, par exemple gpus: 4.

• Augmente la taille de lot en conséquence pour utiliser pleinement les multiples 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)

Paramètres de surveillance continue

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

Solution : Bien que la perte soit une métrique cruciale à surveiller, il est également essentiel de suivre d'autres métriques pour l'optimisation des performances du modèle. Voici quelques métriques clés à surveiller pendant l'entraînement :

• Précision
• Recall
• Précision Moyenne (mAP)

Tu peux accéder à ces métriques depuis les journaux d'entraînement ou en utilisant des outils comme TensorBoard ou wandb pour la visualisation. Implémenter l'arrêt précoce (early stopping) basé sur ces métriques peut t'aider à obtenir de meilleurs résultats.

Outils pour suivre 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 choix populaire pour visualiser les métriques d'entraînement, y compris la perte, la précision, et plus encore. Tu peux l'intégrer avec ton processus d'entraînement YOLO26.
• Comet : Comet fournit une boîte à outils étendue pour le suivi et la comparaison d'expériences. Il te permet de suivre les métriques, les hyperparamètres et même les poids du modèle. L'intégration avec les modèles YOLO est également simple, te fournissant un aperçu complet de ton cycle d'expérience.
• Ultralytics Platform: Ultralytics Platform offers a specialized environment for tracking YOLO models, giving you a one-stop platform to manage metrics, datasets, and even collaborate with your team. Given its tailored focus on YOLO, it offers more customized tracking options.

Chacun de ces outils offre son propre ensemble d'avantages, tu voudras peut-être prendre en compte les besoins spécifiques de ton projet lors de ton choix.

Comment vérifier si l'entraînement se déroule sur le GPU

Problème : La valeur 'device' dans les journaux d'entraînement est 'null', et tu n'es pas sûr si l'entraînement se déroule sur le GPU.

Solution : Une valeur 'device' à 'null' signifie généralement que le processus d'entraînement est configuré pour utiliser automatiquement un GPU disponible, ce qui est le comportement par défaut. Pour t'assurer que l'entraînement se produit sur un GPU spécifique, tu peux définir manuellement la valeur 'device' sur l'index du GPU (par exemple, '0' pour le premier GPU) dans ton fichier de configuration .yaml :

device: 0

Cela assignera explicitement le processus d'entraînement au GPU spécifié. Si tu souhaites entraîner sur le CPU, règle 'device' sur 'cpu'.

Garde un œil sur le dossier 'runs' pour les journaux et les métriques afin de surveiller efficacement la progression de l'entraînement.

Considérations clés pour un entraînement de modèle efficace

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 fondation de tout modèle d'apprentissage automatique repose sur 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 ses étiquettes associées respectent le format attendu. Il est crucial de vérifier que les annotations sont précises et de haute qualité. Des annotations incorrectes ou médiocres peuvent faire dérailler le processus d'apprentissage du modèle, conduisant à des résultats imprévisibles.

Convergence du modèle

• Importance : Atteindre la convergence du modèle garantit que celui-ci a suffisamment appris à partir des données d'entraînement.
• Recommandation : Lors de l'entraînement d'un modèle 'à partir de zéro' (from scratch), il est vital de s'assurer que le modèle atteint un niveau satisfaisant de convergence. Cela pourrait nécessiter une durée d'entraînement plus longue, avec plus d'époques, par rapport à un réglage fin (fine-tuning) d'un modèle existant.

Taux d'apprentissage et taille de lot

• Importance : Ces hyperparamètres jouent un rôle pivot dans la détermination de 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 de lot choisis sont optimaux pour ton jeu de données spécifique. Des paramètres qui ne sont pas en harmonie avec les caractéristiques du jeu de données peuvent entraver la performance du modèle.

Distribution des classes

• Importance : La distribution des classes dans ton jeu de données peut influencer les tendances de prédiction du modèle.
• Recommandation : Évalue régulièrement la distribution des classes au sein de ton jeu de données. S'il y a un déséquilibre de classes, il y a un risque que le modèle développe un biais envers la classe la plus fréquente. Ce biais peut être visible dans la matrice de confusion, où le modèle pourrait prédire principalement la classe majoritaire.

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

• Importance : Tirer parti de poids pré-entraînés peut fournir un point de départ solide pour l'entraînement du modèle, surtout lorsque les données sont limitées.
• Recommandation : En tant qu'étape diagnostique, envisage d'entraîner ton modèle en utilisant les mêmes données mais en l'initialisant avec des poids pré-entraînés. Si cette approche donne une matrice de confusion bien formée, cela pourrait suggérer que le modèle 'à partir de zéro' pourrait nécessiter un entraînement supplémentaire ou des ajustements.

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

Cette section abordera les problèmes courants rencontrés lors de la prédiction du modèle.

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 YOLO26 personnalisé, il y a des défis avec le format et la visualisation des coordonnées des boîtes englobantes.

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 (allant de 0 à 1), tu dois diviser par les dimensions de l'image. Par exemple, disons que la taille de ton image est de 640x640. Alors, tu ferais ce qui 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 de fichier : Pour obtenir le nom de fichier de l'image sur laquelle tu fais des prédictions, accède au chemin du fichier image directement depuis l'objet résultat dans ta boucle de prédiction.

Filtrer les objets dans les prédictions YOLO26

Problème : Faire face à des problèmes sur la façon de filtrer et d'afficher uniquement des objets spécifiques dans les résultats de prédiction lors de l'exécution de YOLO26 en utilisant la bibliothèque Ultralytics.

Solution : Pour détecter des classes spécifiques, utilise l'argument classes pour spécifier les classes que tu veux inclure dans la sortie. Par exemple, pour détecter uniquement les voitures (en supposant que 'voitures' ont l'index de classe 2) :

yolo task=detect mode=segment 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 concernant la différence entre la précision de la boîte, la précision du masque et la précision de la matrice de confusion dans YOLO26.

Solution : La précision de la boîte mesure la précision des boîtes englobantes prédites par rapport aux boîtes de vérité terrain réelles en utilisant l'IoU (Intersection sur Union) comme métrique. La précision du masque évalue l'accord entre les masques de segmentation prédits et les masques de vérité terrain dans la classification d'objets au niveau des pixels. La précision de la matrice de confusion, en revanche, se concentre sur la précision globale de classification à travers toutes les classes et ne prend pas en compte la précision géométrique des prédictions. Il est important de noter qu'une boîte englobante peut être géométriquement précise (vrai positif) même si la prédiction de classe est erronée, menant à des différences entre la précision de la boîte et la précision de la matrice de confusion. Ces métriques évaluent des aspects distincts de la performance d'un modèle, reflétant le besoin de différentes métriques d'évaluation dans diverses 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, surtout 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. Ensuite, extrais les informations de largeur et de hauteur des boîtes englobantes 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}")

Défis de déploiement

Problèmes de déploiement GPU

Problème : Déployer des modèles dans un environnement multi-GPU peut parfois mener à des comportements inattendus comme une utilisation mémoire imprévue, des résultats incohérents à travers les GPU, etc.

Solution : Vérifie l'initialisation par défaut du GPU. Certains frameworks, comme PyTorch, pourraient initialiser les opérations CUDA sur un GPU par défaut avant de passer aux GPU désignés. Pour contourner les initialisations par défaut inattendues, spécifie le GPU directement lors du déploiement et de la prédiction. Ensuite, utilise des outils pour surveiller l'utilisation du GPU et la consommation mémoire afin d'identifier toute anomalie en temps réel. Assure-toi également que tu utilises la dernière version du framework ou de la bibliothèque.

Problèmes de conversion/exportation de modèle

Problème : Pendant le processus de conversion ou d'exportation de modèles d'apprentissage automatique vers différents formats ou plateformes, les utilisateurs peuvent rencontrer des erreurs ou des comportements inattendus.

Solution :

• Vérification de compatibilité : Assure-toi que tu utilises des versions de bibliothèques et de frameworks compatibles entre elles. Des versions dépareillées peuvent mener à des erreurs inattendues pendant la conversion.
• Réinitialisation de l'environnement : Si tu utilises un environnement interactif comme Jupyter ou Colab, envisage de redémarrer ton environnement après avoir effectué des changements ou des installations significatifs. Un nouveau départ peut parfois résoudre des problèmes sous-jacents.
• Documentation officielle : Référe-toi toujours à la documentation officielle de l'outil ou de la bibliothèque que tu utilises pour la conversion. Elle contient souvent des directives spécifiques et les meilleures pratiques pour l'exportation de modèles.
• Support communautaire : Vérifie le dépôt officiel de la bibliothèque ou du framework pour des problèmes similaires signalés par d'autres utilisateurs. Les mainteneurs ou la communauté pourraient avoir fourni des solutions ou des alternatives dans les fils de discussion.
• Mise à jour régulière : 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 bugs connus ou améliorent la fonctionnalité.
• Tester progressivement : Avant d'effectuer une conversion complète, teste le processus avec un modèle ou un jeu de données plus petit pour identifier les problèmes potentiels dès le début.

Communauté et support

S'engager avec une communauté d'individus partageant les mêmes idées peut considérablement améliorer ton expérience et ton succès dans le travail avec YOLO26. Voici ci-dessous quelques canaux et ressources que tu pourrais trouver utiles.

Forums et canaux pour obtenir de l'aide

GitHub Issues : Le dépôt YOLO26 sur GitHub possède un onglet Issues 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 possède un serveur Discord où tu peux interagir avec d'autres utilisateurs et les développeurs.

Documentation officielle et ressources

Documentation YOLO26 d'Ultralytics : La documentation officielle fournit un aperçu complet de YOLO26, ainsi que des guides sur l'installation, l'utilisation et le dépannage.

Ces ressources devraient te fournir une base solide pour dépanner et améliorer tes projets YOLO26, ainsi que pour te connecter avec d'autres membres de la communauté YOLO26.

Conclusion

Le dépannage est une partie intégrante de tout processus de développement, et être équipé des bonnes connaissances peut réduire considérablement le temps et les efforts consacrés à la résolution des problèmes. Ce guide visait à aborder les défis les plus courants rencontrés par les utilisateurs du modèle YOLO26 au sein de l'écosystème Ultralytics. En comprenant et en traitant ces problèmes courants, tu peux assurer une progression de projet plus fluide et obtenir de meilleurs résultats avec tes tâches de computer vision.

N'oublie pas que la communauté Ultralytics est une ressource précieuse. Échanger avec d'autres développeurs et experts peut fournir des perspectives et des solutions supplémentaires qui pourraient ne pas être couvertes dans la documentation standard. Continue toujours à apprendre, à expérimenter et à partager tes expériences pour contribuer au savoir collectif de la communauté.

FAQ

Comment puis-je résoudre les erreurs d'installation avec YOLO26 ?

Les erreurs d'installation sont souvent dues à des problèmes de compatibilité ou à des dépendances manquantes. Assure-toi d'utiliser Python 3.8 ou une version ultérieure et d'avoir PyTorch 1.8 ou une version ultérieure installée. Il est avantageux d'utiliser des environnements virtuels pour éviter les conflits. Pour un guide d'installation étape par étape, suis notre guide d'installation officiel. Si tu rencontres des erreurs d'importation, essaie une nouvelle installation ou mets à jour la bibliothèque vers la dernière version.

Pourquoi mon entraînement de modèle YOLO26 est-il lent sur un seul GPU ?

L'entraînement sur un seul GPU peut être lent en raison de tailles de lots importantes ou d'une mémoire insuffisante. Pour accélérer l'entraînement, utilise plusieurs GPU. Assure-toi que ton système dispose de plusieurs GPU disponibles et ajuste ton fichier de configuration .yaml pour spécifier le nombre de GPU, par exemple gpus: 4. Augmente la taille du lot en conséquence pour utiliser pleinement les GPU sans dépasser les limites de mémoire. Exemple de commande :

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

Comment puis-je m'assurer que mon modèle YOLO26 s'entraîne sur le GPU ?

Si la valeur 'device' affiche 'null' dans les journaux d'entraînement, cela signifie généralement que le processus d'entraînement est configuré pour utiliser automatiquement un GPU disponible. Pour assigner explicitement un GPU spécifique, définis la valeur 'device' dans ton fichier de configuration .yaml. Par exemple :

device: 0

Cela règle le processus d'entraînement sur le premier GPU. Consulte la commande nvidia-smi pour confirmer ta configuration CUDA.

Comment puis-je surveiller et suivre la progression de l'entraînement de mon modèle YOLO26 ?

Le suivi et la visualisation de la progression de l'entraînement peuvent être gérés efficacement via des outils comme TensorBoard, Comet et Ultralytics Platform. Ces outils te permettent d'enregistrer et de visualiser des métriques telles que la perte, la precision, le recall et le mAP. Mettre en œuvre l'early stopping basé sur ces métriques peut également t'aider à obtenir de meilleurs résultats d'entraînement.

Que dois-je faire si YOLO26 ne reconnaît pas le format de mon jeu de données ?

Assure-toi que ton jeu de données et tes étiquettes sont conformes au format attendu. Vérifie que les annotations sont précises et de haute qualité. Si tu rencontres des problèmes, reporte-toi au guide Data Collection and Annotation pour les meilleures pratiques. Pour des conseils plus spécifiques au jeu de données, consulte la section Datasets dans la documentation.