Inizia

Risoluzione dei problemi più comuni di YOLO

YOLO common training and deployment issues

Questa guida tratta i problemi più comuni che potresti incontrare lavorando con Ultralytics YOLO26, suddivisi in base alla fase in cui si verificano: installazione, addestramento del modello, predizione e distribuzione. Vai alla categoria corrispondente al tuo errore oppure consulta le FAQ per trovare rapidamente una risposta. Ogni voce descrive il problema e una soluzione concreta che puoi applicare direttamente.



Guarda: Problemi comuni di Ultralytics YOLO26 | Errori di installazione, problemi di addestramento dei modelli

Problemi comuni#

Errori di installazione#

Gli errori di installazione possono avere diverse cause, come versioni incompatibili, dipendenze mancanti o configurazioni dell'ambiente errate. Per prima cosa, verifica quanto segue:

  • Stai usando Python 3.8 o una versione successiva.
  • Hai installato una versione compatibile di PyTorch (1.8 o successiva).
  • Stai usando un ambiente virtuale per evitare conflitti.
  • Segui passo dopo passo la guida ufficiale all'installazione.

Ecco inoltre alcune soluzioni ai problemi di installazione più comuni.

Mantieni aggiornati Ultralytics e le sue dipendenze

Molti errori di importazione, GPU ed esportazione si risolvono semplicemente con un aggiornamento. Esegui pip install -U ultralytics e verifica che le versioni di PyTorch e CUDA siano compatibili prima di procedere con un debug più approfondito.

Errori di importazione o problemi con le dipendenze#

Se ricevi errori durante l'importazione di YOLO26 o riscontri conflitti tra dipendenze, prova a seguire questi passaggi:

  • Nuova installazione: partire da un'installazione pulita può risolvere problemi imprevisti, soprattutto dopo aggiornamenti che modificano la struttura o le funzionalità del pacchetto.
  • Aggiornamenti regolari: usa la versione più recente della libreria, perché le release meno recenti potrebbero non essere compatibili con gli aggiornamenti recenti.
  • Verifica delle dipendenze: controlla che tutte le dipendenze richieste siano installate correttamente e abbiano versioni compatibili.
  • Esamina le modifiche: se hai installato una versione meno recente, consulta la documentazione ufficiale o il changelog per capire quali modifiche strutturali importanti sono state apportate.

Eseguire YOLO26 su GPU#

Se hai problemi a eseguire YOLO26 su una GPU, prova a seguire questi passaggi per la risoluzione dei problemi:

  • Verifica della compatibilità e dell'installazione di CUDA: assicurati che la GPU sia compatibile con CUDA e che CUDA sia installato correttamente. Usa il comando nvidia-smi per controllare lo stato della GPU NVIDIA e la versione di CUDA.
  • Verifica l'integrazione tra PyTorch e CUDA: assicurati che PyTorch possa utilizzare CUDA eseguendo import torch; print(torch.cuda.is_available()) in un terminale Python. Se restituisce True, PyTorch è configurato per usare CUDA.
  • Attivazione dell'ambiente: assicurati di trovarti nell'ambiente corretto, in cui sono installati tutti i pacchetti necessari.
  • Aggiorna i pacchetti: i pacchetti obsoleti potrebbero non essere compatibili con la tua GPU. Mantienili aggiornati.
  • Configurazione del programma: controlla se il codice richiede l'uso della GPU. Puoi impostare l'argomento device durante l'addestramento o la predizione (ad esempio, device=0).
GPU meno recenti e cuDNN 9.11.0+

Il supporto per le architetture GPU precedenti a Turing — capacità di calcolo (SM) inferiore a 7.5, come la GTX 1080 Ti — è stato rimosso in cuDNN 9.11.0. Se hai una GPU meno recente, potrebbe servirti una build di PyTorch compilata con una versione precedente di CUDA/cuDNN. Verifica la configurazione con:

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}")

Problemi di addestramento del modello#

Di seguito trovi i problemi di addestramento più comuni e le relative soluzioni.

