Estás leyendo la publicación: Guía práctica para usar el transformador de visión para la clasificación de imágenes
Los transformadores de visión son uno de los transformadores populares en el campo del aprendizaje profundo. Antes del origen de los transformadores de visión, teníamos que usar redes neuronales convolucionales en visión artificial para tareas complejas. Con la introducción de los transformadores de visión, obtuvimos un modelo más potente para tareas de visión por computadora, ya que tenemos BERT y GPT para tareas complejas de NLP. En este artículo, aprenderemos cómo podemos usar un transformador de visión para una tarea de clasificación de imágenes. Para este propósito, demostraremos una implementación práctica de un transformador de visión para la clasificación de imágenes. Los siguientes son los puntos principales que se tratarán en este artículo.
Tabla de contenido
- Acerca de los transformadores de visión
- Implementación de transformador de visión para clasificación de imágenes.
Paso 1: inicialización de la configuración
Paso 2: Construcción de red
Paso 3 Transformador de visión del edificio
Paso 4: compilar y entrenar
Comencemos por comprender primero el transformador de visión.
Acerca de los transformadores de visión
El transformador de visión (ViT) es un transformador utilizado en el campo de la visión artificial que funciona en función de la naturaleza funcional de los transformadores utilizados en el campo del procesamiento del lenguaje natural. Internamente, el transformador aprende midiendo la relación entre los pares de fichas de entrada. En visión por computadora, podemos usar los parches de imágenes como token. Esta relación se puede aprender prestando atención en la red. Esto se puede hacer junto con una red convolucional o reemplazando algunos componentes de las redes convolucionales. Estas estructuras de la red se pueden aplicar a las tareas de clasificación de imágenes. El procedimiento completo de clasificación de imágenes utilizando un transformador de visión se puede explicar en la siguiente imagen.
Fuente de imagen
En la imagen de arriba, podemos ver el procedimiento que debemos seguir. En este artículo, vamos a discutir cómo podemos realizar todos estos pasos utilizando la biblioteca Keras.
Para esta implementación, seguiremos los siguientes pasos.
Paso 1: inicialización de la configuración
En esta sección, realizaremos algunos de los procedimientos básicos de modelado, como importar conjuntos de datos, definir hiperparámetros, aumento de datos, etc.
Paso 1.1: Importación de datos
Empecemos por obtener datos. En este procedimiento, vamos a utilizar el conjunto de datos CIFAR-10 proporcionado por la biblioteca Keras. En el conjunto de datos, tenemos 50 000 imágenes de tamaño 32×32 en el conjunto de datos de entrenamiento y 10 000 imágenes del mismo tamaño en el conjunto de datos de prueba. Disponemos de las siguientes etiquetas con estas imágenes:
| Índice | Etiqueta | Descripción |
| 1 | avión | |
| 2 | 1 | automóvil |
| 3 | 2 | pájaro |
| 4 | 3 | gato |
| 5 | 4 | ciervo |
| 6 | 5 | perro |
| 7 | 6 | rana |
| 8 | 7 | caballo |
| 9 | 8 | barco |
| 10 | 9 | camión |
Podemos llamar a este conjunto de datos usando las siguientes líneas de códigos.
desde keras.datasets import cifar10 (x_train, y_train), (x_test, y_test) = cifar10.load_data()
Producción:
Comprobación de la forma de los conjuntos de datos.
print(f”x_train: {x_train.shape} – y_train: {y_train.shape}”) print(f”x_test: {x_test.shape} – y_test: {y_test.shape}”)
Producción:
Paso 1.2: Definición de hiperparámetros
En esta sección, definiremos algunos de los parámetros que usaremos con los otros subprocesos.
learning_rate = 0.001 weight_decay = 0.0001 batch_size = 256 num_epochs = 100 image_size = 72 patch_size = 6 num_patches = (image_size // patch_size) ** 2 project_dim = 64 num_heads = 4 transformer_units = [projection_dim * 2,projection_dim,]
transformer_layers = 8 mlp_head_units = [2048, 1024]
Teniendo en cuenta los parámetros anteriores, podemos decir que en el proceso usaremos 100 épocas en el entrenamiento y cambiaremos el tamaño de la imagen y la convertiremos en parches.
Ahora, llamaremos a las bibliotecas importantes.
Paso 1.3: Aumento de datos
En el procedimiento, proporcionaremos imágenes aumentadas al transformador. En el aumento, normalizaremos y cambiaremos el tamaño de las imágenes y luego las voltearemos aleatoriamente. Este procedimiento se completará en métodos secuenciales y utilizando las capas proporcionadas por Keras.
importar numpy como np importar tensorflow como tf de tensorflow importar keras de tensorflow.keras importar capas importar tensorflow_addons como tfa data_augmentation = keras.Sequential(
[
layers.Normalization(),
layers.Resizing(72, 72),
layers.RandomFlip(“horizontal”),
layers.RandomRotation(factor=0.02),
layers.RandomZoom(
height_factor=0.2, width_factor=0.2
),
]nombre=”aumento_datos”, ) aumento_datos.capas[0].adaptar(x_tren)
En el paso final del aumento, calcularemos la media y la varianza de los datos de entrenamiento para la normalización.
Paso 1.4 visualización de imágenes
Veamos cómo se verán las imágenes en el conjunto de datos.
importar matplotlib.pyplot como plt plt.figure(figsize=(4, 4)) image = x_train[np.random.choice(range(x_train.shape[0]))]plt.imshow(imagen.astype(“uint8”)) plt.axis(“off”)
Producción:
El resultado anterior es el ejemplo de una imagen en el conjunto de datos, dado que las imágenes en los datos tienen un tamaño bajo, no es claramente visible. Ahora podemos continuar con nuestro segundo paso.
Paso 2: Construcción de red
En este paso, construiremos una red donde usaremos una red MLP y una capa que separará nuestras imágenes en parches. Además, usaremos un codificador de parches para transformar los parches donde los proyectará en vectores de tamaño 64. Comencemos construyendo una red MLP.
Paso 2.1: Creación de una red MLP
def mlp(x, hidden_units, dropout_rate): para unidades en hidden_units: x = capas.Dense(unidades, activación=tf.nn.gelu)(x) x = capas.Dropout(dropout_rate)(x) return x
En los códigos anteriores, podemos ver que hemos construido una red MLP que simplemente tiene una capa densa y una capa de abandono.
Paso 2.2 Fabricante de parches
En este paso, definiremos una red que pueda convertir las imágenes en parches. Para esto, usamos principalmente el flujo de tensor proporcionado por el módulo extract_patches.
class Parches(capas.Capa): def __init__(self, tamaño_parche): super(Parches, self).__init__() self.tamaño_parche = tamaño_parche def call(self, imágenes): tamaño_lote = tf.shape(imágenes)[0]
parches = tf.image.extract_patches( imágenes=imágenes, tamaños=[1, self.patch_size, self.patch_size, 1]pasos =[1, self.patch_size, self.patch_size, 1]tarifas=[1, 1, 1, 1]padding=”VALID”, ) patch_dims = patches.shape[-1]
parches = tf.reshape(parches, [batch_size, -1, patch_dims]) devolver parches n = int(np.sqrt(parches.forma[1])) plt.figure(figsize=(4, 4)) para i, parche en enumerate(parches[0]): ax = plt.subplot(n, n, i + 1) patch_img = tf.reshape(parche, (parche_tamaño, parche_tamaño, 3)) plt.imshow(parche_img.numpy().astype(“uint8”)) plt .eje(“apagado”)
Producción:
En el resultado anterior, podemos ver que hemos convertido las imágenes en parches mediante los cuales el transformador de visión aprenderá a clasificar las imágenes.
Paso 2.3: Codificador de parches
Este codificador de parches realizará la transformación lineal de los parches de imagen y agregará una incrustación de posición aprendible al vector proyectado.
class PatchEncoder(layers.Layer): def __init__(self, num_patches, proyección_dim): super(PatchEncoder, self).__init__() self.num_patches = num_patches self.projection = capas.Dense(unidades=projection_dim) self.position_embedding = capas .Embedding( input_dim=num_patches, output_dim=projection_dim ) def call(self, patch): posiciones = tf.range(start=0, limit=self.num_patches, delta=1) codificado = self.projection(parche) + self. position_embedding(posiciones) retorno codificado
Después de construir esta red, estamos listos para construir un modelo de transformador de visión.
Paso 3: Construir un transformador de visión
En esta sección, construiremos bloques para el transformador de visión. Como se discutió e implementó anteriormente, usaremos los datos aumentados que pasarán por el bloque del creador de parches y luego los datos pasarán por el bloque del codificador de parches. En el bloque transformador, usaremos una capa de autoatención en las secuencias de parches. La salida del bloque del transformador pasará por un cabezal de clasificación que ayudará a producir las salidas finales. Veamos en los siguientes códigos.
def create_vit_classifier(): entradas = capas. Entrada(forma=forma_entrada) aumentado = aumento_datos(entradas) parches = Parches(tamaño_parche)(aumentado) parches_codificados = PatchEncoder(núm_parches, proyección_dim)(parches) for _ en rango(transformer_layers): x1 = capas.LayerNormalization(epsilon=1e-6)(parches_codificados) atención_salida = capas.MultiHeadAttention( num_heads=num_heads, key_dim=projection_dim, dropout=0.1 )(x1, x1) x2 = layers.Add()([attention_output, encoded_patches]) x3 = capas.LayerNormalization(epsilon=1e-6)(x2) x3 = mlp(x3, hidden_units=transformer_units, dropout_rate=0.1) encoded_patches = layers.Add()([x3, x2]) representación = capas.LayerNormalization(épsilon=1e-6)(encoded_patches) representación = capas.Flatten()(representación) representación = capas.Dropout(0.5)(representación) características = mlp(representación, hidden_units=mlp_head_units, dropout_rate=0.5 ) logits = capas.Dense(núm_clases)(características) modelo = keras.Modelo(entradas=entradas, salidas=logits) modelo de retorno
Usando la función anterior, podemos definir un clasificador usando el transformador de visión en el que proporcionamos los métodos para el aumento de datos, la creación de parches y la codificación de parches. Los parches codificados serán nuestra entrada final como representación de imagen para el transformador. Aplanar la capa nos ayudará a cambiar la forma de la salida.
Paso 4: Compilación y entrenamiento
En esta sección lo haremos; compilar y entrenar el modelo que hemos creado y después de eso, evaluaremos el modelo en términos de precisión.
Paso 4.1: Compilar el modelo
Usando la siguiente línea de códigos podemos compilar el modelo.
optimizador = tfa.optimizers.AdamW(índice_de_aprendizaje=índice_de_aprendizaje, decaimiento_de_peso=decadencia_de_peso) model.compile(optimizador=optimizador, pérdida=keras.pérdidas.SparseCategoricalCrossentropy(from_logits=True), metrics=[
keras.metrics.SparseCategoricalAccuracy(name=”accuracy”),
keras.metrics.SparseTopKCategoricalAccuracy(5, name=”top-5-accuracy”), ],)
En la compilación, hemos utilizado el optimizador de Adam con escasa pérdida de entropía cruzada categórica.
Paso 4.2: Entrenamiento
El entrenamiento del transformador se puede hacer usando las siguientes líneas de códigos:
history = model.fit( x=tren_x, y=tren_y, tamaño_lote=tamaño_lote, épocas=número_épocas, división_validación=0.1,)
Producción:
En el resultado anterior, podemos ver que el entrenamiento ha comenzado. Puede tomar una cantidad significativa de tiempo. Entonces, para hacerlo rápido, se recomienda habilitar la GPU durante el entrenamiento. En Google Colab, podemos encontrar la configuración de GPU en la pestaña de administración de la sesión de tiempo de ejecución en la pestaña de tiempo de ejecución.
Paso 4.3: Comprobación de la precisión
Comprobemos la precisión del transformador de visión en la tarea de clasificación de imágenes.
_, precisión, top_5_accuracy = model.evaluate(x_test, y_test) print(f”Exactitud de la prueba: {redondo(precisión * 100, 2)}%”) print(f”Precisión de la prueba de los 5 principales: {round(top_5_accuracy * 100, 2)}%”)
Producción:
Aquí, en el resultado anterior, podemos ver que nuestro modelo tiene un rendimiento del 84,21 % de precisión y nuestras 5 precisiones principales son del 99,24 %.
Ultimas palabras
En este artículo, presentamos el transformador y vimos cómo se puede usar para la clasificación de imágenes a través de una imagen. Implementamos un transformador de visión para la clasificación de imágenes utilizando el conjunto de datos CIFAR-10 y seguimos todos los pasos que se incluyeron en la imagen. Con este transformador logramos un muy buen resultado en la tarea.
