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

Este guia aborda os problemas mais comuns que vais encontrar ao trabalhar com o Ultralytics YOLO26, agrupados pelo local onde ocorrem: instalação, treino de modelos, previsão e implementação. Salta para a categoria que corresponde ao teu erro ou consulta o FAQ para respostas rápidas. Cada entrada indica o problema e uma correção concreta que podes aplicar diretamente.

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.

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

Link to this sectionErros de Importação ou Problemas de Dependências#

Se obtiveres erros ao importar o YOLO26 ou se encontrares conflitos de dependências, tenta estes passos:

• Instalação Limpa: Começar com uma instalação limpa pode resolver problemas inesperados, especialmente após atualizações que alteram a estrutura ou funcionalidade do pacote.
• Atualiza Regularmente: Usa a versão mais recente da biblioteca, uma vez que versões antigas podem não ser compatíveis com atualizações recentes.
• Verifica Dependências: Confirma se todas as dependências necessárias estão corretamente instaladas e se possuem versões compatíveis.
• Analisa Alterações: Se instalaste uma versão antiga, consulta a documentação oficial ou o registo de alterações para compreender quaisquer mudanças estruturais importantes.

Link to this sectionExecutar o YOLO26 no GPU#

Se estás com dificuldades em executar o YOLO26 num 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.
• 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 teu código solicita o uso do GPU. Podes definir o argumento device ao executar o treino ou a previsão (por exemplo, device=0).

import torch

cap = torch.cuda.get_device_capability(0) if torch.cuda.is_available() else (0, 0)
cudnn = torch.backends.cudnn.version() or 0
ok = "not compatible" if cudnn >= 91100 and (cap[0] < 7 or (cap[0] == 7 and cap[1] < 5)) else "should be ok"
print(f"Compute capability: SM {cap[0]}.{cap[1]}, cuDNN: {cudnn} => {ok}")

Link to this sectionProblemas de Treino do Modelo#

Os problemas comuns de treino e as suas correções são abordados abaixo.

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:

• Precisão
• Recall
• Mean Average Precision (mAP)

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 conjunto de ferramentas extenso para rastreio e comparação de experiências. Permite-te monitorizar métricas, hiperparâmetros e até pesos de modelos. A integração com modelos YOLO é também direta, proporcionando-te uma visão geral completa do ciclo da tua experiência.
• 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.

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 'device' ser 'null' significa tipicamente que o processo de treino está configurado para selecionar automaticamente um GPU disponível, que é o comportamento predefinido. Para treinar num GPU específico, define o argumento device quando iniciares o treino. O device é um argumento de treino, por isso defini-lo no teu ficheiro .yaml de dataset não tem efeito:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")

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

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#

Os problemas comuns encontrados durante a previsão de modelos e as suas correções são abordados abaixo.

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 obter as dimensões da caixa delimitadora (bounding box), utiliza primeiro o modelo Ultralytics YOLO26 para prever objetos numa imagem. Depois, extrai a informação de largura e altura das caixas delimitadoras a partir 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: Analisa os formatos suportados e as opções por formato na documentação do Modo de Exportação e, em seguida, realiza estas verificações:

• 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#

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

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.

Link to this sectionConclusão#

A maioria dos problemas do YOLO26 deve-se a algumas causas: incompatibilidades de versão, formatação do dataset e configuração do GPU. Quando um erro não estiver aqui coberto, pesquisa no separador GitHub Issues ou pergunta no servidor Discord — é provável que alguém já o tenha resolvido. Para problemas mais complexos de treino, consulta o guia Dicas de Treino de Modelos para conselhos práticos sobre como obter melhores resultados nos teus projetos de visão computacional.

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 'device' aparecer como 'null' nos registos de treino, significa geralmente que o processo de treino está configurado para selecionar automaticamente um GPU disponível. Para atribuir explicitamente um GPU específico, passa o argumento device ao iniciar o treino, por exemplo yolo train data=path/to/data.yaml device=0 para o primeiro GPU. Consulta o comando nvidia-smi para confirmar a tua configuração do CUDA.

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

O rastreio 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, precisão, revocação e mAP. Implementar paragem precoce baseada 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?#

Garante que o teu dataset e 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 as melhores práticas. Para mais orientações específicas sobre datasets, verifica a secção Datasets na documentação.