Verifica delle impostazioni di configurazione#

Problema: non sai se le impostazioni di configurazione nel file .yaml vengono applicate correttamente durante l'addestramento del modello.

Soluzione: le impostazioni del dataset e quelle di addestramento si trovano in file .yaml distinti e vengono passate tramite argomenti diversi di model.train(). Per assicurarti che queste impostazioni siano applicate correttamente, segui questi passaggi:

  • Verifica che i percorsi dei file .yaml siano corretti.

  • Passa .yaml del dataset (percorsi, nomi delle classi, split) come argomento data e un .yaml personalizzato per le impostazioni di addestramento (ad esempio epochs o lr0) come argomento cfg. Gli argomenti passati direttamente a model.train() hanno la precedenza su entrambi:

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

Accelerare l'addestramento con più GPU#

Problema: l'addestramento è lento su una singola GPU e vuoi velocizzarlo usando più GPU.

Soluzione: aumentare la dimensione del batch può accelerare l'addestramento, ma è essenziale considerare la capacità di memoria della GPU. Per velocizzare l'addestramento con più GPU, segui questi passaggi:

  • Assicurati di avere più GPU disponibili.

  • Imposta l'argomento device su un elenco di indici GPU, ad esempio device=[0,1,2,3].

  • Aumenta la dimensione del batch in modo adeguato per sfruttare appieno le GPU senza superare i limiti di memoria.

  • Modifica il comando di addestramento per usare più GPU:

    # # Regola la dimensione del batch e le altre impostazioni secondo necessità per ottimizzare la velocità di addestramento
    model.train(data="/path/to/your/data.yaml", batch=32, device=[0, 1, 2, 3])

Parametri da monitorare costantemente#

Problema: vuoi sapere quali parametri monitorare costantemente durante l'addestramento, oltre alla loss.

Soluzione: la loss è una metrica fondamentale da monitorare, ma è importante tenere traccia anche di altre metriche per ottimizzare le prestazioni del modello. Tra le metriche principali da monitorare durante l'addestramento ci sono:

Puoi accedere a queste metriche dai log di addestramento o usare strumenti come TensorBoard o Weights & Biases per visualizzarle. L'arresto anticipato con l'argomento di addestramento patience (impostato per impostazione predefinita su 100 epoche senza miglioramenti nella convalida) aiuta a evitare epoche sprecate e overfitting.

Strumenti per monitorare i progressi dell'addestramento#

Problema: cerchi consigli sugli strumenti per monitorare i progressi dell'addestramento.

Soluzione: per monitorare e visualizzare i progressi dell'addestramento, puoi valutare l'uso dei seguenti strumenti:

  • TensorBoard: TensorBoard è uno strumento diffuso per visualizzare le metriche di addestramento, tra cui la loss, l'accuratezza e altro ancora. Puoi integrarlo nel flusso di addestramento di YOLO26.
  • Comet: Comet offre un toolkit completo per il monitoraggio e il confronto degli esperimenti. Ti permette di tenere traccia delle metriche, degli iperparametri e persino dei pesi del modello. L'integrazione con i modelli YOLO è semplice e ti offre una panoramica completa del ciclo dell'esperimento.
  • Ultralytics Platform: Ultralytics Platform tiene traccia delle sessioni di addestramento YOLO insieme ai tuoi set di dati e modelli, così puoi confrontare le metriche e collaborare con il tuo team in un unico posto.

Come verificare se l'addestramento viene eseguito sulla GPU#

Problema: il valore device nei log di addestramento è null e non sai se l'addestramento sta avvenendo sulla GPU.

Soluzione: un valore device per null indica in genere che il processo di addestramento è configurato per selezionare automaticamente una GPU disponibile, che è il comportamento predefinito. Per addestrare il modello su una GPU specifica, imposta l'argomento device all'avvio dell'addestramento. device è un argomento di addestramento, quindi impostarlo nel file .yaml del set di dati non ha alcun effetto:

from ultralytics import YOLO

# Carica un modello
model = YOLO("yolo26n.pt")

