Link to this sectionTreine o YOLOv5 em dados personalizados#

📚 Este guia explica como treinar seu 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 além da detecção de objetos genérica.

Link to this sectionAntes de começar#

Primeiro, certifique-se de ter o ambiente necessário configurado. Clone o repositório do YOLOv5 e instale as dependências necessárias a partir do requirements.txt. Um ambiente Python>=3.8.0 com PyTorch>=1.8 é essencial. Modelos e conjuntos de dados são baixados automaticamente da versão mais recente 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

Link to this sectionTreine com dados personalizados#

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

1. Coletar e organizar imagens: Reúna imagens relevantes para sua tarefa específica. Dados diversos e de alta qualidade são cruciais. Veja nosso guia sobre Coleta e anotação de dados.
2. Rotular objetos: Anote os objetos de interesse dentro de suas imagens com precisão.
3. Treinar um modelo: Use os dados rotulados para treinar seu modelo YOLOv5. Aproveite o aprendizado por transferência começando com pesos pré-treinados.
4. Implantar e prever: Utilize o modelo treinado para inferência em novos dados não vistos.
5. Coletar casos extremos: Identifique cenários onde o modelo tem um desempenho ruim (casos extremos) e adicione dados semelhantes ao seu conjunto de dados para melhorar a robustez. Repita o ciclo.

A Plataforma Ultralytics oferece uma solução simplificada e sem código para todo este ciclo de operações de aprendizado de máquina (MLOps), incluindo gerenciamento de conjuntos de dados, treinamento de modelos e implantação.

Antes de iniciar o treinamento, a preparação do conjunto de dados é essencial.

Link to this sectionCriar 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.

Link to this section1.1 Criar dataset.yaml#

O arquivo de configuração do conjunto de dados (por exemplo, coco128.yaml) descreve a estrutura do conjunto de dados, nomes das classes e 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 treinamento e diagnosticar possíveis problemas como sobreajuste.

A estrutura do arquivo 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 contendo imagens ou arquivos de texto que listam os caminhos das imagens para conjuntos de treinamento, validação e teste.
• names: Um dicionário que mapeia índices de classe (começando em 0) para seus nomes de classe correspondentes.

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

Abaixo está 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

Link to this section1.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. Eles podem ser instruídos a identificar e localizar objetos dentro das imagens, gerando caixas delimitadoras ou descrições que podem ser convertidas em rótulos no formato YOLO. Explore seu potencial no tutorial notebook fornecido.
• SAM2 (Segment Anything Model 2): Modelos de base focados em segmentação, como o SAM2, podem identificar e delinear objetos com alta precisão. Embora sejam principalmente para segmentação, as máscaras resultantes geralmente podem ser convertidas em anotações de caixa delimitadora adequadas para tarefas de detecção de objetos.
• YOLOWorld: Este modelo oferece capacidades de detecção de vocabulário aberto. Você pode fornecer descrições de texto dos objetos nos quais está interessado e o YOLOWorld pode localizá-los em imagens sem treinamento prévio nessas classes específicas. Isso pode ser usado como um ponto de partida para gerar rótulos iniciais, que podem então ser refinados.

Usar esses modelos pode fornecer uma etapa de "pré-rotulagem", reduzindo o esforço manual necessário. No entanto, é crucial revisar e refinar os rótulos gerados automaticamente para garantir precisão e consistência, pois a qualidade impacta diretamente o desempenho do seu modelo YOLOv5 treinado. Após gerar (e possivelmente refinar) seus rótulos, garanta que eles sigam o formato YOLO: um arquivo *.txt por imagem, com cada linha representando um objeto como class_index x_center y_center width height (coordenadas normalizadas, classe indexada em zero). Se uma imagem não tiver objetos de interesse, nenhum arquivo *.txt correspondente é necessário.

As especificações do arquivo *.txt no 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 conseguir isso, divida os valores de pixel de x_center e width pela largura total da imagem, e divida y_center e height pela altura total da imagem.
• Os índices de classe são indexados em zero (ou seja, a primeira classe é representada por 0, a segunda por 1, e assim por diante).

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

Link to this section1.3 Organizar diretórios#

Estruture seu diretório de conjuntos de dados como ilustrado abaixo. Por padrão, o YOLOv5 espera 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 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ó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)
            └── ...

