Treina o YOLOv5 em 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, garante que tens o ambiente necessário configurado. Clona o repositório YOLOv5 e instala as dependências necessárias a partir do 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 último lançamento do YOLOv5 caso não sejam encontrados localmente.

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

Treinar em dados personalizados

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

1. Recolhe e organiza imagens: Reúne imagens relevantes para a tua tarefa específica. Dados diversos e de alta qualidade são cruciais. Consulta o nosso guia sobre Recolha e anotação de dados.
2. Etiqueta objetos: Anota os objetos de interesse nas tuas imagens com precisão.
3. Treina um modelo: Usa os dados etiquetados para treinar o teu modelo YOLOv5. Tira partido da transferência de aprendizagem começando com pesos pré-treinados.
4. Implementa e faz previsões: Utiliza o modelo treinado para inferência em dados novos e não vistos.
5. Recolhe casos extremos: Identifica cenários onde 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 Plataforma Ultralytics 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, treino de modelos e implementação.

Antes de iniciares o treino, a preparação do conjunto de dados é essencial.

1. Cria um conjunto de dados

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

1.1 Cria um dataset.yaml

O ficheiro de configuração do conjunto de dados (ex: coco128.yaml) descreve a estrutura do conjunto de dados, nomes das classes e caminhos para os diretórios das imagens. O COCO128 serve como um pequeno exemplo de conjunto de dados, compreendendo as primeiras 128 imagens do vasto conjunto de dados COCO. É útil para testar rapidamente o pipeline de treino e diagnosticar problemas potenciais como 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 a partir de path para diretórios que contêm imagens ou ficheiros de texto que listam caminhos de imagens para conjuntos de treino, validação e teste.
• names: Um dicionário que mapeia índices de classe (começando em 0) para os seus nomes de classe correspondentes.

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

Abaixo está a estrutura para o 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 Tira partido de modelos para etiquetagem automatizada

A etiquetagem manual é a abordagem comum, mas é demorada. Os modelos de fundação podem automatizar ou semi-automatizar a anotação e acelerar a criação de conjuntos de dados. Exemplos de modelos que podem ajudar a gerar etiquetas:

• 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 etiquetas no formato YOLO. Explora o seu potencial no tutorial disponibilizado.
• SAM2 (Segment Anything Model 2): Modelos de fundação focados em segmentação, como o SAM2, podem identificar e delinear objetos com alta precisão. Embora seja principalmente 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 etiquetas iniciais, que podem depois ser refinadas.

Usar estes modelos pode fornecer um passo de "pré-etiquetagem", reduzindo o esforço manual necessário. No entanto, é crucial rever e refinar as etiquetas geradas automaticamente para garantir a precisão e consistência, uma vez que a qualidade impacta diretamente o desempenho do teu modelo YOLOv5 treinado. Após gerares (e potencialmente refinares) as tuas etiquetas, garante que estas seguem 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 com índice 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 conseguires isto, 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 têm base zero (ou seja, a primeira classe é representada por 0, a segunda por 1, e assim sucessivamente).

O ficheiro de etiqueta correspondente à imagem acima, contendo dois objetos 'pessoa' (índice de classe 0) e um objeto 'gravata' (índice de classe 27), ficaria assim:

1.3 Organiza 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 (ex: /coco128) resida numa pasta /datasets localizada adjacente ao diretório do repositório /yolov5.

O YOLOv5 localiza automaticamente as etiquetas para cada imagem substituindo a última instâ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. Seleciona 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 velocidade e precisão de forma diferente. Por exemplo, o YOLOv5s é o segundo menor e mais rápido modelo, adequado para ambientes com recursos limitados. Consulta a tabela README para uma comparação detalhada de todos os modelos disponíveis.

3. Treina

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

