Treinar YOLOv5 em dados personalizados

Este guia explica como treinar seu próprio conjunto de dados personalizado usando o YOLOv5 modelo 🚀. O treinamento de modelos personalizados é uma etapa fundamental para adaptar as soluções de visão computacional a aplicações específicas do mundo real, além da deteção genérica de objetos.

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 a partir de requirements.txt. A Python.8.0 ambiente com PyTorch.8 é essencial. Os modelos e conjuntos de dados são descarregados automaticamente da versão mais recente YOLOv5 libertação 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

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

1. Recolha e organização de imagens: Reúna imagens relevantes para a sua tarefa específica. É crucial dispor de dados diversificados e de alta qualidade. Consulte o nosso guia sobre Recolha e Anotação de Dados.
2. Etiquetar objectos: Anotar com precisão os objectos de interesse nas suas imagens.
3. Treinar um modelo: Utilize os dados rotulados para treinar o seu modelo YOLOv5 . Aproveite a aprendizagem por transferência começando com pesos pré-treinados.
4. Implementar e prever: Utilizar o modelo treinado para inferência em dados novos e não vistos.
5. Recolher casos extremos: Identifique cenários em que o modelo tem um desempenho fraco(casos extremos) e adicione dados semelhantes ao seu conjunto de dados para melhorar a robustez. Repetir o ciclo.

OUltralytics HUB oferece uma solução simplificada e sem código para todo esse ciclo de operações de aprendizado de máquina (MLOps), incluindo gerenciamento de conjunto de dados, treinamento de modelos e implantação.

Antes de iniciar a formação, é essencial preparar o conjunto de dados.

1. Criar um conjunto de dados

Os modelos YOLOv5 requerem dados rotulados para aprender as caraterísticas visuais das classes de objectos. A organização correta do conjunto de dados é 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. COCO128 serve como um pequeno conjunto de dados de exemplo, que inclui as primeiras 128 imagens da extensa COCO conjunto de dados. É útil para testar rapidamente o pipeline de treino e diagnosticar potenciais problemas como sobreajuste.

O dataset.yaml A estrutura do ficheiro inclui:

• path: O diretório de 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 que listam caminhos de imagens para conjuntos de treino, validação e teste.
• names: Um dicionário que mapeia os índices das classes (a partir de 0) para os nomes das classes correspondentes.

Abaixo está a estrutura para coco128.yaml (ver no GitHub):

# Dataset root directory relative to the yolov5 directory
path: ../datasets/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 Utilizar modelos para etiquetagem automatizada

Embora a rotulagem manual com recurso a ferramentas seja uma abordagem comum, o processo pode ser moroso. Os recentes avanços nos modelos de fundação oferecem possibilidades de automatizar ou semi-automatizar o processo de anotação, acelerando potencialmente a criação de conjuntos de dados de forma significativa. Eis alguns exemplos de modelos que podem ajudar a gerar etiquetas:

• Google Gemini: Os modelos multimodais de grandes dimensões, como o Gemini, possuem capacidades poderosas de compreensão de imagens. Podem ser solicitados para identificar e localizar objectos nas imagens, gerando caixas delimitadoras ou descrições que podem ser convertidas em etiquetas de formato YOLO . Explore o seu potencial no bloco de notas tutorial fornecido.
• SAM2 (Segmento Qualquer Modelo 2): Os modelos de base centrados na segmentação, como o SAM2, podem identificar e delinear objectos com elevada precisão. Embora se destinem principalmente à segmentação, as máscaras resultantes podem frequentemente ser convertidas em anotações de caixas delimitadoras adequadas para tarefas de deteção de objectos.
• YOLOWorld: Este modelo oferece capacidades de deteção de vocabulário aberto. O utilizador pode fornecer descrições textuais dos objectos que lhe interessam e o YOLOWorld pode localizá-los nas imagens sem formação prévia nessas classes específicas. Isto pode ser usado como um ponto de partida para gerar rótulos iniciais, que podem depois ser refinados.

A utilização destes modelos pode proporcionar um passo de "pré-rotulagem", reduzindo o esforço manual necessário. No entanto, é crucial rever e refinar as etiquetas geradas automaticamente para garantir a precisão e a consistência, uma vez que a qualidade afecta diretamente o desempenho do modelo YOLOv5 treinado. Depois de gerar (e potencialmente refinar) os seus rótulos, certifique-se de que cumprem a YOLO formato: um *.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 objectos de interesse, não há *.txt é necessário.