Link to this sectionSelecionar um modelo#

Escolha um modelo pré-treinado para iniciar o processo de treinamento. Começar com pesos pré-treinados acelera significativamente o aprendizado e melhora o desempenho em comparação com o treinamento 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. Consulte a tabela do README para uma comparação detalhada de todos os modelos disponíveis.

Link to this sectionTreinar#

Comece o treinamento 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). Escolha o maior tamanho que sua GPU consegue suportar.
• --epochs: Especifica o número total de épocas de treinamento (por exemplo, --epochs 100). Uma época representa uma passagem completa por todo o conjunto de dados de treinamento.
• --data: Caminho para seu arquivo dataset.yaml (por exemplo, --data coco128.yaml).
• --weights: Caminho para o arquivo de pesos iniciais. Usar pesos pré-treinados (por exemplo, --weights yolov5s.pt) é altamente recomendado para uma convergência mais rápida e resultados superiores. Para treinar do zero (não recomendado, a menos que você tenha um conjunto de dados muito grande e necessidades específicas), use --weights '' --cfg yolov5s.yaml.

Pesos pré-treinados são baixados 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

Todas as saídas de treinamento, incluindo pesos e logs, são salvas no diretório runs/train/. Cada sessão de treinamento cria um novo subdiretório (por exemplo, runs/train/exp, runs/train/exp2, etc.). Para uma experiência prática e interativa, explore a seção de treinamento em nossos notebooks de tutorial oficiais:

Link to this sectionVisualizar#

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

Link to this sectionRegistro e visualização com Comet#

O Comet está totalmente integrado para um rastreamento abrangente de experimentos. Visualize métricas ao vivo, salve hiperparâmetros, gerencie conjuntos de dados e pontos de verificação de modelos, e analise previsões de modelos usando Painéis Personalizados do Comet 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!

Mergulhe mais fundo nos recursos suportados em nosso Guia de Integração do Comet. Saiba mais sobre as capacidades do Comet na documentação oficial deles. Experimente o Comet Colab Notebook para uma demonstração ao vivo:

Link to this sectionRegistro e automação com ClearML#

A integração com ClearML permite rastreamento detalhado de experimentos, gerenciamento de versão de conjunto de dados e até execução remota de execuções de treinamento. Ative o ClearML com estes passos simples:

• Instale o pacote: pip install clearml
• Inicializa o ClearML: Executa clearml-init uma vez para te conectares ao teu servidor ClearML (seja ele autohospedado ou o free tier).

O ClearML captura automaticamente detalhes do experimento, carregamentos de modelos, comparações, alterações de código não confirmadas e pacotes instalados, garantindo total reprodutibilidade. Você pode agendar facilmente tarefas de treinamento em agentes remotos e gerenciar versões de conjuntos de dados usando o ClearML Data. Explore o Guia de Integração do ClearML para detalhes abrangentes.

Link to this sectionRegistro local#

Os resultados do treinamento são registrados automaticamente usando o TensorBoard e salvos como arquivos CSV dentro do diretório específico do experimento (por exemplo, runs/train/exp). Os dados registrados 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 importantes, como curvas de Precisão-Recall (PR).
• Matrizes de confusão para análise detalhada de desempenho por classe.

O arquivo results.csv é atualizado após cada época e plotado como results.png assim que o treinamento é concluído. Você também pode plotar qualquer arquivo results.csv manualmente 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

Link to this sectionPróximos passos#

Após a conclusão bem-sucedida do treinamento, o ponto de verificação do modelo com melhor desempenho (best.pt) é salvo e pronto para implantação ou refinamento adicional. Os próximos passos potenciais incluem:

• Execute inferência em novas imagens ou vídeos usando o modelo treinado via CLI ou Python.
• Realize a validação para avaliar a precisão e as capacidades de generalização do modelo em diferentes divisões de dados (por exemplo, um conjunto de teste isolado).
• Exporte o modelo para vários formatos de implantação como ONNX, TensorFlow SavedModel, ou TensorRT para inferência otimizada em diversas plataformas.
• Empregue técnicas de ajuste de hiperparâmetros para potencialmente obter ganhos adicionais de desempenho.
• Continue melhorando seu modelo seguindo nossas Dicas para melhores resultados de treinamento e adicionando iterativamente dados mais diversos e desafiadores com base na análise de desempenho.