• --img: Define o tamanho da imagem de entrada (ex: --img 640). Tamanhos maiores geralmente geram melhor precisão, mas requerem mais memória da GPU.
• --batch: Determina o tamanho do lote (ex: --batch 16). Escolhe o maior tamanho que a tua GPU conseguir gerir.
• --epochs: Especifica o número total de épocas de treino (ex: --epochs 100). Uma época representa uma passagem completa por todo o conjunto de dados de treino.
• --data: Caminho para o teu ficheiro dataset.yaml (ex: --data coco128.yaml).
• --weights: Caminho para o ficheiro de pesos iniciais. Usar pesos pré-treinados (ex: --weights yolov5s.pt) é altamente recomendado para uma convergência mais rápida e resultados superiores. 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 descarregados automaticamente a partir do último lançamento 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 do treino, incluindo pesos e registos, são guardados no diretório runs/train/. Cada sessão de treino cria um novo subdiretório (ex: runs/train/exp, runs/train/exp-2, etc.). Para uma experiência interativa e prática, explora a secção de treino nos nossos cadernos tutoriais oficiais:

4. Visualiza

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 Comet

O Comet está totalmente integrado para o acompanhamento abrangente de experiências. Visualiza métricas em tempo real, guarda hiperparâmetros, gere conjuntos de dados e pontos de verificação de modelos, e analisa as previsões do modelo 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!

Mergulha mais profundamente nas funcionalidades suportadas no nosso Guia de Integração do Comet. Aprende mais sobre as capacidades do Comet a partir da sua documentação oficial. Experimenta o Caderno Colab do Comet para uma demonstração ao vivo:

Registo e automatização com ClearML

A integração do ClearML permite o acompanhamento detalhado de experiências, gestão de versões de conjuntos de dados e até a execução remota de ciclos 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 (seja auto-alojado ou a camada gratuita).

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

Registo local

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

• Perda de treino e validação e métricas de desempenho.
• Imagens de exemplo que mostram aumentos aplicados (como mosaicos).
• Etiquetas de verdade absoluta juntamente com as previsões do modelo para inspeção visual.
• Principais métricas de avaliação 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. Também podes traçar 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 ponto de verificação do modelo com melhor desempenho (best.pt) é guardado e está pronto para implementação ou refinamento adicional. Os potenciais próximos passos incluem:

• Executar inferência em novas imagens ou vídeos usando o modelo treinado através da CLI ou Python.
• Realizar validação para avaliar a precisão e capacidades de generalização do modelo em diferentes divisões de dados (ex: um conjunto de teste separado).
• Exportar o modelo para vários formatos de implementação como ONNX, TensorFlow SavedModel ou TensorRT para inferência otimizada em diversas plataformas.
• Empregar técnicas de ajuste de hiperparâmetros para potencialmente obter ganhos adicionais de desempenho.
• 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 tranquilo.

• Cadernos de GPU Gratuitos:
  • 
  • 
  • 
• Plataformas na 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

This badge indicates that all YOLOv5 GitHub Actions Continuous Integration (CI) tests are passing successfully. These rigorous CI tests cover the core functionalities, including training, validation, inference, export, and benchmarks, across macOS, Windows, and Ubuntu operating systems. Tests are executed automatically every 24 hours and upon each code commit, ensuring consistent stability and optimal performance.

FAQ

Como treino o YOLOv5 no meu conjunto de dados personalizado?

Treinar o YOLOv5 num conjunto de dados personalizado envolve vários passos fundamentais:

1. Prepare o Teu Conjunto de Dados: Recolhe imagens e anota-as. Garante que as anotações estão no formato YOLO necessário. Organiza as imagens e as etiquetas em diretórios train/ e val/ (e opcionalmente test/). Considera usar modelos como o Google Gemini, SAM2 ou YOLOWorld para ajudar ou automatizar o processo de etiquetagem (vê a Secção 1.2).
2. Configura o Teu Ambiente: Clona o repositório YOLOv5 e instala as dependências usando pip install -r requirements.txt.

   git clone https://github.com/ultralytics/yolov5
   cd yolov5
   pip install -r requirements.txt

