Aprovecha la magia de los generadores de datos de imágenes para el aprendizaje profundo

📋 Contenido

• Introducción
• Preprocesamiento de imágenes
  • Carga de imágenes
  • Visualización de imágenes
  • Conversión a escala de grises
  • Creación de versiones más pequeñas
  • Cambio de tamaño de imágenes
  • Volteo horizontal de imágenes
  • Rotación de imágenes
  • Recorte de imágenes
  • Carga de múltiples imágenes
  • Generación de datos de imagen

🖼️ Preprocesamiento de Imágenes: Mejorando la Calidad Visual

El preprocesamiento de imágenes es una parte crucial en el flujo de trabajo de procesamiento de imágenes. Antes de alimentar las imágenes a cualquier modelo o algoritmo, es importante realizar algunas técnicas básicas de preprocesamiento para mejorar su calidad y hacer que sean más adecuadas para su procesamiento. En este artículo, exploraremos algunas técnicas comunes de preprocesamiento de imágenes utilizando Python y las bibliotecas Pillow y Matplotlib.

Carga de Imágenes

Lo primero que debemos hacer antes de comenzar cualquier operación de preprocesamiento es cargar las imágenes en nuestro entorno de trabajo. Utilizaremos la biblioteca Pillow para cargar las imágenes. Para cargar una imagen, simplemente especificamos la ruta del archivo y la biblioteca se encargará del resto. A continuación se muestra un ejemplo de cómo cargar una imagen:

from PIL import Image

imagen = Image.open('ruta/imagen.jpg')

Una vez cargada la imagen, podemos inspeccionar sus propiedades, como el formato de la imagen, el modo de color y el tamaño de la imagen. Estas propiedades son útiles para comprender mejor la imagen antes de realizar cualquier preprocesamiento adicional. Por ejemplo, podemos obtener la información del formato, el modo y el tamaño de la imagen de la siguiente manera:

print("Formato de la imagen:", imagen.format)
print("Modo de la imagen:", imagen.mode)
print("Tamaño de la imagen:", imagen.size)

Visualización de Imágenes

Antes de comenzar a preprocesar las imágenes, es útil visualizar cómo se ven. La biblioteca Matplotlib es ampliamente utilizada para la visualización de imágenes en Python. Podemos utilizar la función imshow de Matplotlib para mostrar una imagen. A continuación se muestra un ejemplo de cómo visualizar una imagen:

import matplotlib.pyplot as plt

plt.imshow(imagen)
plt.axis('off')
plt.show()

También podemos agregar una barra de color a la imagen para ver la intensidad del color en cada píxel. Esto puede ser útil para comprender cómo se distribuyen los valores de intensidad a lo largo de la imagen. Podemos agregar una barra de color a la imagen de la siguiente manera:

plt.imshow(imagen)
plt.colorbar()
plt.axis('off')
plt.show()

Conversión a Escala de Grises

En algunos casos, es posible que deseemos convertir una imagen a escala de grises para simplificar su procesamiento o eliminar el componente de color. Podemos utilizar la biblioteca Pillow para realizar esta conversión. A continuación se muestra un ejemplo de cómo convertir una imagen a escala de grises:

imagen_grises = imagen.convert('L')

plt.imshow(imagen_grises, cmap='gray')
plt.axis('off')
plt.show()

Creación de Versiones Más Pequeñas

En ocasiones, puede ser útil crear versiones más pequeñas de las imágenes originales. Esto puede ser útil para reducir el tamaño de las imágenes y hacer que sean más fáciles de manejar o procesar. Podemos utilizar el método thumbnail de la biblioteca Pillow para crear una versión más pequeña de la imagen. A continuación se muestra un ejemplo de cómo crear una versión más pequeña de una imagen:

imagen.thumbnail((100, 100))

plt.imshow(imagen)
plt.axis('off')
plt.show()

Cambio de Tamaño de Imágenes

En algunos casos, podemos querer cambiar el tamaño de una imagen a un tamaño específico. Podemos utilizar el método resize de la biblioteca Pillow para realizar este cambio de tamaño. A continuación se muestra un ejemplo de cómo cambiar el tamaño de una imagen:

nuevo_tamano = (200, 200)
imagen_redimensionada = imagen.resize(nuevo_tamano)