Link to this sectionAmbientes suportados#

A Ultralytics fornece ambientes prontos para uso equipados com dependências essenciais como CUDA, cuDNN, Python e PyTorch, facilitando um início tranquilo.

• 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 AzureML
• Configuração local:
  • Docker: Guia de início rápido Docker

Link to this sectionStatus 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.

Link to this sectionFAQ#

Link to this sectionComo posso treinar o YOLOv5 no meu conjunto de dados personalizado?#

O treinamento do YOLOv5 em um conjunto de dados personalizado envolve várias etapas fundamentais:

1. Prepare o seu conjunto de dados: Colete imagens e anote-as. Certifique-se de que as anotações estejam no formato YOLO exigido. Organize imagens e rótulos em diretórios train/ e val/ (e opcionalmente test/). Considere usar modelos como Google Gemini, SAM2 ou YOLOWorld para auxiliar ou automatizar o processo de rotulagem (veja a Seção 1.2).
2. Configure o seu ambiente: Clone o repositório YOLOv5 e instale as dependências usando pip install -r requirements.txt.

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

3. Crie a configuração do conjunto de dados: Defina os caminhos do conjunto de dados, o número de classes e os nomes das classes em um arquivo dataset.yaml.
4. Inicie o treinamento: Execute o script train.py, fornecendo os caminhos para o seu dataset.yaml, pesos pré-treinados desejados (por exemplo, yolov5s.pt), tamanho da imagem, tamanho do lote (batch size) e o número de épocas.

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

Link to this sectionPor que devo usar o Ultralytics Platform para treinar meus modelos YOLO?#

O Ultralytics Platform é uma plataforma abrangente projetada para otimizar todo o ciclo de vida de desenvolvimento do modelo YOLO, muitas vezes sem a necessidade de escrever qualquer código. Os principais benefícios incluem:

• Treinamento Simplificado: Treine modelos facilmente usando ambientes pré-configurados e uma interface de usuário intuitiva.
• Gestão de Dados Integrada: Faça upload, controle de versão e gerencie seus conjuntos de dados de forma eficiente dentro da plataforma.
• Monitoramento em Tempo Real: Acompanhe o progresso do treinamento e visualize métricas de desempenho usando ferramentas integradas como Comet ou TensorBoard.
• Recursos de Colaboração: Facilita o trabalho em equipe através de recursos compartilhados, ferramentas de gerenciamento de projetos e fácil compartilhamento de modelos.
• Implantação Sem Código (No-Code): Implante modelos treinados diretamente em vários destinos.

Para um passo a passo prático, confira nossa postagem no blog: Como Treinar Seus Modelos Personalizados com o Ultralytics Platform.

Link to this sectionComo posso converter meus dados anotados para o formato YOLOv5?#

Seja anotando manualmente ou usando ferramentas automatizadas (como as mencionadas na Seção 1.2), os rótulos finais devem estar no formato YOLO específico exigido pelo YOLOv5:

• Crie um arquivo .txt para cada imagem. O nome do arquivo deve corresponder ao nome do arquivo da imagem (por exemplo, image1.jpg corresponde a image1.txt). Coloque esses arquivos em um diretório labels/ paralelo ao seu diretório images/ (por exemplo, ../datasets/mydataset/labels/train/).
• Cada linha dentro de um arquivo .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 ser normalizadas (valores entre 0.0 e 1.0) em relação às dimensões da imagem.
• Os índices de classe 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 estiver usando modelos automatizados, você precisará de scripts ou processos para converter a saída deles (por exemplo, coordenadas de caixa delimitadora, máscaras de segmentação) para este formato de texto normalizado específico. Certifique-se de que a estrutura do seu conjunto de dados final adira ao exemplo fornecido no guia. Para mais detalhes, consulte nosso Guia de Coleta e Anotação de Dados.

Link to this sectionQuais 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 pesquisa acadêmica, projetos pessoais e situações onde a conformidade com código aberto é aceitável. Ela exige que modificações e trabalhos derivados também sejam de código aberto sob a AGPL-3.0. Revise os detalhes da Licença AGPL-3.0.
• Licença Enterprise: Uma licença comercial projetada 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. Visite nossa página de Licenciamento para mais detalhes ou para solicitar uma Licença Enterprise.

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