7.3 Transferencia de Aprendizaje y Ajuste Fino de Redes Preentrenadas

A medida que los modelos de aprendizaje profundo se vuelven cada vez más complejos y costosos de entrenar desde cero, la transferencia de aprendizaje ha surgido como una técnica poderosa para aprovechar el conocimiento preexistente y acelerar el desarrollo de nuevos modelos. Esta sección explora el concepto de la transferencia de aprendizaje, sus aplicaciones y el proceso de ajuste fino de redes preentrenadas para tareas específicas.

La transferencia de aprendizaje nos permite aprovechar el poder de los modelos entrenados en grandes conjuntos de datos y aplicar las características que han aprendido a nuevos conjuntos de datos, a menudo más pequeños. Este enfoque no solo ahorra recursos computacionales, sino que también permite la creación de modelos robustos en dominios donde los datos etiquetados pueden ser escasos. Exploraremos la mecánica de la transferencia de aprendizaje, discutiremos cuándo y cómo aplicarla y proporcionaremos ejemplos prácticos utilizando marcos populares de aprendizaje profundo.

Al comprender y dominar las técnicas de transferencia de aprendizaje, estarás mejor equipado para abordar una amplia gama de desafíos en el aprendizaje automático de manera más eficiente y efectiva, abriendo nuevas posibilidades en diversos dominios, desde la visión por computadora hasta el procesamiento del lenguaje natural.

7.3.1 ¿Qué es la Transferencia de Aprendizaje?

La transferencia de aprendizaje es una técnica poderosa en el aprendizaje automático que permite la adaptación de modelos preentrenados a nuevas tareas relacionadas. Este enfoque aprovecha el conocimiento obtenido de conjuntos de datos a gran escala para mejorar el rendimiento en conjuntos de datos más pequeños y específicos. Por ejemplo, un modelo entrenado en ImageNet, que contiene millones de imágenes diversas, puede reutilizarse para tareas especializadas como el análisis de imágenes médicas o la clasificación de imágenes satelitales.

El principio fundamental detrás de la transferencia de aprendizaje es la naturaleza jerárquica de la extracción de características en las redes neuronales. En las capas iniciales, las redes aprenden a identificar elementos visuales básicos, como bordes, texturas y formas simples. A medida que avanzamos a través de la red, estas características básicas se combinan para formar representaciones más complejas y específicas de la tarea. Al utilizar estas características preaprendidas, la transferencia de aprendizaje nos permite:

Reducir significativamente el tiempo de entrenamiento en comparación con el entrenamiento desde cero.
Lograr un mejor rendimiento con datos limitados.
Mitigar el riesgo de sobreajuste en conjuntos de datos pequeños.

Cuando aplicamos la transferencia de aprendizaje, generalmente seguimos un proceso en dos pasos:

1. Extracción de Características

En este paso crucial, aprovechamos las representaciones aprendidas por el modelo preentrenado utilizándolo como un extractor de características fijo. Este proceso implica:

Congelar los pesos de las capas preentrenadas, preservando el conocimiento adquirido del conjunto de datos original a gran escala.
Agregar nuevas capas diseñadas específicamente para la tarea objetivo, generalmente incluyendo una nueva capa de salida adaptada al número de clases en el nuevo conjunto de datos.
Entrenar solo estas capas recién agregadas, lo que permite que el modelo adapte sus características de alto nivel a los requisitos específicos de la nueva tarea.

Este enfoque es particularmente efectivo cuando la nueva tarea comparte similitudes con la tarea original, ya que nos permite beneficiarnos de las características ricas y de propósito general aprendidas por el modelo preentrenado. Al mantener fijas las capas preentrenadas, reducimos significativamente el riesgo de sobreajuste, especialmente cuando trabajamos con conjuntos de datos más pequeños.

2. Ajuste Fino

