Durante mucho tiempo, el aumento de datos ha servido como un medio para reemplazar un conjunto de datos "estáticos" con variantes transformadas, lo que refuerza la invariancia de Redes neuronales convolucionales (CNN), y generalmente conduce a la robustez de la entrada.

Nota: La invariancia se reduce a hacer que los modelos sean ciegos a ciertas pertubaciones, al tomar decisiones. Una imagen de un gato sigue siendo una imagen de un gato si la reflejas o la rotas.

Si bien el aumento de datos en la forma en que lo hemos estado usando codifica un no tienen de conocimiento sobre la varianza traslacional, que es importante para la detección de objetos, la segmentación semántica y de instancias, etc. invariancia proporciona es a menudo favorable para los modelos de clasificación y, por lo tanto, el aumento se aplica más comúnmente y de manera más agresiva a los modelos de clasificación.

Tipos de aumento

El aumento comenzó siendo muy simple: pequeñas rotaciones, giros horizontales y verticales, fluctuaciones de contraste o brillo, etc. En los últimos años, se han ideado métodos más elaborados, que incluyen Separar (abandono espacial introduciendo cuadrados negros aleatoriamente en las imágenes de entrada) y Confusión (mezclar partes de imágenes y actualizar las proporciones de las etiquetas), y su combinación – cortarmezclar. Los métodos de aumento más nuevos en realidad tienen en cuenta las etiquetas, y métodos como CutMix cambian las proporciones de las etiquetas para que sean iguales a las proporciones de la imagen que ocupan las partes de cada clase que se mezcla.

Con una lista creciente de posibles aumentos, algunos han comenzado a aplicarlos aleatoriamente (o al menos un subconjunto de ellos), con la idea de que un conjunto aleatorio de aumentos reforzará la solidez de los modelos y reemplazará el conjunto original con un conjunto mucho más grande. espacio de imágenes de entrada. Aquí es donde RandAugment ¡patadas en!

KerasCV y RandAugment

KerasCV es un paquete separado, pero sigue siendo una adición oficial a Keras, desarrollado por el equipo de Keras. Esto significa que obtiene la misma cantidad de pulido e intuición del paquete principal, pero también se integra a la perfección con los modelos regulares de Keras y sus capas. La única diferencia que notarás es llamar keras_cv.layers... en lugar de keras.layers....

KerasCV todavía está en desarrollo al momento de escribir, y ya incluye 27 nuevas capas de preprocesamiento, RandAugment, CutMixy MixUp siendo algunos de ellos. Echemos un vistazo a cómo se ve aplicar RandAugment a imágenes, y cómo podemos entrenar un clasificador con y sin aumento aleatorio.

Primero, instale keras_cv:

$ pip install keras_cv

Nota: KerasCV requiere TensorFlow 2.9 para funcionar. Si aún no lo tienes, ejecuta $ pip install -U tensorflow de antemano.

Ahora, importemos TensorFlow, Keras y KerasCV, junto con los conjuntos de datos de TensorFlow para acceder fácilmente a Imagenette:

import tensorflow as tf
from tensorflow import keras
import keras_cv
import tensorflow_datasets as tfds

Carguemos una imagen y mostrémosla en su forma original:

import matplotlib.pyplot as plt
import cv2

cat_img = cv2.cvtColor(cv2.imread('cat.jpg'), cv2.COLOR_BGR2RGB)
cat_img = cv2.resize(cat_img, (224, 224))
plt.imshow(cat_img)

Ahora, apliquemos RandAugment varias veces y echa un vistazo a los resultados:

fig = plt.figure(figsize=(10,10))
for i in range(16):
    ax = fig.add_subplot(4,4,i+1)
    aug_img = keras_cv.layers.RandAugment(value_range=(0, 255))(cat_img)
    
    ax.imshow(aug_img.numpy().astype('int'))

La capa tiene un magnitude argumento, que por defecto es 0.5 y se puede cambiar para aumentar o disminuir el efecto de aumento:

fig = plt.figure(figsize=(10,10))
for i in range(16):
    ax = fig.add_subplot(4,4,i+1)
    aug_img = keras_cv.layers.RandAugment(value_range=(0, 255), magnitude=0.1)(cat_img)
    ax.imshow(aug_img.numpy().astype('int'))

Cuando se establece en un valor bajo como 0.1 – verá un aumento mucho menos agresivo:

Al ser una capa, se puede usar dentro de modelos o en tf.data canalizaciones al crear conjuntos de datos. Esto hace RandAugment bastante flexible! Argumentos adicionales son los augmentations_per_image y rate argumentos que trabajan juntos.

0...augmentations_per_image, la capa agrega una capa de preprocesamiento aleatorio a la canalización para aplicarla a una imagen. En el caso del incumplimiento 3 – Se agregan tres operaciones diferentes a la canalización. Luego, se muestrea un número aleatorio para cada aumento en la canalización, y si es menor que rate (predeterminado en alrededor 0.9) – se aplica el aumento.

En esencia, hay un 90 % de probabilidad de que cada aumento (aleatorio) en la canalización se aplique a la imagen.

