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.

É possível definir path para um diretório absoluto (por exemplo, /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 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 emblema indica que todos os testesde IntegraçãoContínua(CI) YOLOv5 GitHub Actions estão a ser aprovados com êxito. Esses rigorosos testes de CI abrangem as principais funcionalidades, incluindo treinamento, validação, inferência, exportação e benchmarks, nos sistemas operacionais 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

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 file for each image. The filename should match the image filename (e.g., 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.

📅C riado há 2 anos ✏️ Atualizado há 5 dias

Comentários