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

Ce guide couvre les problèmes les plus courants que tu rencontreras en travaillant avec Ultralytics YOLO26, regroupés par domaine : installation, entraînement de modèles, prédiction, et déploiement. Accède à la catégorie correspondant à ton erreur, ou parcours la FAQ pour des réponses rapides. Chaque entrée indique le problème et une solution concrète que tu peux appliquer directement.

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 les choses suivantes :

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

De plus, voici des solutions aux problèmes d'installation courants.

Link to this sectionErreurs d'importation ou problèmes de dépendances#

Si tu obtiens des erreurs lors de l'importation de YOLO26 ou si tu rencontres des conflits de dépendances, essaie ces étapes :

• Installation propre : Commencer par 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.
• Mise à jour régulière : Utilise la dernière version de la bibliothèque, car les versions plus anciennes pourraient 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 qu'elles sont dans des versions compatibles.
• Examen des changements : Si tu as installé une version plus ancienne, réfère-toi à la documentation officielle ou au journal des modifications pour comprendre tout changement structurel majeur.

Link to this sectionExécution de YOLO26 sur GPU#

Si tu as des difficultés à exécuter YOLO26 sur un 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 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 : 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.
• Activation de l'environnement : Assure-toi d'être dans le bon environnement où tous les paquets nécessaires sont installés.
• Mettre à jour tes paquets : Les paquets obsolètes peuvent ne pas être compatibles avec ton GPU. Garde-les à jour.
• Configuration du programme : Vérifie si 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}")

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

Les problèmes d'entraînement courants et leurs solutions sont abordés ci-dessous.

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 comme 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 taille de lot 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.

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

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

Link to this sectionParamètres de surveillance continue#

Problème : Tu veux savoir quels paramètres doivent être surveillés en continu pendant l'entraînement, en dehors 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
• Rappel
• Précision moyenne 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.

Link to this sectionOutils 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 à 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 des modèles. L'intégration avec les modèles YOLO est également directe, te fournissant une vue complète de ton cycle d'expérience.
• Plateforme Ultralytics : La plateforme Ultralytics 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 orientation sur mesure vers YOLO, elle offre des options de suivi plus personnalisées.

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 si l'entraînement se déroule sur le GPU.

Solution : Une valeur 'null' pour '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 sur un GPU spécifique, définis l'argument device au démarrage de l'entraînement. device est un argument d'entraînement, donc le définir dans ton .yaml de jeu de données n'a 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)

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 d'apprentissage automatique 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 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 de qualité inférieure 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 de convergence satisfaisant. 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 du lot

• Importance : Ces hyperparamètres jouent un rôle central dans la détermination de la façon 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 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 au sein de 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 envers 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 : Comme é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 'à partir de zéro' pourrait nécessiter un entraînement supplémentaire ou des ajustements.

Link to this sectionProblèmes liés aux prédictions du modèle#

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

Link to this sectionObtenir 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 du fichier : Pour obtenir le nom du 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.

Link to this sectionFiltrer les objets dans les prédictions YOLO26#

Problème : Difficultés concernant 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'indice 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 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 la précision des boîtes englobantes prédites par rapport aux boîtes réelles (ground truth) 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 réels au niveau pixel. La précision de la matrice de confusion, en revanche, se concentre sur la précision globale de la 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 fausse, ce qui entraîne des différences entre la précision des boîtes 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 métriques d'évaluation différentes pour 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 Ultralytics YOLO26 pour prédire des objets dans une image. Ensuite, extrait 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 : Déployer des modèles dans un environnement multi-GPU peut parfois conduire à des comportements inattendus comme une utilisation mémoire inhabituelle, des résultats incohérents à travers 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 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 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 : Lors du 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 : Consulte les formats pris en charge et les options par format dans la documentation du mode Exportation, puis effectue ces vérifications :

• Vérification de la 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, 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 : Consulte 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 des meilleures pratiques pour l'exportation de modèles.
• Support de la communauté : 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 contournements 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 bogues 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#

Obtiens de l'aide et partage tes solutions via ces canaux et ressources.

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 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 interagir avec d'autres utilisateurs et les développeurs.

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

Link to this sectionConclusion#

La plupart des problèmes YOLO26 remontent à quelques causes : inadéquation des versions, formatage du jeu de données et configuration du GPU. Lorsqu'une erreur n'est pas traitée ici, cherche dans l'onglet GitHub Issues ou demande sur le serveur Discord — il est probable que quelqu'un l'ait déjà résolue. Pour des problèmes plus profonds liés à l'entraînement, consulte le guide Conseils pour l'entraînement de modèles pour obtenir des conseils pratiques afin d'améliorer tes résultats dans tes projets de vision par ordinateur.

Link to this sectionFAQ#

Link to this sectionComment résoudre les erreurs d'installation avec YOLO26 ?#

Les erreurs d'installation peuvent souvent être 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 utile 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 l'entraînement de mon 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 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 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 sélectionner automatiquement un GPU disponible. Pour assigner explicitement un GPU spécifique, passe l'argument device quand tu démarres l'entraînement, par exemple yolo train data=path/to/data.yaml device=0 pour 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 la plateforme Ultralytics. Ces outils te permettent d'enregistrer et de visualiser des métriques telles que la perte, la précision, le rappel et la mAP. Mettre en œuvre un arrêt anticipé basé sur ces métriques peut également aider à obtenir de meilleurs résultats d'entraînement.

Link to this sectionQue 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, réfère-toi au guide Collecte et annotation de données pour les meilleures pratiques. Pour plus de conseils spécifiques aux jeux de données, consulte la section Jeux de données dans la documentation.