[Serie de mecanismos de atención de aprendizaje profundo] - Mecanismo de atención de SKNet (con implementación de pytorch)

SKNet (Selective Kernel Network) es una arquitectura de red neuronal profunda para clasificación de imágenes y tareas de detección de objetivos. Su principal innovación es la introducción de un kernel de convolución multiescala selectivo (Selective Kernel) y un mecanismo de atención novedoso . Por lo tanto, la capacidad de función se mejora la extracción sin aumentar la complejidad de la red. SKNet está diseñado para resolver el problema de la fusión de información a múltiples escalas, lo que permite que la red se adapte a características de diferentes escalas.

1. Idea central

La idea central de SKNet es capturar características de múltiples escalas en diferentes niveles mediante la aplicación selectiva de núcleos de convolución de diferentes escalas. **Para lograr esto, SKNet presenta un módulo de selección para decidir de manera adaptativa qué escalas de núcleos de convolución usar en cada canal. Este núcleo de convolución multiescala selectivo ayuda a mejorar la capacidad de representación de características, lo que hace que la red sea más adaptable y generalizable.

2. Estructura

La estructura de SKNet es la siguiente:

Mecanismo de implementación:

• split : la convolución de separación de múltiples ramas se realiza en el mapa de características, y cada rama utiliza diferentes núcleos de convolución (diferentes campos receptivos) para la extracción de características. (El mapa de características original no se desmonta ni se separa, pero el mapa de características original se enreda usando diferentes núcleos de convolución). Suponiendo que la rama es n, la dimensión del mapa de características se transforma en (c, h, w) -> (n, c, h, w), n=2 en el texto original.

• Fusible : agregue los resultados de extracción del mapa de características de múltiples ramas. La dimensión del mapa de características se transforma en (n, c, h, w) -> (c, h, w). Luego, a través del grupo promedio global, la dimensión del mapa de características se transforma en (c, h, w) -> (c, 1, 1), y luego usa la capa completamente conectada para reducir la dimensión (la dimensión más baja está limitada , y d×1 se genera a través de la capa totalmente conectada El vector (z en la figura), la fórmula se muestra en la figura (δ representa la función de activación de ReLU, B representa la normalización por lotes, W es una dimensión d×C). el valor de d está determinado por la fórmula d = max(C /r, L) determinado, r es una relación reducida (similar a SENet), L representa el valor mínimo de d, el valor de L en el experimento original es 32. ), y luego use dos (o más, y el número de ramas) De la misma manera, en el artículo original, se usan dos) capas completamente conectadas para aumentar la dimensión, y se obtienen dos (múltiples) dimensiones con el mismo mapa de características (vector) como antes de la reducción de dimensionalidad. Realice el procesamiento softmax en los dos vectores de características. Suponiendo que la rama es n, la dimensión del mapa de características es n (c, 1, 1).En el texto original, n=2, es decir, a->(c, 1, 1), b->( c, 1, 1).

• select : múltiples vectores de características después del procesamiento softmax se multiplican por los resultados del mapa de características de la extracción de múltiples ramas en el primer paso. La dimensión de la característica cambia a n (c, 1 ,1) * n (c, h ,w) = (n, c, h, w). Finalmente, se agregan los n mapas de características.

3. Ventajas

El diseño de SKNet tiene ventajas en los siguientes aspectos:

• Fusión de información multiescala

Mediante la aplicación selectiva de núcleos de convolución de diferentes escalas, SKNet puede fusionar de manera efectiva información de características de múltiples escalas. Esto ayuda a la red a capturar características visuales en diferentes niveles y mejora la capacidad de representación de las características.

• adaptado

El módulo de selección permite que la red seleccione de manera adaptativa la escala del kernel de convolución para adaptarse a las características de diferentes tareas e imágenes. Esta adaptabilidad permite que la red funcione bien en varios escenarios.

• reducir el costo computacional

Aunque se introduce el kernel de convolución multiescala, debido a la existencia del módulo de selección, SKNet solo seleccionará una parte del kernel de convolución para el cálculo, lo que reduce el costo de cálculo y mantiene la eficiencia de la red.

4. Implementación del código

class SKNet(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1, M=2, r=16, L=32):
        """
        :param in_channels:  输入通道维度
        :param out_channels: 输出通道维度   原论文中 输入输出通道维度相同
        :param stride:  步长，默认为1
        :param M:  分支数
        :param r: 特征Z的长度，计算其维度d 时所需的比率（论文中 特征S->Z 是降维，故需要规定 降维的下界）
        :param L:  论文中规定特征Z的下界，默认为32
        采用分组卷积： groups = 32,所以输入channel的数值必须是group的整数倍
        """
        super(SKNet, self).__init__()
        d = max(in_channels // r, L)  
        self.M = M
        self.out_channels = out_channels
        self.conv = nn.ModuleList() 
        for i in range(M):
            self.conv.append(nn.Sequential(
                nn.Conv2d(in_channels, out_channels, 3, stride, padding=1 + i, dilation=1 + i, groups=32, bias=False),
                nn.BatchNorm2d(out_channels),
                nn.ReLU(inplace=True)))
        self.global_pool = nn.AdaptiveAvgPool2d(output_size=1) 
        self.fc1 = nn.Sequential(nn.Conv2d(out_channels, d, 1, bias=False),
                                 nn.BatchNorm2d(d),
                                 nn.ReLU(inplace=True))  # 降维
        self.fc2 = nn.Conv2d(d, out_channels * M, 1, 1, bias=False)  
        self.softmax = nn.Softmax(dim=1) 
    def forward(self, input):
        batch_size = input.size(0)
        output = []
        for i, conv in enumerate(self.conv):
            output.append(conv(input))
        U = reduce(lambda x, y: x + y, output)  
        s = self.global_pool(U)  
        z = self.fc1(s)
        a_b = self.fc2(z) 
        a_b = a_b.reshape(batch_size, self.M, self.out_channels, -1) 
        a_b = self.softmax(a_b) 
        a_b = list(a_b.chunk(self.M, dim=1))  
        a_b = list(map(lambda x: x.reshape(batch_size, self.out_channels, 1, 1),
                       a_b))  
        V = list(map(lambda x, y: x * y, output,
                     a_b))  
        V = reduce(lambda x, y: x + y,
                   V)  
        return V

Resumir

SKNet es una innovadora arquitectura de red neuronal profunda que mejora las capacidades de extracción de características mediante la introducción de mecanismos de atención y núcleos de convolución multiescala selectivos. Su estructura central incluye un módulo de selección y una capa de convolución SK, que pueden fusionar de manera efectiva información de múltiples escalas, ajustar de manera adaptativa la escala del kernel de convolución y reducir el costo computacional. Esto permite que SKNet logre un rendimiento superior en tareas como la clasificación de imágenes y la detección de objetos.