O formato YOLO *.txt as especificações dos ficheiros 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 o conseguir, divida os valores de pixel de x_center e width pela largura total da imagem e dividir 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 1e assim por diante).

O ficheiro de etiquetas correspondente à imagem acima, que contém dois objectos "pessoa" (índice de classe 0) e um objeto "gravata" (índice de classe 27), teria o seguinte aspeto:

1.3 Organizar diretórios

Estruture o seu conjuntos de dados como ilustrado abaixo. Por defeito, YOLOv5 antecipa o diretório do conjunto de dados (e.g, /coco128) para residir num /datasets pasta localizada adjacente a a /yolov5 diretório do repositório.

YOLOv5 localiza automaticamente as etiquetas 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 é a seguinte:

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

3. Comboio

Iniciar o formação de modelos utilizando o train.py argumento. Os argumentos essenciais incluem:

• --img: Define a entrada tamanho da imagem (por exemplo, --img 640). Tamanhos maiores geralmente produzem melhor precisão, mas exigem mais memória GPU .
• --batch: Determina o tamanho do lote (por exemplo, --batch 16). Escolha o maior tamanho que a sua GPU pode suportar.
• --epochs: Especifica o número total de acções de formação épocas (por exemplo, --epochs 100). Uma época representa uma passagem completa por todo o conjunto de dados de treino.
• --data: Caminho para o seu dataset.yaml ficheiro (por exemplo, --data coco128.yaml).
• --weights: Caminho para o ficheiro de pesos iniciais. Usando 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 tenha um conjunto de dados muito grande e necessidades específicas), utilize --weights '' --cfg yolov5s.yaml.

Os pesos pré-treinados são automaticamente descarregados da versão mais recente 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 da formação, incluindo pesos e registos, são guardados no ficheiro runs/train/ diretório. Cada sessão de formação cria um novo subdiretório (por exemplo, runs/train/exp, runs/train/exp2, etc.). Para uma experiência interactiva e prática, explore a secção de formação nos nossos cadernos de tutoriais oficiais:

4. Visualize

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

Comet Registo e visualização 🌟 NOVO

Comet está totalmente integrado para um acompanhamento abrangente da experiência. Visualize métricas em tempo real, salve hiperparâmetros, gerencie conjuntos de dados e pontos de verificação de modelos e analise previsões de modelos usando os painéis personalizados interativos Comet .

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 nas funcionalidades suportadas na nossa Guia de integração Comet. Saiba mais sobre as capacidades do Comet na sua página oficial documentação. Experimente o Comet Colab Notebook para uma demonstração ao vivo:

ClearML Registo e automatização 🌟 NOVO

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 treinos. Active ClearML com estes passos simples:

• Instalar o pacote: pip install clearml
• Inicializar ClearML: Executar clearml-init uma vez para se ligar ao seu servidor ClearML (auto-hospedado ou o escalão gratuito).

ClearML captura automaticamente detalhes de experimentos, uploads de modelos, comparações, alterações de código não confirmadas e pacotes instalados, garantindo total reprodutibilidade. É possível 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çãoClearML para obter detalhes abrangentes.

Registo local

Os resultados do treino são registados automaticamente utilizando TensorBoard e guardado como CSV no diretório específico da experiência (por exemplo runs/train/exp). Os dados registados incluem:

• Perda de formação e validação e métricas de desempenho.
• Imagens de amostra que mostram aumentos aplicados (como mosaicos).
• Rótulos da verdade terrestre juntamente com previsões de modelos para inspeção visual.
• Principais métricas de avaliação, como as curvas Precisão-Recall (PR).
• Matrizes de confusão para uma análise pormenorizada do desempenho por classe.

O results.csv é atualizado após cada época e é representado como results.png uma vez concluída a formação. Também pode traçar qualquer 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

5. Próximos passos

Após a conclusão bem sucedida da formação, o ponto de controlo do modelo com melhor desempenho (best.pt) é guardado e está pronto para ser implementado ou aperfeiçoado. Os possíveis próximos passos incluem:

