O YOLOV4 é um algoritmo de detecção de objetos de última geração. Ele pode ser encontrado hoje em sistemas de detecção e monitoramento em tempo real, como câmeras de CFTV e veículos de direção autônoma. É famoso por ser muito preciso e rápido ao mesmo tempo. YOLOv4 é uma das versões mais recentes da família YOLO. Este tutorial explicará como preparar dados no formato YOLOv4 do zero e como treinar o modelo.
A primeira versão do YOLO foi lançada em 2015 por Joseph Redmon et al . Você pode encontrar o documento original para YOLO em You Only Look Once: Unified, Real-Time Object Detection .
Você pode usar meu Notebook COLAB.
Indice
YOLOv4: preparação de dados
A etapa mais crucial em qualquer tarefa de aprendizado profundo é a preparação de dados. Existe uma regra geral de que lixo entra == lixo sai. É também o mais demorado, pois queremos garantir boas imagens e anotações corretas.
COLEÇÃO DE DADOS
Você pode encontrar muitos conjuntos de dados abertos gratuitos no formato Yolo online, mas para este tutorial, vamos criar um do zero. Criaremos um conjunto de dados de tráfego personalizado para 5 classes (carro, pessoa, placa de número, bicicleta e motocicleta). Open Images Dataset V6 é um recurso gratuito para coletar dataset, e OIDv4_ToolKit é um kit de ferramentas que usamos para baixar o dataset. Clique no link do kit de ferramentas OIDv4 que forneci e baixe-o do repositório Github. Após o download, abra sua linha de comando e vá para o diretório usando o comando cd.
Digite o seguinte comando para instalar os pacotes Python necessários.
pip install -r requirements.txt
Em seguida, para baixar o conjunto de dados necessário, digite o seguinte na janela da linha de comando.
Train
python main.py downloader --classes Car Bicycle Person Vehicle_registration_number Motorcycle --type_csv train --multiclasses 1 --limit 50
Validação
python main.py downloader --classes Car Bicycle Person Vehicle_registration_number Motorcycle --type_csv validation --multiclasses 1 --limit 5
Se houver espaço entre palavras como “Número de registro do veículo”, você deve escrever junto como Vehicle_registration_number. Quando você os inserir, o kit de ferramentas solicitará o download de arquivos .csv pela primeira vez. Digite Y para baixá-los. Depois do .csv, os arquivos do kit de ferramentas baixam as imagens e suas caixas delimitadoras.
Depois de fazer tudo isso, você pode encontrar o conjunto de dados baixado em
OIDv4_ToolKit-master>OID>Dataset>train OIDv4_ToolKit-master>OID>Dataset>validation
Se você abrir a pasta de treinamento e validação, verá que também há uma pasta “Etiquetas” dentro delas. Ele contém caixas delimitadoras para o objeto nas imagens que baixamos. Mas não podemos usá-los, pois são anotações como um tipo de objeto por imagem. Isso significa que se uma imagem contém “placas de matrícula” e “carros”, as anotações terão caixas delimitadoras apenas para carros ou apenas placas de matrícula. Mas precisamos de anotações para cada objeto na imagem. Isso pode ser melhor compreendido pelo diagrama a seguir.
O que temos vs como precisamos
Yolo é treinado melhor quando vê muitas informações em uma imagem, então precisamos mudá-la para o novo formato. Para isso, remova a pasta Labels das pastas “train” e “validation”.
PREPARAÇÃO DE DADOS
Para preparar o conjunto de dados, usaremos LabelImg (procedimento de instalação explicado no repositório Github). É um anotador de imagem de código aberto gratuito que podemos usar para criar anotações no formato YOLOv4.
Abra LabelImg e abra a pasta de localização. Pressione “w” e faça caixas delimitadoras ao redor dos objetos e rotule-os. Depois disso, salve o arquivo. Mas certifique-se de que esteja no formato .txt e que esteja sendo salvo na mesma pasta que as imagens.
Fonte: Conjunto de dados de imagens abertas V6
Assim que terminar as anotações, corte o arquivo chamado “classes.txt” na pasta e salve-o em um local seguro. Porque precisaremos depois. Renomeie a pasta que contém as imagens de treinamento como “obj” e as imagens de validação como “teste”. Compacte-os separadamente e carregue-os em seu Google Drive.
Treinamento
Usaremos o Google COLAB para treinar nosso modelo (se você nunca usou o Google COLAB antes, verifique nosso blog sobre o Google COLAB ). Clique neste link para abrir o Notebook .
Clique em Copiar para o Drive para salvar uma cópia em seu próprio Drive.
yolov4: Copiar para o Drive
Para se conectar a uma GPU, vá para Editar> Configurações do Notebook> Acelerador de hardware> GPU
yolov4: Configurações de Notebook no Google Colab
Clone o repositório Darknet Github
# clone darknet repo !git clone https://github.com/AlexeyAB/darknet
Para dizer ao YOLOv4 para usar a GPU e OpenCV
# change makefile to have GPU and OPENCV enabled %cd darknet !sed -i 's/OPENCV=0/OPENCV=1/' Makefile !sed -i 's/GPU=0/GPU=1/' Makefile !sed -i 's/CUDNN=0/CUDNN=1/' Makefile !sed -i 's/CUDNN_HALF=0/CUDNN_HALF=1/' Makefile
Verifique se você tem cuda
# verify CUDA !/usr/local/cuda/bin/nvcc --version
Você deve obter a seguinte saída
nvcc: NVIDIA (R) Cuda compiler driver Copyright (c) 2005-2019 NVIDIA Corporation Built on Sun_Jul_28_19:07:16_PDT_2019 Cuda compilation tools, release 10.1, V10.1.243
Execute o arquivo make
!make
Baixar arquivo de pesos YOLOv4
!wget https://github.com/AlexeyAB/darknet/releases/download/darknet_yolo_v3_optimal /yolov4.weights
Execute esta função auxiliar
import cv2
import matplotlib.pyplot as plt
%matplotlib inline
def imShow(path):
image = cv2.imread(path)
height, width = image.shape[:2]
resized_image = cv2.resize(image,(3*width, 3*height), interpolation = cv2.INTER_CUBIC)
fig = plt.gcf() fig.set_size_inches(18, 10)
plt.axis("off")
plt.imshow(cv2.cvtColor(resized_image, cv2.COLOR_BGR2RGB))
plt.show()
Se essas execuções e previsões para data / person.jpg forem mostradas, tudo estará pronto para prosseguir. Agora podemos começar a treinar nosso modelo
!./darknet detector test cfg/coco.data cfg/yolov4.cfg yolov4.weights data/person.jpg imShow('predictions.jpg')
Fonte: Conjunto de dados de imagens abertas V6
No momento, nosso link para dirigir é
/content/drive/My Drive/
Podemos simplificar isso para / mydrive / por
!ln -s /content/drive/My\ Drive/ /mydrive !ls /mydrive
Agora copie o obj.zip e o test.zip em seu ambiente virtual
# %cd .. !cp -r '/mydrive/data/obj.zip' /content !cp -r '/mydrive/data/test.zip' /content
E descompacte-os em content> darknet> data
!unzip '/content/obj.zip' -d '/content/darknet/data' !unzip '/content/test.zip' -d '/content/darknet/data'
Vá para a pasta OIDv4_ToolKit-master em seu computador e carregue generate_train.py e g enerate_test.py em / content / darknet /
Em seguida, execute os seguintes comandos
!python generate_train.py !python generate_test.py
Verifique se você tem train.txt e test.txt em sua pasta / content / darknet / data .
! ls data /
yolov4: verificar teste e treinar
Baixe os pesos das camadas convolucionais.
! wget https://github.com/AlexeyAB/darknet/releases/download/darknet_yolo_v3_optimal/yolov4.conv.137
Precisamos fazer dois arquivos em / content / darknet / data. Ou seja, obj.data e obj.names
obj.data deve ter o seguinte conteúdo
yolov4: Obj.data
Depois disso, vá até sua unidade e crie uma pasta chamada backup. YOLOv4 salva os pesos do modelo a cada 100 iterações e depois de 1000, ele salva a cada 1000 iterações. Se o treinamento parar por algum motivo, você pode reiniciá-lo a partir do último arquivo de pesos salvo.
obj.names deve ter o mesmo conteúdo do classes.txt que você salvou durante a fase de preparação de dados. Na mesma ordem, é assim que o meu se parece:
yolov4: obj.names
Finalmente, você precisa alterar o conteúdo da configuração.
Vá para / content / darknet / cfg / e abra yolov4-custom.cfg
Faça as seguintes alterações:
batch=64 subdivisions=16 max_batches = 10000 (num_classes*2000 but if classes are less then or equal to 3 put max_batches = 6000) width = 416 (has to be multiple of 32, increase height and width will increase accuracy but training speed will slow down). height = 416 (has to be multiple of 32). steps = 8000, 9000 (80% of max_batches), (90% of max_batches)
Finally scroll done the file and find classes and filters (they are in three different locations so change all). classes = 5 filters = 30 ( (num_classes + 5) * 3 )
E é isso! Seu modelo está pronto para treinar. Execute para treinar:
# %%capture !./darknet detector train data/obj.data cfg/yolov4-custom.cfg yolov4.conv.137 -dont_show -map
Se o seu notebook começar a travar, apenas descomente a linha de captura %% .
Para começar o treinamento de onde você salvou seus pesos, use isto:
!./darknet detector train data/obj.data cfg/yolov4-custom.cfg /mydrive/backup /yolov4-obj_last.weights -dont_show
PERDA
Assim que você iniciar o treinamento, este texto começará a aparecer.
Ele mostrará a iteração e a perda atual do modelo. A perda diminuirá rapidamente no início, mas diminuirá conforme as iterações aumentam.
yolov4: perda
Você também pode observar a perda usando o gráfico abaixo. Por padrão, ele é salvo no diretório darknet. 
yolov4: gráfico de perda
Deixe o modelo rodar por algumas horas até que a curva do gráfico comece a se achatar.
YOLOV4: FAÇA PREVISÕES
Para fazer previsões, primeiro execute isso para alterar o yolov4-custom.cfg
%cd cfg !sed -i 's/batch=64/batch=1/' yolov4-custom.cfg !sed -i 's/subdivisions=16/subdivisions=1/' yolov4-custom.cfg %cd ..
Finalmente, execute este comando para executar previsões:
!./darknet detector test data/obj.data cfg/yolov4-custom.cfg /mydrive/backup /yolov4-custom_best.weights '/content/test_image.jpg' -thresh 0.6
imShow('predictions.jpg')
Parece muito preciso !!!
yolov4: bicicleta pesada
yolov4: pessoa e ciclo
yolov4: carro