Aplicando data augmentation

Algunos resultados de Nhaga con la siguiente configuración:

datagen = ImageDataGenerator(rotation_range=60,
                            width_shift_range=0.4,
                            height_shift_range=0.4,
                            zoom_range=0.3,
                            horizontal_flip=True,
                            fill_mode='reflect',
                            brightness_range=[0.3,1.4]                   
) 

Ya tengo nuevo wallpaper

Para aplicar `data augmentation` en tus modelos de clasificación de imágenes, puedes utilizar bibliotecas como TensorFlow y Keras, que proporcionan herramientas fáciles de usar para generar imágenes aumentadas durante el entrenamiento del modelo. \### Pasos para aplicar `data augmentation` en un flujo de trabajo de clasificación de imágenes: 1\. \*\*Cargar y preprocesar los datos\*\*: Primero, necesitas un conjunto de datos de imágenes. En este ejemplo usaremos CIFAR-10 como conjunto de datos. 2\. \*\*Definir el generador de imágenes con augmentación\*\*: El generador de datos será el que aplique las transformaciones aleatorias a las imágenes. 3\. \*\*Entrenar el modelo con datos aumentados\*\*: Usar el generador para alimentar el modelo durante el entrenamiento. \### Ejemplo práctico en Keras con `ImageDataGenerator` ```python import tensorflow as tf from tensorflow.keras.preprocessing.image import ImageDataGenerator from tensorflow.keras.datasets import cifar10 import matplotlib.pyplot as plt \# Cargar el conjunto de datos CIFAR-10 (x\_train, y\_train), (x\_test, y\_test) = cifar10.load\_data() \# Normalizar los datos a un rango entre 0 y 1 x\_train = x\_train.astype('float32') / 255.0 x\_test = x\_test.astype('float32') / 255.0 \# Definir el generador de imágenes con augmentación datagen = ImageDataGenerator( rotation\_range=20, # Rotación de hasta 20 grados width\_shift\_range=0.2, # Desplazamiento horizontal del 20% height\_shift\_range=0.2, # Desplazamiento vertical del 20% horizontal\_flip=True, # Voltear la imagen horizontalmente zoom\_range=0.2 # Aplicar zoom hasta un 20% ) \# Previsualización de augmentación en algunas imágenes sample\_images = x\_train\[:5] fig, axes = plt.subplots(1, 5, figsize=(15, 15)) for i, img in enumerate(sample\_images): augmented\_image = datagen.random\_transform(img) axes\[i].imshow(augmented\_image) axes\[i].axis('off') plt.show() \# Crear un modelo simple model = tf.keras.models.Sequential(\[ tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input\_shape=(32, 32, 3)), tf.keras.layers.MaxPooling2D((2, 2)), tf.keras.layers.Conv2D(64, (3, 3), activation='relu'), tf.keras.layers.MaxPooling2D((2, 2)), tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation='relu'), tf.keras.layers.Dense(10, activation='softmax') ]) \# Compilar el modelo model.compile(optimizer='adam', loss='sparse\_categorical\_crossentropy', metrics=\['accuracy']) \# Entrenar el modelo usando el generador de datos con augmentación history = model.fit(datagen.flow(x\_train, y\_train, batch\_size=32), epochs=10, validation\_data=(x\_test, y\_test)) \# Evaluar el modelo test\_loss, test\_acc = model.evaluate(x\_test, y\_test) print(f'Test accuracy: {test\_acc:.4f}') ``` \### Explicación del código: 1\. \*\*Cargar y normalizar los datos\*\*: \- Cargamos el conjunto de datos CIFAR-10 y normalizamos los valores de los píxeles a un rango de 0 a 1. 2\. \*\*`ImageDataGenerator`\*\*: \- Definimos el generador de imágenes, especificando las transformaciones que queremos aplicar. En este caso, incluimos rotación, traslación horizontal/vertical, zoom y flip horizontal. 3\. \*\*Visualización de augmentación\*\*: \- Se muestra cómo algunas imágenes del conjunto de datos original son transformadas aleatoriamente con `data augmentation` para darle más diversidad al conjunto de datos de entrenamiento. 4\. \*\*Modelo de red neuronal\*\*: \- Creamos un modelo simple de CNN (red neuronal convolucional) con dos capas convolucionales seguidas de capas de pooling y una capa densa para la clasificación. 5\. \*\*Entrenamiento con augmentación\*\*: \- Durante el entrenamiento, las imágenes de entrenamiento se pasan por el generador de datos, el cual aplica `data augmentation` en tiempo real. 6\. \*\*Evaluación\*\*: \- Finalmente, se evalúa el modelo en el conjunto de pruebas (sin `data augmentation`). \### ¿Por qué usar `data augmentation`? \- \*\*Evita el sobreajuste\*\*: El modelo no memoriza los datos de entrenamiento, ya que cada imagen se transforma de manera aleatoria en cada época. \- \*\*Mejora la generalización\*\*: Al exponer al modelo a múltiples variaciones de las imágenes, se entrena para detectar características importantes de las imágenes y no solo sus características específicas. \### ¿Qué transformaciones aplicar? Las transformaciones dependen del tipo de datos con los que estés trabajando. Si tienes imágenes de objetos que pueden estar en diferentes orientaciones, como en CIFAR-10, las transformaciones como rotación, flips y desplazamientos son útiles. Si trabajas con imágenes donde el contexto espacial es importante, como en medicina, deberías ser más cuidadoso con qué transformaciones aplicas. Este flujo de trabajo es aplicable para muchos otros problemas de visión por computadora y mejora el rendimiento del modelo con conjuntos de datos limitados.

img = load_img('/kaggle/input/projfreddy/DL.png')
x = img_to_array(img)
x = np.expand_dims(x, axis=0)
datagen = ImageDataGenerator(
    rotation_range=40,
    width_shift_range=0.2,
    height_shift_range=0.2,
    shear_range=0.2,
    zoom_range=0.4,
    horizontal_flip=True,
    fill_mode='nearest'
)



i = 0
for batch in datagen.flow(x, batch_size=10):
    plt.figure(i)
    imgplot = plt.imshow(array_to_img(batch[0]))
    i += 1
    if i % 4 == 0:  # Mostrar solo 4 imágenes aumentadas
        break

plt.show()

Mis perritas  Incluso en ciertas iteraciones, el target puede quedar por fuera de la imagen generada