Meet YOLO26: next-gen vision AI.

Link to this sectionSolução de problemas comuns do YOLO#

YOLO common training and deployment issues

Link to this sectionIntrodução#

Este guia serve como uma ajuda abrangente para solucionar problemas comuns encontrados ao trabalhar com o YOLO26 nos teus projetos Ultralytics. Navegar por essas questões pode ser simples com a orientação certa, garantindo que os teus projetos permaneçam no caminho certo sem atrasos desnecessários.



Watch: Ultralytics YOLO26 Common Issues | Installation Errors, Model Training Issues

Link to this sectionProblemas Comuns#

Link to this sectionErros de instalação#

Erros de instalação podem surgir devido a vários motivos, como versões incompatíveis, dependências ausentes ou configurações de ambiente incorretas. Primeiro, verifica se estás a fazer o seguinte:

  • Estás a usar o Python 3.8 ou posterior conforme recomendado.
  • Certifica-te de que tens a versão correta do PyTorch (1.8 ou posterior) instalada.
  • Considera usar ambientes virtuais para evitar conflitos.
  • Segue o guia oficial de instalação passo a passo.

Adicionalmente, aqui estão alguns problemas comuns de instalação que os utilizadores encontraram, juntamente com as suas respetivas soluções:

  • Erros de Importação ou Problemas de Dependência - Se estás a obter erros durante a importação do YOLO26, ou se estás a ter problemas relacionados com dependências, considera os seguintes passos de resolução de problemas:

    • Instalação Limpa: Às vezes, começar com uma instalação limpa pode resolver problemas inesperados. Especialmente com bibliotecas como a Ultralytics, onde atualizações podem introduzir alterações na estrutura da árvore de ficheiros ou funcionalidades.

    • Atualiza Regularmente: Garante que estás a usar a versão mais recente da biblioteca. Versões mais antigas podem não ser compatíveis com atualizações recentes, levando a potenciais conflitos ou problemas.

    • Verifica Dependências: Verifica se todas as dependências necessárias estão instaladas corretamente e se possuem as versões compatíveis.

    • Revê Alterações: Se inicialmente clonaste ou instalaste uma versão mais antiga, tem em conta que atualizações significativas podem afetar a estrutura ou as funcionalidades da biblioteca. Consulta sempre a documentação oficial ou os registos de alterações para compreender quaisquer mudanças importantes.

    • Lembra-te, manter as tuas bibliotecas e dependências atualizadas é crucial para uma experiência fluida e sem erros.

  • Executar o YOLO26 no GPU - Se estás a ter problemas em executar o YOLO26 no GPU, considera os seguintes passos de resolução de problemas:

    • Verifica a Compatibilidade e Instalação do CUDA: Garante que o teu GPU é compatível com CUDA e que o CUDA está instalado corretamente. Usa o comando nvidia-smi para verificar o estado do teu GPU NVIDIA e a versão do CUDA.

    • Verifica a Integração do PyTorch e CUDA: Garante que o PyTorch consegue utilizar o CUDA executando import torch; print(torch.cuda.is_available()) num terminal Python. Se retornar 'True', o PyTorch está configurado para usar o CUDA.

    • Verifica a compatibilidade do GPU: O suporte para arquiteturas de GPU anteriores a Turing e capacidade de computação (SM) < 7.5 foi abandonado desde o cuDNN 9.11.0. Portanto, se tens um GPU mais antigo - como a 1080Ti - poderás ter de usar uma versão do PyTorch compilada com uma versão mais antiga do CUDA/cuDNN. Podes verificar isto executando 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}")

    • Ativação do Ambiente: Garante que estás no ambiente correto onde todos os pacotes necessários estão instalados.

    • Atualiza os Teus Pacotes: Pacotes desatualizados podem não ser compatíveis com o teu GPU. Mantém-nos atualizados.

    • Configuração do Programa: Verifica se o programa ou código especifica a utilização de GPU. No YOLO26, isto pode estar nas definições ou na configuração.

Link to this sectionProblemas de Treino do Modelo#

Esta secção abordará problemas comuns enfrentados durante o treino e as suas respetivas explicações e soluções.

