Começar

Solução de problemas comuns do YOLO

YOLO common training and deployment issues

Este guia aborda os problemas mais comuns que você pode encontrar ao trabalhar com o Ultralytics YOLO26, agrupados por etapa: instalação, treinamento do modelo, previsão e implantação. Vá para a categoria correspondente ao seu erro ou consulte as perguntas frequentes para obter respostas rápidas. Cada tópico descreve o problema e uma solução concreta que você pode aplicar diretamente.



Assista: Problemas comuns do Ultralytics YOLO26 | Erros de instalação, problemas no treinamento do modelo

Problemas comuns#

Erros de instalação#

Os erros de instalação podem ocorrer por vários motivos, como versões incompatíveis, dependências em falta ou configurações incorretas do ambiente. Primeiro, verifica o seguinte:

  • Estás a usar Python 3.8 ou posterior.
  • Tens instalada uma versão compatível do PyTorch (1.8 ou posterior).
  • Estás a usar um ambiente virtual para evitar conflitos.
  • Siga o guia oficial de instalação passo a passo.

Além disso, veja algumas soluções para problemas comuns de instalação.

Mantenha o Ultralytics e suas dependências atualizados

Muitos erros de importação, GPU e exportação são resolvidos simplesmente com uma atualização. Execute pip install -U ultralytics e confirme se as versões do PyTorch e do CUDA são compatíveis antes de iniciar uma depuração mais aprofundada.

Erros de importação ou problemas com dependências#

Se você receber erros ao importar o YOLO26 ou encontrar conflitos entre dependências, tente estas etapas:

  • Instalação limpa: começar com uma instalação limpa pode resolver problemas inesperados, especialmente após atualizações que alteram a estrutura ou a funcionalidade do pacote.
  • Atualize regularmente: use a versão mais recente da biblioteca, pois versões antigas podem não ser compatíveis com atualizações recentes.
  • Verifique as dependências: confirme se todas as dependências necessárias estão instaladas corretamente e se as versões são compatíveis.
  • Revise as alterações: se você instalou uma versão antiga, consulte a documentação oficial ou o changelog para entender as principais alterações estruturais.

Executar o YOLO26 na GPU#

Se você estiver com dificuldades para executar o YOLO26 em uma GPU, considere estas etapas de solução de problemas:

  • Verifique a compatibilidade e a instalação do CUDA: confirme se sua GPU é compatível com CUDA e se o CUDA está instalado corretamente. Use o comando nvidia-smi para verificar o status da GPU NVIDIA e a versão do CUDA.
  • Verifica a integração entre PyTorch e CUDA: certifica-te de que o PyTorch consegue utilizar CUDA, executando import torch; print(torch.cuda.is_available()) num terminal Python. Se devolver True, o PyTorch está configurado para usar CUDA.
  • Ativação do ambiente: confirme se você está no ambiente correto, onde todos os pacotes necessários estão instalados.
  • Atualize seus pacotes: pacotes desatualizados podem não ser compatíveis com sua GPU. Mantenha-os atualizados.
  • Configuração do programa: verifique se seu código solicita o uso da GPU. Você pode definir o argumento device ao executar o treinamento ou a previsão (por exemplo, device=0).
GPUs antigas e cuDNN 9.11.0+

O suporte para arquiteturas de GPU anteriores à Turing — capacidade de computação (SM) inferior a 7.5, como a GTX 1080 Ti — foi removido no cuDNN 9.11.0. Numa GPU mais antiga, poderás precisar de uma compilação do PyTorch compilada com uma versão anterior do CUDA/cuDNN. Verifica a tua configuração com:

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

Problemas no treinamento do modelo#

Veja abaixo os problemas comuns de treinamento e suas soluções.

Verificação das configurações#

Problema: você não tem certeza se as configurações no arquivo .yaml estão sendo aplicadas corretamente durante o treinamento do modelo.