Después de la fase inicial de entrenamiento, podemos optimizar aún más el modelo "descongelando" algunas o todas las capas preentrenadas. Este proceso, conocido como ajuste fino, implica continuar el entrenamiento a una tasa de aprendizaje más baja. El ajuste fino permite que el modelo adapte su conocimiento general a las especificidades de la nueva tarea, lo que resulta en un mejor rendimiento y precisión.

Durante el ajuste fino, ajustamos cuidadosamente los pesos de las capas preentrenadas, permitiendo que se modifiquen ligeramente para adaptarse mejor al nuevo conjunto de datos. Este paso es crucial porque permite que el modelo capture características específicas de la tarea que pueden no haber estado presentes en los datos de entrenamiento originales. Al utilizar una tasa de aprendizaje más baja, aseguramos que la información valiosa aprendida del conjunto de datos original a gran escala no se sobrescriba por completo, sino que se refine y aumente con información nueva y relevante para la tarea.

El proceso de ajuste fino típicamente incluye:

Descongelar capas selectas: A menudo, comenzamos descongelando las capas superiores de la red, ya que estas contienen características más específicas de la tarea.
Descongelamiento gradual: En algunos casos, podemos emplear una técnica llamada "descongelamiento gradual", en la que progresivamente descongelamos más capas de arriba hacia abajo a medida que avanza el entrenamiento.
Programación de la tasa de aprendizaje: Utilizar técnicas como la decaída de la tasa de aprendizaje o tasas de aprendizaje cíclicas para optimizar el proceso de ajuste fino.
Monitoreo del rendimiento: Seguir cuidadosamente el rendimiento del modelo en un conjunto de validación para evitar el sobreajuste y determinar cuándo detener el ajuste fino.

Al equilibrar cuidadosamente la preservación del conocimiento general con la adquisición de características específicas de la tarea, el ajuste fino permite que la transferencia de aprendizaje logre resultados notables en una amplia gama de aplicaciones, desde la visión por computadora hasta tareas de procesamiento del lenguaje natural.

La transferencia de aprendizaje ha revolucionado muchas áreas del aprendizaje automático, permitiendo el desarrollo rápido de modelos de alto rendimiento en dominios donde la escasez de datos solía ser un obstáculo importante. Su versatilidad y eficiencia lo han convertido en una herramienta esencial en el conjunto de herramientas del aprendizaje automático moderno, fomentando la innovación en campos diversos, desde la visión por computadora hasta el procesamiento del lenguaje natural.

7.3.2 Cuándo Usar la Transferencia de Aprendizaje

La transferencia de aprendizaje es una técnica poderosa que ofrece ventajas significativas en varios escenarios:

Tamaño Limitado del Conjunto de Datos: Cuando tienes una cantidad pequeña o moderada de datos para tu nueva tarea, la transferencia de aprendizaje te permite aprovechar el conocimiento de un modelo entrenado en un conjunto de datos mucho más grande, reduciendo el riesgo de sobreajuste.
Restricciones de Recursos: Si careces de la potencia computacional o el tiempo para entrenar una red neuronal profunda desde cero, la transferencia de aprendizaje proporciona un atajo al utilizar pesos preentrenados.
Similitud de la Tarea: Cuando tu nueva tarea comparte similitudes con la tarea original del modelo preentrenado, la transferencia de aprendizaje puede ser particularmente efectiva, ya que las características aprendidas probablemente serán relevantes.
Adaptación de Dominio: Incluso cuando las tareas difieren, la transferencia de aprendizaje puede ayudar a cerrar la brecha entre dominios, como adaptar un modelo entrenado en imágenes naturales a tareas de imágenes médicas.

Por ejemplo, en el análisis de imágenes médicas, puedes aprovechar un modelo preentrenado en ImageNet (un gran conjunto de datos de imágenes naturales) para clasificar escaneos médicos. El modelo preentrenado ya ha aprendido a reconocer elementos visuales básicos como bordes, texturas y formas. Al ajustar este modelo en tu conjunto de datos médico específico, permite que adapte estas características generales a las sutilezas de las imágenes médicas, como identificar anormalidades sutiles en los tejidos o estructuras de órganos.

