Los parches son todo lo que necesitas

Publicado: [Presentado el 24 de enero de 2022];

Revista/conferencia publicada: visión artificial y reconocimiento de patrones;

Dirección en papel: https://arxiv.org/abs/2201.09792;

Dirección del código: https://github.com/locuslab/convmixer;

0 resumen

Aunque CNN ha sido la principal arquitectura para tareas de visión por computadora durante muchos años, algunos trabajos recientes han demostrado que los modelos basados en Transformer, especialmente ViT, pueden superar el rendimiento de CNN en algunos casos (especialmente el transformador swin posterior, superando por completo a CNN, Milestone );

Sin embargo, dado que el tiempo de ejecución de autoatención del Transformador es cuadrático/cuadrado ( $O(n^2)$ ), ViT utiliza la incrustación de parches para combinar pequeñas regiones de una imagen en una única función de entrada para su aplicación a tamaños de imagen más grandes.

Esto plantea la pregunta: ¿el rendimiento de ViT se debe al hecho de que el transformador en sí es lo suficientemente potente, o se debe a que la entrada es un parche?

Este documento proporciona alguna evidencia de lo último;

Este artículo propone un modelo muy simple: ConvMixer, la idea es similar a MLP-Mixer;

MLP-Mixer opera directamente en los parches como entrada, separa la información de mezcla en dimensiones espaciales y de canal, y mantiene el mismo tamaño y resolución en toda la red .
ConvMixer solo usa circunvoluciones estándar para implementar el paso de mezcla.

A pesar de su simplicidad, este documento muestra que ConvMixer supera a ViT, MLP-Mixer y algunas de sus variantes en recuentos de parámetros y tamaños de conjuntos de datos similares, además de modelos de visión clásicos como ResNet.

1. Introducción

Este artículo explora una pregunta: ¿El poderoso rendimiento de ViT se debe a la estructura del Transformador en sí, o se deriva más de la representación de este parche?

Este artículo propone una arquitectura convolucional muy simple, que llamamos "ConvMixer" debido a su similitud con el MLP-Mixer propuesto recientemente (Tolstikhin et al, 2021).

Muchos aspectos de ConvMixer son similares a ViT o MLP-Mixer :

Operar directamente en el parche;
Mantenga la misma representación de resolución y tamaño en todas las capas (el mapa de características no reduce la dimensionalidad, no reduce la resolución);
Las representaciones de capas sucesivas no se reducen;
Separe la "mezcla de canales" de información de la "mezcla espacial" (conv. en profundidad y puntual);

la diferencia:

ConvMixer hace todo esto con solo circunvoluciones estándar;

Conclusión: La forma de representación del parche es muy importante;

2 modelo ConvMixer

Descripción general del modelo 2.0

como se muestra en la imagen 2:

El tamaño de la imagen de entrada es $C \times norte \times n$ , c-canal, n-ancho/alto;
El tamaño del parche es $p$ , después de la incrustación del parche, el número es $n / p \times n / p$ , un vector incrustado en la dimensión h, obtiene un bloque vectorial (también llamado mapa de características) $h \times (n / p) \times (n / p)$ ;
- Esta incrustación de parches es diferente de la incrustación de parches de Transformer;
- Este paso es equivalente a usar un canal de entrada como $c$ , el canal de salida es $h$ , tamaño del kernel de convolución = patch_size, stride = patch_size mapa de características desconvolucionado del kernel de convolución;
Realice la activación de GeLU y BN en este mapa de funciones e introdúzcalo en la capa ConvMixer;
La capa ConvMixer consta de convolución profunda, convolución en profundidad, convolución puntual, convolución puntual y conexión residual.Después de cada convolución, habrá activación de GeLU y BN;
- conv en profundidad: will $Cada uno de los canales h$ está convolucionado => mezcla espacial;
- conversión puntual: convolución 1×1, mezcla entre canales;
La capa ConvMixer ciclará los tiempos de profundidad;
Finalmente acceda al encabezado de clasificación;

Figura 2: descripción general de ConvMixer

Implementación de Pytorch:

class ConvMixerLayer(nn.Module):
    def __init__(self,dim,kernel_size = 9):
        super().__init__()
        #残差结构
        self.Resnet =  nn.Sequential(
            nn.Conv2d(dim,dim,kernel_size=kernel_size,groups=dim,padding='same'),
            nn.GELU(),
            nn.BatchNorm2d(dim)
        )
        #逐点卷积
        self.Conv_1x1 = nn.Sequential(
            nn.Conv2d(dim,dim,kernel_size=1),
            nn.GELU(),
            nn.BatchNorm2d(dim)
        )
    def forward(self,x):
        x = x +self.Resnet(x)
        x = self.Conv_1x1(x)
        return x

class ConvMixer(nn.Module):
    def __init__(self,dim,depth,kernel_size=9, patch_size=7, n_classes=1000):
        super().__init__()
        self.conv2d1 = nn.Sequential(
            nn.Conv2d(3,dim,kernel_size=patch_size,stride=patch_size),
            nn.GELU(),
            nn.BatchNorm2d(dim)
        )
        self.ConvMixer_blocks =nn.ModuleList([])

        for _ in range(depth):
            self.ConvMixer_blocks.append(ConvMixerLayer(dim=dim,kernel_size=kernel_size))

        self.head =  nn.Sequential(
            nn.AdaptiveAvgPool2d((1,1)),
            nn.Flatten(),
            nn.Linear(dim,n_classes)
        )
    def forward(self,x):
    	#编码时的卷积
        x = self.conv2d1(x)
		#多层ConvMixer_block  的计算
        for ConvMixer_block in  self.ConvMixer_blocks:
             x = ConvMixer_block(x)
        #分类输出
        x = self.head(x)

        return x


