Transfer Learning en Visión por Computadora: Reutilizando Modelos Pre-entrenados para la Clasificación de Imágenes

El Deep Learning ha revolucionado la Visión por Computadora, permitiendo avances impresionantes en tareas como la clasificación de imágenes, detección de objetos y segmentación semántica. Sin embargo, entrenar una red neuronal convolucional (CNN) profunda desde cero para un nuevo problema puede ser una tarea monumental. Requiere grandes cantidades de datos etiquetados, recursos computacionales significativos y un tiempo considerable. Aquí es donde el Transfer Learning (Aprendizaje por Transferencia) entra en juego como una solución poderosa y eficiente. ✨

El Transfer Learning nos permite aprovechar el conocimiento adquirido por un modelo entrenado en una tarea similar (a menudo en un dataset masivo como ImageNet) y adaptarlo para una nueva tarea específica con menos datos y recursos.

🎯 ¿Qué es el Transfer Learning y por qué es tan útil?

En esencia, el Transfer Learning consiste en tomar un modelo de Deep Learning que ya ha sido entrenado en un gran conjunto de datos para una tarea particular y reutilizar sus pesos y arquitectura como punto de partida para una nueva tarea. En el contexto de la Visión por Computadora, esto significa tomar una CNN pre-entrenada para clasificar miles de categorías de objetos (como animales, vehículos, objetos del hogar) y ajustarla para clasificar un conjunto de imágenes completamente diferente, como tipos de cáncer, plantas específicas o defectos de fabricación.

💡 Ventajas clave del Transfer Learning:

• Menos datos: No necesitas un dataset tan grande como si entrenaras desde cero. Los modelos pre-entrenados ya han aprendido características de bajo nivel (bordes, texturas) y de alto nivel (partes de objetos) que son transferibles.
• Menos tiempo de entrenamiento: Al empezar con pesos ya optimizados, el modelo converge más rápido.
• Menos recursos computacionales: Reducir el tiempo de entrenamiento se traduce en menos uso de GPUs y CPUs.
• Mejor rendimiento: Los modelos pre-entrenados a menudo han sido optimizados por expertos y alcanzan un rendimiento superior al que se lograría entrenando un modelo pequeño desde cero con pocos datos.
• Accesibilidad: Permite a investigadores y desarrolladores con recursos limitados construir modelos de Deep Learning robustos.

📖 Fundamentos del Transfer Learning en CNNs

Las Redes Neuronales Convolucionales (CNNs) están compuestas por varias capas. Las capas iniciales de una CNN suelen aprender características muy genéricas, como bordes, esquinas y blobs de color. Estas características son universales y útiles para reconocer objetos en casi cualquier imagen. A medida que avanzamos hacia las capas más profundas de la red, estas capas aprenden características más complejas y específicas de las clases en las que fue entrenado el modelo.

Cuando aplicamos Transfer Learning, típicamente hacemos lo siguiente:

1. Cargar un modelo pre-entrenado: Obtenemos una CNN que ya ha sido entrenada en un dataset muy grande (por ejemplo, ImageNet). Esto incluye su arquitectura y sus pesos.
2. "Congelar" las capas convolucionales (Extractor de Características): Mantenemos las capas convolucionales iniciales (o todas ellas, dependiendo de la estrategia) con sus pesos originales. Estas capas actúan como un potente extractor de características genéricas de las imágenes de entrada.
3. Reemplazar o añadir una nueva capa de clasificación: Quitamos las capas de clasificación originales del modelo pre-entrenado (ya que están diseñadas para las clases de ImageNet) y añadimos nuestras propias capas, generalmente una o más capas densas (Fully Connected) al final, que se encargarán de clasificar las imágenes en nuestras nuevas categorías.
4. Entrenar solo las nuevas capas: Entrenamos el modelo con nuestros propios datos, permitiendo que solo las capas recién añadidas se ajusten. Los pesos de las capas convolucionales pre-entrenadas permanecen fijos.

