Link to this sectionDépannage des problèmes courants de YOLO#

Link to this sectionIntroduction#

Ce guide sert d'aide complète pour dépanner 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.

Link to this sectionProblèmes courants#

Link to this sectionErreurs 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. Tout 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 que les utilisateurs ont rencontrés, ainsi que 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 mises à jour récentes, ce qui entraîne 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 correspondent aux versions compatibles.

  • Examen des changements : Si tu as initialement cloné ou installé une ancienne version, 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 notes de version pour comprendre les changements majeurs.

  • N'oublie pas que maintenir 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 des difficultés à exécuter YOLO26 sur GPU, envisage les étapes de dépannage suivantes :

  • Vérifier la compatibilité et l'installation de CUDA : Assure-toi que ton GPU est compatible 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 : 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é GPU : Le support des architectures GPU antérieures à Turing et aux capacités de calcul (SM) < 7.5 a été abandonné depuis cuDNN 9.11.0. Donc, si tu as un ancien GPU - comme un 1080Ti - tu devras peut-être utiliser une version de PyTorch construite avec une ancienne version de CUDA/cuDNN. Tu peux le vérifier 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 que tu es dans le bon environnement où tous les paquets nécessaires sont installés.

  • Mettre à jour tes paquets : Des paquets 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.

Link to this sectionProblèmes d'entraînement du modèle#

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

Link to this sectionVé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 pendant l'entraînement du modèle.

Solution : Les paramètres de configuration dans le 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 à model.train(), comme indiqué ci-dessous :

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

Link to this sectionAccé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 batch size peut accélérer l'entraînement, mais il est essentiel de prendre en compte la capacité de mémoire du GPU. Pour accélérer l'entraînement avec plusieurs GPU, suis ces étapes :

• Assure-toi d'avoir plusieurs GPU disponibles.

• Règle l'argument device sur une liste d'index de GPU, par exemple device=[0,1,2,3].

• Augmente la taille du batch 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, device=[0, 1, 2, 3])

Link to this sectionParamètres de surveillance continue#

Problème : Tu souhaites 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 mesures pour l'optimisation des performances du modèle. Certaines métriques clés à surveiller pendant l'entraînement incluent :

• Précision
• Rappel
• Mean Average Precision (mAP)

Tu peux accéder à ces métriques à partir des journaux d'entraînement ou en utilisant des outils comme TensorBoard ou wandb pour la visualisation. La mise en œuvre d'un arrêt anticipé basé sur ces métriques peut t'aider à obtenir de meilleurs résultats.

Link to this sectionOutils pour suivre la progression de l'entraînement#

Problème : Tu recherches des recommandations sur des 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, l'accuracy, et plus encore. Tu peux l'intégrer à ton processus d'entraînement YOLO26.
• Comet : Comet fournit une boîte à outils étendue pour le suivi et la comparaison des 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 une vue d'ensemble complète de ton cycle d'expérience.
• Ultralytics Platform : Ultralytics Platform offre un environnement spécialisé pour le suivi des modèles YOLO, te donnant une plateforme unique pour gérer les métriques, les jeux de données et même collaborer avec ton équipe. Étant donné son focus sur YOLO, il offre des options de suivi plus personnalisées.

Chacun de ces outils offre son propre ensemble d'avantages, tu voudras donc peut-être considérer les besoins spécifiques de ton projet au moment de faire un choix.

Link to this sectionComment 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 que l'entraînement se déroule sur le GPU.

Solution : La valeur 'device' étant 'null' signifie généralement que le processus d'entraînement est réglé 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 régler 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.

Link to this sectionConsidérations clés pour un entraînement de modèle efficace#

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 de machine learning 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 le modèle 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 au réglage fin d'un modèle existant.

Taux d'apprentissage et taille du batch

• 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 du batch 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 les performances 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 dans ton jeu de données. S'il y a un déséquilibre des classes, il y a un risque que le modèle développe un biais vers la classe la plus prévalente. Ce biais peut être évident dans la matrice de confusion, où le modèle pourrait prédire de manière prédominante la classe majoritaire.

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

