El aumento de datos (data augmentation) es una técnica utilizada para aumentar la cantidad de datos disponibles para entrenar un modelo, mediante la creación de nuevas imágenes a partir de transformaciones de las imágenes originales. Esto es útil cuando se tiene un conjunto de datos limitado.
Algunas transformaciones comunes incluyen rotaciones, desplazamientos, inversiones y escalado.
Existen varias transformaciones que puedes aplicar para aumentar el tamaño de tu conjunto de datos y mejorar la generalización del modelo. Aquí están algunas de ellas:
Estas transformaciones pueden ser útiles para entrenar modelos de visión por computadora robustos que no se sobreajusten a los datos específicos de entrenamiento.
Las imágenes de entrada deben tener un tamaño consistente para ser procesadas por los modelos de Machine Learning. El redimensionamiento es un paso común antes de alimentar las imágenes al modelo. En TensorFlow, por ejemplo, se puede redimensionar imágenes con la función `tf.image.resize()`:
import tensorflow as tf
# Cargar la imagen
image = tf.io.read_file('imagen.jpg')
image = tf.image.decode_jpeg(image, channels=3)
# Redimensionar la imagen
resized_image = tf.image.resize(image, [224, 224])
# Mostrar la imagen redimensionada
import matplotlib.pyplot as plt
plt.imshow(resized_image.numpy())
plt.axis('off')
plt.show()
Este ejemplo redimensiona la imagen a 224x224 píxeles, un tamaño comúnmente utilizado en modelos preentrenados como VGG16 o ResNet.
TensorFlow también proporciona varias utilidades para cargar y preprocesar imágenes. Usamos `tf.image` para aplicar transformaciones directamente sobre las imágenes, y se puede aprovechar su rendimiento optimizado para manejar grandes cantidades de datos de imágenes.
A continuación se muestra cómo cargar y preprocesar imágenes con TensorFlow:
import tensorflow as tf
# Cargar y decodificar la imagen
image_path = 'imagen.jpg'
image = tf.io.read_file(image_path)
image = tf.image.decode_jpeg(image, channels=3)
# Preprocesar la imagen
image = tf.image.convert_image_dtype(image, tf.float32) # Normalización
image = tf.image.resize(image, [224, 224]) # Redimensionar
# Mostrar la imagen
import matplotlib.pyplot as plt
plt.imshow(image.numpy())
plt.axis('off')
plt.show()
Este código realiza el procesamiento necesario para convertir una imagen a un formato adecuado para alimentar un modelo, que incluye la normalización (dividiendo por 255) y la redimensión a un tamaño fijo.
La normalización es el proceso de escalar los valores de los píxeles de las imágenes a un rango específico, normalmente [0, 1] o [-1, 1]. Esto mejora la eficiencia y estabilidad del entrenamiento de modelos.
En TensorFlow, podemos hacer esto fácilmente con la función `convert_image_dtype()`:
import tensorflow as tf
# Cargar y decodificar la imagen
image_path = 'imagen.jpg'
image = tf.io.read_file(image_path)
image = tf.image.decode_jpeg(image, channels=3)
# Normalizar la imagen
normalized_image = tf.image.convert_image_dtype(image, tf.float32)
# Mostrar la imagen normalizada
import matplotlib.pyplot as plt
plt.imshow(normalized_image.numpy())
plt.axis('off')
plt.show()
Este código convierte los valores de los píxeles a un rango entre 0 y 1, lo cual es útil para alimentar redes neuronales.
La transferencia de aprendizaje (transfer learning) es una técnica en la que un modelo preentrenado en una gran base de datos, como ImageNet, es ajustado para tareas específicas. Esto permite que los modelos se entrenen con menos datos y en menos tiempo.
En TensorFlow, se puede utilizar un modelo preentrenado como base para construir una red más profunda:
import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
# Cargar el modelo preentrenado ResNet50, sin la capa superior (fully connected layers)
model = tf.keras.applications.ResNet50(weights='imagenet')
# Cargar la imagen
img_path = 'imagen.jpg'
image = tf.io.read_file(img_path)
image = tf.image.decode_jpeg(image, channels=3)
image = tf.image.resize(image, [224, 224]) # Redimensionar la imagen a 224x224 para ResNet50
# Normalizar la imagen para que esté en el rango correcto para el modelo preentrenado
image = tf.image.convert_image_dtype(image, tf.float32)
image = tf.keras.applications.resnet50.preprocess_input(image) # Normalización específica de ResNet50
# Expande las dimensiones de la imagen para que sea compatible con la entrada del modelo
image = np.expand_dims(image, axis=0)
# Hacer la predicción
predictions = model.predict(image)
# Decodificar las predicciones (obtendremos la clase predicha con la probabilidad más alta)
decoded_predictions = tf.keras.applications.resnet50.decode_predictions(predictions, top=3)[0]
# Mostrar la imagen y las 3 predicciones principales
plt.imshow(image[0])
plt.title(f"Predicción: {decoded_predictions[0][1]} ({decoded_predictions[0][2]*100:.2f}%)")
plt.axis('off')
plt.show()
# Imprimir las 3 mejores predicciones
print("Las 3 principales predicciones:")
for i in decoded_predictions:
print(f"{i[1]}: {i[2]*100:.2f}%")
Este código muestra cómo usar un modelo preentrenado (VGG16 en este caso) y agregarle nuevas capas para un problema específico. La base del modelo se congela para evitar que se entrene de nuevo.
Una vez que un modelo de Machine Learning ha sido entrenado, puedes usarlo para hacer predicciones sobre nuevas imágenes. Para ver cómo el modelo está prediciendo, puedes visualizar las imágenes junto con sus etiquetas predichas.
Este es un ejemplo de cómo visualizar las predicciones:
import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
# Cargar la imagen
image = tf.io.read_file('imagen.jpg')
image = tf.image.decode_jpeg(image, channels=3)
image = tf.image.resize(image, [224, 224])
# Preprocesar la imagen para el modelo
image = tf.image.convert_image_dtype(image, tf.float32)
image = np.expand_dims(image, axis=0)
# Hacer la predicción
predictions = model.predict(image)
# Mostrar la imagen y la predicción
plt.imshow(image[0])
plt.title(f"Predicción: {predictions[0]}")
plt.axis('off')
plt.show()
Este ejemplo muestra cómo tomar una imagen de entrada, pasarla por el modelo y visualizar la imagen junto con la predicción realizada por el modelo.