print("Nuevo tamaño de la imagen:", imagen_redimensionada.size)

plt.imshow(imagen_redimensionada)
plt.axis('off')
plt.show()

Volteo Horizontal de Imágenes

A veces, podemos querer voltear una imagen horizontalmente para obtener una perspectiva diferente. Podemos utilizar el método transpose de la biblioteca Pillow para realizar este volteo. A continuación se muestra un ejemplo de cómo voltear horizontalmente una imagen:

imagen_volteada = imagen.transpose(Image.FLIP_LEFT_RIGHT)

plt.imshow(imagen_volteada)
plt.axis('off')
plt.show()

Rotación de Imágenes

La rotación de imágenes es otra técnica común de preprocesamiento que se utiliza para cambiar la orientación de una imagen. Podemos utilizar el método rotate de la biblioteca Pillow para realizar una rotación. A continuación se muestra un ejemplo de cómo rotar una imagen:

angulo = 45
imagen_rotada = imagen.rotate(angulo)

plt.imshow(imagen_rotada)
plt.axis('off')
plt.show()

Recorte de Imágenes

El recorte de imágenes implica seleccionar una región específica de una imagen y eliminar el resto. Podemos utilizar el método crop de la biblioteca Pillow para realizar este recorte. A continuación se muestra un ejemplo de cómo recortar una imagen:

coordenadas_recorte = (x1, y1, x2, y2)
imagen_recortada = imagen.crop(coordenadas_recorte)

plt.imshow(imagen_recortada)
plt.axis('off')
plt.show()

Carga de Múltiples Imágenes

En muchos casos, no trabajaremos solo con una imagen, sino con un conjunto de imágenes. Podemos cargar múltiples imágenes desde un directorio especificado utilizando la biblioteca Pillow y un ciclo for. A continuación se muestra un ejemplo de cómo cargar múltiples imágenes:

import os

directorio = 'ruta/directorio_de_imagenes'
imagenes_cargadas = []

for nombre_archivo in os.listdir(directorio):
    ruta_archivo = os.path.join(directorio, nombre_archivo)
    imagen = Image.open(ruta_archivo)
    imagenes_cargadas.append(imagen)
    print("Nombre del archivo:", nombre_archivo)
    print("Tamaño de la imagen:", imagen.size)

Generación de Datos de Imagen

La generación de datos de imagen es una técnica útil para aumentar la cantidad de datos de entrenamiento mediante la aplicación de transformaciones aleatorias a las imágenes existentes. Podemos utilizar la clase ImageDataGenerator de la biblioteca Keras para generar nuevos ejemplos de imágenes a partir de un conjunto de imágenes existente. A continuación se muestra un ejemplo de cómo generar datos de imagen:

from tensorflow.keras.preprocessing.image import ImageDataGenerator

directorio = 'ruta/directorio_de_entrenamiento'

generador_imagenes = ImageDataGenerator(rescale=1./255)
datos_generados = generador_imagenes.flow_from_directory(
    directorio,
    target_size=(150, 150),
    batch_size=4,
    class_mode='binary'
)

for imagenes, etiquetas in datos_generados:
    for i in range(len(etiquetas)):
        imagen = imagenes[i]
        etiqueta = etiquetas[i]
        plt.imshow(imagen)
        plt.colorbar()
        plt.axis('off')
        if etiqueta == 0:
            plt.title("Clase: Gato")
        else:
            plt.title("Clase: Perro")
        plt.show()
    break

✅ Conclusiones

En este artículo, hemos explorado algunas técnicas básicas de preprocesamiento de imágenes utilizando Python y las bibliotecas Pillow y Matplotlib. Hemos aprendido cómo cargar imágenes, visualizarlas, convertirlas a escala de grises, crear versiones más pequeñas, cambiar su tamaño, voltearlas, rotarlas, recortarlas, cargar múltiples imágenes y generar nuevos datos de imagen. Estas técnicas son fundamentales para mejorar la calidad visual de las imágenes y hacerlas más adecuadas para su procesamiento en modelos y algoritmos de aprendizaje automático.

📚 Recursos

• Documentación de Pillow
• Documentación de Matplotlib
• Documentación de Keras
• Guía de TensorFlow sobre preprocesamiento de imágenes