Link to this sectionVerificação das Definições de Configuração#

Problema: Não tens a certeza se as definições de configuração no ficheiro .yaml estão a ser aplicadas corretamente durante o treino do modelo.

Solução: As definições de configuração no ficheiro .yaml devem ser aplicadas ao usar a função model.train(). Para garantir que estas definições são aplicadas corretamente, segue estes passos:

  • Confirma que o caminho para o teu ficheiro de configuração .yaml está correto.

  • Certifica-te de que passas o caminho para o teu ficheiro .yaml como o argumento data ao chamar model.train(), como mostrado abaixo:

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

Link to this sectionAcelerar o Treino com Múltiplos GPUs#

Problema: O treino é lento num único GPU e queres acelerar o processo usando múltiplos GPUs.

Solução: Aumentar o batch size pode acelerar o treino, mas é essencial considerar a capacidade de memória do GPU. Para acelerar o treino com múltiplos GPUs, segue estes passos:

  • Garante que tens múltiplos GPUs disponíveis.

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

  • Aumenta o batch size correspondentemente para utilizar totalmente os múltiplos GPUs sem exceder os limites de memória.

  • Modifica o teu comando de treino para utilizar múltiplos GPUs:

    # Adjust the batch size and other settings as needed to optimize training speed
model.train(data="/path/to/your/data.yaml", batch=32, device=[0, 1, 2, 3])

Link to this sectionParâmetros de Monitorização Contínua#

Problema: Queres saber que parâmetros devem ser monitorizados continuamente durante o treino, além da loss.

Solução: Embora a loss seja uma métrica crucial para monitorizar, também é essencial acompanhar outras métricas para a otimização do desempenho do modelo. Algumas métricas chave a monitorizar durante o treino incluem:

Podes aceder a estas métricas a partir dos registos de treino ou usando ferramentas como o TensorBoard ou wandb para visualização. Implementar paragem antecipada (early stopping) com base nestas métricas pode ajudar-te a alcançar melhores resultados.

Link to this sectionFerramentas para Rastrear o Progresso do Treino#

Problema: Estás à procura de recomendações de ferramentas para rastrear o progresso do treino.

Solução: Para rastrear e visualizar o progresso do treino, podes considerar o uso das seguintes ferramentas:

  • TensorBoard: O TensorBoard é uma escolha popular para visualizar métricas de treino, incluindo loss, accuracy, e mais. Podes integrá-lo no teu processo de treino YOLO26.
  • Comet: O Comet fornece um kit de ferramentas extenso para rastreio e comparação de experiências. Permite-te rastrear métricas, hiperparâmetros e até pesos do modelo. A integração com modelos YOLO é também simples, proporcionando-te uma visão geral completa do teu ciclo de experimentação.
  • Ultralytics Platform: A Ultralytics Platform oferece um ambiente especializado para rastrear modelos YOLO, dando-te uma plataforma única para gerir métricas, datasets e até colaborar com a tua equipa. Dado o seu foco adaptado ao YOLO, oferece opções de rastreio mais personalizadas.

Cada uma destas ferramentas oferece o seu próprio conjunto de vantagens, por isso podes querer considerar as necessidades específicas do teu projeto ao fazer uma escolha.

Link to this sectionComo verificar se o treino está a ocorrer no GPU#

Problema: O valor de 'device' nos registos de treino é 'null' e não tens a certeza se o treino está a acontecer no GPU.

Solução: O valor de 'device' ser 'null' significa tipicamente que o processo de treino está configurado para usar automaticamente um GPU disponível, o que é o comportamento padrão. Para garantir que o treino ocorra num GPU específico, podes definir manualmente o valor de 'device' para o índice do GPU (por exemplo, '0' para o primeiro GPU) no teu ficheiro de configuração .yaml:

device: 0

Isto irá atribuir explicitamente o processo de treino ao GPU especificado. Se desejares treinar no CPU, define 'device' como 'cpu'.

Mantém-te atento à pasta 'runs' para registos e métricas para monitorizar o progresso do treino eficazmente.

Link to this sectionConsiderações Chave para um Treino de Modelo Eficaz#