Además, la transferencia de aprendizaje puede reducir significativamente la cantidad de datos etiquetados necesarios para el entrenamiento. Esto es particularmente valioso en campos especializados como la atención médica, donde obtener grandes conjuntos de datos anotados puede ser un desafío debido a preocupaciones de privacidad y a la experiencia requerida para el etiquetado.

7.3.3 Ajuste Fino de una Red Preentrenada en Keras

Vamos a profundizar en el proceso de implementar la transferencia de aprendizaje ajustando un modelo ResNet50 preentrenado en ImageNet para una tarea de clasificación de imágenes personalizada. Este enfoque aprovecha el poder de un modelo que ya ha aprendido ricas representaciones de características a partir de un conjunto diverso de imágenes, lo que nos permite adaptarlo de manera eficiente a nuestro conjunto de datos específico.

La arquitectura ResNet50, conocida por su marco de aprendizaje residual profundo, es particularmente adecuada para la transferencia de aprendizaje debido a su capacidad para mitigar el problema del gradiente que desaparece en redes muy profundas. Al usar un modelo preentrenado en ImageNet, comenzamos con una red que ya ha aprendido a reconocer una amplia variedad de características, desde bordes y texturas de bajo nivel hasta estructuras de objetos de alto nivel.

Para adaptar este modelo preentrenado a nuestra tarea personalizada, emplearemos una técnica llamada "ajuste fino". Esto implica dos pasos clave:

Congelación de las capas preentrenadas: Inicialmente, mantendremos los pesos de las capas preentrenadas de ResNet50 fijos, preservando las valiosas características aprendidas de ImageNet.
Agregar y entrenar nuevas capas: Agregaremos una nueva capa de salida adaptada a nuestro número específico de clases. Esta capa se entrenará desde cero en nuestro conjunto de datos personalizado.

Siguiendo este enfoque, podemos reducir significativamente el tiempo de entrenamiento y los recursos computacionales mientras potencialmente logramos un mejor rendimiento, especialmente cuando trabajamos con conjuntos de datos limitados. Este método permite que el modelo aproveche su comprensión general de las características de las imágenes mientras se adapta a los matices de nuestra tarea de clasificación específica.

Ejemplo: Transferencia de Aprendizaje con ResNet50 en Keras

Aquí tienes una versión mejorada del ejemplo de transferencia de aprendizaje utilizando ResNet50 en Keras:

import tensorflow as tf
from tensorflow.keras.applications import ResNet50
from tensorflow.keras.layers import Dense, GlobalAveragePooling2D, Dropout
from tensorflow.keras.models import Model
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.preprocessing.image import ImageDataGenerator

# Load the ResNet50 model pretrained on ImageNet, excluding the top layer
base_model = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3))

# Freeze the layers of the base model
for layer in base_model.layers:
    layer.trainable = False

# Add custom layers for the new task
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(1024, activation='relu')(x)
x = Dropout(0.5)(x)
x = Dense(512, activation='relu')(x)
predictions = Dense(10, activation='softmax')(x)  # Assuming 10 classes

# Define the new model
model = Model(inputs=base_model.input, outputs=predictions)

# Compile the model
model.compile(optimizer=Adam(learning_rate=0.001), 
              loss='categorical_crossentropy', 
              metrics=['accuracy'])

# Data augmentation for training
train_datagen = ImageDataGenerator(
    rescale=1./255,
    rotation_range=20,
    width_shift_range=0.2,
    height_shift_range=0.2,
    horizontal_flip=True,
    zoom_range=0.2
)

# Validation data should only be rescaled
validation_datagen = ImageDataGenerator(rescale=1./255)

# Load and preprocess the data
train_generator = train_datagen.flow_from_directory(
    'path/to/train/data',
    target_size=(224, 224),
    batch_size=32,
    class_mode='categorical'
)

validation_generator = validation_datagen.flow_from_directory(
    'path/to/validation/data',
    target_size=(224, 224),
    batch_size=32,
    class_mode='categorical'
)

