Treine o YOLOv5 em dados personalizados#

📚 Este guia explica como treinar o teu próprio conjunto de dados personalizado usando o modelo YOLOv5 🚀. O treino de modelos personalizados é um passo fundamental para adaptar as 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çar#

Primeiro, certifica-te de que tens o ambiente necessário configurado. Clona o repositório do 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 descarregados automaticamente a partir do lançamento 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

Treine com dados personalizados#

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

1. Recolher e Organizar Imagens: Reúne imagens relevantes para a tua tarefa específica. Dados diversos e de alta qualidade são cruciais. Vê o nosso guia sobre Recolha e Anotação de Dados.
2. Rotular objetos: Anote os objetos de interesse dentro de suas imagens com precisão.
3. Treinar um Modelo: Usa os dados rotulados para treinar o teu modelo YOLOv5. Tira partido da aprendizagem por transferência começando com pesos pré-treinados.
4. Implementar e Prever: Utiliza o modelo treinado para inferência em dados novos e nunca antes vistos.
5. Recolher Casos Extremos: Identifica cenários em que o modelo tem um desempenho fraco (casos extremos) 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 iniciar o treinamento, a preparação do conjunto de dados é essencial.

Criar um conjunto de dados#

Os modelos YOLOv5 exigem dados rotulados para aprender as características visuais das classes de objetos. Organizar seu conjunto de dados corretamente é 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 serve como um pequeno conjunto de dados de exemplo, compreendendo as primeiras 128 imagens do extenso conjunto de dados COCO. É útil para testar rapidamente o pipeline de treino e diagnosticar potenciais problemas como overfitting.

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 os caminhos das imagens para os conjuntos de treino, validação e teste.
• names: Um dicionário que mapeia os índices de classes (começando em 0) para os respetivos nomes de classes.

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

Abaixo encontra-se a estrutura para 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 rotulagem automatizada#

A rotulagem manual é a abordagem comum, mas é demorada. Modelos de base podem automatizar ou semiautomatizar a anotação e acelerar a criação do conjunto de dados. Exemplos de modelos que podem ajudar a gerar rótulos:

• Google Gemini: Grandes modelos multimodais como o Gemini possuem capacidades poderosas de compreensão de imagem. Podem ser instruídos para identificar e localizar objetos dentro de imagens, gerando caixas delimitadoras ou descrições que podem ser convertidas em rótulos no formato YOLO. Explora o seu potencial no caderno de tutorial fornecido.
• SAM2 (Segment Anything Model 2): Modelos de fundação focados na segmentação, como o SAM2, podem identificar e delinear objetos com alta precisão. Embora sejam primariamente para 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 em texto dos objetos em que estás interessado, e o YOLOWorld pode localizá-los em imagens sem treino prévio nessas classes específicas. Isto pode ser usado como ponto de partida para gerar rótulos iniciais, que podem depois ser refinados.

A utilização destes modelos pode fornecer um passo de "pré-rotulagem", reduzindo o esforço manual necessário. No entanto, é crucial rever e refinar os rótulos gerados automaticamente para garantir a precisão e a consistência, uma vez que a qualidade afeta diretamente o desempenho do teu modelo YOLOv5 treinado. Após gerar (e potencialmente refinar) os teus rótulos, 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 zero). Se uma imagem não tiver objetos de interesse, não é necessário qualquer ficheiro *.txt correspondente.

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

• Uma linha por caixa delimitadora de objeto.
• 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 consegui-lo, 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 de classe são indexados a zero (ou seja, a primeira classe é representada por 0, a segunda por 1, e assim por diante).

O ficheiro de rótulos correspondente à imagem acima, contendo dois objetos 'person' (índice de classe 0) e um objeto 'tie' (índice de classe 27), seria assim:

1.3 Organizar diretórios#

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

