Modelo Yolov2 - implementación de pytorch

Portal de papel: YOLO9000: mejor, más rápido, más fuerte

Mejoras de Yolov2:

1. Normalización por lotes (normalización por lotes) : agregue BN después de conv (conv ya no usa sesgo), mejore la convergencia del modelo y elimine la deserción al mismo tiempo
2. Clasificador de alta resolución (clasificador de alta resolución) : use el resolución de 448x448 Convolucional con cajas de anclaje
3. introduce el concepto de ancla para predecir bbox, cada ancla predice el objetivo y la categoría por separado, y el objetivo predice el IOU de caja anterior (ancla) entre el marco real y la probabilidad condicional de la categoría bajo la premisa de que la categoría se predice para guardar el objetivo; 4. Grupos de dimensiones : use el método de agrupación de k-means para obtener el tamaño preestablecido del ancla; 5. Predicción de ubicación directa : compense las coordenadas centrales de la salida de la red por el parámetro tx t_x

$t_{}$ty $t_{}$y confianza (pagaré) $t_{}$A través de la función de activación sigmoidea, su valor se comprime en (0,1);
6. Características de grano fino : extrae características superficiales en la columna vertebral y conecta con características profundas después de la capa de paso (foco) (concat);
7. Multi- Entrenamiento de escala (entrenamiento de escala múltiple) : cada 10 lotes, cambie aleatoriamente el tamaño de la imagen de entrada de red, de $[320,352,...,608]$ (un múltiplo entero de 32, porque la imagen se reduce 32 veces a través de la red), para mejorar la robustez del modelo;

La estructura de Yolov2:

Use Darknet19 (elimine la parte de clasificación) como la columna vertebral para extraer características, use convolución y capa de transferencia para procesar características superficiales, use dos capas de convolución para procesar características profundas y realice Concat en las dos capas de características, y finalmente obtenga el número de canales a ser 125 después de la transformación de convolución Salida.
La figura muestra que el tamaño de la imagen de entrada de Darknet19 es 224, pero como columna vertebral en Yolov2, el tamaño de la imagen de entrada es $[320,352,...,608]$。

Salida de Yolov2:

Para el conjunto de datos VOC, cuando el tamaño de la imagen de entrada es 416, la salida de la red es (125,13,13), donde 13x13 representa 169 posiciones de anclaje; 125 = $125=(4+1+20)\ast 5$ , 4 representa el parámetro de regresión objetivo, 1 representa la confianza objetivo, 20 representa la probabilidad condicional de 20 categorías y el último 5 representa el tamaño del ancla, es decir, hay 5 tamaños de anclas en cada posición.

Significado de Yolo9000:

El autor adopta un método de entrenamiento conjunto para que el modelo pueda detectar más de 9000 categorías al mismo tiempo, por lo que se denomina Yolo9000.
(El código solo implementa la parte de la estructura del modelo)

import torch
import torch.nn as nn
import random


def conv(in_channels, out_channels, kernel_size):  # conv+bn+leakyrelu
    padding = 1 if kernel_size == 3 else 0
    return nn.Sequential(
        nn.Conv2d(in_channels, out_channels, kernel_size, 1, padding, bias=False),
        nn.BatchNorm2d(out_channels),
        nn.LeakyReLU(0.1)
    )


class Darknet19(nn.Module):  # darknet19
    def __init__(self):
        super(Darknet19, self).__init__()

        self.maxpool = nn.MaxPool2d(2, 2)
        self.conv1 = conv(3, 32, 3)
        self.conv2 = conv(32, 64, 3)
        self.bottleneck1 = nn.Sequential(
            conv(64, 128, 3),
            conv(128, 64, 1),
            conv(64, 128, 3)
        )
        self.bottleneck2 = nn.Sequential(
            conv(128, 256, 3),
            conv(256, 128, 1),
            conv(128, 256, 3)
        )
        self.bottleneck3 = nn.Sequential(
            conv(256, 512, 3),
            conv(512, 256, 1),
            conv(256, 512, 3),
            conv(512, 256, 1),
            conv(256, 512, 3)
        )
        self.bottleneck4 = nn.Sequential(
            conv(512, 1024, 3),
            conv(1024, 512, 1),
            conv(512, 1024, 3),
            conv(1024, 512, 1),
            conv(512, 1024, 3)
        )

    def forward(self, x):
        x = self.conv1(x)
        x = self.maxpool(x)
        x = self.conv2(x)
        x = self.maxpool(x)
        x = self.bottleneck1(x)
        x = self.maxpool(x)
        x = self.bottleneck2(x)
        x = self.maxpool(x)
        shallow_x = self.bottleneck3(x)  # 浅层特征
        deep_x = self.maxpool(shallow_x)
        deep_x = self.bottleneck4(deep_x)  # 深层特征

        return shallow_x, deep_x


class Yolov2(nn.Module):
    def __init__(self):
        super(Yolov2, self).__init__()
        self.backbone = Darknet19()
        self.deep_conv = nn.Sequential(
            conv(1024, 1024, 3),
            conv(1024, 1024, 3)
        )
        self.shallow_conv = conv(512, 64, 1)
        self.final_conv = nn.Sequential(
            conv(1280, 1024, 3),
            nn.Conv2d(1024, 125, 1, 1, 0)
        )

    def passthrough(self, x):  # passthrough layer
        return torch.cat([x[:, :, ::2, ::2], x[:, :, ::2, 1::2], x[:, :, 1::2, ::2], x[:, :, 1::2, 1::2]], dim=1)

    def forward(self, x):
        shallow_x, deep_x = self.backbone(x)  # (B,512,26,26)、(B,1024,13,13)
        shallow_x = self.shallow_conv(shallow_x)  # (B,512,26,26)-->(B,64,26,26)
        shallow_x = self.passthrough(shallow_x)  # (B,64,26,26)-->(B,256,13,13)
        deep_x = self.deep_conv(deep_x)  # (B,1024,13,13)-->(B,1024,13,13)
        feature = torch.cat([deep_x, shallow_x], dim=1)  # (B,1024,13,13)cat(B,256,13,13)-->(B,1280,13,13)
        return self.final_conv(feature)  # (B,1280,13,13)-->(B,1024,13,13)-->(B,125,13,13)


if __name__ == "__main__":
    batch_size = 8
    image_channels = 3
    image_size = random.randrange(320, 608 + 32, 32)  # [320,352,...,608]
    images = torch.randn(batch_size, image_channels, image_size, image_size)
    print(images.shape)
    yolov2 = Yolov2()
    print(yolov2(images).shape)