Solução: as configurações do conjunto de dados e as configurações de treinamento ficam em arquivos .yaml diferentes e são passadas por argumentos diferentes de model.train(). Para garantir que essas configurações sejam aplicadas corretamente, siga estas etapas:

  • Confirme se os caminhos para seus arquivos .yaml estão corretos.

  • Passe o .yaml do seu conjunto de dados (caminhos, nomes de classes, divisões) como o argumento data e um .yaml personalizado para as configurações de treinamento (por exemplo, epochs ou lr0) como o argumento cfg. Os argumentos passados diretamente para model.train() têm prioridade sobre ambos:

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

Acelerar o treinamento com várias GPUs#

Problema: o treinamento está lento em uma única GPU, e você quer acelerar o processo usando várias GPUs.

Solução: aumentar o tamanho do lote pode acelerar o treinamento, mas é essencial considerar a capacidade de memória da GPU. Para acelerar o treinamento com várias GPUs, siga estas etapas:

  • Confirme se você tem várias GPUs disponíveis.

  • Defina o argumento device como uma lista de índices de GPU, por exemplo, device=[0,1,2,3].

  • Aumente o tamanho do lote adequadamente para aproveitar ao máximo as várias GPUs sem exceder os limites de memória.

  • Modifique o comando de treinamento para usar várias GPUs:

    # Ajuste o tamanho do lote e outras configurações conforme necessário para otimizar a velocidade do treinamento
    model.train(data="/path/to/your/data.yaml", batch=32, device=[0, 1, 2, 3])

Parâmetros para monitoramento contínuo#

Problema: você quer saber quais parâmetros devem ser monitorados continuamente durante o treinamento, além da perda.

Solução: embora a perda seja uma métrica crucial a monitorar, também é essencial acompanhar outras métricas para otimizar o desempenho do modelo. Algumas métricas importantes para acompanhar durante o treinamento incluem:

Podes aceder a estas métricas nos registos de treino ou usar ferramentas como o TensorBoard ou o Weights & Biases para as visualizar. A paragem antecipada com o argumento de treino patience (por predefinição, 100 épocas sem melhorias na validação) ajuda a evitar épocas desperdiçadas e o sobreajuste.

Ferramentas para acompanhar o progresso do treinamento#

Problema: você está procurando recomendações de ferramentas para acompanhar o progresso do treinamento.

Solução: para acompanhar e visualizar o progresso do treinamento, considere usar as seguintes ferramentas:

  • TensorBoard: o TensorBoard é uma opção popular para visualizar métricas de treinamento, incluindo perda, acurácia e muito mais. Você pode integrá-lo ao processo de treinamento do YOLO26.
  • Comet: o Comet oferece um amplo conjunto de ferramentas para acompanhar e comparar experimentos. Ele permite acompanhar métricas, hiperparâmetros e até pesos do modelo. A integração com modelos YOLO também é simples, oferecendo uma visão completa do ciclo do experimento.
  • Ultralytics Platform: a Ultralytics Platform acompanha as execuções de treino do YOLO juntamente com os teus conjuntos de dados e modelos, para que possas comparar métricas e colaborar com a tua equipa num só lugar.

Como verificar se o treinamento está sendo executado na GPU#

Problema: o valor de device nos registos de treino é null e não tens a certeza de que o treino esteja a decorrer na GPU.

Solução: um valor device para null normalmente significa que o processo de treino está configurado para selecionar automaticamente uma GPU disponível, que é o comportamento predefinido. Para treinar numa GPU específica, define o argumento device ao iniciar o treino. device é um argumento de treino, pelo que defini-lo no ficheiro .yaml do conjunto de dados não tem efeito:

from ultralytics import YOLO

# Carregar um modelo
model = YOLO("yolo26n.pt")

# Use GPU 0; device=[0, 1] para várias GPUs, device="cpu" para CPU
model.train(data="path/to/data.yaml", device=0)

