Este artigo foi publicado como parte do Blogathon de Ciência de Dados

“Você pode ter dados sem informação, mas não pode ter informação sem dados” – Daniel Keys Moran

Introdução

Se você está aqui, talvez já esteja interessado em Machine Learning ou Deep Learning, então não preciso explicar o que é? Então, começando com uma pequena introdução ao tópico, a Detecção de Objetos é o método de detecção de objetos desejados em imagens ou vídeos, e nos últimos anos, muitos modelos foram introduzidos para o mesmo. YoloV5 é um daqueles modelos que é considerado um dos mais rápidos e precisos. Neste artigo, vou explicar como você pode treinar o YoloV5 modele em seus próprios dados para sistemas baseados em GPU e CPU. Vou explicar como você terá que configurar a GPU ou a CPU, pois ela pode ser treinada em qualquer um deles, embora a GPU seja preferida, pois levaria quase três vezes mais na CPU para treinar o mesmo, se você não tiver GPU baseada sistema e não quiser treinar seu modelo no Google Colab, você ainda poderá treinar o modelo na CPU.

As etapas que vamos discutir neste tutorial são as seguintes:

Opcional: Criação de um ambiente virtual para treinamento.

1. Clonando repositório e instalando dependências para YoloV5
2. Criar anotações para um conjunto de dados personalizado usando a ferramenta VIA
3. Converter anotações para o formato Coco
4. Criando arquivo YAML para treinamento
5. Treinamento YoloV5
6. Inferência YoloV5

O Python 3.6 é recomendado para o treinamento.

Vamos começar com a criação de um ambiente virtual, esta etapa é opcional, se você deseja instalar pacotes no ambiente raiz, pode pular isso, caso contrário, se quiser manter essa configuração separada, siga-a para criar um ambiente virtual. Comece com a instalação virtualenv pacote que ajuda na criação do ambiente virtual.

$ pip instalar virtualenv

uma vez que o pacote está instalado, você pode ir em frente e criar o ambiente virtual para o treinamento YoloV5:

 $ virtualenv yolov5_training_env

a saída do comando ficaria assim:

após criar um ambiente você terá que ativar o mesmo para instalar os pacotes necessários.

Unix:

$ fonte yolov5_training_env/bin/ativar

Windows:

$ yolov5_training_envScriptsativar

Clonagem de repositório e instalação de dependências

Para começar, precisamos clonar o arquivo oficial YoloV5 repositório, se você já tiver o git instalado, o comando a seguir pode ser usado para clonar o repositório.

$ git clone https://github.com/ultralytics/yolov5

caso contrário, você pode baixar diretamente o código do seguinte site:

Código YoloV5: https://github.com/ultralytics/yolov5

Este repositório yolov5 vem com um arquivo “requirements.txt” que contém todas as bibliotecas necessárias para treinar o modelo. Uma coisa a lembrar aqui é a tocha biblioteca que seria diferente para ambientes de GPU e CPU, então teremos que remover torch e torchvision dos arquivos de requisitos e instalar as outras bibliotecas. Para instalar outras bibliotecas a partir do arquivo “requirements.txt” é usado o seguinte comando.

$ pip install -r requisitos.txt

depois de instalar outras bibliotecas, instalaremos o torch e o torchvision, que são a espinha dorsal do treinamento.

Instalação da versão da CPU da tocha:

O sistema de gerenciamento de pacotes Python (pip) pode ser usado para instalar o torch e o torchvision para a CPU.

Windows e Linux:

$ pip instalar torch==1.7.0+cpu torchvision==0.8.0+cpu torchaudio==0.7.0 -f https://download.pytorch.org/whl/torch_stable.html

Mac:

$ pip install torch==1.7.0 torchvision==0.8.0 torchaudio==0.7.0

Instalação da versão da GPU do Torch: 

Conda é preferível para instalar bibliotecas de torch e torchvision baseadas em GPU, pois já o compila com CUDA. Além disso, se estiver enfrentando algum problema com a instalação do conda, você pode usar a instalação do pip. Antes das instalações, verifique se você está instalando a versão da tocha compatível com CUDA, que você pode encontrar aqui https://pytorch.org/get-started/previous-versions/.

Windows e Linux:

$ conda install pytorch==1.7.0 torchvision==0.8.0 torchaudio==0.7.0 cudatoolkit=10.1 -c pytorch

or

$ pip install torch==1.7.0+cu101 torchvision==0.8.0+cu101 torchaudio==0.7.0 -f https://download.pytorch.org/whl/torch_stable.html

Mac:

$ conda install pytorch==1.7.0 torchvision==0.8.0 torchaudio==0.7.0 -c pytorch

or

$ pip install torch==1.7.0 torchvision==0.8.0 torchaudio==0.7.0

certifique-se de que esta instalação seja feita corretamente, caso contrário, haveria muitos problemas de compatibilidade.

