Clasificación de imágenes en 2022

Los modelos de visión basados en transformadores están evolucionando gradualmente y se informa que son tan buenos como los modelos convolucionales en tareas de clasificación, segmentación y reconocimiento de acciones. Tenemos toda una gama de modelos convolucionales para tareas de visión y son más populares que los basados en transformadores. Este blog profundiza en el modelo SWin Transformer Vision que fue presentado en la Conferencia Internacional de Visión por Computador (ICCV) 2021 por el Equipo de Investigación de Microsoft. Compara su rendimiento con varios modelos basados en SOTA Convolution en la tarea de clasificación de imágenes de razas de perros.

¿Se convertirán los modelos basados en transformadores en el próximo gran avance de la visión artificial? Dado que los transformadores son una solución exitosa para las tareas de lenguaje, ¿unificará los diversos subcampos de IA y presentará soluciones poderosas para problemas más complejos? Así que me arremangué para evaluar qué tan buenos son en la tarea de clasificación, para empezar.

Datos elegidos y su enunciado del problema:

La gran cantidad de razas de perros con cambios sutiles en su apariencia física ha sido un desafío para los veterinarios, los dueños de perros, el personal de los refugios de animales y los posibles dueños de perros para identificar la raza adecuada. Necesitan identificar la raza para brindar la capacitación y el tratamiento adecuados y satisfacer sus necesidades nutricionales. Los datos provienen del conjunto de datos de perros de Stanford que contiene aproximadamente 20 000 imágenes de 120 razas de perros en todo el mundo. Estos datos se han dividido casi por igual en el conjunto de prueba y entrenamiento para una identificación de raza de perro de competencia Kaggle.

El objetivo de la solución es construir un sistema de identificación de razas de perros capaz de identificar correctamente razas de perros con datos mínimos e identificar correctamente incluso razas de perros de aspecto similar. Esta es una tarea de clasificación de varias clases y para cada imagen, el modelo tiene que predecir la probabilidad de todas las 120 razas. El que tiene la probabilidad más alta es la raza más probable del perro en la imagen.

Análisis exploratorio de datos

• Para una raza, los datos de entrenamiento tienen un máximo de más de 120 imágenes y un mínimo de 66 imágenes. Cada clase, en promedio, se espera que tenga 85 imágenes. Mirando el gráfico de barras, se concluye que no hay desequilibrios de clase.

• Aunque no hay desequilibrio de clases, los datos pueden ser insuficientes para entrenar la red neuronal. El aumento de imágenes mediante perturbaciones aleatorias de imágenes y modelos preentrenados podrá sortear este problema.

  
  

• Las 5 razas principales con más imágenes son scottish_deerhound, maltese_dog, afghan_hound, entlebucher y bernese_mountain_dog. Las 5 razas inferiores con menos imágenes son golden_retriever, brabancon_griffon, komondor, eskimo_dog y briard.

  
  

• Se realiza un análisis rápido de las dimensiones espaciales de las imágenes de entrenamiento para comprender la distribución de la altura y el ancho de la imagen y sus relaciones de aspecto.

• Las imágenes con relaciones de aspecto muy bajas (<0,5) y muy altas (>2,3) se consideran imágenes anómalas. 1.5 se considera una buena relación de aspecto.

  

• Al analizar varias razas de perros, generalmente se encontró que los siguientes pares de razas se parecían.

  • 'boston_bull', 'french_bulldog'
  • 'beagle', 'english_foxhound'
  • 'bernese_mountain_dog', 'greer_swiss_mountain_dog'
  • 'malamute', 'husky_siberiano'
  • 'basenji', 'ibizan_hound'
  • 'vizsla', 'rhodesian_ridgeback'
  • 'lhasa', 'shih-tzu'
  • 'lebrel', 'galgo_italiano'
  • 'brittany_spaniel', 'welsh_springer_spaniel', 'blenheim_spaniel'
  • 'malinois', 'pastor_aleman'
  • 'border_collie', 'collie'
  • 'norfolk_terrier', 'norwich_terrier'

Métricas de evaluación

• LogLoss, que evalúa rigurosamente la confianza de las predicciones del modelo para las 120 clases comparando la probabilidad de predicción con la probabilidad real, es la métrica clave.
• La matriz de confusión N*N se usa para estudiar el resultado de las predicciones para analizar si hay algún par de clases confundidas por el modelo y predichas incorrectamente.

SWIN - Modelo basado en transformador