# Train the model
history = model.fit(
    train_generator,
    steps_per_epoch=train_generator.samples // 32,
    epochs=10,
    validation_data=validation_generator,
    validation_steps=validation_generator.samples // 32
)

# Fine-tuning: unfreeze some layers of the base model
for layer in base_model.layers[-20:]:
    layer.trainable = True

# Recompile the model with a lower learning rate
model.compile(optimizer=Adam(learning_rate=1e-5), 
              loss='categorical_crossentropy', 
              metrics=['accuracy'])

# Continue training (fine-tuning)
history_fine = model.fit(
    train_generator,
    steps_per_epoch=train_generator.samples // 32,
    epochs=5,
    validation_data=validation_generator,
    validation_steps=validation_generator.samples // 32
)

# Save the model
model.save('transfer_learning_model.h5')

Ahora, desglosamos este ejemplo expandido:

Importación de Bibliotecas: Importamos los módulos necesarios de TensorFlow y Keras.
Carga del Modelo Preentrenado: Cargamos el modelo ResNet50 preentrenado en ImageNet, excluyendo la capa superior. Esto nos permite usar los pesos preentrenados para la extracción de características mientras personalizamos la salida para nuestra tarea específica.
Congelación del Modelo Base: Congelamos las capas del modelo base para evitar que se actualicen durante el entrenamiento inicial. Esto preserva las valiosas características aprendidas de ImageNet.
Adición de Capas Personalizadas: Agregamos capas personalizadas sobre el modelo base. En esta versión expandida, hemos agregado una capa densa adicional y una capa de dropout para una mejor regularización.
Compilación del Modelo: Compilamos el modelo con el optimizador Adam, la función de pérdida de entropía cruzada categórica (adecuada para clasificación multiclase) y la métrica de precisión.
Aumento de Datos: Usamos ImageDataGenerator para el aumento de datos, lo que ayuda a prevenir el sobreajuste y mejora la generalización del modelo. Aplicamos varias transformaciones a los datos de entrenamiento, mientras que solo reescalamos los datos de validación.
Carga de Datos: Usamos flow_from_directory para cargar y preprocesar los datos directamente desde directorios. Esta es una forma conveniente de manejar grandes conjuntos de datos que no caben en la memoria.
Entrenamiento Inicial: Entrenamos el modelo durante 10 épocas utilizando el método fit. Los parámetros steps_per_epoch y validation_steps aseguran que usemos todos los datos disponibles en cada época.
Ajuste Fino: Después del entrenamiento inicial, descongelamos las últimas 20 capas del modelo base para el ajuste fino. Esto permite que el modelo adapte algunas de las características preentrenadas a nuestro conjunto de datos específico.
Recompilación y Ajuste Fino: Recompilamos el modelo con una tasa de aprendizaje más baja (1e-5) para evitar cambios drásticos en los pesos preentrenados. Luego, continuamos entrenando durante 5 épocas más.
Guardado del Modelo: Finalmente, guardamos el modelo entrenado para su uso futuro.

Este ejemplo demuestra un enfoque integral para la transferencia de aprendizaje, incluyendo el aumento de datos, el manejo adecuado de los datos de entrenamiento y validación, y un proceso de entrenamiento en dos etapas (entrenamiento inicial con capas base congeladas, seguido de ajuste fino). Este enfoque probablemente producirá mejores resultados, especialmente cuando se trabaja con conjuntos de datos limitados o tareas que difieren significativamente de la clasificación de ImageNet.

7.3.4 Ajuste Fino del Modelo

Una vez que hemos entrenado el modelo durante algunas épocas con las capas base congeladas, podemos proceder a ajustar algunas de las capas preentrenadas. Este paso crucial nos permite adaptar aún más el modelo a nuestra tarea y conjunto de datos específicos. El ajuste fino implica ajustar cuidadosamente los pesos de algunas capas del modelo preentrenado, permitiendo que aprenda características específicas de la tarea mientras conserva su comprensión general del dominio.