# # Usa la GPU 0; device=[0, 1] per più GPU, device="cpu" per la CPU
model.train(data="path/to/data.yaml", device=0)

Tieni d'occhio la cartella runs per monitorare efficacemente l'avanzamento dell'addestramento tramite i log e le metriche.

Aspetti fondamentali per un addestramento efficace del modello#

Se riscontri problemi relativi all'addestramento del modello, tieni presente quanto segue.

Formato del dataset ed etichette

  • Importanza: le fondamenta di qualsiasi modello di machine learning sono la qualità e il formato dei dati su cui viene addestrato.
  • Consiglio: assicurati che il tuo dataset personalizzato e le relative etichette rispettino il formato previsto. È fondamentale verificare che le annotazioni siano accurate e di alta qualità. Annotazioni errate o scadenti possono compromettere l'apprendimento del modello e portare a risultati imprevedibili.

Convergenza del modello

  • Importanza: raggiungere la convergenza del modello garantisce che il modello abbia appreso a sufficienza dai dati di addestramento.
  • Consiglio: quando addestri un modello "da zero", è fondamentale assicurarsi che raggiunga un livello di convergenza soddisfacente. Potrebbe essere necessario prolungare l'addestramento, aumentando il numero di epoche rispetto a quando esegui il fine-tuning di un modello esistente.

Learning rate e dimensione del batch

  • Importanza: questi iperparametri determinano il modo in cui il modello aggiorna i propri pesi durante l'addestramento.
  • Consiglio: valuta regolarmente se il tasso di apprendimento e la dimensione del batch scelti sono adatti al tuo set di dati specifico e considera l'ottimizzazione degli iperparametri per trovare valori migliori. Parametri non in linea con le caratteristiche del set di dati possono penalizzare le prestazioni del modello.

Distribuzione delle classi

  • Importanza: la distribuzione delle classi nel dataset può influenzare le tendenze del modello nelle predizioni.
  • Consiglio: valuta regolarmente la distribuzione delle classi nel dataset, per esempio con uno script di controllo del dataset. Se c'è uno sbilanciamento tra classi, il modello rischia di sviluppare una tendenza a favore della classe più frequente. Questa tendenza può risultare evidente nella matrice di confusione, in cui il modello potrebbe prevedere soprattutto la classe maggioritaria.

Verifica incrociata con pesi preaddestrati

  • Importanza: sfruttare pesi preaddestrati può fornire una solida base per l'addestramento del modello, soprattutto quando i dati sono limitati.
  • Consiglio: come passaggio diagnostico, valuta l'addestramento del modello sugli stessi dati, inizializzandolo però con pesi preaddestrati. Se questo approccio produce una matrice di confusione ben strutturata, il modello addestrato "da zero" potrebbe aver bisogno di ulteriore addestramento o di alcune modifiche.

Di seguito sono descritti i problemi più comuni che si verificano durante le previsioni del modello e le relative soluzioni.

Ottenere previsioni dei riquadri di delimitazione con il tuo modello YOLO26 personalizzato#

Problema: quando esegui previsioni con un modello YOLO26 personalizzato, puoi incontrare difficoltà con il formato e la visualizzazione delle coordinate dei riquadri di delimitazione.

Soluzione:

  • Formato delle coordinate: YOLO26 fornisce le coordinate dei riquadri di delimitazione in valori assoluti di pixel. Per convertirle in coordinate relative (comprese tra 0 e 1), devi dividerle per le dimensioni dell'immagine. Ad esempio, se l'immagine misura 640x640:

    # Converti le coordinate assolute in coordinate relative
    x1 = x1 / 640  # Dividi le coordinate x per la larghezza dell'immagine
    x2 = x2 / 640
    y1 = y1 / 640  # Dividi le coordinate y per l'altezza dell'immagine
    y2 = y2 / 640

    In alternativa, usa gli attributi boxes.xyxyn o boxes.xywhn di ogni risultato, che restituiscono già coordinate normalizzate.

  • Nome del file: per ottenere il nome del file dell'immagine su cui esegui la previsione, leggi il percorso del file immagine dall'attributo path di ciascun oggetto risultato (ad esempio result.path) all'interno del ciclo di previsione.