Esta estrategia es conocida como feature extraction (extracción de características) y es la forma más básica de Transfer Learning.

📚 Modelos pre-entrenados populares

Existen varios modelos pre-entrenados de CNN muy populares que han ganado concursos como el ImageNet Large Scale Visual Recognition Challenge (ILSVRC) y son ampliamente utilizados en Transfer Learning. Algunos de los más conocidos incluyen:

🛠️ Implementando Transfer Learning con Keras y TensorFlow

Vamos a ilustrar el Transfer Learning con un ejemplo práctico usando Keras (una API de alto nivel para TensorFlow). Nos centraremos en la clasificación de un dataset pequeño de imágenes. Para este ejemplo, usaremos un dataset de flores simple.

🚀 Paso 1: Configuración del entorno y carga de librerías

Asegúrate de tener TensorFlow y Keras instalados. Si no, puedes instalarlos con pip:

pip install tensorflow keras matplotlib numpy

Ahora, importemos las librerías necesarias:

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import numpy as np
import matplotlib.pyplot as plt
import os

print("TensorFlow Version:", tf.__version__)

💾 Paso 2: Preparación del Dataset

Para este tutorial, utilizaremos un subconjunto del dataset Flower Photos de TensorFlow. Asumiremos que ya tienes el dataset descargado y organizado en directorios, por ejemplo:

flowers/
  daisy/
    image1.jpg
    image2.jpg
  dandelion/
    imageA.jpg
    imageB.jpg
  roses/
    imageX.jpg
    imageY.jpg
  sunflowers/
  tulips/

Usaremos ImageDataGenerator para cargar las imágenes y aplicar aumentación de datos (data augmentation), lo cual es crucial para evitar el overfitting en datasets pequeños.

# Directorio raíz de las imágenes
data_dir = 'path/to/your/flowers_photos' # ¡Asegúrate de cambiar esto!

# Parámetros del dataset
IMG_HEIGHT = 224 # VGG16 y ResNet esperan 224x224
IMG_WIDTH = 224
BATCH_SIZE = 32

# Aumentación de datos y preprocesamiento
train_datagen = ImageDataGenerator(
    rescale=1./255, # Normalizar píxeles a [0, 1]
    rotation_range=40,
    width_shift_range=0.2,
    height_shift_range=0.2,
    shear_range=0.2,
    zoom_range=0.2,
    horizontal_flip=True,
    fill_mode='nearest',
    validation_split=0.2 # 20% para validación
)

validation_datagen = ImageDataGenerator(
    rescale=1./255, # Solo normalizar para validación
    validation_split=0.2
)

train_generator = train_datagen.flow_from_directory(
    data_dir,
    target_size=(IMG_HEIGHT, IMG_WIDTH),
    batch_size=BATCH_SIZE,
    class_mode='categorical',
    subset='training'
)

validation_generator = validation_datagen.flow_from_directory(
    data_dir,
    target_size=(IMG_HEIGHT, IMG_WIDTH),
    batch_size=BATCH_SIZE,
    class_mode='categorical',
    subset='validation'
)

num_classes = train_generator.num_classes
class_names = list(train_generator.class_indices.keys())
print("Número de clases:", num_classes)
print("Clases:", class_names)

🏗️ Paso 3: Cargar el modelo pre-entrenado (VGG16 como ejemplo)

Utilizaremos VGG16 por su simplicidad conceptual, pero puedes sustituirlo por ResNet50, InceptionV3, etc., importándolos desde tensorflow.keras.applications.

# Cargar el modelo base VGG16 pre-entrenado en ImageNet
base_model = keras.applications.VGG16(
    weights='imagenet',  # Usar pesos pre-entrenados en ImageNet
    include_top=False,   # No incluir las capas densas de clasificación finales
    input_shape=(IMG_HEIGHT, IMG_WIDTH, 3) # Definir la forma de entrada
)

