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 optimizador | Características principales | Escenarios de aplicación |
|---|---|---|
| SGD | Simple y básico, admite momentum | Enseñanza básica, modelos simples, CNN |
| Adam | Tasa de aprendizaje adaptativa | La mayoría de las tareas de aprendizaje profundo |
| AdamW | Adam + weight decay separado | Tareas que requieren regularización L2 |
| RMSprop | Tasa de aprendizaje adaptativa | Redes RNN, reconocimiento de voz |
| Adagrad | Tasa de aprendizaje independiente por parámetro | Datos dispersos, procesamiento de texto |
| Adadelta | Tasa de aprendizaje adaptativa | Tareas 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.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
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
# 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
# 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
# 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
# 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
# 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
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
# 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
# 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
# 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.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 tarea | Optimizador recomendado | Tasa de aprendizaje recomendada | Notas |
|---|---|---|---|
| Clasificación de imágenes (CNN) | SGD + Momentum | 0.01 ~ 0.1 | Convergencia lenta pero alta precisión |
| Clasificación de imágenes (CNN) | AdamW | 0.001 | Convergencia rápida |
| NLP / Transformer | AdamW | 1e-5 ~ 1e-4 | Tasa de aprendizaje más pequeña |
| RNN / LSTM | RMSprop / Adam | 0.001 | Tasa de aprendizaje adaptativa |
| GAN | Adam (G) / Adam (D) | 0.0001 | Tasa de aprendizaje más pequeña |
| Aprendizaje por refuerzo | Adam / RMSprop | 0.0001 ~ 0.001 | Depende de la tarea específica |
| Experimentación rápida | Adam / AdamW | 0.001 | Convergencia rápida |
Comparación de rendimiento
| Optimizador | Velocidad de convergencia | Uso de memoria | Sensibilidad a hiperparámetros | Precisión final |
|---|---|---|---|---|
| SGD + Momentum | Lento | bajo | Alto | Alto |
| Adam | Rápido | Medio | bajo | Medio |
| AdamW | Rápido | Medio | bajo | Alto |
| RMSprop | Medio | Medio | Medio | Medio |
| Adagrad | Medio | Alto | Medio | bajo |
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