Naturalmente, esto significa que no es necesario aplicar todos los aumentos, especialmente si baja el rate. También puede personalizar qué operaciones están permitidas a través de un RandomAugmentationPipeline capa, que RandAugment es el caso especial de. Una guía separada sobre RandomAugmentationPipeline será publicado pronto.

Entrenamiento de un Clasificador con y sin RandAugment

Para simplificar el aspecto de preparación/carga de datos y centrarse en RandAugment, usemos tfds para cargar en una porción de Imagette:

(train, valid_set, test_set), info = tfds.load("imagenette", 
                                           split=["train[:70%]", "validation", "train[70%:]"],
                                           as_supervised=True, with_info=True)

class_names = info.features["label"].names
n_classes = info.features["label"].num_classes
print(f'Class names: {class_names}') 
print('Num of classes:', n_classes) 

print("Train set size:", len(train)) 
print("Test set size:", len(test_set)) 
print("Valid set size:", len(valid_set)) 

Solo hemos cargado una parte de los datos de entrenamiento para que sea más fácil sobreajustar el conjunto de datos en menos épocas (lo que hace que nuestro experimento se ejecute más rápido, en efecto). Dado que las imágenes en Imagette son de diferentes tamaños, vamos a crear una preprocess() función que los redimensiona para mapear el conjunto de datos, así como un augment() función que aumenta las imágenes en un tf.data.Dataset:

def preprocess(images, labels):
  return tf.image.resize(images, (224, 224)), tf.one_hot(labels, 10)
  
def augment(images, labels):
  inputs = {"images": images, "labels": labels}
  outputs = keras_cv.layers.RandAugment(value_range=(0, 255))(inputs)
  return outputs['images'], outputs['labels']

Ahora, codificamos las etiquetas en caliente. No necesariamente teníamos que hacerlo, pero para aumentos como CutMix que alteran las etiquetas y sus proporciones, tendrá que hacerlo. Dado que es posible que desee aplicar esos, así como RandAugment funciona muy bien con ellos para crear clasificadores robustos; dejemos la codificación one-hot. Además, RandAugment toma un diccionario con imágenes y etiquetas exactamente por esto: algunos aumentos que puede agregar cambiarán las etiquetas, por lo que son obligatorios. Puede extraer las imágenes aumentadas y las etiquetas de la outputs diccionario fácilmente, por lo que este es un paso adicional, pero simple, para realizar durante el aumento.

Mapeemos los conjuntos de datos existentes devueltos desde tfds con el preprocess() función, agruparlos y aumentar solo el conjunto de entrenamiento:

valid_set = valid_set.map(preprocess).batch(32).prefetch(tf.data.AUTOTUNE)
train_set = train.map(preprocess).batch(32).prefetch(tf.data.AUTOTUNE)
train_set_aug = train.map(preprocess).map(augment_data, 
                                          num_parallel_calls=tf.data.AUTOTUNE).batch(32).prefetch(tf.data.AUTOTUNE)

¡Formemos una red! keras_cv.models tiene algunas redes integradas, similares a keras.applications. Si bien la lista aún es corta, se expandirá con el tiempo y se hará cargo keras.applications. La API es muy similar, por lo que la portabilidad del código será bastante sencilla para la mayoría de los profesionales:

effnet = keras_cv.models.EfficientNetV2B0(include_rescaling=True, include_top=True, classes=10)
          
effnet.compile(
    loss='categorical_crossentropy',
    optimizer='adam',
    metrics=['accuracy']
)

history = effnet.fit(train_set, epochs=25, validation_data = valid_set)

Alternativamente, puede utilizar el actual keras.applications:

effnet = keras.applications.EfficientNetV2B0(weights=None, classes=10)

effnet.compile(
  loss='categorical_crossentropy',
  optimizer='adam',
  metrics=['accuracy']
)

history1 = effnet.fit(train_set, epochs=50, validation_data=valid_set)

Esto da como resultado un modelo que realmente no funciona muy bien:

Epoch 1/50
208/208 [==============================] - 60s 238ms/step - loss: 2.7742 - accuracy: 0.2313 - val_loss: 3.2200 - val_accuracy: 0.3085
...
Epoch 50/50
208/208 [==============================] - 48s 229ms/step - loss: 0.0272 - accuracy: 0.9925 - val_loss: 2.0638 - val_accuracy: 0.6887

Ahora, entrenemos la misma configuración de red en el conjunto de datos aumentado. Cada lote se aumenta individualmente, por lo que siempre que aparezca el mismo lote de imágenes (en la próxima época), tendrán diferentes aumentos:

effnet = keras.applications.EfficientNetV2B0(weights=None, classes=10)
effnet.compile(
  loss='categorical_crossentropy',
  optimizer='adam',
  metrics=['accuracy']
)

history2 = effnet.fit(train_set_aug, epochs=50, validation_data = valid_set)

Epoch 1/50
208/208 [==============================] - 141s 630ms/step - loss: 2.9966 - accuracy: 0.1314 - val_loss: 2.7398 - val_accuracy: 0.2395
...
Epoch 50/50
208/208 [==============================] - 125s 603ms/step - loss: 0.7313 - accuracy: 0.7583 - val_loss: 0.6101 - val_accuracy: 0.8143

