Data augmentation en red convolucional es una de las estrategias más funcionales dentro del Deep Learning. Por esta razón, a continuación, te explicamos cómo funciona Data augmentation en red convolucional.

¿Qué encontrarás en este post?

Data augmentation en red convolucional

El fine tuning es muy útil cuando nuestros datasets no son muy grandes y estamos limitados por el número de imágenes que tenemos disponibles. No obstante, hay otra forma, muy potente, de conseguir mejores resultados, sobretodo si nuestro dataset es limitado.

Esta técnica se llama Data augmentation en red convolucional, probablemente porque lo que hace es sacar más datos a partir de los que tenemos disponibles. Básicamente, lo que hacemos es girar/trasladar/emborronar/cambiar el color/acercar o alejar/lo que se os ocurra las imágenes que tenemos. De esta forma, damos lugar a muchas más imágenes de las que teníamos inicialmente.

Ahora, ¿cómo sabemos las clases de esas nuevas imágenes generadas?

¡Es una muy buena pregunta! De hecho, es algo que tenemos que tener muy en cuenta: las nuevas imágenes toman la clase de la imagen origen, por lo que las transformaciones no pueden ser muy exageradas y mucho menos ocasionar que se parezcan a otra clase.

Para llevar a cabo este proceso existe una librería muy útil en Python que se llama imgaug.

Ejemplo práctico de Data augmentation en red convolucional

# Ejemplo con Data augmentation en red convolucional

# importamos lo necesario
import tensorflow as tf
from tensorflow.keras import callbacks,optimizers, Model
from tensorflow.keras.layers import Dropout, Flatten, Dense
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.applications import VGG16
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.utils import to_categorical
import numpy as np

# primero cargamos nuestro dataset y lo redimensionamos a las dimensiones mínimas
# permitidas por la VGG16 -> (48, 48, 3)

input_shape = (48, 48, 3)

(X_train, y_train), (X_test, y_test) = cifar10.load_data()
Y_train = to_categorical(y_train)
Y_test = to_categorical(y_test)

# resize train set
X_train_resized = []
for img in X_train:
  X_train_resized.append(np.resize(img, input_shape) / 255)
  
X_train_resized = np.array(X_train_resized)
print(X_train_resized.shape)

# resize test set
X_test_resized = []
for img in X_test:
  X_test_resized.append(np.resize(img, input_shape) / 255)
  
X_test_resized = np.array(X_test_resized)
print(X_test_resized.shape)

(50000, 48, 48, 3)
(10000, 48, 48, 3)

base_model = VGG16(weights='imagenet', include_top=False, input_shape=input_shape)

# data generators => hacemos data augmentation
print('Usando real-time data augmentation.')
# This will do preprocessing and realtime data augmentation:
datagen_train = ImageDataGenerator(
    rotation_range=15,  # randomly rotate images in the range (degrees, 0 to 180)
    width_shift_range=0.1,  # randomly shift images horizontally (fraction of total width)
    height_shift_range=0.1,  # randomly shift images vertically (fraction of total height)
    zoom_range=0.1,  # set range for random zoom
    horizontal_flip=True)  # randomly flip images
datagen_train.fit(X_train_resized)

datagen_test = ImageDataGenerator()
datagen_test.fit(X_test_resized)

# permitimos que, además de la etapa de clasificación, se entrenen también el
# último bloque convolucional
for layer in base_model.layers:
  if layer.name == 'block5_conv1':
    break
  layer.trainable = False
  print('Capa ' + layer.name + ' congelada.')

# cogemos la última capa del model y le añadimos nuestro clasificador (top_model)
last = base_model.layers[-1].output
x = Flatten()(last)
x = Dense(1000, activation='relu', name='fc1')(x)
x = Dropout(0.3)(x)
x = Dense(10, activation='softmax', name='predictions')(x)
model = Model(base_model.input, x)

# compilamos el modelo
model.compile(optimizer=Adam(lr=0.001), loss='categorical_crossentropy', metrics=['accuracy'])

# vemos la estructura del modelo
model.summary()

Data augmentation en red convolucional 1

X_train_resized.shape[0]

50000

# comenzamos con el entrenamiento
epochs = 15
batch_size = 256
train_steps_per_epoch = X_train_resized.shape[0] / batch_size
test_steps_per_epoch = X_test_resized.shape[0] / batch_size

# entrenamos con el datagenerator (nos permite aplicar transformaciones en tiempo real)
model.fit_generator(datagen_train.flow(X_train_resized, Y_train, batch_size=batch_size),
                    steps_per_epoch=train_steps_per_epoch,
                    epochs=epochs,
                    validation_data=datagen_test.flow(X_test_resized, Y_test, batch_size=batch_size),
                    validation_steps=test_steps_per_epoch,
                    workers=8)

# comprobamos el accuracy y el loss en el test set
scores = model.evaluate(X_test_resized, Y_test, verbose=1)
print('Test loss:', scores[0])
print('Test accuracy:', scores[1])

Data augmentation en red convolucional 2

Aprender más del Big Data

Ahora que conoces Data augmentation en red convolucional, te animamos a continuar aprendiendo sobre las demás estrategias para el manejo del Big Data.

No dudes en echarle un vistazo al Bootcamp Full Stack Big Data, Inteligencia Artificial & Machine Learning si lo que deseas es continuar aprendiendo y formarte como un data scientist profesional. Por medio de 11 módulos y de la mano de grandes expertos en el mundo del Big Data, podrás instruirte en los sistemas, lenguajes y programas más importantes para el manejo de los macrodatos. ¡No esperes más para inscribirte!