Treinar YOLOv5 com Dados Personalizados#

📚 Este guia explica como treinar o teu próprio conjunto de dados personalizado usando o modelo YOLOv5 🚀. Treinar modelos personalizados é um passo fundamental para adaptar soluções de visão computacional a aplicações específicas do mundo real, para além da deteção de objetos genérica.

Antes de Começares#

Primeiro, certifica-te de que tens o ambiente necessário configurado. Clona o repositório YOLOv5 e instala as dependências necessárias a partir de requirements.txt. Um ambiente Python>=3.8.0 com PyTorch>=1.8 é essencial. Os modelos e conjuntos de dados são transferidos automaticamente da versão mais recente do YOLOv5 se não forem encontrados localmente.

git clone https://github.com/ultralytics/yolov5 # Clone the repository
cd yolov5
pip install -r requirements.txt # Install dependencies

Treinar com Dados Personalizados#

Desenvolver um modelo personalizado de deteção de objetos é um processo iterativo:

1. Recolher e Organizar Imagens: Reúne imagens relevantes para a tua tarefa específica. Dados diversificados e de alta qualidade são essenciais. Consulta o nosso guia sobre Recolha e Anotação de Dados.
2. Etiquetar Objetos: Anota com precisão os objetos de interesse nas tuas imagens.
3. Treinar um Modelo: Usa os dados etiquetados para treinar o teu modelo YOLOv5. Aproveita a aprendizagem por transferência, começando com pesos pré-treinados.
4. Implementar e Fazer Predições: Usa o modelo treinado para realizar inferência em dados novos e não vistos.
5. Recolher Casos-Limite: Identifica cenários em que o modelo tem um desempenho fraco (casos-limite) e adiciona dados semelhantes ao teu conjunto de dados para melhorar a robustez. Repete o ciclo.

A Ultralytics Platform oferece uma solução simplificada e sem código para todo este ciclo de operações de aprendizagem automática (MLOps), incluindo a gestão de conjuntos de dados, o treino de modelos e a implementação.

Antes de iniciares o treino, é essencial preparar o conjunto de dados.

1. Criar um Conjunto de Dados#

Os modelos YOLOv5 precisam de dados etiquetados para aprender as características visuais das classes de objetos. Organizar corretamente o teu conjunto de dados é fundamental.

1.1 Criar dataset.yaml#

O ficheiro de configuração do conjunto de dados (por exemplo, coco128.yaml) descreve a estrutura do conjunto de dados, os nomes das classes e os caminhos para os diretórios de imagens. O COCO128 é um pequeno conjunto de dados de exemplo, composto pelas primeiras 128 imagens do extenso conjunto de dados COCO. É útil para testar rapidamente o pipeline de treino e diagnosticar possíveis problemas, como o sobreajuste.

A estrutura do ficheiro dataset.yaml inclui:

• path: O diretório raiz que contém o conjunto de dados.
• train, val, test: Caminhos relativos de path para diretórios que contêm imagens ou ficheiros de texto com listas de caminhos de imagens para os conjuntos de treino, validação e teste.
• names: Um dicionário que associa índices de classes, começando em 0, aos respetivos nomes de classes.

Podes definir path como um diretório absoluto (por exemplo, /home/user/datasets/coco128) ou como um caminho relativo, como ../datasets/coco128, ao iniciar o treino a partir da raiz do repositório YOLOv5.

Abaixo encontra-se a estrutura de coco128.yaml (ver no GitHub):

# Dataset root directory relative to the yolov5 directory
path: coco128

# Train/val/test sets: specify directories, *.txt files, or lists
train: images/train2017 # 128 images for training
val: images/train2017 # 128 images for validation
test: # Optional path to test images

# Classes (example using 80 COCO classes)
names:
    0: person
    1: bicycle
    2: car
    # ... (remaining COCO classes)
    77: teddy bear
    78: hair drier
    79: toothbrush

1.2 Aproveitar Modelos para Etiquetagem Automatizada#

A etiquetagem manual é a abordagem mais comum, mas consome muito tempo. Os modelos fundacionais podem automatizar ou semiautomatizar a anotação e acelerar a criação de conjuntos de dados. Exemplos de modelos que podem ajudar a gerar etiquetas:

• Google Gemini: Modelos multimodais de grande escala, como o Gemini, possuem capacidades avançadas de compreensão de imagens. Podem ser instruídos a identificar e localizar objetos em imagens, gerando caixas delimitadoras ou descrições que podem ser convertidas em etiquetas no formato YOLO. Explora o seu potencial no notebook do tutorial fornecido.
• SAM2 (Modelo Segment Anything 2): Os modelos fundacionais focados em segmentação, como o SAM2, podem identificar e delimitar objetos com elevada precisão. Embora sejam principalmente destinados à segmentação, as máscaras resultantes podem frequentemente ser convertidas em anotações de caixas delimitadoras adequadas para tarefas de deteção de objetos.
• YOLOWorld: Este modelo oferece capacidades de deteção de vocabulário aberto. Podes fornecer descrições de texto dos objetos que te interessam, e o YOLOWorld consegue localizá-los em imagens sem ter sido previamente treinado nessas classes específicas. Isto pode ser usado como ponto de partida para gerar etiquetas iniciais, que podem depois ser refinadas.