Filtrare gli oggetti nelle previsioni YOLO26#

Problema: difficoltà a filtrare e visualizzare solo determinati oggetti nei risultati delle previsioni quando esegui YOLO26 con la libreria Ultralytics.

Soluzione: per rilevare classi specifiche, usa l'argomento classes per indicare le classi da includere nell'output. Ad esempio, per rilevare solo le automobili (indice di classe 2 in COCO):

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

Comprendere le metriche di precisione in YOLO26#

Problema: confusione sulla differenza tra la precisione dei riquadri, la precisione delle maschere e la precisione della matrice di confusione in YOLO26.

Soluzione: la precisione dei riquadri misura l'accuratezza dei riquadri di delimitazione previsti rispetto ai riquadri effettivi di riferimento, usando IoU (intersezione sull'unione) come metrica. La precisione delle maschere valuta la corrispondenza tra le maschere di segmentazione previste e quelle di riferimento nella classificazione degli oggetti a livello di pixel. La precisione della matrice di confusione, invece, si concentra sull'accuratezza complessiva della classificazione di tutte le classi e non considera l'accuratezza geometrica delle previsioni. È importante notare che un riquadro di delimitazione può essere geometricamente accurato (vero positivo) anche se la classe prevista è errata, causando differenze tra la precisione dei riquadri e quella della matrice di confusione. Queste metriche valutano aspetti distinti delle prestazioni del modello e riflettono la necessità di metriche di valutazione diverse per attività diverse.

Estrarre le dimensioni degli oggetti in YOLO26#

Problema: difficoltà nel recuperare la larghezza e l'altezza degli oggetti rilevati in YOLO26, soprattutto quando vengono rilevati più oggetti in un'immagine.

Soluzione: per recuperare le dimensioni dei riquadri di delimitazione, usa innanzitutto il modello Ultralytics YOLO26 per prevedere gli oggetti in un'immagine. Quindi, estrai le informazioni su larghezza e altezza dei riquadri di delimitazione dai risultati della previsione.

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}")

Problemi di distribuzione#

Problemi di distribuzione su GPU#

Problema: la distribuzione dei modelli in un ambiente multi-GPU può talvolta causare comportamenti imprevisti, come un uso anomalo della memoria o risultati incoerenti tra GPU.

Soluzione: verifica che non venga inizializzata una GPU predefinita. Alcuni framework, come PyTorch, potrebbero inizializzare le operazioni CUDA su una GPU predefinita prima di passare alle GPU designate. Per evitare inizializzazioni predefinite indesiderate, specifica direttamente la GPU durante la distribuzione e la previsione. Usa quindi strumenti per monitorare in tempo reale l'utilizzo della GPU e della memoria e individuare eventuali anomalie. Assicurati inoltre di usare la versione più recente del framework o della libreria.

Problemi di conversione/esportazione dei modelli#

Problema: durante la conversione o l'esportazione dei modelli di machine learning in formati o piattaforme diversi, potresti incontrare errori o comportamenti imprevisti.

Soluzione: consulta i formati supportati e le opzioni disponibili per ciascun formato nella documentazione della modalità di esportazione, quindi esegui questi controlli:

  • Controllo della compatibilità: assicurati di usare versioni di librerie e framework compatibili tra loro. Le versioni non corrispondenti possono causare errori imprevisti durante la conversione.
  • Ripristino dell'ambiente: se usi un ambiente interattivo come Jupyter o Colab, valuta di riavviarlo dopo modifiche o installazioni importanti. Ripartire da un ambiente pulito può talvolta risolvere problemi sottostanti.
  • Documentazione ufficiale: fai sempre riferimento alla documentazione ufficiale dello strumento o della libreria che usi per la conversione. Spesso include indicazioni specifiche e best practice per l'esportazione dei modelli.
  • Supporto della community: controlla il repository ufficiale della libreria o del framework per verificare se altri utenti hanno segnalato problemi simili. I responsabili della manutenzione o la community potrebbero aver fornito soluzioni o metodi alternativi nelle discussioni.
  • Aggiornamenti regolari: assicurati di usare la versione più recente dello strumento o della libreria. Gli sviluppatori rilasciano spesso aggiornamenti che correggono bug noti o migliorano le funzionalità.
  • Test incrementali: prima di eseguire una conversione completa, prova il processo con un modello o un dataset più piccolo per individuare per tempo eventuali problemi.

