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 mergulha profundamente 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 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 sectionEstrutura 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 a 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 a YOLOv3 Head para esse propósito.

A estrutura do modelo é retratada 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 seus predecessores:

1. A estrutura Focus, encontrada em versões anteriores, foi substituída por uma estrutura 6x6 Conv2d. Essa mudança aumenta a eficiência #4825.
2. A estrutura SPP foi substituída pela SPPF. Essa alteração mais do que dobra 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 sectionTécnicas de Data Augmentation#

O YOLOv5 emprega várias técnicas de data augmentation para melhorar a capacidade do modelo de generalizar e reduzir overfitting. Essas técnicas incluem:

• Mosaic Augmentation: Uma técnica de processamento de imagem que combina quatro imagens de treinamento em uma, de maneiras que incentivam os modelos de detecção de objetos 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 os cola em outra imagem escolhida aleatoriamente, gerando efetivamente uma nova amostra de treinamento.

  

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

  

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

  

• Albumentations: Uma biblioteca poderosa de augmentation de imagens que suporta uma ampla variedade de técnicas de augmentation. Saiba mais sobre usar augmentations do Albumentations.

• HSV Augmentation: Mudanças 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 sectionEstraté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 um intervalo de 0,5 a 1,5 vezes o seu tamanho original durante o processo de treinamento.
• AutoAnchor: Esta estratégia otimiza as caixas âncora prior para corresponder às características estatísticas das caixas de ground truth em seus dados personalizados.
• Warmup and Cosine LR Scheduler: Um método para ajustar a taxa de aprendizado para melhorar o desempenho do modelo.
• Exponential Moving Average (EMA): Uma estratégia que usa a média de parâmetros ao longo de etapas anteriores para estabilizar o processo de treinamento e reduzir o erro de generalização.
• Treinamento em Mixed Precision: Um método para realizar operações em formato de meia-precisão, reduzindo o uso de memória e aumentando a velocidade computacional.
• Hyperparameter Evolution: Uma estratégia para ajustar automaticamente os hiperparâmetros para obter o desempenho ideal. Saiba mais sobre ajuste de hiperparâmetros.

Link to this sectionRecursos Adicionais#

Link to this section4.1 Calcular Perdas (Compute Losses)#

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

• Classes Loss (BCE Loss): Perda de Entropia Cruzada Binária, mede o erro para a tarefa de classificação.
• Objectness Loss (BCE Loss): Outra perda de Entropia Cruzada Binária, calcula o erro na detecção se um objeto está presente ou não em uma célula de grade específica.
• Location Loss (CIoU Loss): Perda Complete IoU, mede o erro na localização do objeto dentro da célula da grade.

A função de perda geral é representada por:

Link to this section4.2 Balancear Perdas#

As perdas de objectness das três camadas de previsão (P3, P4, P5) são ponderadas de forma diferente. Os pesos de equilíbrio são [4.0, 1.0, 0.4] respectivamente. Essa abordagem garante que as previsõ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 previsão de caixa 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 evitar que o modelo preveja dimensões de caixa ilimitadas.

As fórmulas revisadas para calcular a caixa delimitadora 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 taxa de escalonamento de altura e largura (em relação à âncora) antes e depois do ajuste. As equações originais de caixa do yolo/darknet possuem uma falha grave. 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, finalmente, uma perda completa do treinamento. Consulte este problema para obter mais detalhes.

Link to this section4.4 Construir Alvos (Build Targets)#

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

Este processo segue estas etapas:

• Calcule a razão entre as dimensões da caixa de ground truth e as dimensões de cada template de âncora.

• Se a razão calculada estiver dentro do limite, combine a caixa de ground truth com a âncora correspondente.

• Atribua a âncora correspondente às células apropriadas, lembrando que, devido ao deslocamento do ponto central revisado, uma caixa de ground truth 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.

Dessa 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 com mais eficácia.

Link to this sectionConclusão#

O YOLOv5 representa um passo significativo na evolução da detecção de objetos em tempo real. Suas escolhas arquitetônicas, estratégias de treinamento e refinamentos de engenharia entregam 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 ampla 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 essas 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.