PyTorch torch.optim Módulo de optimizadores

El optimizador es un componente central en el aprendizaje profundo, responsable de ajustar los parámetros del modelo según el gradiente de la función de pérdida, permitiendo que el modelo se aproxime gradualmente a la solución óptima.

En PyTorch, el módulo torch.optim proporciona implementaciones de diversos algoritmos de optimización y es una herramienta indispensable para entrenar redes neuronales.


¿Por qué se necesita un optimizador?

El optimizador desempeña un papel crucial en el aprendizaje profundo, ya que resuelve el tedioso problema de actualizar los parámetros manualmente.

  • Actualización automática de parámetros: calcular y actualizar manualmente cada parámetro es muy tedioso; el optimizador realiza este trabajo automáticamente
  • Acelera la convergencia: el uso de algoritmos de optimización encuentra la solución óptima más rápido que el descenso de gradiente ordinario
  • Evita óptimos locales: algunos optimizadores tienen la capacidad de escapar de los óptimos locales

Tipos comunes de optimizadores

Diferentes optimizadores son adecuados para diferentes escenarios; elegir el optimizador adecuado puede mejorar significativamente el rendimiento del entrenamiento.

Nombre del optimizadorCaracterísticas principalesEscenarios de aplicación
SGDSimple y básico, admite momentumEnseñanza básica, modelos simples, CNN
AdamTasa de aprendizaje adaptativaLa mayoría de las tareas de aprendizaje profundo
AdamWAdam + weight decay separadoTareas que requieren regularización L2
RMSpropTasa de aprendizaje adaptativaRedes RNN, reconocimiento de voz
AdagradTasa de aprendizaje independiente por parámetroDatos dispersos, procesamiento de texto
AdadeltaTasa de aprendizaje adaptativaTareas de entrenamiento a largo plazo

API principal del optimizador

Dominar el flujo básico de uso del optimizador es el primer paso en el aprendizaje profundo.

Flujo básico de uso

El uso del optimizador sigue un patrón fijo: crear la instancia → vaciar los gradientes → propagación hacia atrás → actualizar los parámetros.

Ejemplo

import torch
import torch.nn as nn
import torch.optim as optim

# 1. Definir un modelo simple
class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Linear(784, 10)

    def forward(self, x):
        return self.fc(x)

model = SimpleNet()

# 2. Crear una instancia del optimizador
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 3. Bucle de entrenamiento
for epoch in range(epochs):
    # Propagación hacia adelante
    outputs = model(inputs)
    loss = criterion(outputs, labels)

    # Propagación hacia atrás
    optimizer.zero_grad()  # Vaciar la caché de gradientes para evitar la acumulación de gradientes
    loss.backward()        # Calcular los gradientes

    # Actualización de parámetros
    optimizer.step()       # Actualizar los parámetros

Descripción de métodos clave

El optimizador proporciona varios métodos centrales para gestionar el proceso de actualización de parámetros.

  • zero_grad(set_to_none=True): vacía la caché de gradientes de los parámetros. Al establecerlo en True, los gradientes se establecen en None, lo que ahorra más memoria de video que establecerlos en 0
  • step(): ejecuta una actualización de parámetros, actualizando los parámetros del modelo según el gradiente y la tasa de aprendizaje
  • state_dict(): obtiene el diccionario de estado del optimizador, útil para guardar checkpoints
  • load_state_dict(state_dict): carga el estado del optimizador para reanudar el entrenamiento
  • add_param_group(param_group): añade dinámicamente grupos de parámetros

Nota: se debe llamar a zero_grad() antes de cada propagación hacia atrás; de lo contrario, los gradientes se acumularán, causando inestabilidad en el entrenamiento. Se recomienda usar zero_grad(set_to_none=True) para ahorrar memoria de video.

Guardar y cargar el estado del optimizador

Al reanudar el entrenamiento, es necesario guardar tanto el estado del modelo como el del optimizador.

Ejemplo

# Guardar el checkpoint (guardar modelo, optimizador y scheduler simultáneamente)
checkpoint = {
    'epoch': epoch,
    'model_state_dict': model.state_dict(),
    'optimizer_state_dict': optimizer.state_dict(),
    'scheduler_state_dict': scheduler.state_dict(),
    'loss': loss,
}
torch.save(checkpoint, 'checkpoint.pth')