Durante el ajuste fino, típicamente descongelamos un subconjunto de las capas del modelo, a menudo comenzando desde la parte superior (más cercana a la salida) y avanzando hacia abajo. Este enfoque de descongelamiento gradual ayuda a prevenir el "olvido catastrófico", donde el modelo podría perder información valiosa aprendida durante el preentrenamiento. Al permitir que estas capas se actualicen con una tasa de aprendizaje más baja, permitimos que el modelo refine sus representaciones de características para nuestra tarea específica.

El ajuste fino ofrece varios beneficios:

Mejora del Rendimiento: Al adaptar las características preentrenadas a la nueva tarea, a menudo logramos una mejor precisión y generalización en comparación con el entrenamiento desde cero o el uso del modelo preentrenado como extractor de características fijo.
Convergencia Más Rápida: El ajuste fino generalmente requiere menos épocas para alcanzar el rendimiento óptimo en comparación con el entrenamiento desde cero, ya que el modelo comienza desde un buen punto de partida.
Mejor Generalización: La combinación de conocimiento preentrenado y adaptaciones específicas de la tarea a menudo lleva a modelos que generalizan mejor a datos no vistos.

Sin embargo, es importante abordar el ajuste fino con cuidado. El proceso requiere equilibrar la preservación del conocimiento general con la adquisición de características específicas de la tarea. Técnicas como el ajuste fino discriminativo (usando diferentes tasas de aprendizaje para diferentes capas) y el descongelamiento gradual pueden ayudar a lograr este equilibrio de manera efectiva.

Ejemplo: Ajuste Fino de Capas Específicas

import tensorflow as tf
from tensorflow.keras.applications import ResNet50
from tensorflow.keras.layers import Dense, GlobalAveragePooling2D, Dropout
from tensorflow.keras.models import Model
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.preprocessing.image import ImageDataGenerator

# Load the ResNet50 model pretrained on ImageNet, excluding the top layer
base_model = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3))

# Freeze all layers in the base model
for layer in base_model.layers:
    layer.trainable = False

# Add custom layers for the new task
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(1024, activation='relu')(x)
x = Dropout(0.5)(x)
x = Dense(512, activation='relu')(x)
predictions = Dense(10, activation='softmax')(x)  # Assuming 10 classes

# Create the full model
model = Model(inputs=base_model.input, outputs=predictions)

# Compile the model
model.compile(optimizer=Adam(learning_rate=0.001), 
              loss='categorical_crossentropy', 
              metrics=['accuracy'])

# Data augmentation for training
train_datagen = ImageDataGenerator(
    rescale=1./255,
    rotation_range=20,
    width_shift_range=0.2,
    height_shift_range=0.2,
    horizontal_flip=True,
    zoom_range=0.2
)

# Validation data should only be rescaled
validation_datagen = ImageDataGenerator(rescale=1./255)

# Load and preprocess the data
train_generator = train_datagen.flow_from_directory(
    'path/to/train/data',
    target_size=(224, 224),
    batch_size=32,
    class_mode='categorical'
)

validation_generator = validation_datagen.flow_from_directory(
    'path/to/validation/data',
    target_size=(224, 224),
    batch_size=32,
    class_mode='categorical'
)

# Train the model (initial training phase)
history = model.fit(
    train_generator,
    steps_per_epoch=train_generator.samples // 32,
    epochs=10,
    validation_data=validation_generator,
    validation_steps=validation_generator.samples // 32
)

# Fine-tuning phase
# Unfreeze the top layers of the base model
for layer in base_model.layers[-10:]:
    layer.trainable = True

# Recompile the model with a lower learning rate
model.compile(optimizer=Adam(learning_rate=1e-5), 
              loss='categorical_crossentropy', 
              metrics=['accuracy'])

# Continue training (fine-tuning)
history_fine = model.fit(
    train_generator,
    steps_per_epoch=train_generator.samples // 32,
    epochs=5,
    validation_data=validation_generator,
    validation_steps=validation_generator.samples // 32
)

