Commencer

Résolution des problèmes courants de YOLO

YOLO common training and deployment issues

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.



À regarder : Problèmes courants avec Ultralytics YOLO26 | Erreurs d’installation, problèmes d’entraînement du modèle

Problèmes courants#

Erreurs d’installation#

Des erreurs d’installation peuvent survenir pour diverses raisons, notamment 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.
  • Tu as installé une version compatible de PyTorch (1.8 ou ultérieure).
  • Tu utilises un environnement virtuel pour éviter les conflits.
  • Suis étape par étape le guide officiel d’installation.

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

Garde Ultralytics et ses dépendances à jour

De nombreuses erreurs d’importation, liées au GPU ou à l’exportation se résolvent simplement en effectuant une mise à niveau. Exécute pip install -U ultralytics et vérifie que tes versions de PyTorch et de CUDA sont compatibles avant de pousser le débogage plus loin.

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 : assure-toi 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).
Anciens GPU et cuDNN 9.11.0+

La prise en charge des architectures GPU antérieures à Turing — capacité de calcul (SM) inférieure à 7.5, comme la GTX 1080 Ti — a été supprimée dans cuDNN 9.11.0. Avec un ancien GPU, tu devras peut-être utiliser une version de PyTorch compilée avec une version antérieure de CUDA/cuDNN. Vérifie ta configuration avec :

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 :

Tu peux consulter ces métriques dans les journaux d’entraînement ou utiliser des outils comme TensorBoard ou Weights & Biases pour les visualiser. L’arrêt anticipé, configuré avec l’argument d’entraînement patience (par défaut, 100 époques sans amélioration de la validation), permet d’éviter les époques inutiles et le surapprentissage.

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.
  • Ultralytics Platform : Ultralytics Platform suit les exécutions d’entraînement YOLO ainsi que tes jeux de données et tes modèles, afin que tu puisses comparer les métriques et collaborer avec ton équipe au même endroit.

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 : une valeur device pour null 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 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#

Si tu rencontres des problèmes liés à l’entraînement du modèle, garde les points suivants à l’esprit.

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 : lors de l’entraînement d’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 un entraînement plus long, avec davantage d’époques que lorsque tu effectues le réglage fin d’un modèle existant.

Taux d’apprentissage et taille du lot

  • Importance : ces hyperparamètres déterminent 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 conviennent à ton jeu de données spécifique, et envisage un réglage des hyperparamètres pour rechercher de meilleures valeurs. 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, par exemple à l’aide d’un script d’audit du jeu de données. En cas de déséquilibre des classes, le modèle risque de privilégier 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 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 sur les mêmes données en l’initialisant avec des poids préentraînés. Si cette approche produit une matrice de confusion bien formée, cela pourrait indiquer que le modèle entraîné « à partir de zéro » nécessite davantage d’entraînement ou des ajustements.

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 absolues de pixels. Pour les convertir en coordonnées relatives (entre 0 et 1), tu dois les diviser par les dimensions de l’image. Par exemple, si ton image mesure 640x640 :

    # 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

    Tu peux aussi utiliser les attributs boxes.xyxyn ou boxes.xywhn de chaque résultat, qui renvoient déjà des coordonnées normalisées.

  • 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 spécifier les classes à inclure dans la sortie. Par exemple, pour détecter uniquement les voitures (indice de classe 2 dans COCO) :

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 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 référence réelles en utilisant l’IoU (intersection sur l’union) comme métrique. La précision des masques évalue la concordance entre les masques de segmentation prédits et les masques de référence pour la classification des objets au niveau du pixel. La précision de la matrice de confusion, quant à elle, porte sur l’exactitude globale de la classification de toutes les classes et ne tient pas compte de la précision 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 prédiction de classe est incorrecte ; cela explique les 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é d’utiliser des métriques d’évaluation distinctes selon les tâches.

Extraire les dimensions des objets dans YOLO26#

