Fine-tuning: adaptación de modelos preentrenados

El Fine-Tuning (ajuste fino) es una técnica avanzada en Machine Learning que permite adaptar modelos preentrenados a tareas específicas. En lugar de entrenar un modelo desde cero, lo que requiere grandes volúmenes de datos y potencia computacional, el Fine-Tuning reutiliza conocimientos previos y los ajusta a nuevos contextos.  

Hoy en día, este enfoque es ampliamente utilizado en aplicaciones como procesamiento de lenguaje natural (NLP), visión por computadora y más. Gracias a frameworks como TensorFlow, PyTorch y Hugging Face, el Fine-Tuning se ha convertido en una herramienta accesible para desarrolladores y científicos de datos.  

Qué es el Fine-Tuning en Machine Learning 

El Fine-Tuning es el proceso de ajustar un modelo preentrenado a una nueva tarea mediante un entrenamiento adicional con datos específicos del dominio.  

Diferencia entre Fine-Tuning y Transfer Learning 

El Fine-Tuning es una forma avanzada de Transfer Learning, pero tienen diferencias clave:  

Entrenar el modelo con tasas de aprendizaje diferenciadas 

El entrenamiento debe realizarse con diferentes tasas de aprendizaje:  

En TensorFlow, configuramos el optimizer con un learning_rate bajo para el modelo base: 

from tensorflow.keras.optimizers import Adam 
 
# Configurar diferentes tasas de aprendizaje 
modelo_base.trainable = True  # Descongelar modelo base 
for capa in modelo_base.layers[:-20]:  # Mantener congeladas las primeras capas 
    capa.trainable = False 
 
# Compilar el modelo con una tasa de aprendizaje diferenciada 
modelo.compile(optimizer=Adam(learning_rate=1e-4), loss="categorical_crossentropy", metrics=["accuracy"]) 
  

En PyTorch, asignamos distintas tasas de aprendizaje para las capas nuevas y el modelo base: 

import torch.optim as optim 
 
# Definir tasas de aprendizaje diferentes 
optimizador = optim.Adam([ 
    {"params": modelo_base.fc.parameters(), "lr": 1e-3},  # Capas nuevas con mayor LR 
    {"params": modelo_base.parameters(), "lr": 1e-5}  # Modelo base con menor LR 
]) 
  

Evaluar y ajustar el modelo 

Después del entrenamiento, se evalúa el modelo en un conjunto de datos de validación. Si el rendimiento no es óptimo, se pueden hacer ajustes en hiperparámetros o utilizar técnicas como Early Stopping.  

En TensorFlow, utilizamos EarlyStopping para detener el entrenamiento cuando la pérdida no mejora: 

from tensorflow.keras.callbacks import EarlyStopping 
 
# Aplicar Early Stopping para evitar sobreajuste 
early_stopping = EarlyStopping(monitor="val_loss", patience=5, restore_best_weights=True) 
 
# Entrenar el modelo 
modelo.fit(X_train, y_train, epochs=20, validation_data=(X_val, y_val), callbacks=[early_stopping]) 
  

En PyTorch, evaluamos la precisión en el conjunto de validación manualmente: 

from torch.utils.data import DataLoader 
import torch.nn.functional as F 
 
# Función de evaluación 
def evaluar_modelo(modelo, dataloader, dispositivo): 
    modelo.eval()  # Modo evaluación 
    correctos = 0 
    total = 0 
    with torch.no_grad(): 
        for datos, etiquetas in dataloader: 
            datos, etiquetas = datos.to(dispositivo), etiquetas.to(dispositivo) 
            salidas = modelo(datos) 
            _, predicciones = torch.max(salidas, 1) 
            correctos += (predicciones == etiquetas).sum().item() 
            total += etiquetas.size(0) 
    return correctos / total 
 
# Evaluar el modelo en el conjunto de validación 
precision = evaluar_modelo(modelo_base, DataLoader(val_dataset, batch_size=32), dispositivo="cuda") 
print(f"Precisión en validación: {precision:.2f}") 
  

Aplicando estos pasos, se puede hacer un Fine-Tuning efectivo en distintos modelos. En la siguiente sección, exploraremos técnicas avanzadas para mejorar aún más el rendimiento.  

Consideraciones avanzadas en Fine-Tuning 

Una vez comprendidos los pasos básicos, es importante aplicar técnicas avanzadas que mejoren el rendimiento y eficiencia del Fine-Tuning.  

Estrategia de descongelamiento progresivo 

En lugar de descongelar todas las capas del modelo base de una vez, una estrategia más efectiva es descongelar progresivamente las capas superiores y entrenarlas en diferentes etapas.  

Esto permite que el modelo aprenda de manera más controlada, evitando ajustes bruscos que puedan afectar negativamente su desempeño.  

Ejemplo en TensorFlow: Descongelar capas por bloques  

import tensorflow as tf 
from tensorflow import keras 
 
# Cargar modelo preentrenado (Ej: ResNet50) 
base_model = keras.applications.ResNet50(weights="imagenet", include_top=False) 
 
# Congelar todas las capas inicialmente 
base_model.trainable = False 
 
# Añadir capas personalizadas 
inputs = keras.Input(shape=(224, 224, 3)) 
x = base_model(inputs, training=False) 
x = keras.layers.GlobalAveragePooling2D()(x) 
outputs = keras.layers.Dense(10, activation="softmax")(x) 
modelo = keras.Model(inputs, outputs) 
 