# Save the fine-tuned model
model.save('fine_tuned_model.h5')

Ahora desglosamos este ejemplo:

Importación de Bibliotecas: Importamos los módulos necesarios de TensorFlow y Keras para construir y entrenar nuestro modelo.
Carga del Modelo Preentrenado: Cargamos el modelo ResNet50 preentrenado en ImageNet, excluyendo la capa superior. Esto nos permite usar los pesos preentrenados para la extracción de características mientras personalizamos la salida para nuestra tarea específica.
Congelación del Modelo Base: Inicialmente, congelamos todas las capas del modelo base para evitar que se actualicen durante la primera fase de entrenamiento. Esto preserva las valiosas características aprendidas de ImageNet.
Adición de Capas Personalizadas: Añadimos capas personalizadas sobre el modelo base, incluyendo una capa de Global Average Pooling, dos capas Dense con activación ReLU, una capa Dropout para regularización y una capa Dense final con activación softmax para la clasificación.
Compilación del Modelo: Compilamos el modelo con el optimizador Adam, la pérdida de entropía cruzada categórica (adecuada para la clasificación multiclase) y la métrica de precisión.
Aumento de Datos: Usamos ImageDataGenerator para el aumento de datos, lo que ayuda a prevenir el sobreajuste y mejora la generalización del modelo. Aplicamos varias transformaciones a los datos de entrenamiento, mientras que solo reescalamos los datos de validación.
Carga de Datos: Usamos flow_from_directory para cargar y preprocesar los datos directamente desde directorios. Esta es una forma conveniente de manejar grandes conjuntos de datos que no caben en la memoria.
Entrenamiento Inicial: Entrenamos el modelo durante 10 épocas utilizando el método fit. Los parámetros steps_per_epoch y validation_steps aseguran que usemos todos los datos disponibles en cada época.
Ajuste Fino: Después del entrenamiento inicial, descongelamos las últimas 10 capas del modelo base para el ajuste fino. Esto permite que el modelo adapte algunas de las características preentrenadas a nuestro conjunto de datos específico.
Recompilación: Recompilamos el modelo con una tasa de aprendizaje más baja (1e-5) para evitar cambios drásticos en los pesos preentrenados.
Entrenamiento de Ajuste Fino: Continuamos entrenando el modelo durante 5 épocas más, permitiendo que las capas descongeladas se adapten a nuestra tarea específica.
Guardar el Modelo: Finalmente, guardamos el modelo ajustado para su uso futuro.

Este enfoque para la transferencia de aprendizaje incluye aumento de datos, manejo adecuado de los datos de entrenamiento y validación, y un proceso de entrenamiento en dos etapas (entrenamiento inicial con capas base congeladas, seguido de ajuste fino). Este método probablemente producirá mejores resultados, especialmente cuando se trabaja con conjuntos de datos limitados o tareas que son significativamente diferentes de la clasificación de ImageNet.

7.3.5 Transferencia de Aprendizaje en PyTorch

Veamos ahora cómo realizar la transferencia de aprendizaje en PyTorch usando el modelo preentrenado ResNet18.

Ejemplo: Transferencia de Aprendizaje con ResNet18 en PyTorch

import torch
import torch.nn as nn
import torchvision.models as models
import torchvision.transforms as transforms
from torch.optim import Adam
from torch.utils.data import DataLoader
from torchvision.datasets import CIFAR10

# Set device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# Load the ResNet18 model pretrained on ImageNet
model = models.resnet18(pretrained=True)

# Freeze the pretrained layers
for param in model.parameters():
    param.requires_grad = False

# Replace the last fully connected layer with a new one for 10 classes (CIFAR10)
num_features = model.fc.in_features
model.fc = nn.Linear(num_features, 10)

# Move model to device
model = model.to(device)

# Define loss function and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = Adam(model.fc.parameters(), lr=0.001)