• Executar a inferência em novas imagens ou vídeos utilizando o modelo treinado através do CLI ou Python.
• Efetuar a validação para avaliar a exatidã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 implantação, como ONNX, TensorFlow SavedModelou TensorRT para inferência optimizada em diversas plataformas.
• Utilizar técnicas de afinação de hiperparâmetros para obter potencialmente ganhos de desempenho adicionais.
• Continue a melhorar o seu modelo seguindo as nossas sugestões para obter os melhores resultados de treino e adicionando iterativamente dados mais diversificados e desafiantes com base na análise de desempenho.

Ambientes suportados

Ultralytics fornece ambientes prontos a utilizar equipados com dependências essenciais como CUDAcuDNN, Pythone PyTorchfacilitando um arranque sem problemas.

• Grátis GPU Notebooks:
  • 
  • 
  • 
• Plataformas de nuvem:
  • Google Nuvem: Guia de início rápido do GCP
  • Amazon AWS: Guia de início rápido do 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 testes de Integração Contí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

Perguntas mais frequentes

Como é que treino YOLOv5 no meu conjunto de dados personalizado?

O treino YOLOv5 num conjunto de dados personalizado envolve vários passos importantes:

1. Preparar o conjunto de dados: Recolher imagens e anotá-las. Assegurar-se de que as anotações estão no local necessário YOLO formato. Organizar imagens e etiquetas em train/ e val/ (e opcionalmente test/). Considere a utilização de modelos como Google Gemini, SAM2, ou YOLOWorld para ajudar ou automatizar o processo de rotulagem (ver secção 1.2).
2. Configurar 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. Criar configuração de conjunto de dados: Definir caminhos de conjuntos de dados, número de classes e nomes de classes num dataset.yaml ficheiro.
4. Iniciar a formação: Executar o train.py fornecendo caminhos para o seu dataset.yaml, 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 razão devo utilizar o Ultralytics HUB para formar os meus modelos YOLO ?

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

• Treinamento simplificado: Treine facilmente modelos utilizando ambientes pré-configurados e uma interface de utilizador intuitiva.
• Gestão integrada de dados: Carregue, controle a versão e gira os seus conjuntos de dados de forma eficiente dentro da plataforma.
• Monitorização em tempo real: Acompanhe o progresso da formação e visualize as métricas de desempenho utilizando ferramentas integradas como Comet ou TensorBoard.
• Caraterísticas de colaboração: Facilita o trabalho em equipa através de recursos partilhados, ferramentas de gestão de projectos e partilha fácil de modelos.
• Implantação sem código: Implante modelos treinados diretamente em vários alvos.

Para um passo a passo prático, confira nossa postagem no blog: Como treinar seus modelos personalizados com o Ultralytics HUB.

Como é que converto os meus dados anotados para o formato YOLOv5 ?

Quer faça anotações manualmente ou utilize ferramentas automatizadas (como as mencionadas na Secção 1.2), as etiquetas finais devem estar no formatoYOLO específico exigido pelo YOLOv5:

• Criar um .txt para cada imagem. O nome do ficheiro deve corresponder ao nome do ficheiro da imagem (por exemplo, image1.jpg corresponde a image1.txt). Coloque estes ficheiros numa pasta labels/ paralelo ao seu diretório images/ diretório (por exemplo, ../datasets/mydataset/labels/train/).
• Cada linha dentro de um .txt 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) relativamente às dimensões da imagem.
• Os índices de classe são de base zero (a primeira aula é 0, o segundo é 1, etc.).

Muitas ferramentas de anotação manual oferecem exportação direta para o formato YOLO . Se utilizar modelos automatizados, necessitará de scripts ou processos para converter os seus resultados (por exemplo, coordenadas da caixa delimitadora, máscaras de segmentação) para este formato de texto normalizado específico. Certifique-se de que a estrutura final do conjunto de dados segue o exemplo fornecido no guia. Para obter mais detalhes, consulte o nosso Guia de recolha e anotação de dados.

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

Ultralytics oferece um licenciamento flexível adaptado às diferentes necessidades:

• LicençaAGPL-3.0 : Esta licença de código aberto é adequada para investigação académica, projectos pessoais e situações em que a conformidade com o código aberto é aceitável. Ela exige que as modificações e trabalhos derivados também sejam de código aberto sob a AGPL-3.0. Reveja os detalhes da LicençaAGPL-3.0 .
• Licença Empresarial: Uma licença comercial concebida para empresas que integram 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 obter mais detalhes ou para solicitar uma Licença Empresarial.

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

📅C riado há 1 ano ✏️ Atualizado há 1 dia

Comentários