Aqui estão algumas coisas a ter em mente, se estás a enfrentar problemas relacionados com o treino de modelos.

Formato do Dataset e Etiquetas

  • Importância: A base de qualquer modelo de machine learning reside na qualidade e formato dos dados com os quais é treinado.
  • Recomendação: Garante que o teu dataset personalizado e as suas etiquetas associadas cumprem o formato esperado. É crucial verificar se as anotações são precisas e de alta qualidade. Anotações incorretas ou de baixa qualidade podem descarrilar o processo de aprendizagem do modelo, levando a resultados imprevisíveis.

Convergência do Modelo

  • Importância: Alcançar a convergência do modelo garante que o modelo aprendeu suficientemente com os training data.
  • Recomendação: Ao treinar um modelo 'do zero', é vital garantir que o modelo atinja um nível satisfatório de convergência. Isto pode exigir uma duração de treino mais longa, com mais epochs, comparado com quando estás a ajustar um modelo existente.

Learning Rate e Batch Size

  • Importância: Estes hiperparâmetros desempenham um papel fundamental na determinação de como o modelo atualiza os seus pesos durante o treino.
  • Recomendação: Avalia regularmente se a taxa de aprendizagem e o batch size escolhidos são ideais para o teu dataset específico. Parâmetros que não estão em harmonia com as características do dataset podem prejudicar o desempenho do modelo.

Distribuição de Classes

  • Importância: A distribuição de classes no teu dataset pode influenciar as tendências de previsão do modelo.
  • Recomendação: Avalia regularmente a distribuição de classes dentro do teu dataset. Se houver um desequilíbrio de classes, há o risco de o modelo desenvolver uma tendência para a classe mais prevalente. Esta tendência pode ser evidente na matriz de confusão, onde o modelo pode prever predominantemente a classe maioritária.

Verificação Cruzada com Pesos Pré-treinados

  • Importância: Aproveitar pesos pré-treinados pode fornecer um ponto de partida sólido para o treino do modelo, especialmente quando os dados são limitados.
  • Recomendação: Como passo de diagnóstico, considera treinar o teu modelo usando os mesmos dados, mas inicializando-o com pesos pré-treinados. Se esta abordagem produzir uma matriz de confusão bem formada, pode sugerir que o modelo treinado 'do zero' pode precisar de mais treino ou ajustes.

Link to this sectionProblemas Relacionados com Previsões do Modelo#

Esta secção abordará problemas comuns enfrentados durante a previsão do modelo.

Link to this sectionObter Previsões de Bounding Box com o Teu Modelo Personalizado YOLO26#

Problema: Ao executar previsões com um modelo personalizado YOLO26, existem desafios com o formato e visualização das coordenadas das bounding boxes.

Solução:

  • Formato de Coordenadas: O YOLO26 fornece coordenadas de bounding box em valores absolutos de píxeis. Para convertê-las para coordenadas relativas (variando de 0 a 1), precisas de dividir pelas dimensões da imagem. Por exemplo, digamos que o tamanho da tua imagem é 640x640. Então farias o seguinte:

    # Convert absolute coordinates to relative coordinates
x1 = x1 / 640  # Divide x-coordinates by image width
x2 = x2 / 640
y1 = y1 / 640  # Divide y-coordinates by image height
y2 = y2 / 640

  • Nome do Ficheiro: Para obter o nome do ficheiro da imagem na qual estás a fazer previsões, acede ao caminho do ficheiro da imagem diretamente a partir do objeto de resultado dentro do teu ciclo de previsão.

Link to this sectionFiltrar Objetos em Previsões YOLO26#

Problema: Enfrentar problemas sobre como filtrar e exibir apenas objetos específicos nos resultados de previsão ao executar o YOLO26 usando 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 (assumindo que 'carros' têm o índice de classe 2):

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

Link to this sectionCompreender as Métricas de Precisão no YOLO26#

Problema: Confusão relativamente à diferença entre precisão de caixa (box), precisão de máscara e precisão da confusion matrix no YOLO26.