Acompanha a pasta runs para consultar os registos e as métricas e monitorizar eficazmente o progresso do treino.

Principais considerações para um treinamento eficaz do modelo#

Tem em conta o seguinte se estiveres a ter problemas relacionados com o treino do modelo.

Formato do conjunto de dados e rótulos

  • Importância: a base de qualquer modelo de aprendizado de máquina está na qualidade e no formato dos dados usados no treinamento.
  • Recomendação: confirme se seu conjunto de dados personalizado e os rótulos associados seguem o formato esperado. É fundamental verificar se as anotações são precisas e de alta qualidade. Anotações incorretas ou de baixa qualidade podem prejudicar o aprendizado do modelo e levar a resultados imprevisíveis.

Convergência do modelo

  • Importância: alcançar a convergência do modelo garante que ele tenha aprendido o suficiente com os dados de treinamento.
  • Recomendação: ao treinares um modelo «do zero», é essencial garantir que o modelo atinge um nível de convergência satisfatório. Isto poderá exigir um treino mais prolongado, com mais épocas, do que ao ajustares um modelo existente.

Taxa de aprendizado e tamanho do lote

  • Importância: estes hiperparâmetros determinam como o modelo atualiza os seus pesos durante o treino.
  • Recomendação: avalia regularmente se a taxa de aprendizagem e o tamanho do lote escolhidos são adequados ao teu conjunto de dados específico e considera a afinação de hiperparâmetros para procurar valores melhores. Parâmetros que não estejam em sintonia com as características do conjunto de dados podem prejudicar o desempenho do modelo.

Distribuição de classes

  • Importância: a distribuição de classes no conjunto de dados pode influenciar as tendências de previsão do modelo.
  • Recomendação: avalie regularmente a distribuição das classes no seu conjunto de dados, por exemplo, com um script de auditoria do conjunto de dados. Se houver um desequilíbrio entre classes, existe o risco de o modelo desenvolver um viés em favor da classe mais frequente. Esse viés pode ficar evidente na matriz de confusão, em que o modelo pode prever predominantemente a classe majoritária.

Verificação cruzada com pesos pré-treinados

  • Importância: Aproveitar pesos pré-treinados pode proporcionar um ponto de partida sólido para o treinamento do modelo, especialmente quando há poucos dados.
  • Recomendação: como passo de diagnóstico, considera treinar o teu modelo com os mesmos dados, mas inicializando-o com pesos pré-treinados. Se esta abordagem gerar uma matriz de confusão bem formada, isso poderá indicar que o modelo treinado «do zero» precisa de mais treino ou de ajustes.

Abaixo, abordamos problemas comuns encontrados durante a previsão do modelo e as respetivas soluções.

Obter previsões de caixas delimitadoras com o teu modelo personalizado YOLO26#

Problema: Ao executar previsões com um modelo personalizado YOLO26, surgem desafios relacionados com o formato e a visualização das coordenadas das caixas delimitadoras.

Solução:

  • Formato das coordenadas: o YOLO26 fornece as coordenadas das caixas delimitadoras em valores absolutos de píxeis. Para as converter em coordenadas relativas (entre 0 e 1), tens de dividir pelas dimensões da imagem. Por exemplo, se o tamanho da imagem for 640x640:

    # Converter coordenadas absolutas em coordenadas relativas
    x1 = x1 / 640  # Dividir as coordenadas x pela largura da imagem
    x2 = x2 / 640
    y1 = y1 / 640  # Dividir as coordenadas y pela altura da imagem
    y2 = y2 / 640

    Em alternativa, usa os atributos boxes.xyxyn ou boxes.xywhn de cada resultado, que já devolvem coordenadas normalizadas.

  • Nome do ficheiro: Para obter o nome do ficheiro da imagem na qual estás a fazer previsões, lê o caminho do ficheiro de imagem do atributo path de cada objeto de resultado (por exemplo, result.path) dentro do ciclo de previsão.