¡Mucho mejor! Si bien aún desearía aplicar otros aumentos, como CutMix y MixUp, junto con otras técnicas de entrenamiento para maximizar la precisión de la red, solo RandAugment ayudó significativamente y puede ser comparable a una canalización de aumento más larga.

Si comparas las curvas de entrenamiento, incluido el entrenamiento y curvas de validación: solo queda claro cuánto RandAugment ayuda:

En la canalización no aumentada, la red se sobreajusta (la precisión del entrenamiento alcanza el techo) y la precisión de la validación se mantiene baja. En la canalización aumentada, el la precisión del entrenamiento permanece más baja que la precisión de la validación de principio a fin.

Con una mayor pérdida de entrenamiento, la red es mucho más consciente de los errores que aún comete y se pueden realizar más actualizaciones para que sea invariable a las transformaciones. El primero no ve la necesidad de actualizarse, mientras que el segundo sí lo hace y eleva el techo de potencial.

Conclusión

KerasCV es un paquete separado, pero sigue siendo una adición oficial a Keras, desarrollado por el equipo de Keras, con el objetivo de brindar un CV sólido en la industria a sus proyectos de Keras. KerasCV todavía está en desarrollo al momento de escribir, y ya incluye 27 nuevas capas de preprocesamiento, RandAugment, CutMixy MixUp siendo algunos de ellos.

En esta breve guía, hemos echado un vistazo a cómo puede utilizar RandAugment para aplicar una cantidad de transformaciones aleatorias de una lista determinada de transformaciones aplicadas y lo fácil que es incluirlo en cualquier proceso de capacitación de Keras.

Yendo más lejos: aprendizaje profundo práctico para la visión por computadora

¿Tu naturaleza inquisitiva te hace querer ir más allá? Recomendamos revisar nuestro Curso: “Aprendizaje Profundo Práctico para Visión por Computador con Python”.

¿Otro curso de visión artificial?

No haremos clasificación de dígitos MNIST o moda MNIST. Cumplieron su parte hace mucho tiempo. Demasiados recursos de aprendizaje se centran en conjuntos de datos básicos y arquitecturas básicas antes de permitir que las arquitecturas avanzadas de caja negra carguen con la carga del rendimiento.

queremos centrarnos en desmitificación, sentido práctico, comprensión, intuición y proyectos reales. Querer aprender cómo ¿Tu puedes hacer la diferencia? Lo llevaremos en un viaje desde la forma en que nuestros cerebros procesan imágenes hasta escribir un clasificador de aprendizaje profundo de grado de investigación para el cáncer de mama y redes de aprendizaje profundo que "alucinan", enseñándole los principios y la teoría a través del trabajo práctico, equipándolo con el conocimientos y herramientas para convertirse en un experto en la aplicación del aprendizaje profundo para resolver la visión artificial.

¿Qué hay adentro?

• Los primeros principios de la visión y cómo se puede enseñar a las computadoras a “ver”
• Diferentes tareas y aplicaciones de la visión artificial
• Las herramientas del oficio que facilitarán tu trabajo
• Encontrar, crear y utilizar conjuntos de datos para la visión por computadora
• La teoría y aplicación de las Redes Neuronales Convolucionales
• Manejo de cambio de dominio, co-ocurrencia y otros sesgos en conjuntos de datos
• Transfiera el aprendizaje y utilice el tiempo de capacitación y los recursos computacionales de otros para su beneficio
• Construyendo y entrenando un clasificador de cáncer de mama de última generación
• Cómo aplicar una buena dosis de escepticismo a las ideas principales y comprender las implicaciones de las técnicas ampliamente adoptadas
• Visualización del "espacio conceptual" de ConvNet usando t-SNE y PCA
• Casos prácticos de cómo las empresas utilizan técnicas de visión artificial para lograr mejores resultados
• Evaluación adecuada del modelo, visualización del espacio latente e identificación de la atención del modelo.
• Realizar investigaciones de dominio, procesar sus propios conjuntos de datos y establecer pruebas modelo
• Arquitecturas de vanguardia, la progresión de las ideas, qué las hace únicas y cómo implementarlas
• KerasCV: una biblioteca WIP para crear canalizaciones y modelos de última generación
• Cómo analizar y leer documentos e implementarlos usted mismo
• Selección de modelos en función de su aplicación
• Creación de una canalización de aprendizaje automático de extremo a extremo
• Panorama e intuición sobre la detección de objetos con Faster R-CNN, RetinaNets, SSD y YOLO
• Instancia y segmentación semántica
• Reconocimiento de objetos en tiempo real con YOLOv5
• Capacitación de detectores de objetos YOLOv5
• Trabajando con Transformers usando KerasNLP (biblioteca WIP de fuerza industrial)
• Integrando Transformers con ConvNets para generar subtítulos de imágenes
• sueño profundo
• Optimización del modelo de Deep Learning para visión artificial