Solução: A precisão de caixa mede a precisão das bounding boxes previstas comparadas com as caixas de verdade (ground truth) reais usando IoU (Intersection over Union) como métrica. A precisão de máscara avalia a concordância entre as máscaras de segmentação previstas e as máscaras de ground truth na classificação de objetos ao nível do píxel. A precisão da matriz de confusão, por outro lado, foca-se na precisão geral da classificação em todas as classes e não considera a precisão geométrica das previsões. É importante notar que uma bounding box pode ser geometricamente precisa (verdadeiro positivo) mesmo que a previsão da classe esteja errada, levando a diferenças entre a precisão da caixa e a precisão da matriz de confusão. Estas métricas avaliam aspetos distintos do desempenho de um modelo, refletindo a necessidade de diferentes métricas de avaliação em várias tarefas.

Link to this sectionExtrair Dimensões de Objetos no YOLO26#

Problema: Dificuldade em recuperar o comprimento e altura dos objetos detetados no YOLO26, especialmente quando múltiplos objetos são detetados numa imagem.

Solução: Para recuperar as dimensões da bounding box, primeiro usa o modelo YOLO26 da Ultralytics para prever objetos numa imagem. Depois, extrai a informação de largura e altura das bounding boxes 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}")

Link to this sectionDesafios de Implementação#

Link to this sectionProblemas de Implementação em GPU#

Problema: Implementar modelos num ambiente multi-GPU pode, por vezes, levar a comportamentos inesperados como uso de memória inesperado, resultados inconsistentes entre GPUs, etc.

Solução: Verifica a inicialização padrão do GPU. Alguns frameworks, como o PyTorch, podem inicializar operações CUDA num GPU padrão antes de transitar para os GPUs designados. Para contornar inicializações padrão inesperadas, especifica o GPU diretamente durante a implementação e previsão. Em seguida, usa ferramentas para monitorizar a utilização do GPU e o uso de memória para identificar quaisquer anomalias em tempo real. Além disso, garante que estás a usar a versão mais recente do framework ou biblioteca.

Link to this sectionProblemas de Conversão/Exportação de Modelos#

Problema: Durante o processo de conversão ou exportação de modelos de machine learning para diferentes formatos ou plataformas, os utilizadores podem encontrar erros ou comportamentos inesperados.

Solução:

  • Verificação de Compatibilidade: Garante que estás a usar versões de bibliotecas e frameworks que são compatíveis entre si. Versões incompatíveis podem levar a erros inesperados durante a conversão.
  • Reinicialização do Ambiente: Se estás a usar um ambiente interativo como o Jupyter ou Colab, considera reiniciar o teu ambiente após fazeres alterações ou instalações significativas. Um novo começo 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. Frequentemente, contém diretrizes específicas e melhores práticas para a exportação de modelos.
  • Suporte da Comunidade: Verifica o repositório oficial da biblioteca ou framework para problemas semelhantes reportados por outros utilizadores. Os responsáveis ou a comunidade podem ter fornecido soluções ou alternativas em tópicos de discussão.
  • Atualiza Regularmente: Garante que estás a usar a versão mais recente da ferramenta ou biblioteca. Os programadores lançam frequentemente atualizações que corrigem bugs conhecidos ou melhoram a funcionalidade.
  • Testa de Forma Incremental: Antes de realizar uma conversão completa, testa o processo com um modelo ou dataset menor para identificar potenciais problemas precocemente.

Link to this sectionComunidade e Suporte#

Envolver-se com uma comunidade de indivíduos com mentalidade semelhante pode melhorar significativamente a tua experiência e sucesso ao trabalhar com o YOLO26. Abaixo estão alguns canais e recursos que poderás achar úteis.

Link to this sectionFóruns e Canais para Obter Ajuda#

Issues do GitHub: O repositório do YOLO26 no GitHub possui uma aba de Issues onde podes fazer perguntas, reportar bugs e sugerir novas funcionalidades. A comunidade e os responsáveis pela manutenção são ativos aqui, sendo um excelente lugar para obteres ajuda com problemas específicos.

Servidor Discord da Ultralytics: A Ultralytics tem um servidor Discord onde podes interagir com outros utilizadores e com os desenvolvedores.

Link to this sectionDocumentação Oficial e Recursos#