Filtrar objetos nas previsões YOLO26#

Problema: Dificuldade em filtrar e apresentar apenas objetos específicos nos resultados da previsão ao executar YOLO26 com a biblioteca Ultralytics.

Solução: para detetar classes específicas, usa o argumento classes para especificar as classes que queres incluir na saída. Por exemplo, para detetar apenas carros (índice de classe 2 no COCO):

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

Compreender as métricas de precisão em YOLO26#

Problema: confusão entre a precisão das caixas, a precisão das máscaras e a precisão da matriz de confusão no YOLO26.

Solução: a precisão das caixas mede a exatidão das caixas delimitadoras previstas em comparação com as caixas de referência reais, usando a IoU (interseção sobre união) como métrica. A precisão das máscaras avalia a concordância entre as máscaras de segmentação previstas e as máscaras de referência na classificação de objetos ao nível do píxel. A precisão da matriz de confusão, por outro lado, centra-se na exatidão geral da classificação em todas as classes e não considera a exatidão geométrica das previsões. É importante notar que uma caixa delimitadora pode ser geometricamente exata (verdadeiro positivo), mesmo que a previsão da classe esteja errada, o que resulta em diferenças entre a precisão das caixas e a precisão da matriz de confusão. Estas métricas avaliam aspetos distintos do desempenho de um modelo, refletindo a necessidade de métricas de avaliação diferentes para várias tarefas.

Extrair as dimensões dos objetos em YOLO26#

Problema: dificuldade em obter a largura e a altura dos objetos detetados no YOLO26, especialmente quando são detetados vários objetos numa imagem.

Solução: Para obter as dimensões das caixas delimitadoras, começa por usar o modelo Ultralytics YOLO26 para prever objetos numa imagem. Em seguida, extrai as informações de largura e altura das caixas delimitadoras dos resultados da previsão.

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

Desafios de implementação#

Problemas de implementação em GPU#

Problema: a implementação de modelos num ambiente com várias GPU pode, por vezes, levar a comportamentos inesperados, como um uso invulgar da memória ou resultados inconsistentes entre GPU.

Solução: verifica a inicialização da GPU predefinida. Algumas estruturas, como o PyTorch, podem inicializar operações CUDA numa GPU predefinida antes de passar para as GPU designadas. Para evitar inicializações predefinidas inesperadas, especifica diretamente a GPU durante a implementação e a previsão. Em seguida, usa ferramentas para monitorizar a utilização da GPU e da memória e identificar anomalias em tempo real. Além disso, certifica-te de que estás a usar a versão mais recente da estrutura ou biblioteca.

Problemas de conversão/exportação de modelos#

Problema: Durante a conversão ou exportação de modelos de aprendizagem automática para diferentes formatos ou plataformas, os utilizadores podem encontrar erros ou comportamentos inesperados.

Solução: Consulta os formatos suportados e as opções de cada formato na documentação do modo Export e, em seguida, verifica o seguinte:

  • Verificação de compatibilidade: Certifica-te de que estás a usar versões de bibliotecas e frameworks compatíveis entre si. Versões incompatíveis podem causar erros inesperados durante a conversão.
  • Reinicialização do ambiente: Se estiveres a usar um ambiente interativo como Jupyter ou Colab, considera reiniciar o ambiente depois de fazer alterações importantes ou instalar componentes. Recomeçar do zero pode, por vezes, resolver problemas subjacentes.
  • Documentação oficial: Consulta sempre a documentação oficial da ferramenta ou biblioteca que estás a usar para a conversão. Muitas vezes, contém diretrizes específicas e boas práticas para exportar modelos.
  • Apoio da comunidade: Consulta o repositório oficial da biblioteca ou framework para ver se outros utilizadores relataram problemas semelhantes. Os responsáveis pela manutenção ou a comunidade podem ter apresentado soluções ou alternativas nos tópicos de discussão.
  • Atualizações regulares: Certifica-te de que estás a usar a versão mais recente da ferramenta ou biblioteca. Os programadores lançam atualizações frequentemente para corrigir erros conhecidos ou melhorar as funcionalidades.
  • Testes incrementais: Antes de fazer uma conversão completa, testa o processo com um modelo ou conjunto de dados menor para identificar possíveis problemas com antecedência.