# Define data transformations
transform = transforms.Compose([
    transforms.Resize(224),  # ResNet18 expects 224x224 input
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

# Load CIFAR10 dataset
train_dataset = CIFAR10(root='./data', train=True, download=True, transform=transform)
test_dataset = CIFAR10(root='./data', train=False, download=True, transform=transform)

# Create data loaders
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

# Training loop
num_epochs = 10
for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    for i, (inputs, labels) in enumerate(train_loader):
        inputs, labels = inputs.to(device), labels.to(device)
        
        # Zero the parameter gradients
        optimizer.zero_grad()
        
        # Forward pass
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        
        # Backward pass and optimize
        loss.backward()
        optimizer.step()
        
        # Print statistics
        running_loss += loss.item()
        if i % 100 == 99:    # print every 100 mini-batches
            print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 100:.3f}')
            running_loss = 0.0

    # Validation
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for inputs, labels in test_loader:
            inputs, labels = inputs.to(device), labels.to(device)
            outputs = model(inputs)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

    print(f'Accuracy on test images: {100 * correct / total:.2f}%')

print('Finished Training')

# Save the model
torch.save(model.state_dict(), 'resnet18_cifar10.pth')

Ahora desglosamos este ejemplo:

Importación de Bibliotecas: Importamos los módulos necesarios de PyTorch, incluidos los modelos y las transformaciones de torchvision.
Configuración del Dispositivo: Configuramos el dispositivo para que sea la GPU si está disponible, de lo contrario, CPU. Esto permite un entrenamiento más rápido en hardware compatible.
Carga del Modelo Preentrenado: Cargamos el modelo ResNet18 preentrenado en ImageNet. Esto nos permite aprovechar la transferencia de aprendizaje.
Congelación del Modelo Base: Congelamos todas las capas del modelo base para evitar que se actualicen durante el entrenamiento. Esto preserva las valiosas características aprendidas de ImageNet.
Reemplazo de la Capa Final: Reemplazamos la última capa completamente conectada con una nueva que genera 10 clases, coincidiendo con el número de clases en CIFAR10.
Movimiento del Modelo al Dispositivo: Movemos el modelo al dispositivo seleccionado (GPU/CPU) para un cálculo eficiente.
Definición de la Pérdida y el Optimizador: Usamos CrossEntropyLoss como nuestra función de criterio y el optimizador Adam para actualizar los parámetros del modelo.
Transformaciones de Datos: Definimos transformaciones para cambiar el tamaño de las imágenes a 224x224 (como espera ResNet18), convertirlas en tensores y normalizarlas.
Carga del Conjunto de Datos: Cargamos el conjunto de datos CIFAR10, aplicando nuestras transformaciones definidas.
Creación de DataLoaders: Creamos objetos DataLoader tanto para los conjuntos de datos de entrenamiento como de prueba, que manejan el procesamiento por lotes y el barajado de datos.
Bucle de Entrenamiento: Iteramos sobre el conjunto de datos durante un número especificado de épocas. En cada época:
- Ponemos el modelo en modo de entrenamiento.
- Iteramos sobre los lotes, realizando pasos hacia adelante y hacia atrás, y actualizando los parámetros del modelo.
- Imprimimos la pérdida cada 100 lotes para monitorear el progreso del entrenamiento.
Validación: Después de cada época, evaluamos el modelo en el conjunto de prueba:
- Ponemos el modelo en modo de evaluación.
- Deshabilitamos el cálculo de gradientes para mayor eficiencia.
- Calculamos e imprimimos la precisión en el conjunto de prueba.
Guardar el Modelo: Después del entrenamiento, guardamos el diccionario de estado del modelo para su uso futuro.

Este ejemplo proporciona un enfoque integral para la transferencia de aprendizaje, que incluye un manejo adecuado de los datos, bucles de entrenamiento y validación, y el guardado del modelo. Demuestra cómo usar un modelo ResNet18 preentrenado y ajustarlo en el conjunto de datos CIFAR10, que es un referente común en tareas de visión por computadora.