# Congelar las capas convolucionales del modelo base
base_model.trainable = False

# Mostrar el resumen del modelo base (ahora congelado)
base_model.summary()

🎨 Paso 4: Añadir las nuevas capas de clasificación

Crearemos un nuevo modelo Keras apilando el base_model (congelado) y nuestras propias capas densas para la clasificación de las flores.

# Crear un nuevo modelo sobre el modelo base
model = keras.Sequential([
    base_model,
    layers.Flatten(), # Aplanar la salida de las capas convolucionales
    layers.Dense(256, activation='relu'), # Capa densa oculta
    layers.Dropout(0.5), # Regularización para evitar overfitting
    layers.Dense(num_classes, activation='softmax') # Capa de salida con activación softmax para clasificación multiclase
])

# Compilar el modelo
model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=0.0001),
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

model.summary()

🏃 Paso 5: Entrenar el nuevo clasificador

Ahora entrenaremos las capas que hemos añadido. Dado que las capas convolucionales están congeladas, el entrenamiento será relativamente rápido.

epochs = 10

history = model.fit(
    train_generator,
    epochs=epochs,
    validation_data=validation_generator
)

📊 Paso 6: Evaluar y visualizar resultados

Podemos graficar la precisión y la pérdida para ver cómo se comportó el entrenamiento.

# Visualizar la historia del entrenamiento
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']

epochs_range = range(epochs)

plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, acc, label='Training Accuracy')
plt.plot(epochs_range, val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

Después de este paso, el modelo es capaz de clasificar las imágenes de flores con una precisión razonable, incluso con un dataset pequeño, gracias al conocimiento transferido de VGG16.

🔄 Fine-tuning: Ajuste fino de modelos pre-entrenados

La estrategia anterior de congelar todas las capas convolucionales y solo entrenar el clasificador es efectiva, especialmente cuando tienes un dataset pequeño y muy diferente al original. Sin embargo, para obtener un rendimiento aún mejor, a menudo podemos realizar un ajuste fino (fine-tuning).

El Fine-tuning implica descongelar algunas de las capas convolucionales superiores del modelo base y entrenarlas junto con las nuevas capas de clasificación. La idea es que las capas convolucionales más profundas del modelo pre-entrenado han aprendido características más específicas. Al descongelarlas y entrenarlas con una tasa de aprendizaje muy baja, permitimos que se adapten ligeramente a las características específicas de nuestro nuevo dataset, sin "olvidar" lo que ya aprendieron.

📝 Proceso de Fine-tuning:

1. Entrenar el clasificador superior: Primero, seguimos los pasos anteriores: congelar el modelo base y entrenar solo las capas de clasificación recién añadidas. Esto asegura que las nuevas capas tienen un buen punto de partida.
2. Descongelar capas superiores del modelo base: Una vez que el clasificador ha sido entrenado, elegimos un número de capas convolucionales superiores del modelo base para descongelar.
3. Entrenar con una tasa de aprendizaje baja: Recompilamos el modelo con una tasa de aprendizaje mucho más baja (generalmente 10 a 100 veces menor que la anterior) y continuamos el entrenamiento. La tasa baja evita cambios bruscos en los pesos pre-entrenados.

💻 Implementando Fine-tuning

Continuando con nuestro ejemplo de flores:

# Descongelar el modelo base (o parte de él)
base_model.trainable = True

# Ver cuántas capas hay en el modelo base
print("Número de capas en el modelo base:", len(base_model.layers))

# Descongelar las últimas N capas para fine-tuning (ej. las últimas 4 capas convolucionales)
fine_tune_at = 100 # Puedes ajustar este número. Capas antes de este índice permanecerán congeladas.

for layer in base_model.layers[:fine_tune_at]:
    layer.trainable = False

# Recompilar el modelo con una tasa de aprendizaje muy baja
model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=0.00001), # ¡Tasa de aprendizaje muy baja!
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