• Importance : Tirer parti des 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 de diagnostic, 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 'from scratch' pourrait nécessiter un entraînement supplémentaire ou des ajustements.

Link to this sectionProblè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.

Link to this sectionObtenir des prédictions de boîtes englobantes (bounding box) 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 de la boîte englobante.

Solution :

• Format des coordonnées : YOLO26 fournit des coordonnées de boîte englobante 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 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 effectues une prédiction, accède directement au chemin de fichier de l'image à partir de l'objet résultat dans ta boucle de prédiction.

Link to this sectionFiltrer 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 souhaites inclure dans la sortie. Par exemple, pour détecter uniquement les voitures (en supposant que les 'voitures' ont l'index de classe 2) :

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

Link to this sectionComprendre 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 par pixel. La précision de la matrice de confusion, quant à elle, se concentre sur l'exactitude globale de la classification sur 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, conduisant à 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.

Link to this sectionExtraire 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 de la boîte englobante, utilise d'abord le modèle YOLO26 d'Ultralytics pour prédire les objets dans une image. Ensuite, extrais les informations de largeur et de 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}")

Link to this sectionDéfis de déploiement#

Link to this sectionProblèmes de déploiement GPU#

Problème : Le déploiement de modèles dans un environnement multi-GPU peut parfois conduire à des comportements inattendus comme une utilisation de mémoire inattendue, des résultats incohérents sur les GPU, etc.

Solution : Vérifie l'initialisation par défaut du GPU. 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 contourner les initialisations par défaut inattendues, spécifie directement le GPU lors du déploiement et de la prédiction. Ensuite, utilise des outils pour surveiller l'utilisation du GPU et la consommation de mémoire afin d'identifier toute anomalie en temps réel. Assure-toi également d'utiliser la dernière version du framework ou de la bibliothèque.

Link to this sectionProblèmes de conversion/exportation de modèle#

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

Solution :

• Vérification de la compatibilité : Assure-toi d'utiliser des versions de bibliothèques et de frameworks compatibles entre elles. Des versions dépareillées 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, 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é peuvent avoir fourni des solutions ou des solutions de contournement 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é.
• Test incrémental : 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.

Link to this sectionCommunauté et support#

S'engager avec une communauté de personnes partageant les mêmes idées peut considérablement améliorer ton expérience et ton succès dans le travail avec YOLO26. Tu trouveras ci-dessous quelques canaux et ressources qui pourraient t'être utiles.

Link to this sectionForums 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 tes 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 interagir avec d'autres utilisateurs et les développeurs.

Link to this sectionDocumentation officielle et ressources#

Documentation Ultralytics YOLO26 : La documentation officielle fournit une vue d'ensemble complète 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.

Link to this sectionConclusion#

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 vise à traiter 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 plus fluide de tes projets 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 t'apporter des perspectives et des solutions supplémentaires qui ne sont pas forcément couvertes dans la documentation standard. Continue toujours à apprendre, à expérimenter et à partager tes expériences pour contribuer au savoir collectif de la communauté.

Link to this sectionFAQ#

Link to this sectionComment 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 installé PyTorch 1.8 ou une version ultérieure. 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.

Link to this sectionPourquoi 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 grandes tailles de lots (batch sizes) 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 définis l'argument device, par exemple device=[0,1,2,3]. 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, device=[0, 1, 2, 3])

Link to this sectionComment puis-je m'assurer que mon modèle YOLO26 s'entraîne bien 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 configure le processus d'entraînement sur le premier GPU. Consulte la commande nvidia-smi pour confirmer ta configuration CUDA.

Link to this sectionComment 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 (loss), la precision, le recall et le mAP. Implémenter l'early stopping basé sur ces métriques peut également t'aider à obtenir de meilleurs résultats d'entraînement.

Link to this sectionQue 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 connaître les bonnes pratiques. Pour des conseils plus spécifiques au jeu de données, consulte la section Datasets dans la documentation.