# Cargar el checkpoint
checkpoint = torch.load('checkpoint.pth')
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
scheduler.load_state_dict(checkpoint['scheduler_state_dict'])
start_epoch = checkpoint['epoch'] + 1

Explicación detallada de optimizadores comunes

SGD (descenso de gradiente estocástico)

SGD es el algoritmo de optimización más básico; actualiza los parámetros calculando el gradiente de una sola muestra o de un mini-lote de muestras. Es la piedra angular de la optimización en el aprendizaje profundo, y muchos optimizadores avanzados se han desarrollado a partir de SGD.

Ejemplo

# Descripción de los parámetros del optimizador SGD
# params: parámetros a optimizar (generalmente provienen de model.parameters())
# lr: tasa de aprendizaje, controla el tamaño del paso en la actualización de parámetros, por defecto 0.01
# momentum: factor de momento, utilizado para acelerar la convergencia y reducir las oscilaciones, por defecto 0
# weight_decay: coeficiente de regularización L2, utilizado para evitar el sobreajuste, por defecto 0
# dampening: amortiguación del momento, controla el cálculo del término de momento, por defecto 0
# nesterov: si usar el momentum de Nesterov, por defecto False
optimizer = optim.SGD(
    params=model.parameters(),
    lr=0.01,           # Tasa de aprendizaje
    momentum=0.9,      # Factor de momento
    weight_decay=1e-4, # Regularización L2
    nesterov=True      # Habilitar el momentum de Nesterov
)

Descripción de los parámetros clave:

  • lr (float): tasa de aprendizaje, controla el tamaño del paso en la actualización de parámetros
  • momentum (float): factor de momento, utilizado para acelerar la convergencia y reducir oscilaciones, valor común 0.9
  • weight_decay (float): coeficiente de regularización L2, utilizado para evitar el sobreajuste, valor común 1e-4
  • nesterov (bool): si usar el momentum de Nesterov, al habilitarlo se reducen las oscilaciones

Características:

  • Implementación simple, es el algoritmo base de la optimización en el aprendizaje profundo
  • Añadir el término de momento puede acelerar la convergencia y mejorar la estabilidad del entrenamiento
  • La convergencia es más lenta, pero la precisión final puede ser mayor
  • Adecuado como referencia para comparar con otros optimizadores

Aunque SGD es simple, con hiperparámetros adecuados suele lograr muy buenos resultados y es un excelente punto de partida para aprender algoritmos de optimización. En tareas de clasificación de imágenes, SGD junto con momentum sigue siendo la opción dominante.

Adam (estimación adaptativa de momentos)

Adam es uno de los optimizadores más utilizados actualmente; combina las ventajas del momentum y la tasa de aprendizaje adaptativa. Ajusta adaptativamente la tasa de aprendizaje de cada parámetro calculando las estimaciones de primer y segundo momento del gradiente.

Ejemplo

# Descripción de los parámetros del optimizador Adam
# params: parámetros a optimizar
# lr: tasa de aprendizaje, por defecto 0.001 (valor recomendado)
# betas: coeficientes de media móvil para calcular el gradiente y el gradiente al cuadrado (beta1, beta2)
# beta1 controla la estimación del primer momento (momentum), por defecto 0.9
# beta2 controla la estimación del segundo momento (varianza), por defecto 0.999
# eps: término de estabilidad numérica, evita errores de división por cero, por defecto 1e-8
# weight_decay: coeficiente de regularización L2, por defecto 0
# amsgrad: si usar la variante AMSGrad, por defecto False
optimizer = optim.Adam(
    params=model.parameters(),
    lr=0.001,                      # Se recomienda usar una tasa de aprendizaje más pequeña
    betas=(0.9, 0.999),            # Parámetros de momentum comunes
    eps=1e-8,                      # Término de estabilidad numérica
    weight_decay=1e-4,             # Regularización L2
    amsgrad=False                  # Si usar AMSGrad
)

Descripción de los parámetros clave:

  • betas (Tuple[float, float]): controlan la media móvil exponencial del gradiente y del gradiente al cuadrado
  • eps (float): término de estabilidad numérica, evita que el denominador sea cero
  • amsgrad (bool): si usar la variante AMSGrad; al usarla se garantiza la convergencia

