Treinar YOLOv5 em Dados Personalizados

📚 Este guia explica como treinar seu próprio dataset personalizado usando o modelo YOLOv5 🚀. Treinar modelos personalizados é uma etapa fundamental na adaptação de soluções de visão computacional para aplicações específicas do mundo real, além da detecção de objetos genérica.

Antes de Começar

Primeiro, certifique-se de que tem o ambiente necessário configurado. Clone o repositório YOLOv5 e instale as dependências necessárias de requirements.txt. Um Python>=3.8.0 ambiente com PyTorch>=1.8 é essencial. Modelos e conjuntos de dados são baixados automaticamente da versão mais recente do YOLOv5. lançamento 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 em 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. Consulte nosso guia sobre Coleta e Anotação de Dados.
2. Rotular Objetos: Anote os objetos de interesse nas suas imagens com precisão.
3. Treinar um Modelo: Use os dados rotulados para treinar seu modelo YOLOv5. Aproveite a transferência de aprendizado começando com pesos pré-treinados.
4. Implementar e Prever: Utilize o modelo treinado para inferência em dados novos e não vistos.
5. Coletar Casos Limite: Identifique cenários onde o modelo tem um desempenho ruim (casos limite) e adicione dados semelhantes ao seu conjunto de dados para melhorar a robustez. Repita o ciclo.

Ultralytics HUB oferece uma solução simplificada e sem código para todo este ciclo de operações de machine learning (MLOps), incluindo gerenciamento de conjuntos de dados, treinamento de modelos e implementação.

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

1. Criar um Conjunto de Dados

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

1.1 Criar dataset.yaml

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

O dataset.yaml A estrutura do arquivo inclui:

• path: O diretório raiz que contém o conjunto de dados.
• train, val, test: Caminhos relativos de path para diretórios contendo imagens ou arquivos de texto listando os caminhos das imagens para os conjuntos de treinamento, validação e teste.
• names: Um dicionário que mapeia os índices de classe (começando em 0) para seus nomes de classe correspondentes.

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

1.2 Aproveitar Modelos para Rotulagem Automatizada

Embora a rotulagem manual usando ferramentas seja uma abordagem comum, o processo pode ser demorado. Os avanços recentes em modelos de fundação oferecem possibilidades para automatizar ou semi-automatizar o processo de anotação, potencialmente acelerando significativamente a criação do conjunto de dados. Aqui estão alguns exemplos de modelos que podem ajudar na geração de rótulos:

• Google Gemini: Modelos multimodais grandes como o Gemini possuem poderosas capacidades de compreensão de imagem. Eles podem ser solicitados a identificar e localizar objetos dentro de imagens, gerando caixas delimitadoras ou descrições que podem ser convertidas em rótulos no formato YOLO. Explore seu potencial no notebook tutorial fornecido.
• 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 primariamente para segmentação, as máscaras resultantes podem frequentemente ser convertidas em anotações de caixa delimitadora adequadas para tarefas de detecção de objetos.
• YOLOWorld: Este modelo oferece recursos de detecção de vocabulário aberto. Você pode fornecer descrições textuais 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 ponto de partida para gerar rótulos iniciais, que podem ser refinados posteriormente.

A utilização destes 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 a precisão e a consistência, uma vez que a qualidade impacta diretamente o desempenho do seu modelo YOLOv5 treinado. Após gerar (e potencialmente refinar) os seus rótulos, certifique-se de que eles aderem aos formato YOLO: um *.txt ficheiro por imagem, com cada linha representando 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, nenhum correspondente *.txt ficheiro é necessário.

O formato YOLO *.txt As especificações do arquivo 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 normalizado para um intervalo entre 0 e 1. Para conseguir isso, divida os valores dos pixels 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 a zero (ou seja, a primeira classe é representada por 0, o segundo por 1, e assim por diante).

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

1.3 Organizar Diretórios

Estruture seu conjuntos de dados diretório, conforme ilustrado abaixo. Por padrão, o YOLOv5 antecipa o diretório do conjunto de dados (por exemplo, /coco128) para residir dentro de um /datasets pasta localizada adjacente a o /yolov5 diretório do repositório.

O YOLOv5 localiza automaticamente os rótulos para cada imagem, substituindo a última instância de /images/ no caminho da imagem com /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

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 README para uma comparação detalhada de todos os modelos disponíveis.

3. Treinar

Comece o treino do modelo usando o train.py script. Argumentos essenciais incluem:

• --img: Define a entrada tamanho da imagem (e.g., --img 640). Tamanhos maiores geralmente produzem melhor precisão, mas exigem mais memória da GPU.
• --batch: Determina o tamanho de lote (e.g., --batch 16). Escolha o maior tamanho que sua GPU pode suportar.
• --epochs: Especifica o número total de treinamentos épocas (e.g., --epochs 100). Uma época representa uma passagem completa por todo o conjunto de dados de treinamento.
• --data: Caminho para o seu dataset.yaml ficheiro (por exemplo, --data coco128.yaml).
• --weights: Caminho para o arquivo de pesos inicial. Usando 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.

