Link to this sectionArquitetura do Ultralytics YOLOv5#

O YOLOv5 (v6.0/6.1) é um algoritmo de detecção de objetos poderoso desenvolvido pela Ultralytics. Este artigo aprofunda-se na arquitetura do YOLOv5, estratégias de data augmentation, metodologias de treinamento e técnicas de cálculo de perda. Esta compreensão abrangente ajudará a melhorar a sua aplicação prática de detecção de objetos em vários campos, incluindo vigilância, veículos autônomos e reconhecimento de imagem.

Link to this section1. Estrutura do Modelo#

A arquitetura do YOLOv5 consiste em três partes principais:

• Backbone: Este é o corpo principal da rede. Para o YOLOv5, o backbone é projetado usando a estrutura CSPDarknet53, uma modificação da arquitetura Darknet usada em versões anteriores.
• Neck: Esta parte conecta o backbone e o head. No YOLOv5, são utilizadas as estruturas SPPF (Spatial Pyramid Pooling - Fast) e PANet (Path Aggregation Network).
• Head: Esta parte é responsável por gerar a saída final. O YOLOv5 usa o YOLOv3 Head para este propósito.

A estrutura do modelo está representada na imagem abaixo. Os detalhes da estrutura do modelo podem ser encontrados em models/yolov5l.yaml.

O YOLOv5 introduz algumas melhorias notáveis em comparação com os seus antecessores:

1. A estrutura Focus, encontrada em versões anteriores, é substituída por uma estrutura 6x6 Conv2d. Esta alteração aumenta a eficiência #4825.
2. A estrutura SPP é substituída por SPPF. Esta alteração mais do que duplica a velocidade de processamento enquanto mantém a mesma saída.

Para testar a velocidade de SPP e SPPF, o seguinte código pode ser usado:

import time

import torch
import torch.nn as nn

class SPP(nn.Module):
    def __init__(self):
        """Initializes an SPP module with three different sizes of max pooling layers."""
        super().__init__()
        self.maxpool1 = nn.MaxPool2d(5, 1, padding=2)
        self.maxpool2 = nn.MaxPool2d(9, 1, padding=4)
        self.maxpool3 = nn.MaxPool2d(13, 1, padding=6)

    def forward(self, x):
        """Applies three max pooling layers on input `x` and concatenates results along channel dimension."""
        o1 = self.maxpool1(x)
        o2 = self.maxpool2(x)
        o3 = self.maxpool3(x)
        return torch.cat([x, o1, o2, o3], dim=1)

class SPPF(nn.Module):
    def __init__(self):
        """Initializes an SPPF module with a specific configuration of MaxPool2d layer."""
        super().__init__()
        self.maxpool = nn.MaxPool2d(5, 1, padding=2)

    def forward(self, x):
        """Applies sequential max pooling and concatenates results with input tensor."""
        o1 = self.maxpool(x)
        o2 = self.maxpool(o1)
        o3 = self.maxpool(o2)
        return torch.cat([x, o1, o2, o3], dim=1)

def main():
    """Compares outputs and performance of SPP and SPPF on a random tensor (8, 32, 16, 16)."""
    input_tensor = torch.rand(8, 32, 16, 16)
    spp = SPP()
    sppf = SPPF()
    output1 = spp(input_tensor)
    output2 = sppf(input_tensor)

    print(torch.equal(output1, output2))

    t_start = time.time()
    for _ in range(100):
        spp(input_tensor)
    print(f"SPP time: {time.time() - t_start}")

    t_start = time.time()
    for _ in range(100):
        sppf(input_tensor)
    print(f"SPPF time: {time.time() - t_start}")

if __name__ == "__main__":
    main()

True
SPP time: 0.5373051166534424
SPPF time: 0.20780706405639648

Link to this section2. Técnicas de Data Augmentation#

O YOLOv5 emprega várias técnicas de data augmentation para melhorar a capacidade de generalização do modelo e reduzir o overfitting. Estas técnicas incluem:

• Mosaic Augmentation: Uma técnica de processamento de imagem que combina quatro imagens de treinamento em uma só, de maneiras que encorajam os modelos de object detection a lidar melhor com várias escalas e translações de objetos.

  

• Copy-Paste Augmentation: Um método inovador de data augmentation que copia patches aleatórios de uma imagem e cola-os noutra imagem escolhida aleatoriamente, gerando efetivamente uma nova amostra de treinamento.

  

• Random Affine Transformations: Isto inclui rotação aleatória, escala, translação e cisalhamento das imagens.

  

• MixUp Augmentation: Um método que cria imagens compostas ao tomar uma combinação linear de duas imagens e os seus rótulos associados.

  

• Albumentations: Uma poderosa biblioteca de aumento de imagem que suporta uma grande variedade de técnicas de aumento. Saiba mais sobre como usar os augmentations do Albumentations.

• HSV Augmentation: Alterações aleatórias na Matiz (Hue), Saturação (Saturation) e Valor (Value) das imagens.

  

• Random Horizontal Flip: Um método de augmentation que inverte imagens horizontalmente de forma aleatória.

  

Link to this section3. Estratégias de Treinamento#