A utilização destes modelos pode fornecer uma etapa de "pré-etiquetagem", reduzindo o esforço manual necessário. No entanto, é crucial rever e refinar as etiquetas geradas automaticamente para garantir precisão e consistência, uma vez que a qualidade afeta diretamente o desempenho do teu modelo YOLOv5 treinado. Depois de gerares (e, potencialmente, refinares) as tuas etiquetas, certifica-te de que cumprem o formato YOLO: um ficheiro *.txt por imagem, com cada linha a representar um objeto como class_index x_center y_center width height (coordenadas normalizadas, classe indexada a partir de zero). Se uma imagem não tiver objetos de interesse, não é necessário um ficheiro *.txt correspondente.

As especificações do ficheiro *.txt do formato YOLO são precisas:

• Uma linha por objeto caixa delimitadora.
• Cada linha deve conter: class_index x_center y_center width height.
• As coordenadas devem ser normalizadas para um intervalo entre 0 e 1. Para isso, divide os valores de píxeis de x_center e width pela largura total da imagem e divide y_center e height pela altura total da imagem.
• Os índices das classes começam em zero, ou seja, a primeira classe é representada por 0, a segunda por 1, e assim por diante.

O ficheiro de etiquetas correspondente à imagem acima, contendo dois objetos "person" (índice de classe 0) e um objeto "tie" (índice de classe 27), teria o seguinte aspeto:

1.3 Organizar Diretórios#

Estrutura o teu diretório de conjuntos de dados conforme ilustrado abaixo. Por predefinição, o YOLOv5 espera que o diretório do conjunto de dados (por exemplo, /coco128) esteja dentro de uma pasta /datasets localizada junto ao diretório do repositório /yolov5.

O YOLOv5 localiza automaticamente as etiquetas de cada imagem substituindo a última ocorrência de /images/ no caminho da imagem por /labels/. Por exemplo:

../datasets/coco128/images/im0.jpg # Path to the image file
../datasets/coco128/labels/im0.txt # Path to the corresponding label file

A estrutura de diretórios recomendada é:

/datasets/
└── coco128/  # Dataset root
    ├── images/
    │   ├── train2017/  # Training images
    │   │   ├── 000000000009.jpg
    │   │   └── ...
    │   └── val2017/    # Validation images (optional if using same set for train/val)
    │       └── ...
    └── labels/
        ├── train2017/  # Training labels
        │   ├── 000000000009.txt
        │   └── ...
        └── val2017/    # Validation labels (optional if using same set for train/val)
            └── ...

2. Selecionar um Modelo#

Escolhe um modelo pré-treinado para iniciar o processo de treino. Começar com pesos pré-treinados acelera significativamente a aprendizagem e melhora o desempenho em comparação com o treino a partir do zero. O YOLOv5 oferece vários tamanhos de modelo, cada um equilibrando a velocidade e a precisão de forma diferente. Por exemplo, o YOLOv5s é o segundo modelo mais pequeno e o mais rápido, sendo adequado para ambientes com recursos limitados. Consulta a tabela do README para uma comparação detalhada de todos os modelos disponíveis.

3. Treinar#

Inicia o treino do modelo usando o script train.py. Os argumentos essenciais incluem:

• --img: Define o tamanho da imagem de entrada (por exemplo, --img 640). Tamanhos maiores geralmente proporcionam melhor precisão, mas requerem mais memória da GPU.
• --batch: Determina o tamanho do lote (por exemplo, --batch 16). Escolhe o maior tamanho que a tua GPU consiga suportar.
• --epochs: Especifica o número total de épocas de treino (por exemplo, --epochs 100). Uma época representa uma passagem completa por todo o conjunto de dados de treino.
• --data: Caminho para o teu ficheiro dataset.yaml (por exemplo, --data coco128.yaml).
• --weights: Caminho para o ficheiro de pesos iniciais. A utilização de pesos pré-treinados (por exemplo, --weights yolov5s.pt) é altamente recomendada para uma convergência mais rápida e melhores resultados. Para treinar a partir do zero (não recomendado, exceto se tiveres um conjunto de dados muito grande e necessidades específicas), usa --weights '' --cfg yolov5s.yaml.

Os pesos pré-treinados são transferidos automaticamente da versão mais recente do YOLOv5 se não forem encontrados localmente.

# Example: Train YOLOv5s on the COCO128 dataset for 3 epochs
python train.py --img 640 --batch 16 --epochs 3 --data coco128.yaml --weights yolov5s.pt

Todos os resultados do treino, incluindo pesos e registos, são guardados no diretório runs/train/. Cada sessão de treino cria um novo subdiretório (por exemplo, runs/train/exp, runs/train/exp2, etc.). Para uma experiência interativa e prática, explora a secção de treino nos nossos notebooks oficiais do tutorial:

4. Visualizar#

O YOLOv5 integra-se perfeitamente com várias ferramentas para visualizar o progresso do treino, avaliar resultados e monitorizar o desempenho em tempo real.

Registo e Visualização com o Comet#

O Comet está totalmente integrado para um acompanhamento abrangente de experiências. Visualiza métricas em tempo real, guarda hiperparâmetros, gere conjuntos de dados e checkpoints de modelos e analisa predições dos modelos usando Painéis Personalizados do Comet interativos.

Começar é simples:

pip install comet_ml                                                          # 1. Install Comet library
export COMET_API_KEY=YOUR_API_KEY_HERE                                        # 2. Set your Comet API key (create a free account at Comet.ml)
python train.py --img 640 --epochs 3 --data coco128.yaml --weights yolov5s.pt # 3. Train your model - Comet automatically logs everything!

Explora em maior profundidade as funcionalidades suportadas no nosso Guia de Integração do Comet. Obtém mais informações sobre as capacidades do Comet na sua documentação oficial. Experimenta o Notebook Colab do Comet para uma demonstração ao vivo:

Registo e Automatização com o ClearML#

A integração com o ClearML permite um acompanhamento detalhado de experiências, a gestão de versões de conjuntos de dados e até a execução remota de sessões de treino. Ativa o ClearML com estes passos simples:

• Instala o pacote: pip install clearml
• Inicializa o ClearML: Executa clearml-init uma vez para te ligares ao teu servidor ClearML, alojado localmente ou no nível gratuito.

O ClearML captura automaticamente detalhes das experiências, carregamentos de modelos, comparações, alterações de código não confirmadas e pacotes instalados, garantindo uma reprodutibilidade completa. Podes agendar facilmente tarefas de treino em agentes remotos e gerir versões de conjuntos de dados usando o ClearML Data. Consulta o Guia de Integração do ClearML para obter todos os detalhes.

Registo Local#

Os resultados do treino são registados automaticamente usando o TensorBoard e guardados como ficheiros CSV no diretório específico da experiência (por exemplo, runs/train/exp). Os dados registados incluem:

• Perdas e métricas de desempenho do treino e da validação.
• Imagens de exemplo que mostram as transformações aplicadas, como mosaicos.
• Etiquetas de verdade fundamental juntamente com as predições do modelo para inspeção visual.
• Métricas de avaliação essenciais, como curvas de Precisão-Revocação (PR).
• Matrizes de confusão para uma análise detalhada do desempenho por classe.

O ficheiro results.csv é atualizado após cada época e representado como results.png quando o treino termina. Também podes representar manualmente qualquer ficheiro results.csv usando a função utilitária fornecida:

from utils.plots import plot_results

# Plot results from a specific training run directory
plot_results("runs/train/exp/results.csv")  # This will generate 'results.png' in the same directory

5. Próximos Passos#

Após a conclusão bem-sucedida do treino, o melhor checkpoint do modelo (best.pt) é guardado e está pronto para implementação ou aperfeiçoamento adicional. Os próximos passos possíveis incluem:

• Executa inferência em novas imagens ou vídeos usando o modelo treinado através da CLI ou de Python.
• Realiza a validação para avaliar a precisão e as capacidades de generalização do modelo em diferentes divisões de dados, como um conjunto de teste separado.
• Exporta o modelo para vários formatos de implementação, como ONNX, TensorFlow SavedModel ou TensorRT, para uma inferência otimizada em diversas plataformas.
• Usa técnicas de ajuste de hiperparâmetros para obter potencialmente ganhos adicionais de desempenho.
• Continua a melhorar o teu modelo seguindo as nossas Dicas para Obter os Melhores Resultados de Treino e adicionando iterativamente dados mais diversificados e desafiantes com base na análise do desempenho.

Ambientes suportados#

A Ultralytics disponibiliza ambientes prontos a usar, equipados com dependências essenciais como CUDA, cuDNN, Python e PyTorch, facilitando um início simples.

• Notebooks GPU Gratuitos:
  • 
  • 
  • 
• Plataformas na Nuvem:
  • Google Cloud: Guia de início rápido do GCP
  • Amazon AWS: Guia de Início Rápido do AWS
  • Microsoft Azure: Guia de Início Rápido do AzureML
• Configuração Local:
  • Docker: Guia de início rápido do Docker

Estado do projeto#

Este selo indica que todos os testes de Integração Contínua (CI) das GitHub Actions do YOLOv5 estão a passar com sucesso. Estes testes rigorosos de CI abrangem as funcionalidades essenciais, incluindo treino, validação, inferência, exportação e benchmarks, nos sistemas operativos macOS, Windows e Ubuntu. Os testes são executados automaticamente a cada 24 horas e após cada commit de código, garantindo estabilidade consistente e desempenho ideal.

Perguntas frequentes#