Comunidade e apoio#

Pede ajuda e partilha soluções através destes canais e recursos.

Fóruns e canais de ajuda#

Problemas no GitHub: O repositório da Ultralytics no GitHub tem uma guia Issues, onde você pode fazer perguntas, relatar bugs e sugerir novos recursos. A comunidade e os responsáveis pela manutenção são ativos por lá, e esse é um ótimo lugar para obter ajuda com problemas específicos.

Servidor Discord da Ultralytics: A Ultralytics tem um servidor Discord onde você pode interagir com outros usuários e desenvolvedores.

Documentação e recursos oficiais#

Documentação Ultralytics YOLO26: A documentação oficial apresenta uma visão abrangente de YOLO26, bem como guias de instalação, utilização e resolução de problemas.

Conclusão#

A maioria dos problemas com YOLO26 deve-se a algumas causas comuns: incompatibilidades de versões, formatação do conjunto de dados e configuração da GPU. Se não encontrares aqui a resposta para um erro, pesquisa no separador Issues do GitHub ou pergunta no servidor Discord — é provável que alguém já o tenha resolvido. Para problemas mais complexos de treinamento, consulta o guia Dicas de treinamento de modelos para obter conselhos práticos sobre como conseguir melhores resultados nos teus projetos de visão computacional.

Perguntas frequentes#

  • Os erros de instalação devem-se frequentemente a problemas de compatibilidade ou dependências em falta. Certifica-te de que usas Python 3.8 ou posterior e que tens PyTorch 1.8 ou posterior instalado. É recomendável usar ambientes virtuais para evitar conflitos. Para obteres instruções de instalação passo a passo, segue o nosso guia oficial de instalação. Se encontrares erros de importação, tenta fazer uma instalação limpa ou atualizar a biblioteca para a versão mais recente.

  • O treinamento numa única GPU pode ser lento devido a tamanhos de lote grandes ou a memória insuficiente. Para acelerar o treinamento, usa várias GPU. Certifica-te de que o teu sistema tem várias GPU disponíveis e define o argumento device, por exemplo, device=[0,1,2,3]. Aumenta o tamanho do lote em conformidade para aproveitar ao máximo as GPU sem exceder os limites de memória. Exemplo de comando:

    model.train(data="/path/to/your/data.yaml", batch=32, device=[0, 1, 2, 3])
  • Se o valor de device mostrar null nos registos de treino, geralmente significa que o processo de treino está configurado para selecionar automaticamente uma GPU disponível. Para atribuir explicitamente uma GPU específica, passa o argumento device ao iniciar o treino, por exemplo, yolo train data=path/to/data.yaml device=0 para a primeira GPU. Executa nvidia-smi para confirmar a configuração de CUDA.

  • Podes acompanhar e visualizar eficazmente o progresso do treino com ferramentas como o TensorBoard, o Comet e a Ultralytics Platform. Estas ferramentas permitem registar e visualizar métricas como a perda, a precisão, a revocação e o mAP. Implementar a paragem antecipada com base nestas métricas também pode ajudar a obter melhores resultados de treino.

  • Certifica-te de que o teu conjunto de dados e as respetivas etiquetas estão no formato esperado. Verifica se as anotações são precisas e de alta qualidade. Se tiveres algum problema, consulta o guia Recolha e anotação de dados para conhecer as boas práticas. Para obter orientações específicas sobre conjuntos de dados, consulta a secção Conjuntos de dados da documentação.

Comentários70

Faz uma pergunta, partilha os teus resultados ou ajuda alguém.

  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.