Os 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

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

4. Visualizar

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

Registro e Visualização do Comet 🌟 NOVO

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

Aprofunde-se nos recursos suportados em nossos Guia de Integração do Comet. Saiba mais sobre os recursos do Comet em seu site oficial documentação. Experimente o Notebook Comet Colab para uma demonstração ao vivo:

Registro e Automação do ClearML 🌟 NOVO

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

• Instale o pacote: pip install clearml
• Inicializar ClearML: Executar clearml-init uma vez para se conectar ao seu servidor ClearML (seja auto-hospedado ou o nível gratuito).

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

Registro Local

Os resultados do treino são automaticamente registados usando TensorBoard e salvo como CSV arquivos dentro do diretório de experimento específico (por exemplo, runs/train/exp). Os dados registrados incluem:

• Perda de treino e validação e métricas de desempenho.
• Imagens de amostra mostrando aumentos aplicados (como mosaicos).
• Rótulos de verdade básica juntamente com as predições do modelo para inspeção visual.
• Métricas de avaliação chave, como curvas de Precisão-Recall (PR).
• Matrizes de confusão para análise detalhada do desempenho por classe.

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

5. Próximos Passos

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

• Execute a 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 do modelo e as capacidades de generalização em diferentes divisões de dados (por exemplo, um conjunto de testes reservado).
• 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 extrair ganhos de desempenho adicionais.
• Continue aprimorando seu modelo seguindo nossas Dicas para Obter os Melhores Resultados de Treinamento e adicionando iterativamente dados mais diversos e desafiadores com base na análise de desempenho.

Ambientes 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 GPU Gratuitos:
  • 
  • 
  • 
• Plataformas de Nuvem:
  • Google Cloud: Guia de Início Rápido do GCP
  • Amazon AWS: Guia de Início Rápido 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 GitHub Actions de Integração Contínua (CI) do YOLOv5 estão passando com sucesso. Esses testes de CI rigorosos cobrem as funcionalidades principais, incluindo treinamento, validação, inferência, exportação e benchmarks, em sistemas operacionais macOS, Windows e Ubuntu. Os testes são executados automaticamente a cada 24 horas e a cada commit de código, garantindo estabilidade consistente e desempenho ideal.

FAQ

Perguntas Frequentes

Como posso treinar o YOLOv5 no meu conjunto de dados personalizado?

Treinar YOLOv5 num dataset personalizado envolve vários passos principais:

1. Prepare Seu Conjunto de Dados: Colete imagens e anote-as. Garanta que as anotações estejam no formato necessário formato YOLO. Organize imagens e rótulos em train/ e val/ (e opcionalmente test/) diretórios. Considere usar modelos como Google Gemini, SAM2, ou YOLOWorld para auxiliar ou automatizar o processo de rotulagem (ver Seção 1.2).
2. Configure 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. Criar Arquivo de 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 dataset.yaml ficheiro.
4. Começar Treinamento: Execute o método train.py script, fornecendo os caminhos para seus dataset.yaml, pesos pré-treinados desejados (por exemplo, yolov5s.pt), tamanho da imagem, 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 devo usar o Ultralytics HUB para treinar meus modelos YOLO?

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

• Treinamento Simplificado: Treine facilmente modelos usando ambientes pré-configurados e uma interface de usuário intuitiva.
• Gerenciamento Integrado de Dados: Carregue, controle a 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 as métricas de desempenho usando ferramentas integradas como Comet ou TensorBoard.
• Funcionalidades de Colaboração: Facilita o trabalho em equipe através de recursos compartilhados, ferramentas de gestão de projetos e fácil compartilhamento de modelos.
• Implantação Sem Código: Implante modelos treinados diretamente em vários destinos.

Para um passo a passo prático, consulte a nossa publicação no blog: Como Treinar os Seus Modelos Personalizados com o Ultralytics HUB.

Como converto meus dados anotados para o formato YOLOv5?

Quer você anote manualmente ou use 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 .txt ficheiro para cada imagem. O nome do ficheiro deve corresponder ao nome do ficheiro da imagem (por exemplo, image1.jpg corresponde a image1.txt). Coloque esses arquivos em um labels/ diretório paralelo ao seu images/ diretório (por exemplo, ../datasets/mydataset/labels/train/).
• Cada linha dentro de um .txt O arquivo representa uma anotação de objeto e segue o formato: class_index center_x center_y width height.
• Coordenadas (center_x, center_y, width, height) deve ser normalizado (valores entre 0.0 e 1.0) relativos às dimensões da imagem.
• Os índices de classe são baseado em zero (a primeira classe é 0, o segundo é 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) neste formato de texto normalizado específico. Garanta que a estrutura final do seu conjunto de dados esteja de acordo com o exemplo fornecido no guia. Para mais detalhes, consulte nosso Guia de Coleta 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 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 AGPL-3.0. Consulte os detalhes da Licença AGPL-3.0.
• Licença Empresarial: 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 Empresarial.

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

📅 Criado há 1 ano ✏️ Atualizado há 19 dias

Comentários