Problème : difficulté à récupérer la largeur et la hauteur des objets détectés avec 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. 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 inhabituelle 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 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 en temps réel l’utilisation du GPU et de la mémoire afin de repérer les anomalies. Assure-toi également d’utiliser 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#

  • 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. L’utilisation d’environnements virtuels permet d’éviter les conflits. Pour suivre les instructions d’installation étape par étape, consulte notre guide d’installation officiel. Si tu rencontres des erreurs d’importation, essaie de réinstaller la bibliothèque ou de la mettre à jour vers la dernière version.

  • L’entraînement sur un seul GPU peut être lent si la taille des lots est importante ou si la mémoire est insuffisante. Pour accélérer l’entraînement, utilise plusieurs GPU. Assure-toi que ton système dispose de plusieurs GPU et définis l’argument device, par exemple device=[0,1,2,3]. Augmente la taille des lots en conséquence pour exploiter 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])
  • Si la valeur device affichée dans les journaux d’entraînement est null, cela signifie généralement que le processus d’entraînement est configuré pour sélectionner automatiquement un GPU disponible. Pour attribuer explicitement un GPU spécifique, passe l’argument device au démarrage de l’entraînement, par exemple yolo train data=path/to/data.yaml device=0 pour le premier GPU. Exécute nvidia-smi pour vérifier ta configuration CUDA.

  • Tu peux suivre et visualiser efficacement la progression de l’entraînement à l’aide d’outils comme TensorBoard, Comet et Ultralytics Platform. Ces outils permettent de journaliser et de visualiser des métriques comme la perte, la précision, le rappel et mAP. L’arrêt anticipé basé sur ces métriques peut également contribuer à améliorer les résultats de l’entraînement.

  • Assure-toi que ton jeu de données et ses étiquettes respectent le format attendu. Vérifie que les annotations sont exactes et de bonne qualité. En cas de problème, consulte le guide Collecte et annotation des données pour connaître les bonnes pratiques. Pour des conseils propres aux jeux de données, consulte la section Jeux de données de la documentation.

Commentaires70