Community e supporto#

Chiedi aiuto e condividi soluzioni tramite questi canali e risorse.

Forum e canali per ricevere aiuto#

Segnalazioni su GitHub: Il repository di Ultralytics su GitHub ha una scheda Issues in cui puoi porre domande, segnalare bug e proporre nuove funzionalità. La community e i maintainer sono attivi e questo è un ottimo posto per ricevere aiuto su problemi specifici.

Server Discord di Ultralytics: Ultralytics ha un server Discord in cui puoi interagire con altri utenti e con gli sviluppatori.

Documentazione e risorse ufficiali#

Documentazione Ultralytics YOLO26: la documentazione ufficiale offre una panoramica completa di YOLO26 e include guide all'installazione, all'utilizzo e alla risoluzione dei problemi.

Conclusione#

La maggior parte dei problemi di YOLO26 dipende da poche cause: versioni incompatibili, formattazione del dataset e configurazione della GPU. Se qui non trovi un errore, cerca nella scheda GitHub Issues oppure chiedi sul server Discord: probabilmente qualcuno ha già trovato una soluzione. Per problemi più complessi di addestramento, consulta la guida ai consigli per l'addestramento dei modelli, che offre suggerimenti pratici per ottenere risultati migliori nei tuoi progetti di visione artificiale.

Domande frequenti#

  • Gli errori di installazione possono spesso dipendere da problemi di compatibilità o dipendenze mancanti. Assicurati di usare Python 3.8 o versioni successive e di avere installato PyTorch 1.8 o versioni successive. È utile usare ambienti virtuali per evitare conflitti. Per una guida dettagliata all'installazione, segui la nostra guida ufficiale all'installazione. Se riscontri errori di importazione, prova a eseguire una nuova installazione o ad aggiornare la libreria alla versione più recente.

  • L'addestramento su una singola GPU può essere lento a causa di batch di grandi dimensioni o memoria insufficiente. Per accelerare l'addestramento, usa più GPU. Assicurati che il sistema disponga di più GPU e imposta l'argomento device, ad esempio device=[0,1,2,3]. Aumenta di conseguenza la dimensione del batch per sfruttare appieno le GPU senza superare i limiti di memoria. Comando di esempio:

    model.train(data="/path/to/your/data.yaml", batch=32, device=[0, 1, 2, 3])
  • Se nei log di addestramento il valore device è null, in genere significa che il processo di addestramento è configurato per selezionare automaticamente una GPU disponibile. Per assegnare esplicitamente una GPU specifica, passa l'argomento device all'avvio dell'addestramento, ad esempio yolo train data=path/to/data.yaml device=0 per la prima GPU. Esegui nvidia-smi per verificare la configurazione di CUDA.

  • Puoi gestire efficacemente il monitoraggio e la visualizzazione dell'avanzamento dell'addestramento con strumenti come TensorBoard, Comet e Ultralytics Platform. Questi strumenti consentono di registrare e visualizzare metriche come loss, precisione, richiamo e mAP. Applicare l'arresto anticipato in base a queste metriche può contribuire a migliorare i risultati dell'addestramento.

  • Assicurati che il dataset e le etichette rispettino il formato previsto. Verifica che le annotazioni siano accurate e di alta qualità. Se riscontri problemi, consulta la guida alla raccolta e annotazione dei dati per conoscere le best practice. Per indicazioni più specifiche sui dataset, consulta la sezione Dataset della documentazione.

Commenti70

Fai una domanda, condividi i tuoi risultati o aiuta qualcun altro.

  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.