Características:

  • Tasa de aprendizaje adaptativa: ajusta automáticamente la tasa de aprendizaje según el gradiente histórico del parámetro
  • Incorpora el concepto de momentum: utiliza la estimación del primer momento para acelerar la convergencia
  • Alta robustez: relativamente insensible a la elección de hiperparámetros
  • Convergencia rápida, adecuado para el desarrollo rápido de prototipos

Adam es la opción predeterminada en la mayoría de las tareas de aprendizaje profundo, pero en ciertos escenarios específicos (como GAN, aprendizaje por refuerzo) puede ser necesario probar otros optimizadores.

AdamW(Adam with Weight Decay)

AdamW es una versión mejorada de Adam, que desacopla la reducción de peso de la actualización del gradiente, lo que teóricamente favorece la convergencia. En la práctica, AdamW suele funcionar mejor que Adam.

Ejemplo

# Optimizador AdamW
# Diferencia principal con Adam: la forma de implementar weight_decay es diferente
# La reducción de peso de AdamW es más correcta y no afecta el cálculo del gradiente
optimizer = optim.AdamW(
    params=model.parameters(),
    lr=0.001,
    betas=(0.9, 0.999),
    weight_decay=0.01,    # Coeficiente de reducción de peso, normalmente se configura más grande que en Adam
    amsgrad=False
)

# Configuración recomendada: AdamW normalmente usa un weight_decay de 0.01
# Mientras que Adam normalmente usa 0.001

Si tu tarea requiere usar reducción de peso (regularización L2), se recomienda encarecidamente usar AdamW en lugar de Adam.

RMSprop

RMSprop es un optimizador de tasa de aprendizaje adaptativa, especialmente adecuado para manejar objetivos no estacionarios y redes neuronales recurrentes.

Ejemplo

# Optimizador RMSprop
# Normaliza la tasa de aprendizaje dividiendo por el promedio ponderado exponencial del gradiente
optimizer = optim.RMSprop(
    params=model.parameters(),
    lr=0.01,               # Tasa de aprendizaje
    alpha=0.99,            # Tasa de decaimiento exponencial del gradiente al cuadrado
    eps=1e-8,              # Término de estabilidad numérica
    weight_decay=0,        # Regularización L2
    momentum=0,            # Factor de momento
    centered=False         # Si se centra el gradiente
)

Adagrad

Adagrad es adecuado para manejar datos dispersos; ajusta adaptativamente la tasa de aprendizaje para cada parámetro.

Ejemplo

# Optimizador Adagrad
# Adecuado para optimización con datos dispersos; usa una tasa de aprendizaje más pequeña para los parámetros actualizados con frecuencia
optimizer = optim.Adagrad(
    params=model.parameters(),
    lr=0.01,               # Tasa de aprendizaje
    lr_decay=0,            # Decaimiento de la tasa de aprendizaje
    weight_decay=0,       # Regularización L2
    initial_accumulator_value=0  # Valor acumulado inicial
)

Técnicas avanzadas de optimizadores

Programación de la tasa de aprendizaje

La programación de la tasa de aprendizaje permite ajustar dinámicamente la tasa de aprendizaje durante el entrenamiento, lo que generalmente puede mejorar significativamente la convergencia del modelo.

Ejemplo: múltiples programadores de tasa de aprendizaje

from torch.optim.lr_scheduler import (
    StepLR,                # Decaimiento por pasos
    MultiStepLR,           # Decaimiento por múltiples hitos
    ExponentialLR,         # Decaimiento exponencial
    CosineAnnealingLR,     # Recocido por coseno
    ReduceLROnPlateau,     # Ajuste automático basado en métricas
)

# Método 1: StepLR - decae cada 30 épocas
optimizer = optim.SGD(model.parameters(), lr=0.1)
scheduler = StepLR(optimizer, step_size=30, gamma=0.1)

# Método 2: MultiStepLR - decae en épocas específicas
optimizer = optim.SGD(model.parameters(), lr=0.1)
scheduler = MultiStepLR(optimizer, milestones=[30, 60, 80], gamma=0.1)

# Método 3: CosineAnnealingLR - recocido con curva de coseno
optimizer = optim.Adam(model.parameters(), lr=0.001)
scheduler = CosineAnnealingLR(optimizer, T_max=50, eta_min=1e-6)