# Descongelar las últimas 50 capas del modelo base 
for capa in base_model.layers[-50:]: 
    capa.trainable = True 
 
# Compilar y entrenar el modelo 
modelo.compile(optimizer=keras.optimizers.Adam(1e-5), loss="categorical_crossentropy", metrics=["accuracy"]) 
modelo.fit(train_data, epochs=5) 
  

Ejemplo en PyTorch: Ajuste progresivo de requires_grad  

import torch 
import torchvision.models as models 
 
# Cargar modelo preentrenado 
modelo = models.resnet50(pretrained=True) 
 
# Congelar todas las capas 
for param in modelo.parameters(): 
    param.requires_grad = False 
 
# Descongelar progresivamente las últimas capas 
for param in list(modelo.layer4.parameters()): 
    param.requires_grad = True 
 
# Definir optimizador solo para capas descongeladas 
import torch.optim as optim 
optimizador = optim.Adam(filter(lambda p: p.requires_grad, modelo.parameters()), lr=1e-5) 
  

Uso de tasas de aprendizaje diferenciadas 

El Discriminative Learning Rate consiste en asignar distintos + a las capas del modelo:  

Ejemplo en TensorFlow: Configurar distintos learning rates  

from tensorflow.keras.optimizers import Adam 
 
# Definir tasa de aprendizaje por capas 
lr_schedule = [ 
    (base_model.layers[:100], 1e-6),  # Capas profundas con menor learning rate 
    (base_model.layers[100:], 1e-4)   # Capas superiores con mayor learning rate 
] 
 
# Aplicar learning rate a cada capa 
for capas, lr in lr_schedule: 
    for capa in capas: 
        capa.trainable = True 
        capa.add_weight(name="lr", shape=(), initializer=tf.constant_initializer(lr)) 
 
# Compilar y entrenar 
modelo.compile(optimizer=Adam(learning_rate=1e-4), loss="categorical_crossentropy", metrics=["accuracy"]) 
modelo.fit(train_data, epochs=5) 
  

Ejemplo en PyTorch: Configuración de optimizador con múltiples learning rates  

import torch.optim as optim 
 
# Definir optimizador con distintos learning rates 
optimizador = optim.Adam([ 
    {"params": modelo.layer1.parameters(), "lr": 1e-6}, 
    {"params": modelo.layer2.parameters(), "lr": 1e-5}, 
    {"params": modelo.layer3.parameters(), "lr": 1e-4}, 
], lr=1e-4) 
  

Data Augmentation adaptado a Fine-Tuning 

El Data Augmentation ayuda a mejorar la capacidad de generalización del modelo cuando hay pocos datos.  

Ejemplo en TensorFlow: Augmentación de imágenes con ImageDataGenerator  

from tensorflow.keras.preprocessing.image import ImageDataGenerator 
 
# Crear generador de datos con Data Augmentation 
datagen = ImageDataGenerator( 
    rotation_range=20, 
    width_shift_range=0.2, 
    height_shift_range=0.2, 
    horizontal_flip=True, 
    brightness_range=[0.8, 1.2] 
) 
 
# Aplicar Data Augmentation a imágenes 
train_generator = datagen.flow_from_directory("dataset/", target_size=(224, 224), batch_size=32) 
  

Ejemplo en PyTorch: Transformaciones con torchvision.transforms  

import torchvision.transforms as transforms 
 
# Definir transformaciones para Data Augmentation 
transformacion = transforms.Compose([ 
    transforms.RandomRotation(20), 
    transforms.RandomHorizontalFlip(), 
    transforms.ColorJitter(brightness=0.2, contrast=0.2), 
    transforms.ToTensor() 
]) 
  

Fine-Tuning en dominios distintos al original 

El Fine-Tuning es útil cuando se usa un modelo entrenado en un dominio y se adapta a otro diferente (ejemplo: usar un modelo de imágenes naturales para imágenes médicas).  

En estos casos, se recomienda:  

Ejemplo en TensorFlow: Transferencia de aprendizaje en dominios distintos  

# Cargar modelo base 
base_model = keras.applications.VGG16(weights="imagenet", include_top=False) 
 
# Congelar la mayoría de capas y modificar la salida 
for capa in base_model.layers[:-5]:  # Descongelar solo las últimas 5 capas 
    capa.trainable = False 
 
# Construir nuevo modelo para otra tarea 
inputs = keras.Input(shape=(224, 224, 3)) 
x = base_model(inputs, training=False) 
x = keras.layers.GlobalAveragePooling2D()(x) 
outputs = keras.layers.Dense(2, activation="sigmoid")(x)  # Para clasificación binaria 
modelo = keras.Model(inputs, outputs) 
 
# Compilar y entrenar 
modelo.compile(optimizer=Adam(learning_rate=1e-4), loss="binary_crossentropy", metrics=["accuracy"]) 
modelo.fit(train_data, epochs=10) 
  

Ejemplo en PyTorch: Modificar capas de salida para otra tarea  

import torch.nn as nn 
 
# Modificar la última capa de un modelo ResNet50 para una nueva tarea 
modelo.fc = nn.Linear(modelo.fc.in_features, 2)  # Cambio para clasificación binaria 
  

Con estas técnicas avanzadas, se puede lograr un Fine-Tuning más eficiente y adaptado a cada tipo de problema. En la siguiente sección, exploraremos estrategias para evitar el sobreajuste durante el entrenamiento.