Arquitetura Ultralytics YOLOv5

YOLOv5 (v6.0/6.1) é um poderoso algoritmo de detecção de objetos desenvolvido pela Ultralytics. Este artigo explora em profundidade a arquitetura do YOLOv5, estratégias de aumento de dados, metodologias de treinamento e técnicas de cálculo de perda. Essa 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.

1. Estrutura do Modelo

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

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

A estrutura do modelo é representada na imagem abaixo. Os detalhes da estrutura do modelo podem ser encontrados em yolov5l.yaml.

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

1. O Focus é substituída por uma 6x6 Conv2d estrutura. Essa mudança aumenta a eficiência #4825.
2. O SPP a estrutura é substituída por SPPF. Essa 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 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

2. Técnicas de Aumento de Dados

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

• Aumento de Mosaico: Uma técnica de processamento de imagem que combina quatro imagens de treinamento em uma, incentivando os modelos de detecção de objetos a lidar melhor com várias escalas e traduções de objetos.

  

• Aumento de Copiar-Colar: Um método inovador de aumento de dados que copia patches aleatórios de uma imagem e os cola em outra imagem escolhida aleatoriamente, gerando efetivamente uma nova amostra de treinamento.

  

• Transformações Afins Aleatórias: Isso inclui rotação, escala, translação e cisalhamento aleatórios das imagens.

  

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

  

• Albumentations: Uma biblioteca poderosa para aumentar imagens que suporta uma ampla variedade de técnicas de aumento. Saiba mais sobre como usar aumentos do Albumentations.

• Aumento HSV: Mudanças aleatórias na Matiz, Saturação e Valor das imagens.

  

• Inversão Horizontal Aleatória: Um método de aumento que inverte aleatoriamente as imagens horizontalmente.

  

3. Estratégias de Treinamento

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

• Treinamento Multiescala: As imagens de entrada são redimensionadas aleatoriamente dentro de uma faixa de 0,5 a 1,5 vezes seu tamanho original durante o processo de treinamento.
• AutoAnchor: Esta estratégia otimiza as caixas de âncora anteriores para corresponder às características estatísticas das caixas de verdade fundamental em seus dados personalizados.
• Warmup e Cosine LR Scheduler: Um método para ajustar a taxa de aprendizado para melhorar o desempenho do modelo.
• Média Móvel Exponencial (EMA): Uma estratégia que usa a média dos parâmetros em etapas passadas para estabilizar o processo de treinamento e reduzir o erro de generalização.
• Treinamento de Precisão Mista: Um método para realizar operações em formato de meia-precisão, 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 o desempenho ideal. Saiba mais sobre ajuste de hiperparâmetros.

4. Recursos Adicionais

4.1 Calcular Perdas

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

• Perda de Classes (Perda BCE): Perda de Entropia Cruzada Binária, mede o erro para a tarefa de classificação.
• Perda de Objetividade (Perda BCE): Outra perda de Entropia Cruzada Binária, calcula o erro ao detectar se um objeto está presente em uma determinada célula da grade ou não.
• Perda de Localização (Perda CIoU): Perda de IoU Completo, mede o erro ao localizar o objeto dentro da célula da grade.

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

4.2 Balancear Perdas

As perdas de objetividade 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. Essa abordagem garante que as previsões em diferentes escalas contribuam adequadamente para a perda total.

4.3 Eliminar a Sensibilidade da Grade

A arquitetura YOLOv5 faz algumas mudanças importantes na estratégia de prediçã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 bounding box prevista são as seguintes:

Compare o deslocamento do ponto central antes e depois do dimensionamento. 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 razão de escala da altura e da largura (relativa à âncora) antes e depois do ajuste. As equações originais da caixa yolo/darknet têm uma falha grave. A largura e a altura são completamente ilimitadas, uma vez que 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. Consulte este problema para obter mais detalhes.

4.4 Construir Alvos

O processo de build target no YOLOv5 é fundamental para a eficiência do treinamento e precisão do modelo. Envolve a atribuição de caixas de verdade fundamental às células de grade apropriadas no mapa de saída e a correspondência delas com as caixas de âncora apropriadas.

Este processo segue estas etapas:

• Calcule a razão entre as dimensões da caixa de verdade fundamental e as dimensões de cada modelo de âncora.

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

• Atribua a âncora correspondente às células apropriadas, tendo em mente que, devido ao deslocamento revisado do ponto central, uma caixa de verdade fundamental pode ser atribuída a mais de uma âncora. Como o intervalo de deslocamento do ponto central é ajustado de (0, 1) para (-0,5, 1,5). A caixa GT pode ser atribuída a mais âncoras.

Dessa forma, o processo de build targets garante que cada objeto de verdade fundamental seja devidamente atribuído e correspondido durante o processo de treinamento, permitindo que o YOLOv5 aprenda a tarefa de detecção de objetos de forma mais eficaz.

Conclusão

Em conclusão, o YOLOv5 representa um avanço significativo no desenvolvimento de modelos de detecção de objetos em tempo real. Ao incorporar vários novos recursos, aprimoramentos e estratégias de treinamento, ele supera as versões anteriores da família YOLO em desempenho e eficiência.

Os principais aprimoramentos no YOLOv5 incluem o uso de uma arquitetura dinâmica, uma extensa gama de técnicas de aumento de dados, 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.

📅 Criado há 1 ano ✏️ Atualizado há 4 meses

Comentários