# Método 4: ReduceLROnPlateau - ajuste automático monitoreando métricas
optimizer = optim.Adam(model.parameters(), lr=0.001)
scheduler = ReduceLROnPlateau(
    optimizer, mode='min',     # Monitorear loss
    factor=0.5,                 # Coeficiente de decaimiento
    patience=5,                 # Número de épocas de espera
    verbose=True                # Información de impresión
)

# Bucle de entrenamiento
for epoch in range(100):
    train_loss = train(...)
    val_loss = validate(...)

    # Programadores como StepLR
    scheduler.step()

    # ReduceLROnPlateau necesita recibir la métrica monitoreada
    scheduler.step(val_loss)

El programador de tasa de aprendizaje debe usarse junto con el optimizador; step() debe llamarse después de optimizer.step(); de lo contrario, puede causar actualizaciones anómalas de la tasa de aprendizaje.

Optimización con agrupación de parámetros

La agrupación de parámetros permite establecer diferentes tasas de aprendizaje para diferentes capas, lo cual es especialmente útil en el aprendizaje por transferencia.

Ejemplo

# Ejemplo de optimización por agrupación de parámetros
# Establecer diferentes tasas de aprendizaje para diferentes capas
# Normalmente: la red troncal usa una tasa de aprendizaje más pequeña, la cabeza de clasificación usa una tasa de aprendizaje más grande
optimizer = optim.SGD([
    {'params': model.base.parameters(), 'lr': 1e-3},      # Capa base: tasa de aprendizaje grande
    {'params': model.classifier.parameters(), 'lr': 1e-2} # Capa de clasificación: tasa de aprendizaje grande
], lr=1e-4)  # Tasa de aprendizaje global predeterminada (usada cuando no se especifica un grupo de parámetros)

# Forma más común en aplicaciones reales
optimizer = optim.Adam([
    {'params': model.fc.parameters(), 'lr': 1e-3},       # Cabeza de clasificación
    {'params': [p for n, p in model.named_parameters()    # Red troncal
                if not n.startswith('fc')],
     'lr': 1e-5},
])

Recorte de gradientes

El recorte de gradiente puede prevenir la explosión del gradiente y mejorar la estabilidad del entrenamiento. Es especialmente útil en redes profundas como RNN, LSTM, etc.

Ejemplo

import torch.nn as nn

# Ejemplo de recorte de gradiente
# max_norm: norma máxima del gradiente; los gradientes que superen este valor se escalan
# norm_type: tipo de norma, por defecto 2 (norma euclidiana)
nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

# Ubicación de uso en el bucle de entrenamiento
for epoch in range(epochs):
    optimizer.zero_grad()
    outputs = model(inputs)
    loss = criterion(outputs, labels)
    loss.backward()

    # Recortar el gradiente después de loss.backward() y antes de optimizer.step()
    nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

    optimizer.step()

# Otra forma de recorte de gradiente: recorte por valor
for param in model.parameters():
    if param.grad is not None:
        param.grad.data.clamp_(min=-1.0, max=1.0)

El recorte de gradiente es una técnica común para entrenar redes neuronales profundas (especialmente RNN, LSTM, etc.) que puede prevenir eficazmente el colapso del entrenamiento causado por la explosión del gradiente.

Acumulación de gradientes

Cuando la memoria de video es insuficiente, se puede simular el efecto de entrenamiento de un tamaño de batch grande mediante la acumulación de gradientes.

Ejemplo

# Ejemplo de acumulación de gradientes
# batch_size real = batch_size * accumulation_steps
accumulation_steps = 4   # Acumular 4 batches pequeños

optimizer.zero_grad()

for i, (inputs, labels) in enumerate(train_loader):
    outputs = model(inputs)
    loss = criterion(outputs, labels)

    # Dividir la pérdida entre el número de pasos de acumulación para promediar
    loss = loss / accumulation_steps
    loss.backward()

    # Actualizar los parámetros cada vez que se acumulan los pasos especificados
    if (i + 1) % accumulation_steps == 0:
        nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
        optimizer.step()
        optimizer.zero_grad()

# Procesar los gradientes restantes
if (i + 1) % accumulation_steps != 0:
    optimizer.step()
    optimizer.zero_grad()

Ejemplo completo de entrenamiento

A continuación se muestra un flujo de entrenamiento completo que demuestra las mejores prácticas con optimizadores.

Ejemplo

import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim.lr_scheduler import CosineAnnealingLR

# Configuración
DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
EPOCHS = 100
BATCH_SIZE = 32
LR = 1e-3

