Arquitetura do Ultralytics YOLOv5#

O YOLOv5 (v6.0/6.1) é um algoritmo de deteção de objetos poderoso desenvolvido pela Ultralytics. Este artigo mergulha a fundo na arquitetura do YOLOv5, estratégias de data augmentation, metodologias de treino e técnicas de cálculo de perda. Esta compreensão abrangente ajudará a melhorar a tua aplicação prática da deteção de objetos em vários campos, incluindo vigilância, veículos autónomos e image recognition.

Estrutura do Modelo#

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

• Backbone: Este é o corpo principal da rede. No YOLOv5, o backbone é concebido utilizando a estrutura CSPDarknet53, uma modificação da arquitetura Darknet utilizada em versões anteriores.
• Neck: Esta parte liga o backbone à 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 utiliza a 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 seus predecessores:

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, mantendo a mesma saída.

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

import time

import torch
from torch import 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

Técnicas de Data Augmentation#

O YOLOv5 emprega várias técnicas de aumento de dados para melhorar a capacidade do modelo de generalizar e reduzir o overfitting. Estas técnicas incluem:

• Mosaic Augmentation: Uma técnica de processamento de imagem que combina quatro imagens de treino numa só de formas que incentivam os modelos de object detection a lidar melhor com várias escalas de objetos e translações.

  

• 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 aumento de imagem que suporta uma grande variedade de técnicas de aumento. Sabe mais sobre using Albumentations augmentations.

• 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.

  

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 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 learning rate 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.
• Mixed Precision Training: Um método para realizar operações em formato de meia-precision, reduzindo o uso de memória e melhorando a velocidade computacional.
• Hyperparameter Evolution: Uma estratégia para ajustar automaticamente os hiperparâmetros para alcançar o desempenho ideal. Sabe mais sobre hyperparameter tuning.

Recursos Adicionais#

4.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 loss function geral é representada por:

4.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 respetivamente [4.0, 1.0, 0.4]. Esta abordagem garante que as previsões em diferentes escalas contribuem adequadamente para a perda total.

4.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 revistas 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.

Compara o rácio de dimensionamento da altura e largura (em relação à âncora) antes e depois do ajuste. As equações originais de caixa yolo/darknet têm uma falha grave. A largura e a 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, a uma perda completa do treino. Refer to this issue para mais detalhes.

4.4 Construir Alvos (Build Targets)#

O processo de construção do alvo no YOLOv5 é fundamental para a eficiência do treino e a accuracy do modelo. Envolve a atribuição de caixas de verdade básica (ground truth) às células de grelha apropriadas no mapa de saída e a correspondência das mesmas com as caixas de â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.

Conclusã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.