Precisamos baixar os pesos pré-treinados também para usar o modelo para dados personalizados. Os pesos podem ser baixados no link a seguir https://github.com/ultralytics/yolov5/releases. Uma vez baixados os pesos, precisamos criar uma pasta “Yolov5/weights” e colar o arquivo de pesos lá. Você pode baixar qualquer um dos modelos com base no seu caso de uso (recomendado: yolov5x.pt or yolov5x6.pt).

Criar anotações usando a ferramenta VIA

O coração do treinamento de qualquer modelo de detecção de objeto é a anotação de dados (preparando dados para treinamento). Data Annotation é uma técnica onde criamos diferentes formas geométricas nos objetos que queremos que nosso modelo de detecção de objetos detecte. Existem várias ferramentas de anotação de dados disponíveis, mas a que eu acho fácil de usar é a ferramenta VIA (VGG Image Annotator). Fiz algumas alterações na ferramenta para que você possa usá-la em seus próprios objetos. Você pode baixar a ferramenta aqui https://drive.google.com/file/d/1rJx0fNgnnhODM7H3GP9RQQ5QEsWdkYEd/view?usp=sharing. Esta ferramenta é apenas uma página HTML simples que fornece vários tipos de anotações, como formato de dados COCO, formato CSV, etc. A página da ferramenta tem esta aparência:

Aqui se você vê, existem 3 botões que são para objetos um, dois e três são realmente personalizáveis, ou seja, você pode alterar esses botões de acordo com os nomes dos seus objetos, para isso você terá que abrir o arquivo HTML no modo editável e encontrar as seguintes linhas:

esses nomes de objetos você pode ter como seus objetos personalizados, como carro, pessoa, etc. Depois de ter sua ferramenta pronta, você precisa clicar no botão de atributo que você vê no painel do lado esquerdo e criar um atributo de nome que seria algo assim:

uma vez que você tenha feito a configuração, você pode carregar as imagens usando o botão “Adicionar Arquivos” e pode iniciar as anotações selecionando o objeto e clicando no botão com o nome do objeto de acordo.

Depois que todas as anotações estiverem concluídas, você poderá exportá-las no formato CSV no local desejado.

Converter anotações CSV para o formato COCO

YoloV5 model requer que os dados estejam no formato coco:

Para converter anotações CSV para o formato COCO, você pode usar o seguinte trecho de código:

Comece com a importação de dependências para criar o conjunto de dados COCO.

import os import numpy as np import pandas as pd import shutil as sh do PIL import Imagem de tqdm.auto import tqdm

Depois que todas as dependências forem importadas, precisamos criar algumas colunas necessárias para o conjunto de dados COCO.

data_path = '/Users/gouravbais//Final_Cleaned_Dataset/' df = pd.read_csv(data_path+'train/via_region_export.csv') ## cria x, y, w, h colunas x, y, w, h = [], [ ], [], [] para linha em df['region_shape_attributes']: linha = linha.replace('{}', '').replace('}', '') linha = linha.split(',' ) x.append(int(row[1].split(':')[-1])) y.append(int(row[2].split(':')[-1])) w.append (int(row[3].split(':')[-1])) h.append(int(row[4].split(':')[-1])) ## calculando x, y, coordenadas de largura e altura df['x'], df['y'], df['w'], df['h'] = x, y, w, h ## criando um nome de coluna image_id tendo nomes de imagens como id df['image_id'] = [name.split('.')[0] for name in df['filename']] ## criando duas colunas para armazenar valores centrais de x e y df['x_center'] = df ['x'] + df['w']/2 df['y_center'] = df['y'] + df['h']/2 ## define o número de rótulos de classes = df['region_attributes'] .unique() labels_to_dict = dict(zip(lables, range(0, len(labels)))) print('Lables Directory:', labels_to_dict) df['classes'] = df['region_attributes'] df.rep lace({'classes':labels_to_dict}, inplace=True) df = df[['image_id','x', 'y', 'w', 'h','x_center','y_center','classes' ]] ## set index of images index = list(set(df.image_id))

e, finalmente, criando o conjunto de dados copiando imagens e criando arquivos de texto.