model = ConvMixer(dim=128,depth=2)
print(model)

ConvMixer(
  (conv2d1): Sequential(
    (0): Conv2d(3, 128, kernel_size=(7, 7), stride=(7, 7))
    (1): GELU()
    (2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  )
  (ConvMixer_blocks): ModuleList(
    (0): ConvMixerLayer(
      (Resnet): Sequential(
        (0): Conv2d(128, 128, kernel_size=(9, 9), stride=(1, 1), padding=same, groups=128)
        (1): GELU()
        (2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (Conv_1x1): Sequential(
        (0): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))
        (1): GELU()
        (2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): ConvMixerLayer(
      (Resnet): Sequential(
        (0): Conv2d(128, 128, kernel_size=(9, 9), stride=(1, 1), padding=same, groups=128)
        (1): GELU()
        (2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (Conv_1x1): Sequential(
        (0): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))
        (1): GELU()
        (2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
  )
  (head): Sequential(
    (0): AdaptiveAvgPool2d(output_size=(1, 1))
    (1): Flatten(start_dim=1, end_dim=-1)
    (2): Linear(in_features=128, out_features=1000, bias=True)
  )
)

2.1 Diseño de parámetros

La instanciación de ConvMixer depende de cuatro parámetros:

el "ancho" o dimensión oculta: $h$ (dimensión del empotramiento del parche);
El número de ciclos de la capa ConvMixer: $profundidad$ ; $_$ $_$ $_$
Tamaño del parche que controla la resolución interna del modelo: $pag$ ;
Tamaño del núcleo de la capa convolucional en profundidad: $k$ ;

Reglas de nomenclatura para otros modelos de ConvMixer: ConvMixer-h/d;

2.2 Motivación

Nuestra arquitectura se basa en la idea de mezclar; en particular, elegimos convoluciones en profundidad dw para mezclar ubicaciones espaciales y convoluciones puntuales pw para mezclar ubicaciones de canales.

Una idea clave del trabajo anterior es que MLP y la autoatención pueden mezclar ubicaciones espaciales distantes, es decir, pueden tener campos receptivos arbitrariamente grandes. Por lo tanto, usamos grandes convoluciones de kernel para combinar ubicaciones espaciales distantes.

Mientras que la autoatención y MLP son teóricamente más flexibles, lo que permite grandes campos receptivos y un comportamiento consciente del contenido, el sesgo inductivo de las circunvoluciones es muy adecuado para las tareas de visión . Mediante el uso de tales operaciones estándar, también podemos ver el efecto de la representación de parche en sí misma en comparación con los diseños de red convolucionales piramidales tradicionales y progresivamente muestreados.

3 experimentos

3.1 Configuración de entrenamiento

Evalúe los ConvMixers principalmente en la clasificación ImageNet-1k sin ningún entrenamiento previo u otros datos;

Agregue ConvMixer al marco de timm y entrénelo con una configuración casi estándar: además del aumento de timm predeterminado, usamos RandAugment, mixup, CutMix, borrado aleatorio y recorte de norma de degradado. Utilice el optimizador AdamW;

No hacemos absolutamente ningún ajuste de hiperparámetros en ImageNet debido al cálculo limitado, y entrenamos durante menos épocas que nuestros competidores.

Por lo tanto, nuestros modelos pueden estar sobreregulados o subregularizados, y nuestras precisiones informadas pueden subestimar las capacidades de nuestros modelos.

3.2 Resultados experimentales

Precisión: en ImageNet, el ConvMixer-1536/20 con un parámetro de 52M puede lograr una precisión del 81,4 % entre los 1 principales y el ConvMixer-768/32 con un parámetro de 21M puede lograr una precisión del 80,2 % entre los 1 principales;
Ancho: los ConvMixers más anchos parecen converger más rápido, pero requieren mucha memoria y computación;
Tamaño del núcleo: cuando se reduce el tamaño del núcleo de k = 9 a k = 3, la precisión de ConvMixer-1536/20 se reduce en ≈1 %;
Tamaño de parche: los ConvMixers para parches más pequeños son básicamente mejores, los parches más grandes pueden requerir ConvMixers más profundos; excepto por aumentar el tamaño del parche de 7 a 14, todo sigue igual y ConvMixer-1536/20 logra una precisión del 78,9 % de la máxima -1, pero unas 4 veces más rápido;
Función de activación: se entrenó un modelo con ReLU, lo que demuestra que GELU, popular en los modelos isotrópicos recientes, es innecesario.

3.3 Comparación

Al comparar el modelo ConvMixer con ResNet/DeiT/ResMLP, los resultados se muestran en la Tabla 1 y la Figura 1;

Con la misma cantidad de parámetros, el rendimiento de ConvMixer-1536/20 es mejor que ResNet-152 y ResMLP-B24;
Los ConvMixers son mucho más lentos en la inferencia que sus competidores, probablemente debido a sus tamaños de parche más pequeños; el ajuste y la optimización de hiperparámetros pueden cerrar esta brecha. Consulte la Tabla 2 y el Apéndice A para obtener más información y comparación.

ConvMixer: los parches son todo lo que necesita