Esta arquitectura se basa en "Swin Transformer: Hierarchical Vision Transformer usando Shifted Windows" desarrollado por Microsoft Research Team. Este documento analiza una arquitectura ViT mejorada que produce una representación jerárquica de mapas de características que reduce la complejidad de cálculo del mecanismo de autoatención de cuadrático a lineal. Se ha demostrado que proporciona resultados idénticos a las redes de convolución SOTA como EfficientNet en el problema de clasificación de Imagenet.

Los componentes básicos de esta arquitectura se explican en las siguientes notas:

Parcheo de imagen:

En NLP, los tokens que son los elementos de procesamiento de un modelo, son las palabras en una oración donde el tamaño de 1 token es 1 (solo 1 palabra). ViT (Vision T ransformers) trata los "parches de imagen" como tokens donde cada parche es una partición de una imagen que consta de un grupo de píxeles vecinos. Cada parche de imagen es una ficha. El tamaño de 1 token en cualquier ViT es patch_height * patch_width * número de canales. Según las dimensiones del parche, obtenemos una cantidad de parches o tokens para una sola imagen. Si el tamaño de la imagen (H*W*3) es 224 * 224 * 3 píxeles y el tamaño del parche es 4 * 4, entonces obtenemos 224/4 * 224/4 = 56 * 56 parches o 3136 tokens de la imagen. Cada token o parche tendrá un tamaño de 4*4*3 = 48 dimensiones o 48 píxeles de datos. Entonces, la entrada a la arquitectura para esta imagen consta de 3136 tokens, cada uno de 48 dimensiones.

El mecanismo subyacente del transformador SWIN es análogo a cualquier arquitectura basada en CNN donde las dimensiones espaciales de la imagen disminuyen y la cantidad de canales aumenta. El transformador SWIN en cada etapa de la arquitectura jerárquica también reduce la cantidad de parches de imagen o la cantidad de tokens al tiempo que aumenta las dimensiones de los tokens. Con este mecanismo en mente, es más fácil comprender fácilmente la arquitectura SWIN.

En cada etapa de la arquitectura, podemos ver que la cantidad de tokens disminuye mientras que el tamaño del token aumenta.

La arquitectura SWIN-T, además del " Particionador de parches", también se compone de otros 3 bloques de construcción: incrustación lineal, bloque de transformador Swin, combinación de parches. Estos bloques de construcción se repiten y procesa mapas de características de forma jerárquica.

Incrustación lineal:

Los 3136 tokens, cada uno de 48 dimensiones del "Particionador de parches", se alimentan a una capa de avance para incrustar el token de 48 vectores de características en un vector de características de tamaño 'C'. 'C' aquí actúa como la capacidad del transformador y la arquitectura SWIN tiene 4 variantes basadas en ella.

• Diminuto (Swin-T) - C es '96'
• Pequeño (Swin-S) - C es '96'
• Base (Swin-B) - C es '128'
• Grande (Swin-L) - C es '192'

Bloque transformador SWin:

El bloque transformador SWin es diferente del bloque transformador estándar en la arquitectura ViT. En SWin Transformers, el Atención automática de varios cabezales (MSA) la capa es reemplazada por la Módulo de ventana MSA (W-MSA) o el Módulo MSA de ventana desplazada (SW-MSA) .

La etapa 1 consta de 2 bloques de transformadores SWIN-T (consulte la imagen) en los que el primer bloque de transformadores tiene un módulo de ventana MSA (W-MSA) y el segundo bloque de transformadores tiene un módulo de ventana desplazada MSA (SW-MSA). En el SWin Transformer Block, las entradas y salidas de las capas W-MSA y SW-MSA pasan a través de las capas de normalización. Luego se somete a una red de avance de dos capas con activación de unidades lineales de error gaussiano (GELU). Hay conexiones residuales dentro de cada bloque y entre estos 2 bloques.

Módulos Window MSA (W-MSA) y Shifted Window MSA (SW-MSA)

¿Por qué se reemplaza la capa de atención estándar en ViT con la capa MSA con ventanas?

La capa de atención estándar en ViT era global y calculaba la atención de un parche con todos los demás parches en la imagen, lo que generaba una complejidad cuadrática proporcional a las dimensiones de la imagen. Esto no escala muy bien para imágenes de alta resolución.

El mecanismo de autoatención en el módulo W-MSA o SW-MSA es local y calcula la autoatención solo entre parches dentro de la misma ventana de la imagen y no fuera de las ventanas.

Las ventanas son como particiones más grandes de la imagen donde cada ventana se compone de parches M*M. Reemplazar la autoatención global con autoatención local redujo la complejidad computacional de cuadrática a lineal.

¿Por qué tanto W-MSA como SW-MSA para la autoatención local? ¿Cuál es la diferencia entre ellos?