source = 'train' if True: for fold in [0]: val_index = index[len(index)*fold//5:len(index)*(fold+1)//5] for name,mini in tqdm( df.groupby('image_id')): if name in val_index: path2save = 'val2017/' else: path2save = 'train2017/' if not os.path.exists('convertor/fold{}/labels/'.format( fold)+path2save): os.makedirs('convertor/fold{}/labels/'.format(fold)+path2save) com open('convertor/fold{}/labels/'.format(fold)+path2save+name+ ".txt", 'w+') as f: linha = mini[['classes','x_center','y_center','w','h']].astype(float).values ​​imagename = data_path+"/ {}/{}.jpg".format(source,name) check_image_width_height = Image.open(imagename) img_width, img_height = check_image_width_height.size for r in (row): r[1] = r[1]/img_width r[ 2] = r[2]/img_height r[3] = r[3]/img_width r[4] = r[4]/img_height linha = linha.astype(str) for j in range(len(row)): print(row[j], 'n') row[j][0] = str(int(float(row[j][0]))) text = ' '.join(row[j]) f.write (texto) f.write("n") se não os.path.exists('convertor/fold{}/images/{}'.form at(fold,path2save)): os.makedirs('convertor/fold{}/images/{}'.format(fold,path2save)) sh.copy(data_path+"/{}/{}.jpg".format( source,name),'convertor/fold{}/images/{}/{}.jpg'.format(fold,path2save,name))

O código a seguir geraria uma pasta chamada “conversor/dobra0” que contém Imagens e Rótulos pastas que você precisa copiar e colar dentro do repositório YoloV5 clonado “YoloV5/coco/” pasta.

Criando arquivo YAML para treinamento

Depois que as dependências estiverem instaladas e os dados estiverem prontos, precisamos configurar um Yaml arquivo para treinar o modelo. Para isso, você abre qualquer editor de texto e cria um arquivo “coco.yml” dentro da pasta “YoloV5/dados/”. O conteúdo do arquivo ficaria assim:

# train e val data como 1) diretório: path/images/, 2) arquivo: path/images.txt, ou 3) lista: [path1/images/, path2/images/] train: /Users/gouravbais/yolov5/ coco/images/train2017 val: /Users/gouravbais/yolov5/coco/images/val2017

por favor, mantenha as classes na mesma ordem que você obtém ao converter o conjunto de dados CSV para o conjunto de dados COCO.

Treinamento Yolov5

A configuração do arquivo YAML não deixa muito o que fazer depois, agora só precisamos escrever o comando e fornecer os dados e pesos para treinar o modelo em nosso conjunto de dados personalizado. Você precisa atravessar para a pasta YoloV5 através do terminal ou do prompt do anaconda e executar o seguinte comando:

$ python train.py --img 416 --batch 12 --epochs 50 --data ./data/coco.yml --weights ./weights/yolov5x.pt

Explicação do comando:

trem.py: python contendo o código de treinamento.

imagem: tamanho da imagem padronizado para 640, dependendo da memória da GPU ou CPU, você pode alterá-lo.

lote: tamanho do lote que é novamente diretamente dependente de sua memória.

Dados: o caminho do seu arquivo YAML.

pesos: o caminho do arquivo de pesos que baixamos na etapa 1.

Depois de executar o comando mencionado, o treinamento do modelo começaria. O arquivo de treinamento que estamos usando tem o código que verifica se a GPU está disponível, então o treinamento ocorre na GPU, caso contrário, o treinamento continua na CPU. Não precisamos codificar explicitamente para usar GPU ou CPU.

Uma vez que o treinamento é concluído, você pode encontrar os pesos treinados no “YoloV5/corridas/trem” pasta, que teria dois pesos de arquivo “melhor.pt” e “último.pt” você pode usar qualquer um deles com base em seu treinamento (“melhor.pt” recomendado). Você pode copiar o arquivo e colá-lo dentro do “YoloV5/pesos” pasta. Uma coisa que você terá que observar aqui é que, se a perda ainda estiver diminuindo após 50 épocas, você poderá executá-la por mais épocas, dependendo dos seus dados.

Inferência YoloV5

Em conclusão, o que você precisa é de um modelo de Deep Learning que funcione em seus dados de teste. Então, para testar seu modelo em dados de teste, você terá que usar o “YoloV5/detect.py” script presente no mesmo local que “trem.py”. O comando para testar o modelo em seus dados é o seguinte:

$ python detect.py --img 416 --source ./detect/test_data --weights ./weights/best.pt --conf-thres 0.4

Explicação do comando:

detectar.py: arquivo python para inferência.

imagem: tamanho da imagem que deve ser igual ao tamanho da imagem de treinamento.

fonte: o caminho de dados de teste ou arquivo de imagem de teste.

pesos: o caminho do arquivo de pesos treinados.

conf-thres: limite de confiança acima do qual o objeto deve ser detectado.

A execução do comando acima criaria uma pasta “YoloV5/execuções/detectar” que teria todos os arquivos resultantes nos quais você executou o modelo.

Agora você está pronto para aplicar esse conhecimento de Detecção de Objetos ao seu caso de uso.

Obrigado por ler este artigo goste se você aprendeu algo novo, fique à vontade para comentar Até a próxima !!! ❤️ 

As mídias mostradas neste artigo não são propriedade da Analytics Vidhya e são usadas a critério do autor.

Relacionado

PlatoAi. Web3 Reimagined. Inteligência de dados amplificada.
Clique aqui para acessar.

Fonte: https://www.analyticsvidhya.com/blog/2021/08/train-your-own-yolov5-object-detection-model/