# Crear el modelo y moverlo al dispositivo
model = SimpleNet().to(DEVICE)

# Función de pérdida y optimizador
criterion = nn.CrossEntropyLoss()
optimizer = optim.AdamW(model.parameters(), lr=LR, weight_decay=0.01)

# Programador de tasa de aprendizaje (recocido por coseno)
scheduler = CosineAnnealingLR(optimizer, T_max=EPOCHS, eta_min=1e-6)

# Bucle de entrenamiento
best_acc = 0.0
for epoch in range(EPOCHS):
    model.train()
    total_loss = 0.0
    correct = 0

    for inputs, labels in train_loader:
        inputs = inputs.to(DEVICE)
        labels = labels.to(DEVICE)

        # Limpiar gradientes (se recomienda usar set_to_none=True)
        optimizer.zero_grad(set_to_none=True)

        # Propagación hacia adelante
        outputs = model(inputs)
        loss = criterion(outputs, labels)

        # Propagación hacia atrás
        loss.backward()

        # Recorte de gradiente (previene la explosión del gradiente)
        nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

        # Actualizar parámetros
        optimizer.step()

        # Estadísticas
        total_loss += loss.item()
        correct += (outputs.argmax(1) == labels).sum().item()

    # Actualizar la tasa de aprendizaje
    scheduler.step()

    # Imprimir información del entrenamiento
    avg_loss = total_loss / len(train_loader)
    accuracy = correct / len(train_loader.dataset)
    current_lr = scheduler.get_last_lr()[0]
    print(f"Epoch {epoch+1}/{EPOCHS} | Loss: {avg_loss:.4f} | "
          f"Acc: {accuracy:.4f} | LR: {current_lr:.6f}")

    # Guardar el mejor modelo
    if accuracy > best_acc:
        best_acc = accuracy
        torch.save({
            'epoch': epoch,
            'model_state_dict': model.state_dict(),
            'optimizer_state_dict': optimizer.state_dict(),
            'scheduler_state_dict': scheduler.state_dict(),
            'best_acc': best_acc,
        }, 'best_model.pth')

print(f"Entrenamiento completado, mejor precisión: {best_acc:.4f}")

Guía para elegir optimizador

Elegir el optimizador adecuado depende de la tarea específica, las características de los datos y la etapa de entrenamiento.

Selección según la tarea

Diferentes tipos de tareas tienen diferentes recomendaciones de optimizadores.

Tipo de tareaOptimizador recomendadoTasa de aprendizaje recomendadaNotas
Clasificación de imágenes (CNN)SGD + Momentum0.01 ~ 0.1Convergencia lenta pero alta precisión
Clasificación de imágenes (CNN)AdamW0.001Convergencia rápida
NLP / TransformerAdamW1e-5 ~ 1e-4Tasa de aprendizaje más pequeña
RNN / LSTMRMSprop / Adam0.001Tasa de aprendizaje adaptativa
GANAdam (G) / Adam (D)0.0001Tasa de aprendizaje más pequeña
Aprendizaje por refuerzoAdam / RMSprop0.0001 ~ 0.001Depende de la tarea específica
Experimentación rápidaAdam / AdamW0.001Convergencia rápida

Comparación de rendimiento

OptimizadorVelocidad de convergenciaUso de memoriaSensibilidad a hiperparámetrosPrecisión final
SGD + MomentumLentobajoAltoAlto
AdamRápidoMediobajoMedio
AdamWRápidoMediobajoAlto
RMSpropMedioMedioMedioMedio
AdagradMedioAltoMediobajo

Problemas comunes y soluciones

  • Entrenamiento inestable (fluctuación de loss): reducir la tasa de aprendizaje, añadir recorte de gradiente
  • Convergencia demasiado lenta: usar Adam o AdamW, aumentar la tasa de aprendizaje
  • Sobreajuste: aumentar weight_decay, usar regularización
  • Memoria de video insuficiente: reducir batch_size, usar acumulación de gradientes

La elección del optimizador no es absoluta; se recomienda comenzar con Adam o AdamW y, si el resultado no es bueno, considerar otros optimizadores. Para tareas específicas, puede ser necesario determinar la opción óptima mediante experimentos.

Si necesitas información más detallada, puedes consultarDocumentación oficial de PyTorch。

Otras extensiones