La diferencia clave entre los módulos de atención W-MSA y SW-MSA está en la forma en que se configuran las ventanas para la imagen.

En el módulo W-MSA, se sigue una estrategia de partición de ventanas regular. La imagen se divide uniformemente en ventanas que no se superponen a partir del píxel superior izquierdo de la imagen, y cada ventana contiene parches M*M o M2.

En el módulo SW-MSA, la configuración de la ventana se cambia de la de la capa W-MSA, al desplazar las ventanas por parches (M/2, M/2) de la estrategia de partición normal.

¿Por qué una estrategia de partición de ventana desplazada en SW-MSA?

Dado que la atención está restringida localmente dentro de una ventana en W-MSA, la ventana desplazada permite que la atención entre ventanas aún brinde los beneficios de la atención global. Esto es posible porque los límites de la ventana 1 en la capa W-MSA se comparten con las ventanas W2, W4 y W5 en la capa SW-MSA. Por lo tanto, la atención global ocurre indirectamente a través de la "atención local en las ventanas desplazadas".

Capa de fusión de parches

La capa de combinación de parches reduce la cantidad de tokens a medida que la red se vuelve más y más profunda. La primera capa de fusión de parches concatena las características de cada grupo de parches vecinos de 2×2.

Transformadores SWIN en la clasificación de razas de perros

El paquete tfswin en PyPI tiene variantes TF-Keras preentrenadas de SWIN Transformers y está construido en base a la implementación oficial de pytorch . Su código está disponible en github . tfswin se utiliza para entrenar las imágenes de razas de perros.

 from tfswin import SwinTransformerBase224, preprocess_input def build_model1(swintransformer): tf.keras.backend.clear_session() inputs = Input(shape=(resize_height, resize_width, 3)) outputs = Lambda(preprocess_input)(inputs) outputs = swintransformer(outputs) outputs = Dense(num_classes, activation='softmax')(outputs) swin_model = Model(inputs=inputs, outputs=outputs) return swin_model #build the model swintransformer = SwinTransformerBase224(include_top=False,pooling='avg') swin_model1 = build_model1(swintransformer) #set the layers of the pretrained model as non-trainable for layer in swin_model1.layers[2].layers: layer.trainable = False swin_model1.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),loss='categorical_crossentropy',metrics=['accuracy'])

Modelos basados en convoluciones

• Para empezar, se entrenaron varias variantes de ResNet con diferentes reemplazos para las capas superiores, y parcialmente para congelar totalmente la red.

 #Logloss of the test set using various ResNet variants +------------+---------------+-------------------------+----------+ | Model Name | Retrained | Top Layers Replacement | Log_Loss | +------------+---------------+-------------------------+----------+ | ResNet50 | None | ConvBlock_FC_Output | 0.96463 | | ResNet50 | None | GlobalAvgPooling_Output | 0.58147 | | ResNet50 | last 4 layers | ConvBlock_FC_Output | 2.10158 | | ResNet50 | last 4 layers | GlobalAvgPooling_Output | 0.57019 | +------------+---------------+-------------------------+----------+

Código correspondiente al modelo ResNet50 con menor pérdida de registro

 from tensorflow.keras.layers import Input,Conv2D,Dense,BatchNormalization,Flatten,Concatenate, Dropout,MaxPooling2D from tensorflow.keras.models import Model from tensorflow.keras.applications.resnet50 import ResNet50, preprocess_input def build_model(): tf.keras.backend.clear_session() inputs = Input(shape=(resize_height, resize_width, 3)) #added preprocess_input method as a layer to convert input images to those expected by Resnet processed_inputs = preprocess_input(inputs) #use the pretrained ResNet model (Parameter pooling = 'avg' will take care of the Gobal Average Pooling of the ResNet model features) base_model = ResNet50(weights="imagenet", include_top=False,pooling='avg')(processed_inputs) #output layer output = Dense(units=num_classes,activation='softmax',name='Output')(base_model) resnet_model = Model(inputs=inputs, outputs=output) return resnet_model #build the model resnet_model = build_model() #set the layers of the resnet pretrained model as non-trainable except for its last 4 layers which needs to be re-trained for this data for layer in resnet_model.layers[3].layers[:-4]: layer.trainable = False #compile the model resnet_model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001),loss='categorical_crossentropy',metrics=['accuracy']) print(resnet_model.summary()) history = resnet_model.fit(train_ds, epochs=50, validation_data=val_ds, callbacks=callbacks_list)