Documentação do Ultralytics YOLO26: A documentação oficial fornece uma visão geral completa do YOLO26, juntamente com guias sobre instalação, utilização e resolução de problemas.

Estes recursos devem fornecer uma base sólida para resolver problemas e melhorar os teus projetos com YOLO26, bem como para te conectares com outras pessoas na comunidade YOLO26.

Link to this sectionConclusão#

A resolução de problemas é uma parte integrante de qualquer processo de desenvolvimento, e estar equipado com o conhecimento certo pode reduzir significativamente o tempo e o esforço gastos na resolução de questões. Este guia teve como objetivo abordar os desafios mais comuns enfrentados pelos utilizadores do modelo YOLO26 dentro do ecossistema Ultralytics. Ao compreender e resolver estes problemas comuns, podes garantir um progresso de projeto mais fluido e alcançar melhores resultados nas tuas tarefas de visão computacional.

Lembra-te, a comunidade Ultralytics é um recurso valioso. Envolver-te com colegas desenvolvedores e especialistas pode fornecer insights e soluções adicionais que podem não estar cobertas na documentação padrão. Continua sempre a aprender, a experimentar e a partilhar as tuas experiências para contribuir para o conhecimento coletivo da comunidade.

Link to this sectionFAQ#

Link to this sectionComo resolvo erros de instalação com o YOLO26?#

Erros de instalação podem frequentemente ser devidos a problemas de compatibilidade ou dependências em falta. Certifica-te de que utilizas Python 3.8 ou superior e que tens o PyTorch 1.8 ou superior instalado. É benéfico utilizar ambientes virtuais para evitar conflitos. Para um guia de instalação passo a passo, segue o nosso guia de instalação oficial. Se encontrares erros de importação, tenta uma instalação limpa ou atualiza a biblioteca para a versão mais recente.

Link to this sectionPor que é que o treino do meu modelo YOLO26 está lento num único GPU?#

O treino num único GPU pode ser lento devido a tamanhos de batch grandes ou memória insuficiente. Para acelerar o treino, utiliza múltiplos GPUs. Certifica-te de que o teu sistema tem múltiplos GPUs disponíveis e define o argumento device, por exemplo, device=[0,1,2,3]. Aumenta o tamanho do batch adequadamente para utilizar totalmente os GPUs sem exceder os limites de memória. Comando de exemplo:

model.train(data="/path/to/your/data.yaml", batch=32, device=[0, 1, 2, 3])

Link to this sectionComo posso garantir que o meu modelo YOLO26 está a treinar no GPU?#

Se o valor de 'device' aparecer como 'null' nos registos de treino, geralmente significa que o processo de treino está configurado para utilizar automaticamente um GPU disponível. Para atribuir explicitamente um GPU específico, define o valor 'device' no teu ficheiro de configuração .yaml. Por exemplo:

device: 0

Isto define o processo de treino para o primeiro GPU. Consulta o comando nvidia-smi para confirmar a tua configuração CUDA.

Link to this sectionComo posso monitorizar e acompanhar o progresso do treino do meu modelo YOLO26?#

O acompanhamento e a visualização do progresso do treino podem ser geridos eficientemente através de ferramentas como TensorBoard, Comet e a Plataforma Ultralytics. Estas ferramentas permitem-te registar e visualizar métricas como perda (loss), precisão, recall e mAP. Implementar paragem antecipada com base nestas métricas também pode ajudar a alcançar melhores resultados de treino.

Link to this sectionO que devo fazer se o YOLO26 não reconhecer o formato do meu conjunto de dados?#

Certifica-te de que o teu conjunto de dados e as tuas etiquetas estão em conformidade com o formato esperado. Verifica se as anotações são precisas e de alta qualidade. Se enfrentares algum problema, consulta o guia de Recolha e Anotação de Dados para melhores práticas. Para mais orientações específicas sobre conjuntos de dados, consulta a secção Datasets na documentação.

Contribuidores
GLglenn-jocher14RIRizwanMunawar4ARartest081PDpderrenger1AKakdanz1Y-Y-T-G1WIWillie Maddox1LALaughing-q1

Comentários