Pose une question, partage tes résultats ou aide quelqu’un d’autre.

  1. puzzlemindgamesGitHub

    I’ve been working on a browser-based puzzle solver project using Ultralytics YOLO for board and block detection. The model performs quite well locally, but I’m facing some inconsistent detection behavior after deployment and wanted to ask if anyone has experienced something similar.

    Current Stack: • YOLO (Ultralytics) • FastAPI • OpenCV • Python • Deployed on a low-memory cloud instance

    Issue: The model detects larger blocks correctly, but occasionally misses: • tightly packed shapes • small edge blocks • partially overlapping pieces • low-contrast screenshots from mobile devices This mostly happens on compressed screenshots uploaded by users.

    Current Inference Setup: from ultralytics import YOLO

    model = YOLO("best.pt")

    results = model.predict( source=image, imgsz=512, conf=0.35, max_det=100, verbose=False )

    Things I Already Tried • increasing imgsz • lowering confidence threshold • image sharpening with OpenCV • grayscale preprocessing • CLAHE contrast enhancement • retraining with more difficult samples

    Another Problem Memory usage spikes heavily during multiple inference requests. I solved most of it by forcing: WEB_CONCURRENCY=1 and reducing worker duplication, but I’m still curious if there’s a cleaner optimization strategy specifically for lightweight YOLO deployments.

    My Current Observation YOLO performs extremely well on clear geometric patterns, but puzzle-game screenshots seem tricky because: • blocks are visually similar • spacing is minimal • compression artifacts affect edges • mobile screenshots vary massively between devices

    Question Has anyone optimized YOLO specifically for: • grid-based games • puzzle detection • small repeated objects • mobile screenshot analysis

    Would love to hear: • pre-processing suggestions • augmentation ideas • lightweight deployment optimizations • whether segmentation models performed better for you

    For context, this is part of an AI-powered Block Blast solving project I’ve been experimenting with: https://www.aiblockblastsolver.com/ Appreciate any insights from people who’ve worked with similar detection challenges.

    1. Glenn JocherUltralytics

      For tightly packed small objects on compressed mobile screenshots, seg models often outperform pure detect, and the biggest gains usually come from training/inference at higher resolution plus augmentations that mimic JPEG artifacts, blur, scaling, and low contrast from real uploads; for deployment, keep one loaded model per process, warm it up, and use streaming-style inference to limit memory spikes, and if you can share a few failing images plus yolo checks in GitHub Discussions we can help narrow it down further—see Troubleshooting Common YOLO Issues, deployment best practices, and this small object mAP guide.

      1
    2. puzzlemindgamesGitHub

      Thanks for the detailed insights especially the point about segmentation models potentially outperforming pure detection for tightly packed puzzle objects.

      I’ve already started experimenting with stronger augmentation pipelines focused on: • JPEG compression artifacts • motion blur • brightness/contrast variation • slight perspective distortion and surprisingly, that alone improved small-shape consistency more than lowering confidence thresholds did. Furthermore, will explore the related guides and get back here if needed.

      Really appreciate the guidance.

    3. Glenn JocherUltralytics

      Good to hear that helped; the next thing I’d test is size-aware validation plus image tiling for training/inference, since tiny edge pieces often improve more from preserved spatial detail than from further conf tuning alone, and Model Evaluation Insights has a useful section on that.

  2. Mz-HanGitHub

    Hello, I am using the trained yolov26s-seg.pt for small object segmentation. When I set max-det to a value greater than 500, an error occurs. Would you have time to help me with this? Thank you very much!

    torch.cuda.OutOfMemoryError: CUDA out of memory. Tried to allocate4.95GiB (GPU 0;23.99 GiB total capacity;17.39 GiB already allocated; 0 bytes free; 17.65 GiB reserved in total by PyTorch) If reserved memory is >> allocated memory try setting max_split_size_mb to avoid fragmentation. See documentation for Memory Management and PYTORCH_CUDA_ALLOC_CONF

    1. Glenn JocherUltralytics

      That error is expected when max_det is pushed very high for segmentation—memory scales with the number of kept detections (and masks), so max_det>500 can OOM on a 24GB GPU; best next steps are to raise conf, lower imgsz, or keep max_det lower (see the GPU/OOM notes in YOLO common issues troubleshooting). If you think it’s a bug, please paste a text (not screenshot) minimal repro command plus yolo checks output as described in Minimum Reproducible Example.

      yolo task=segment mode=predict model=yolo26s-seg.pt source=your.mp4 imgsz=640 conf=0.4 max_det=300 half=True device=0
      yolo checks

      If reserved memory is much larger than allocated, also try setting this before running Python (then restart your session/kernel):

      export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:128
  3. EvelynStockardGitHub

    Troubleshooting common YOLO issues involves checking model configuration, image input size, and environment setup to ensure smooth performance. Many users face errors during training or inference while working with https://yolov8.org/ due to version mismatches or incorrect paths.

  4. dvdfaceGitHub

    I ran into a problem. when I started training by yolo cli, after yolo read train and val dataset, it quited, I can only saw many python process in background, but their cpu usage was zero, gpu usage was zero?

    what's happened? How to figure it out?

    I have tried use python script instead , the same problem occured.

    how to tackle it?

    1. Glenn JocherUltralytics

      @dvdface this sounds like a DataLoader multiprocessing issue that can cause training to hang. Try these solutions in order:

      1. Disable multiprocessing workers by adding workers=0 to your training command:

        yolo train model=yolo11n.pt data=dataset.yaml workers=0
      2. Check your environment - ensure you're using the latest ultralytics version:

        pip install -U ultralytics
      3. Verify GPU setup - test if CUDA is working properly:

        import torch
        print(torch.cuda.is_available())
      4. Try a fresh environment - create a new virtual environment and reinstall dependencies if the above doesn't work.

      The workers=0 fix usually resolves hanging issues during training initialization. Let me know if this helps!

  5. sjocnjfjdGitHub

    I have looled  the issue  guides,but I can not find what I  want to solve my problem

    ---Original--- From: "Glenn @.> Date: Sat, Dec 7, 2024 01:27 AM To: @.>; Cc: @.@.>; Subject: Re: [ultralytics/ultralytics] zh/guides/yolo-common-issues/(Discussion #11739)

    @sjocnjfjd your YAML file seems mostly correct, but be cautious with the file path formatting. Replace D:python新建文件夹 (2)/hakusenninnshiki.v2i.yolov11/lane.yaml with a properly formatted path (e.g., D:/python/新建文件夹 (2)/hakusenninnshiki.v2i.yolov11/lane.yaml). Ensure all dataset paths are accessible and the Roboflow url is valid. If issues persist, refer to the YOLO Common Issues guide for troubleshooting.

    — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you were mentioned.Message ID: @.***>

    1. Glenn JocherUltralytics

      @sjocnjfjd thank you for your comment. If you've already reviewed the issue guides and couldn't find a solution, please provide specific details about your problem, such as the error message or unexpected behavior you're encountering. This will help us assist you more effectively. Additionally, you can reference the YOLO Common Issues guide for further troubleshooting. Let us know how we can assist!

  6. sjocnjfjdGitHub

    it is my.yaml: path: D:python新建文件夹 (2)/hakusenninnshiki.v2i.yolov11/lane.yaml train: images/train val: images/val test: images/test

    nc: 1 names: ['hakusen']

    roboflow:   workspace: kitazonoken   project: hakusenninnshiki   version: 2   license: CC BY 4.0   url: https://universe.roboflow.com/kitazonoken/hakusenninnshiki/dataset/2 is it right ?

    ---Original--- From: "Glenn @.> Date: Fri, Dec 6, 2024 23:59 PM To: @.>; Cc: @.@.>; Subject: Re: [ultralytics/ultralytics] zh/guides/yolo-common-issues/(Discussion #11739)

    @sjocnjfjd the error indicates a file path issue. Ensure your data parameter points to the correct yaml file and check that the dataset paths defined in the yaml file are valid and accessible. For guidance on dataset preparation and troubleshooting, refer to YOLO Common Issues. Let us know if you need further clarification!

    — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you were mentioned.Message ID: @.***>

    1. Glenn JocherUltralytics

      @sjocnjfjd your YAML file seems mostly correct, but be cautious with the file path formatting. Replace D:python新建文件夹 (2)/hakusenninnshiki.v2i.yolov11/lane.yaml with a properly formatted path (e.g., D:/python/新建文件夹 (2)/hakusenninnshiki.v2i.yolov11/lane.yaml). Ensure all dataset paths are accessible and the Roboflow url is valid. If issues persist, refer to the YOLO Common Issues guide for troubleshooting.

  7. sjocnjfjdGitHub

    100 epochs completed in 0.146 hours. Optimizer stripped from runs/detect/train/weights/last.pt, 5.5MB Optimizer stripped from runs/detect/train/weights/best.pt, 5.5MB

    Validating runs/detect/train/weights/best.pt... Ultralytics 8.3.44 🚀 Python-3.10.12 torch-2.5.1+cu121 CUDA:0 (Tesla T4, 15102MiB) YOLO11n summary (fused): 238 layers, 2,582,347 parameters, 0 gradients, 6.3 GFLOPs

    FileNotFoundError Traceback (most recent call last) in <cell line: 4>() 2 3 model = YOLO('https://hub.ultralytics.com/models/kYDnuTY9JD3hHyFdnc5T') ----> 4 results = model.train(data='"D://python//新建文件夹 (2)//hakusenninnshiki.v2i.yolov11//lane.yaml"', project='runs/train', name='exp', epochs=100)

    6 frames /usr/local/lib/python3.10/dist-packages/ultralytics/data/utils.py in check_det_dataset(dataset, autodownload) 327 else: 328 m += f"\nNote dataset download directory is '{DATASETS_DIR}'. You can update this in '{SETTINGS_FILE}'" --> 329 raise FileNotFoundError(m) 330 t = time.time() 331 r = None # success

    FileNotFoundError: Dataset '/content/datasets/lane/lane.yaml' images not found ⚠️, missing path '/content/datasets/D:python新/建文件夹 (2)/hakusenninnshiki.v2i.yolov11/lane.yaml/images/val' Note dataset download directory is '/content/datasets'. You can update this in '/root/.config/Ultralytics/settings.json' why can i deploy

    1. Glenn JocherUltralytics

      @sjocnjfjd the error indicates a file path issue. Ensure your data parameter points to the correct yaml file and check that the dataset paths defined in the yaml file are valid and accessible. For guidance on dataset preparation and troubleshooting, refer to YOLO Common Issues. Let us know if you need further clarification!

  8. tylerfrisinger01GitHub

    is it possible that YOLOv11 will take a lot longer to train compared to YOLOv8? My model is currently doing about 1 epoch every hour and a half. I currently have it so it will do 300 epochs as recommended on the training page. Should i switch to YOLOv8 instead?

    1. tylerfrisinger01GitHub

      Is there anything I can do to increase the speed of training either v8 or v11? At this point I’m concerned it may take days. Should I only do 100 epochs the first training round and then train it again at 100? And again and again?

  9. xsvebmxGitHub

    Please help (

    cmd> yolo task=detect mode=train model=yolov8s.pt data=data_custom.yaml epochs=50 imgsz=640 batch=8

    train: Scanning X:\Desktop\NNXTSSS\train\labels.cache... 1 images, 12 backgrounds, 0 corrupt: 100%|██████████| 12/12 [00:00<?, ?it/s] WARNING ⚠️ No labels found in X:\Desktop\NNXTSSS\train\labels.cache, training may not work correctly. See https://docs.ultralytics.com/datasets for dataset formatting guidance. val: Scanning X:\Desktop\NNXTSSS\val\labels.cache... 0 images, 5 backgrounds, 0 corrupt: 100%|██████████| 5/5 [00:00<?, ?it/s] WARNING ⚠️ No labels found in X:\Desktop\NNXTSSS\val\labels.cache, training may not work correctly. See https://docs.ultralytics.com/datasets for dataset formatting guidance. Plotting labels to runs\detect\train7\labels.jpg... zero-size array to reduction operation maximum which has no identity

    WARNING ⚠️ no labels found in detect set, can not compute metrics without labels

      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
       2/50      2.02G          0      210.6          0          0        640: 100%|██████████| 2/2 [00:02<00:00,  1.45s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95):   0%|          | 0/1 [00:00<?, ?it/s]

    files

    data_custom.yaml

    val: X:/Desktop/NNXTSSS/val
    nc: 1
    
    names: ["hat"]```
    1. Glenn JocherUltralytics

      @xsvebmx it seems like there are no labels found in your dataset, which is causing the training issues. Please ensure that your label files are correctly formatted and located in the specified directories. You can refer to the dataset formatting guide at https://docs.ultralytics.com/datasets for more details. If the issue persists, double-check the paths in your data_custom.yaml file to ensure they point to the correct locations.

      1
    2. xsvebmxGitHub

      I was stupid , I compiled the data set incorrectly, and because of this, an error was issued, Thank you for support😁 (i wanna sleep😭)

  10. ManojShakyaGitHub

    Subject: Issue with False Object Detections in YOLOv8 Pre-Trained Model

    Dear Ultralytics Team,

    I am encountering an issue while using a pre-trained YOLOv8 model for object detection. When I input an image containing two objects, such as a cat and a dog, the model unexpectedly detects multiple other objects like a keyboard, sheep, car, train, bus, and more—none of which are actually present in the image and with 100 percentage probability score.

    Could you please provide guidance on how to resolve this issue? Any advice or recommendations would be greatly appreciated.

    1. Glenn JocherUltralytics

      @ManojShakya thank you for reaching out. It sounds like there might be an issue with the model's confidence threshold or potential data inconsistencies. First, ensure you're using the latest version of the YOLOv8 package. If the issue persists, try adjusting the confidence threshold to filter out low-confidence detections. Additionally, verify that your input images and annotations are correctly formatted. For more detailed troubleshooting, please refer to our Common Issues Guide.