• Los modelos convolucionales preentrenados más sofisticados, como EfficientNet, NASNet, InceptionResNet, Xception e InceptionV3, también se entrenaron utilizando imágenes de razas de perros tanto de forma independiente como en conjunto. La pérdida de registro en los datos de prueba (que consta de imágenes de 10 000) de estos modelos fue inferior a la de cualquiera de las variantes de ResNet.

 #Logloss of the standalone model variants +----------------------------+-------------+ | Model Name | Log_Loss | +----------------------------+-------------+ | EfficientNetV2M | 0.28347 | | Inception ResNet | 0.28623 | | NasNetLarge | 0.33285 | | Xception | 0.34187 | | Inception_V3 | 0.54297 | | EfficientNetV2M_GlobalAveg | 0.50423 | | InceptionV3_GlobalAveg | 0.46402 | +----------------------------+-------------+

• Para los modelos independientes, las capas de los modelos preentrenados se congelaron y sus capas superiores se reemplazaron por
  • Capa convolucional seguida de capa MaxPooling
  • Capa de agrupación promedio global

• La arquitectura EfficientNet es un modelo correctamente escalado en las 3 dimensiones: profundidad, ancho y resolución.
• NASNet-Large es el resultado de la búsqueda de arquitectura de modelos realizada con varios algoritmos de búsqueda de hiperparámetros, algoritmos de optimización y algoritmos de aprendizaje por refuerzo.
• InceptionV3 factorizó circunvoluciones más grandes en convoluciones asíncronas más pequeñas y también incluyó clasificadores auxiliares para mejorar la convergencia del modelo.
• La arquitectura Xception realiza circunvoluciones separables en profundidad en lugar de los módulos de inicio en la arquitectura de inicio.
• La pérdida logarítmica de los modelos de conjunto se redujo en > 0,1 que el modelo independiente de mejor rendimiento.

 +--------------------------------------------------------------------------+-----------+ | Model Name | Log_Loss | +--------------------------------------------------------------------------+-----------+ | Ensemble1 - EfficientNEt,InceptionResNet,NasNet,Xception) | 0.17363 | | Ensemble2 - EfficientNEt,InceptionResNet,NasNet,Xception and InceptionV3 | 0.16914 | | Ensemble3 - Ensemble2 with 50% dropout. | 0.16678 | | Ensemble4 - Ensemble of various EfficientNet Architecture | 0.16519 | +--------------------------------------------------------------------------+-----------+

Resultado de la evaluación comparativa

 +----------------------------------+------------+----------------------+----------+ | Model Name | Parameters | Train time (seconds) | Log_Loss | +----------------------------------+------------+----------------------+----------+ | EfficientNet_ConvBlock_Output | 54.7M | ~260s | 0.28347 | | InceptionResNet_ConvBlock_Output | 56.1M | ~260s | 0.28623 | | NASNetLarge_ConvBlock_Output | 89.6M | ~330s | 0.33285 | | XCeption_ConvBlock_Output | 23.3M | ~240s | 0.34187 | | InceptionV3_ConvBlock_Output | 24.2M | ~225s | 0.54297 | | EfficientNet_GlobalAvg | 53.3M | ~260s | 0.50423 | | InceptionV3_GlobalAvg | 22M | ~215s | 0.46402 | | swin_base224 | 86.8M | ~550s | 0.47289 | | swin_base384 | 87M | ~600s | 0.41902 | | swin_large384 | 195M | ~1000s | 0.42207 | +----------------------------------+------------+----------------------+----------+

• Los transformadores SWIN han funcionado mejor que todas las variantes ResNet50 y el modelo InceptionV3.

• La pérdida de registro de SWIN Transformer en estos datos es ligeramente superior en comparación con los modelos InceptionResNet, EfficientNet, Xception y NasNet Large cuando sus salidas se procesan posteriormente mediante una capa convolucional seguida de Maxpooling.

• Sin embargo, SWIN funciona tan bien como el modelo EfficientNet cuando sus salidas promedio son procesadas directamente por la capa de salida.

• Los modelos SWIN son más grandes en comparación con cualquiera de los modelos convolucionales y, por lo tanto, afectarán el rendimiento y la latencia del sistema.

  
  

Este estudio resultó útil para comprender la aplicación de modelos basados en transformadores para la visión artificial.

Puede encontrar el código de los cuadernos en mi Github y la GUI para este caso de uso aquí.

Referencias:

https://www.kaggle.com/competitions/dog-breed-identification

https://arxiv.org/pdf/2103.14030.pdf

https://www.youtube.com/watch?v=tFYxJZBAbE8&t=362s

https://towardsdatascience.com/swin-vision-transformers-hacking-the-human-eye-4223ba9764c3

https://github.com/shkarupa-alex/tfswin