model.summary()

# Continuar el entrenamiento con fine-tuning
fine_tune_epochs = 10
total_epochs =  epochs + fine_tune_epochs

history_fine = model.fit(
    train_generator,
    epochs=total_epochs,
    initial_epoch=history.epoch[-1], # Comenzar desde el último epoch del entrenamiento anterior
    validation_data=validation_generator
)

Ahora, combinemos las historias de entrenamiento para ver el impacto total:

# Visualizar la historia combinada
acc += history_fine.history['accuracy']
val_acc += history_fine.history['val_accuracy']

loss += history_fine.history['loss']
val_loss += history_fine.history['val_loss']

plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(range(total_epochs), acc, label='Training Accuracy')
plt.plot(range(total_epochs), val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy (Fine-tuning)')

plt.subplot(1, 2, 2)
plt.plot(range(total_epochs), loss, label='Training Loss')
plt.plot(range(total_epochs), val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss (Fine-tuning)')
plt.show()

Es probable que observes una mejora en la precisión de validación después del fine-tuning, aunque a veces puede haber un ligero overfitting si no se controla bien.

✅ Consideraciones y Mejores Prácticas

El Transfer Learning es potente, pero hay algunas consideraciones clave para maximizar su efectividad:

• Tamaño y similitud del dataset:

  • Pequeño y similar al original: Entrenar solo el clasificador superior. Poca necesidad de fine-tuning profundo.
  • Pequeño y diferente al original: Entrenar solo el clasificador superior. Si el rendimiento es bajo, intentar fine-tuning de algunas capas superiores.
  • Grande y similar al original: Fine-tuning de muchas capas o incluso del modelo completo con tasa de aprendizaje baja.
  • Grande y diferente al original: Fine-tuning de muchas capas o entrenamiento desde cero (aunque Transfer Learning sigue siendo un buen punto de partida).

• Aumentación de datos: Siempre es una buena práctica, especialmente con datasets pequeños, para aumentar la robustez y reducir el overfitting.

• Tasas de aprendizaje: Utiliza tasas de aprendizaje pequeñas para el fine-tuning para evitar corromper los pesos pre-entrenados.

• Dropout y Regularización: Añade capas de dropout u otras técnicas de regularización en las capas densas que añades para prevenir el overfitting.

• Normalización: Asegúrate de que las imágenes estén normalizadas de la misma manera que el modelo pre-entrenado esperaría (por ejemplo, a valores entre 0 y 1, o usando las medias y desviaciones estándar de ImageNet).

🔮 Más allá de la Clasificación

El concepto de Transfer Learning se extiende más allá de la clasificación de imágenes. Se aplica con éxito en:

• Detección de objetos: Usando CNNs pre-entrenadas como backbone para modelos como Faster R-CNN, YOLO o SSD.
• Segmentación Semántica: Adaptando redes como U-Net que utilizan encoders pre-entrenados para extraer características.
• Generación de imágenes: En Generative Adversarial Networks (GANs), los discriminadores a veces usan arquitecturas pre-entrenadas.
• Procesamiento de Lenguaje Natural (NLP): Modelos de lenguaje como BERT o GPT son el paradigma del Transfer Learning en texto.

Conclusión

El Transfer Learning es una técnica indispensable en el arsenal de cualquier practicante de Deep Learning, especialmente en Visión por Computadora. Permite construir modelos robustos y de alto rendimiento con menos datos y recursos, democratizando el acceso a las capacidades de las redes neuronales profundas. Al comprender cómo reutilizar y adaptar modelos pre-entrenados, no solo ahorras tiempo y potencia computacional, sino que también te posicionas para resolver problemas complejos de manera más efectiva.

¡Experimenta con diferentes modelos base, tasas de aprendizaje y estrategias de fine-tuning para encontrar la mejor combinación para tus proyectos! La práctica constante es clave para dominar esta poderosa técnica.