3. Cria a Configuração do Conjunto de Dados: Define os caminhos do conjunto de dados, o número de classes e os nomes das classes num ficheiro dataset.yaml.
4. Inicia o Treino: Executa o script train.py, fornecendo os caminhos para o teu dataset.yaml, os pesos pré-treinados desejados (por exemplo, yolov5s.pt), o tamanho da imagem, o tamanho do lote e o número de épocas.

   python train.py --img 640 --batch 16 --epochs 100 --data path/to/your/dataset.yaml --weights yolov5s.pt

Por que deves usar a Ultralytics Platform para treinar os teus modelos YOLO?

A Ultralytics Platform é uma plataforma abrangente concebida para simplificar todo o ciclo de vida de desenvolvimento de modelos YOLO, muitas vezes sem precisares de escrever código. Os principais benefícios incluem:

• Treino Simplificado: Treina modelos facilmente usando ambientes pré-configurados e uma interface de utilizador intuitiva.
• Gestão de Dados Integrada: Carrega, controla versões e gere os teus conjuntos de dados de forma eficiente dentro da plataforma.
• Monitorização em Tempo Real: Acompanha o progresso do treino e visualiza métricas de desempenho usando ferramentas integradas como o Comet ou o TensorBoard.
• Funcionalidades de Colaboração: Facilita o trabalho em equipa através de recursos partilhados, ferramentas de gestão de projetos e partilha fácil de modelos.
• Implementação Sem Código: Implementa modelos treinados diretamente para vários destinos.

Para uma demonstração prática, consulta a nossa publicação no blog: Como Treinar os Teus Modelos Personalizados com a Ultralytics Platform.

Como converto os meus dados anotados para o formato YOLOv5?

Quer anotes manualmente ou uses ferramentas automatizadas (como as mencionadas na Secção 1.2), as etiquetas finais devem estar no formato YOLO específico exigido pelo YOLOv5:

• Cria um ficheiro .txt para cada imagem. O nome do ficheiro deve corresponder ao nome do ficheiro da imagem (por exemplo, image1.jpg corresponde a image1.txt). Coloca estes ficheiros num diretório labels/ paralelo ao teu diretório images/ (por exemplo, ../datasets/mydataset/labels/train/).
• Cada linha dentro de um ficheiro .txt representa uma anotação de objeto e segue o formato: class_index center_x center_y width height.
• As coordenadas (center_x, center_y, width, height) devem estar normalizadas (valores entre 0.0 e 1.0) em relação às dimensões da imagem.
• Os índices das classes são baseados em zero (a primeira classe é 0, a segunda é 1, etc.).

Muitas ferramentas de anotação manual oferecem exportação direta para o formato YOLO. Se usares modelos automatizados, precisarás de scripts ou processos para converter a sua saída (por exemplo, coordenadas de caixa delimitadora, máscaras de segmentação) para este formato de texto normalizado específico. Garante que a estrutura final do teu conjunto de dados segue o exemplo fornecido no guia. Para mais detalhes, consulta o nosso Guia de Recolha e Anotação de Dados.

Quais são as opções de licenciamento para usar o YOLOv5 em aplicações comerciais?

A Ultralytics oferece licenciamento flexível adaptado a diferentes necessidades:

• Licença AGPL-3.0: Esta licença de código aberto é adequada para investigação académica, projetos pessoais e situações onde a conformidade com o código aberto é aceitável. Exige que as modificações e os trabalhos derivados também sejam de código aberto sob a AGPL-3.0. Revê os detalhes da Licença AGPL-3.0.
• Licença Enterprise: Uma licença comercial concebida para empresas que integram o YOLOv5 em produtos ou serviços proprietários. Esta licença remove as obrigações de código aberto da AGPL-3.0, permitindo a distribuição de código fechado. Visita a nossa página de Licenciamento para mais detalhes ou para solicitar uma Licença Enterprise.

Seleciona a licença que melhor se alinha com os requisitos e o modelo de distribuição do teu projeto.