O YOLOv5 aplica várias estratégias de treinamento sofisticadas para melhorar o desempenho do modelo. Elas incluem:

• Multiscale Training: As imagens de entrada são redimensionadas aleatoriamente dentro de uma faixa de 0,5 a 1,5 vezes o seu tamanho original durante o processo de treinamento.
• AutoAnchor: Esta estratégia otimiza as anchor boxes prévias para corresponder às características estatísticas das ground truth boxes nos seus dados personalizados.
• Warmup e Cosine LR Scheduler: Um método para ajustar a learning rate para melhorar o desempenho do modelo.
• Exponential Moving Average (EMA): Uma estratégia que usa a média dos parâmetros ao longo de passos anteriores para estabilizar o processo de treinamento e reduzir o erro de generalização.
• Treinamento com Mixed Precision: Um método para realizar operações em formato de meia-precision, reduzindo o uso de memória e aumentando a velocidade computacional.
• Evolução de Hiperparâmetros: Uma estratégia para ajustar automaticamente os hiperparâmetros para alcançar um desempenho ideal. Saiba mais sobre ajuste de hiperparâmetros.

Link to this section4. Recursos Adicionais#

Link to this section4.1 Calcular Perdas#

A perda no YOLOv5 é calculada como uma combinação de três componentes de perda individuais:

• Classes Loss (BCE Loss): Perda de Binary Cross-Entropy, mede o erro para a tarefa de classificação.
• Objectness Loss (BCE Loss): Outra perda de Binary Cross-Entropy, calcula o erro na detecção se um objeto está presente numa célula de grade específica ou não.
• Location Loss (CIoU Loss): Perda de CIoU completa, mede o erro na localização do objeto dentro da célula da grade.

A loss function geral é representada por:

Link to this section4.2 Balancear Perdas#

As perdas de objectness das três camadas de predição (P3, P4, P5) são ponderadas de forma diferente. Os pesos de equilíbrio são [4.0, 1.0, 0.4] respectivamente. Esta abordagem garante que as predições em diferentes escalas contribuam adequadamente para a perda total.

Link to this section4.3 Eliminar Sensibilidade da Grade#

A arquitetura do YOLOv5 faz algumas mudanças importantes na estratégia de predição de caixas em comparação com as versões anteriores do YOLO. No YOLOv2 e YOLOv3, as coordenadas da caixa eram previstas diretamente usando a ativação da última camada.

No entanto, no YOLOv5, a fórmula para prever as coordenadas da caixa foi atualizada para reduzir a sensibilidade da grade e impedir que o modelo preveja dimensões de caixa ilimitadas.

As fórmulas revisadas para calcular a bounding box prevista são as seguintes:

Compare o deslocamento do ponto central antes e depois do escalonamento. O intervalo de deslocamento do ponto central é ajustado de (0, 1) para (-0,5, 1,5). Portanto, o deslocamento pode facilmente obter 0 ou 1.

Compare a proporção de escala de altura e largura (em relação à âncora) antes e depois do ajuste. As equações originais de caixa do yolo/darknet têm uma falha séria. Largura e Altura são completamente ilimitadas, pois são simplesmente out=exp(in), o que é perigoso, pois pode levar a gradientes descontrolados, instabilidades, perdas NaN e, em última análise, uma perda total de treinamento. Consulte este problema para mais detalhes.

Link to this section4.4 Build Targets#

O processo de build targets no YOLOv5 é fundamental para a eficiência do treinamento e a accuracy do modelo. Envolve atribuir ground truth boxes às células de grade apropriadas no mapa de saída e combiná-las com as anchor boxes apropriadas.

Este processo segue estes passos:

• Calcule a proporção das dimensões da ground truth box e as dimensões de cada modelo de âncora.

• Se a proporção calculada estiver dentro do limite, combine a ground truth box com a âncora correspondente.

• Atribua a âncora combinada às células apropriadas, tendo em mente que, devido ao deslocamento revisado do ponto central, uma ground truth box pode ser atribuída a mais de uma âncora porque o intervalo de deslocamento do ponto central é ajustado de (0, 1) para (-0,5, 1,5), tornando possíveis correspondências adicionais.

Desta forma, o processo de build targets garante que cada objeto de ground truth seja adequadamente atribuído e combinado durante o processo de treinamento, permitindo que o YOLOv5 aprenda a tarefa de detecção de objetos de forma mais eficaz.

Link to this sectionConclusão#

O YOLOv5 representa um passo significativo na evolução da detecção de objetos em tempo real. As suas escolhas arquitetônicas, estratégias de treinamento e refinamentos de engenharia proporcionam um forte desempenho e eficiência em relação às versões anteriores do YOLO.

Os principais aprimoramentos no YOLOv5 incluem o uso de uma arquitetura dinâmica, uma vasta gama de técnicas de data augmentation, estratégias de treinamento inovadoras, bem como ajustes importantes no cálculo de perdas e no processo de build targets. Todas estas inovações melhoram significativamente a precisão e a eficiência da detecção de objetos, mantendo um alto grau de velocidade, que é a marca registrada dos modelos YOLO.