O YOLOv5 localiza automaticamente os rótulos para 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ório 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)
            └── ...

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 modelos, cada um equilibrando a velocidade e a precisão de forma diferente. Por exemplo, o YOLOv5s é o segundo mais pequeno e o mais rápido, adequado para ambientes com recursos limitados. Consulta a tabela do README para uma comparação detalhada de todos os modelos disponíveis.

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 produzem melhor precisão, mas exigem mais memória de GPU.
• --batch: Determina o tamanho do lote (por exemplo, --batch 16). Escolhe o maior tamanho que a tua GPU consegue 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 resultados superiores. Para treinar a partir do zero (não aconselhado, a menos que tenhas um conjunto de dados muito grande e necessidades específicas), usa --weights '' --cfg yolov5s.yaml.

Os pesos pré-treinados são descarregados automaticamente a partir do lançamento 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 outputs de 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 prática e interativa, explora a secção de treino nos nossos cadernos de tutoriais oficiais:

Visualizar#

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

Registro e visualização com Comet#

O Comet está totalmente integrado para um acompanhamento abrangente de experiências. Visualiza métricas em direto, guarda hiperparâmetros, gere conjuntos de dados e pontos de controlo de modelos, e analisa previsões de modelos utilizando os Comet Custom Panels interativos.

Começar é direto:

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!

Aprofunda as funcionalidades suportadas no nosso Guia de Integração do Comet. Sabe mais sobre as capacidades do Comet na documentação oficial deles. Experimenta o Caderno do Colab do Comet para uma demonstração em direto:

Registro e automação com ClearML#

A integração com o ClearML permite o acompanhamento detalhado de experiências, a gestão de versões de conjuntos de dados e até a execução remota de execuçõ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 ligar ao teu servidor ClearML (auto-hospedado ou o nível gratuito).

O ClearML captura automaticamente os detalhes da experiência, carregamentos de modelos, comparações, alterações de código não consolidadas e pacotes instalados, garantindo total reprodutibilidade. Podes facilmente agendar tarefas de treino em agentes remotos e gerir versões de conjuntos de dados utilizando o ClearML Data. Explora o Guia de Integração do ClearML para obter detalhes abrangentes.

Registro local#

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

• Perda de treinamento e validação e métricas de desempenho.
• Imagens de amostra mostrando aumentos aplicados (como mosaicos).
• Rótulos de verdade fundamental junto com as previsões do modelo para inspeção visual.
• Métricas de avaliação chave, tais 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 é traçado como results.png assim que o treino termina. Podes também traçar qualquer ficheiro results.csv manualmente utilizando a função de utilidade 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

Próximos passos#

Após a conclusão bem-sucedida do treino, o ponto de controlo do modelo com melhor desempenho (best.pt) é guardado e está pronto para implementação ou refinamento adicional. Os próximos passos potenciais incluem:

• Executar inferência em novas imagens ou vídeos utilizando o modelo treinado através da CLI ou do Python.
• Realizar a validação para avaliar a precisão do modelo e as capacidades de generalização em diferentes divisões de dados (por exemplo, um conjunto de teste retido).
• Exportar o modelo para vários formatos de implementação, como ONNX, TensorFlow SavedModel ou TensorRT para uma inferência otimizada em diversas plataformas.
• Empregar técnicas de afinação de hiperparâmetros para extrair potencialmente ganhos de desempenho adicionais.
• Continua a melhorar o teu modelo seguindo as nossas Dicas para Melhores Resultados de Treino e adicionando iterativamente dados mais diversos e desafiantes com base na análise de desempenho.

Ambientes suportados#

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

• Notebooks de GPU gratuitos:
  • 
  • 
  • 
• Plataformas de nuvem:
  • Google Cloud: Guia de Início Rápido do GCP
  • Amazon AWS: Guia de Início Rápido da AWS
  • Microsoft Azure: Guia de Início Rápido do AzureML
• Configuração local:
  • Docker: Guia de Início Rápido do Docker

Status do projeto#

Este selo indica que todos os testes de Continuous Integration (CI) do GitHub Actions do YOLOv5 estão a passar com sucesso. Estes testes de CI rigorosos cobrem as funcionalidades principais, incluindo training, validation, inference, export e benchmarks, nos sistemas operativos macOS, Windows e Ubuntu. Os testes são executados automaticamente a cada 24 horas e em cada commit de código, garantindo estabilidade consistente e desempenho ideal.

FAQ#