Procesamiento de datos de imágenes de TensorFlow

¿Qué son los datos de imágenes?

Los datos de imágenes son matrices bidimensionales (imágenes en escala de grises) o tensores tridimensionales (imágenes en color) compuestos por píxeles. En TensorFlow, las imágenes generalmente se representan como:

  • Imagen en escala de grises: [altura, ancho] o [altura, ancho, 1]
  • Imagen en color: [altura, ancho, 3] (canales RGB)

¿Por qué se necesita el procesamiento de imágenes?

  • Normalización de datos: unificar el tamaño y el rango de valores de las imágenes
  • Aumento de datos: incrementar la diversidad de las muestras de entrenamiento mediante transformaciones
  • Extracción de características: resaltar la información clave en las imágenes
  • Preprocesamiento: preparar el formato de datos adecuado para la entrada del modelo

API principal de procesamiento de imágenes de TensorFlow

Módulo tf.image

Conjunto de APIs proporcionadas por TensorFlow específicamente para el procesamiento de imágenes:

Ejemplo

import tensorflow as tf
from tensorflow import image as tf_image

Clasificación de funciones comunes:

Categoría de función Ejemplos de métodos principales
Ajuste de color adjust_brightness, adjust_contrast
Transformación geométrica flip, rotate, crop_to_bounding_box
Composición de imágenes blend, draw_bounding_boxes
Conversión de formato encode_jpeg, decode_image
Operaciones estadísticas total_variation, per_image_standardization

Explicación detallada de las técnicas de preprocesamiento de imágenes

Normalización

Normalizar los valores de píxeles a un rango fijo (generalmente [0,1] o [-1,1]):

Ejemplo

def normalize(image):
    """Normalizar imagen uint8 al rango [0,1]"""
    image = tf.cast(image, tf.float32)  # Convertir a float32
    return image / 255.0  # Dividir por el valor máximo

# Ejemplo de uso
image = tf.random.uniform([256,256,3], 0, 255, dtype=tf.uint8)
normalized_image = normalize(image)

Técnicas de aumento de datos

Aumentar la diversidad de datos mediante transformaciones aleatorias:

Ejemplo

def augment_image(image, label):
    """Canalización de procesamiento de imágenes con aumento aleatorio"""
    # Volteo horizontal aleatorio
    image = tf_image.random_flip_left_right(image)
   
    # Ajuste aleatorio de brillo
    image = tf_image.random_brightness(image, max_delta=0.2)
   
    # Ajuste aleatorio de contraste
    image = tf_image.random_contrast(image, lower=0.8, upper=1.2)
   
    # Rotación aleatoria (-15° a +15°)
    angle = tf.random.uniform([], -15, 15) * (3.1415/180)
    image = tf_image.rotate(image, angle)
   
    return image, label

Flujo de carga de imágenes y procesamiento por lotes

Flujo de procesamiento completo

Implementación de código real

Ejemplo

def preprocess_dataset(dataset, batch_size=32, is_training=False):
    """Construir canalización de preprocesamiento de imágenes"""
   
    # Definir función de preprocesamiento
    def _preprocess(image, label):
        # Decodificar imagen JPEG
        image = tf_image.decode_jpeg(image, channels=3)
        # Redimensionar a un tamaño uniforme
        image = tf_image.resize(image, [224, 224])
        # Aplicar aumento de datos durante el entrenamiento
        if is_training:
            image = augment_image(image)
        # Normalización
        image = normalize(image)
        return image, label
   
    # Aplicar preprocesamiento y crear lotes
    dataset = dataset.map(_preprocess, num_parallel_calls=tf.data.AUTOTUNE)
    dataset = dataset.batch(batch_size)
    dataset = dataset.prefetch(tf.data.AUTOTUNE)
   
    return dataset

Técnicas avanzadas de procesamiento de imágenes

Uso de capas de preprocesamiento de Keras

TensorFlow 2.x proporciona APIs de preprocesamiento más avanzadas:

Ejemplo

from tensorflow.keras.layers.experimental import preprocessing

# Crear modelo de preprocesamiento
augmenter = tf.keras.Sequential([
    preprocessing.RandomFlip("horizontal"),
    preprocessing.RandomRotation(0.1),
    preprocessing.RandomZoom(0.1),
    preprocessing.Rescaling(1./255)  # Normalización
])

# Usar en el modelo
model = tf.keras.Sequential([
    augmenter,  # Capa de aumento de datos
    tf.keras.layers.Conv2D(32, 3, activation='relu'),
    # Otras capas...
])

Capas de procesamiento de imágenes personalizadas

Implementar operaciones de preprocesamiento personalizadas:

Ejemplo

class RandomColorDistortion(tf.keras.layers.Layer):
    def __init__(self, contrast_range=[0.5, 1.5], **kwargs):
        super().__init__(**kwargs)
        self.contrast_range = contrast_range
       
    def call(self, images, training=None):
        if not training:
            return images
           
        # Ajuste aleatorio de contraste
        contrast_factor = tf.random.uniform(
            [], self.contrast_range[0], self.contrast_range[1])
        images = tf.image.adjust_contrast(images, contrast_factor)
       
        # Ajuste aleatorio de saturación
        images = tf.image.random_saturation(images, 0.5, 1.5)
       
        return images

Ejercicios prácticos

Ejercicio 1: Comparación de normalización de imágenes

Cargue una imagen de prueba, aplique los siguientes métodos de normalización y visualice los resultados:

  1. Dividir por 255 (rango [0,1])
  2. Normalización por media y desviación estándar de ImageNet (mean=[0.485,0.456,0.406], std=[0.229,0.224,0.225])
  3. Normalización personalizada (por ejemplo, escalar al rango [-1,1])

Ejercicio 2: Observación de los efectos del aumento de datos

Seleccione una imagen, aplique diferentes combinaciones de técnicas de aumento (volteo + rotación + ajuste de color), genere 10 versiones aumentadas y muéstrelas en una cuadrícula para observar el efecto del aumento.

Ejercicio 3: Canalización completa de preprocesamiento

Construya una canalización completa de preprocesamiento de imágenes que incluya los siguientes pasos:

  1. Cargar imágenes desde TFRecord
  2. Decodificar imágenes
  3. Recorte aleatorio a 256x256
  4. Volteo horizontal aleatorio
  5. Normalizar al rango [-1,1]
  6. Crear un conjunto de datos con tamaño de lote 32

Preguntas frecuentes

P1: ¿Cómo manejar imágenes de diferentes tamaños?

R: Usetf.image.resizepara unificar tamaños, o usetf.image.resize_with_crop_or_padpara recortar/rellenar manteniendo la relación de aspecto.

P2: ¿El procesamiento de imágenes debe realizarse en CPU o GPU?

R: Generalmente se recomienda realizar el preprocesamiento de imágenes en la CPU, usandotf.data.Dataset.mapdenum_parallel_callspara el procesamiento paralelo.

P3: ¿Cómo evitar la pérdida de información causada por el aumento de datos?

R: Establezca razonablemente el rango de los parámetros de aumento; para tareas críticas (como imágenes médicas), use las transformaciones geométricas con precaución y priorice las transformaciones en el espacio de color.

P4: ¿Cuáles son las mejores prácticas para procesar imágenes extremadamente grandes?

R: Considere usartf.image.extract_patchespara dividir la imagen grande en parches, o use técnicas de carga progresiva.

Otras extensiones