Evaluación y depuración de modelos PyTorch
El entrenamiento y la optimización de modelos de aprendizaje profundo requieren métodos sistemáticos de evaluación y depuración. Esta sección presenta cómo analizar la curva de Loss, identificar sobreajuste y subajuste, usar la matriz de confusión para evaluar modelos de clasificación, y técnicas comunes de depuración.
1. Análisis de la función de pérdida (Loss)
La función de pérdida es la métrica central durante el entrenamiento; refleja la diferencia entre las predicciones del modelo y los valores reales. Analizar correctamente la curva de Loss es clave para depurar el modelo.
1.1 Comparación de Loss de entrenamiento y validación
Al comparar el Loss de entrenamiento y el Loss de validación, se puede determinar el estado del modelo:
- El Loss de entrenamiento disminuye, el Loss de validación disminuye: Normal, indica que el modelo está aprendiendo
- El Loss de entrenamiento disminuye, el Loss de validación se mantiene estable o aumenta: Sobreajuste, se necesita regularización
- El Loss de entrenamiento no disminuye: Problema de tasa de aprendizaje o problema de arquitectura del modelo
- El Loss de entrenamiento oscila: La tasa de aprendizaje es demasiado alta o el batch size es demasiado pequeño
1.2 Visualización de la curva de Loss
Ejemplo
import numpy as np
def plot_training_history(history):
"""
Trazar el historial de entrenamiento
history: diccionario que contiene 'train_loss', 'val_loss', 'train_acc', 'val_acc'
"""
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
# Curva de Loss
axes[0].plot(history['train_loss'], label='Train Loss', alpha=0.8)
axes[0].plot(history['val_loss'], label='Val Loss', alpha=0.8)
axes[0].set_xlabel('Epoch')
axes[0].set_ylabel('Loss')
axes[0].set_title('Training and Validation Loss')
axes[0].legend()
axes[0].grid(True, alpha=0.3)
# Curva de Accuracy
axes[1].plot(history['train_acc'], label='Train Acc', alpha=0.8)
axes[1].plot(history['val_acc'], label='Val Acc', alpha=0.8)
axes[1].set_xlabel('Epoch')
axes[1].set_ylabel('Accuracy')
axes[1].set_title('Training and Validation Accuracy')
axes[1].legend()
axes[1].grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
# Simular datos de entrenamiento
history = {
'train_loss': np.linspace(2.0, 0.2, 50) + np.random.normal(0, 0.05, 50),
'val_loss': np.linspace(2.0, 0.3, 50) + np.random.normal(0, 0.08, 50),
'train_acc': np.linspace(0.3, 0.95, 50),
'val_acc': np.linspace(0.3, 0.88, 50),
}
plot_training_history(history)
1.3 Identificación del sobreajuste
Cuando el Loss de validación comienza a aumentar mientras el Loss de entrenamiento continúa descendiendo, es el inicio del sobreajuste. En ese momento, el modelo comienza a 'memorizar' los datos de entrenamiento, en lugar de aprender patrones generales.
Ejemplo
import numpy as np
def detect_overfitting(history, patience=5):
"""
Detectar sobreajuste
patience: número de epochs consecutivos con el loss de validación en aumento antes de detener el entrenamiento
"""
val_loss = history['val_loss']
best_loss = float('inf')
best_epoch = 0
early_stop_epoch = None
for epoch in range(patience, len(val_loss)):
# Revisar los últimos patience epochs
recent_losses = val_loss[epoch - patience:epoch]
current_loss = val_loss[epoch]
# Si el loss actual es mayor que el loss mínimo reciente
if min(recent_losses) < current_loss:
early_stop_epoch = epoch
break
if current_loss < best_loss:
best_loss = current_loss
best_epoch = epoch
if early_stop_epoch:
print(f"¡Sobreajuste detectado! Mejor epoch: {best_epoch}, se debe detener en el epoch {early_stop_epoch}")
else:
print("No se detectó sobreajuste")
return early_stop_epoch, best_epoch
# Ejemplo de sobreajuste
overfitting_history = {
'train_loss': np.linspace(1.5, 0.1, 30),
'val_loss': np.concatenate([np.linspace(1.5, 0.3, 15), np.linspace(0.3, 0.8, 15)]),
}
detect_overfitting(overfitting_history)
2. Manejo del sobreajuste y el subajuste
2.1 Soluciones para el sobreajuste
| Método | Descripción | Implementación en código |
|---|---|---|
| Aumentar la cantidad de datos | Recopilar más datos de entrenamiento | Aumento de datos |
| Dropout | Desactivar neuronas aleatoriamente | nn.Dropout(0.5) |
| Decaimiento de pesos | Regularización L2 | weight_decay=1e-4 |
| Parada temprana (Early Stopping) | Detener el entrenamiento cuando el loss de validación deja de disminuir | Parámetro patience |
| Reducir la complejidad del modelo | Reducir el número de capas o neuronas | Reducir hidden_size |
| Aumento de datos | Transformaciones aleatorias para aumentar la diversidad de los datos | Rotación, volteo, recorte |
2.2 Soluciones para el subajuste
| Método | Descripción |
|---|---|
| Aumentar la complejidad del modelo | Aumentar el número de capas o la cantidad de neuronas |
| Entrenar durante más tiempo | Aumentar el número de epochs de entrenamiento |
| Reducir la regularización | Reducir Dropout o weight_decay |
| Ajustar la tasa de aprendizaje | Probar una tasa de aprendizaje mayor |
2.3 Implementación del mecanismo de parada temprana
Ejemplo
import torch.nn as nn
import torch.optim as optim
class EarlyStopping:
"""
Mecanismo de parada temprana: detener el entrenamiento cuando el loss de validación no disminuye de forma consecutiva
"""
def __init__(self, patience=7, min_delta=0, mode='min'):
"""
patience: número de epochs consecutivos sin mejora antes de detenerse
min_delta: cambio mínimo que se considera una mejora
mode: 'min' o 'max', si la métrica es mejor cuanto más pequeña o más grande
"""
self.patience = patience
self.min_delta = min_delta
self.mode = mode
self.counter = 0
self.best_score = None
self.early_stop = False
def __call__(self, val_loss):
score = -val_loss if self.mode == 'min' else val_loss
if self.best_score is None:
self.best_score = score
elif score < self.best_score + self.min_delta:
self.counter += 1
if self.counter >= self.patience:
self.early_stop = True
else:
self.best_score = score
self.counter = 0
return self.early_stop
# Usar parada temprana
def train_with_early_stopping(model, train_loader, val_loader, patience=7):
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)
early_stopping = EarlyStopping(patience=patience, mode='min')
best_val_loss = float('inf')
best_model_state = None
for epoch in range(100):
# Entrenamiento
model.train()
train_loss = 0
for inputs, labels in train_loader:
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
train_loss += loss.item()
# Validación
model.eval()
val_loss = 0
with torch.no_grad():
for inputs, labels in val_loader:
inputs, labels = inputs.to(device), labels.to(device)
outputs = model(inputs)
loss = criterion(outputs, labels)
val_loss += loss.item()
val_loss /= len(val_loader)
print(f"Epoch {epoch+1}: Train Loss={train_loss:.4f}, Val Loss={val_loss:.4f}")
# Verificación de parada temprana
if early_stopping(val_loss):
print(f"¡Parada temprana activada! El loss de validación no ha disminuido durante {patience} epochs consecutivos")
# Guardar el mejor modelo
if val_loss < best_val_loss:
best_val_loss = val_loss
best_model_state = model.state_dict().copy()
# Restaurar el mejor modelo
model.load_state_dict(best_model_state)
return model
3. Matriz de confusión (Confusion Matrix)
La matriz de confusión es una herramienta importante para evaluar modelos de clasificación; muestra la relación entre las predicciones del modelo y las etiquetas reales.
3.1 Cálculo de la matriz de confusión
Ejemplo
import numpy as np
from sklearn.metrics import confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns
def calculate_confusion_matrix(model, dataloader, device, num_classes):
"""
Calcular la matriz de confusión
"""
model.eval()
all_preds = []
all_labels = []
with torch.no_grad():
for inputs, labels in dataloader:
inputs = inputs.to(device)
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
all_preds.extend(preds.cpu().numpy())
all_labels.extend(labels.numpy())
cm = confusion_matrix(all_labels, all_preds)
return cm
def plot_confusion_matrix(cm, class_names):
"""
Trazar la matriz de confusión
"""
plt.figure(figsize=(10, 8))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
xticklabels=class_names, yticklabels=class_names)
plt.xlabel('Predicted Label')
plt.ylabel('True Label')
plt.title('Confusion Matrix')
plt.tight_layout()
plt.show()
# Ejemplo de uso
# Supongamos que hay 10 clases
class_names = [f'Class {i}' for i in range(10)]
cm = np.array([
[45, 1, 0, 0, 0, 0, 2, 1, 1, 0],
[0, 42, 2, 0, 0, 0, 0, 3, 2, 1],
[1, 1, 38, 3, 0, 0, 0, 2, 3, 2],
[0, 0, 1, 41, 2, 1, 0, 1, 1, 3],
[0, 0, 0, 1, 44, 0, 1, 0, 2, 2],
[1, 0, 0, 0, 0, 43, 2, 1, 1, 2],
[2, 1, 0, 0, 1, 1, 39, 2, 2, 2],
[0, 2, 1, 1, 0, 0, 1, 40, 3, 2],
[1, 2, 2, 0, 1, 1, 1, 2, 36, 4],
[0, 1, 1, 2, 2, 2, 2, 1, 2, 37],
])
plot_confusion_matrix(cm, class_names)
3.2 Métricas de evaluación de clasificación
A partir de la matriz de confusión se pueden calcular varias métricas de evaluación:
Ejemplo
def classification_metrics(cm):
"""
Calcular varias métricas de evaluación a partir de la matriz de confusión
"""
# Exactitud (Accuracy)
accuracy = np.trace(cm) / np.sum(cm)
# Calcular precisión, recall y F1 para cada clase
num_classes = cm.shape[0]
precisions = []
recalls = []
f1s = []
for i in range(num_classes):
tp = cm[i, i]
fp = np.sum(cm[:, i]) - tp
fn = np.sum(cm[i, :]) - tp
precision = tp / (tp + fp) if (tp + fp) > 0 else 0
recall = tp / (tp + fn) if (tp + fn) > 0 else 0
f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
precisions.append(precision)
recalls.append(recall)
f1s.append(f1)
# Promedio macro (Macro Average)
macro_precision = np.mean(precisions)
macro_recall = np.mean(recalls)
macro_f1 = np.mean(f1s)
# Promedio ponderado (Weighted Average)
class_counts = np.sum(cm, axis=1)
weights = class_counts / np.sum(class_counts)
weighted_precision = np.average(precisions, weights=weights)
weighted_recall = np.average(recalls, weights=weights)
weighted_f1 = np.average(f1s, weights=weights)
return {
'accuracy': accuracy,
'macro_precision': macro_precision,
'macro_recall': macro_recall,
'macro_f1': macro_f1,
'weighted_precision': weighted_precision,
'weighted_recall': weighted_recall,
'weighted_f1': weighted_f1,
}
# Calcular métricas
metrics = classification_metrics(cm)
print("=" * 50)
print("Métricas de evaluación de clasificación")
print("=" * 50)
print(f"Exactitud (Accuracy): {metrics['accuracy']:.4f}")
print(f"Precisión macro (Macro Precision): {metrics['macro_precision']:.4f}")
print(f"Recall macro (Macro Recall): {metrics['macro_recall']:.4f}")
print(f"F1 macro (Macro F1): {metrics['macro_f1']:.4f}")
print(f"Precisión ponderada (Weighted Precision): {metrics['weighted_precision']:.4f}")
print(f"Recall ponderado (Weighted Recall): {metrics['weighted_recall']:.4f}")
print(f"F1 ponderado (Weighted F1): {metrics['weighted_f1']:.4f}")
3.3 Informe de clasificación
Ejemplo
# Usar el informe de clasificación de sklearn
y_true = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] * 10 # Simular etiquetas reales
y_pred = [0, 1, 2, 3, 4, 5, 6, 7, 8, 8] * 10 # Simular predicciones
report = classification_report(y_true, y_pred, digits=4)
print(report)
4. Programación de la tasa de aprendizaje
La tasa de aprendizaje es uno de los hiperparámetros más importantes en el entrenamiento de modelos de aprendizaje profundo. Una programación adecuada de la tasa de aprendizaje puede mejorar significativamente el rendimiento del entrenamiento.
4.1 Estrategias de programación de la tasa de aprendizaje
| Estrategia | Descripción | Escenarios aplicables |
|---|---|---|
| StepLR | Decaimiento de paso fijo | Cuando se conoce la tasa de aprendizaje óptima |
| MultiStepLR | Decaimiento en épocas específicas | Decaimiento no uniforme |
| CosineAnnealingLR | Recocido coseno | Convergencia suave |
| ReduceLROnPlateau | Decaimiento cuando la pérdida de validación no disminuye | Ajuste automático |
| Warmup | Primero aumentar y luego disminuir | Estabilizar el inicio del entrenamiento |
4.2 Implementación de la programación de la tasa de aprendizaje
Ejemplo
import torch.optim as optim
import matplotlib.pyplot as plt
# Simular épocas de entrenamiento
epochs = 50
# 1. Step LR: decae a la mitad cada 10 épocas
scheduler_step = optim.lr_scheduler.StepLR(
optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1),
step_size=10, gamma=0.5
)
# 2. MultiStep LR: decae en épocas específicas
scheduler_multistep = optim.lr_scheduler.MultiStepLR(
optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1),
milestones=[15, 30, 45], gamma=0.1
)
# 3. Cosine Annealing
scheduler_cosine = optim.lr_scheduler.CosineAnnealingLR(
optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1),
T_max=50
)
# 4. ReduceLROnPlateau
scheduler_plateau = optim.lr_scheduler.ReduceLROnPlateau(
optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1),
mode='min', factor=0.5, patience=5
)
# Dibujar la curva de tasa de aprendizaje
fig, axes = plt.subplots(2, 2, figsize=(14, 10))
# Step LR
lr_history = []
for _ in range(epochs):
lr_history.append(optimizer.param_groups[0]['lr'])
scheduler_step.step()
axes[0, 0].plot(lr_history)
axes[0, 0].set_title('Step LR')
# Reinicializar
optimizer = optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1)
scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=[15, 30, 45], gamma=0.1)
lr_history = []
for _ in range(epochs):
lr_history.append(optimizer.param_groups[0]['lr'])
scheduler.step()
axes[0, 1].plot(lr_history)
axes[0, 1].set_title('MultiStep LR')
# Cosine
optimizer = optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1)
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)
lr_history = []
for _ in range(epochs):
lr_history.append(optimizer.param_groups[0]['lr'])
scheduler.step()
axes[1, 0].plot(lr_history)
axes[1, 0].set_title('Cosine Annealing LR')
# Warmup + Cosine
def warmup_cosine(optimizer, warmup_epochs, total_epochs, min_lr=1e-6):
def lr_lambda(epoch):
if epoch < warmup_epochs:
return epoch / warmup_epochs
return min_lr + 0.5 * (1 - min_lr) * (1 + np.cos(np.pi * (epoch - warmup_epochs) / (total_epochs - warmup_epochs)))
return optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)
optimizer = optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1)
scheduler = warmup_cosine(optimizer, warmup_epochs=5, total_epochs=50)
lr_history = []
for _ in range(epochs):
lr_history.append(optimizer.param_groups[0]['lr'])
scheduler.step()
axes[1, 1].plot(lr_history)
axes[1, 1].set_title('Warmup + Cosine')
for ax in axes.flat:
ax.set_xlabel('Epoch')
ax.set_ylabel('Learning Rate')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
5. Diagnóstico de problemas de gradiente
5.1 Desvanecimiento y explosión de gradientes
import torch.nn as nn
def analyze_gradients(model):
"""
Analizar los gradientes de cada capa del modelo
"""
grad_stats = {}
for name, param in model.named_parameters():
if param.grad is not None:
grad = param.grad
grad_stats[name] = {
'mean': grad.mean().item(),
'std': grad.std().item(),
'max': grad.abs().max().item(),
'min': grad.abs().min().item(),
'norm': grad.norm().item(),
}
return grad_stats
def detect_gradient_issues(model):
"""
Detectar problemas de gradientes
"""
issues = []
grad_norms = []
for param in model.parameters():
if param.grad is not None:
grad_norms.append(param.grad.norm().item())
avg_grad_norm = sum(grad_norms) / len(grad_norms) if grad_norms else 0
if avg_grad_norm < 1e-7:
issues.append("Desvanecimiento de gradiente: el gradiente es demasiado pequeño, el modelo puede no aprender")
elif avg_grad_norm > 100:
issues.append("Explosión de gradiente: el gradiente es demasiado grande, el entrenamiento es inestable")
return issues, avg_grad_norm
# Ejemplo: detectar gradientes
model = nn.Sequential(
nn.Linear(100, 50),
nn.ReLU(),
nn.Linear(50, 50),
nn.ReLU(),
nn.Linear(50, 10)
)
# Simular propagación hacia adelante y hacia atrás
x = torch.randn(32, 100)
y = model(x)
loss = y.sum()
loss.backward()
issues, avg_norm = detect_gradient_issues(model)
print(f"Norma media del gradiente: {avg_norm:.6f}")
if issues:
for issue in issues:
print(f"Advertencia: {issue}")
else:
print("Estado del gradiente normal")
5.2 Recorte de gradientes
Ejemplo
import torch.nn as nn
import torch.optim as optim
import torch.nn.utils as utils
# Ejemplo de recorte de gradientes
def train_with_gradient_clipping(model, dataloader, max_norm=1.0):
"""
Entrenar con recorte de gradientes
max_norm: norma máxima del gradiente; los gradientes que superen este valor serán recortados
"""
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)
model.train()
for inputs, labels in dataloader:
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
# Recorte de gradientes: evita la explosión de gradientes
utils.clip_grad_norm_(model.parameters(), max_norm=max_norm)
optimizer.step()
return model
# Recorte elemento a elemento (más conservador)
def clip_grad_by_value(model, clip_value=1.0):
"""
Recortar gradientes por valor
"""
for param in model.parameters():
if param.grad is not None:
param.grad.data.clamp_(min=-clip_value, max=clip_value)
6. Análisis de rendimiento del modelo
6.1 Cálculo del número de parámetros y FLOPs
Ejemplo
import torch.nn as nn
from thop import profile
def count_parameters(model):
"""Calcular el número de parámetros entrenables del modelo"""
total = sum(p.numel() for p in model.parameters())
trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
return total, trainable
def count_flops(model, input_size=(1, 3, 224, 224)):
"""Calcular FLOPs (requiere instalar la biblioteca thop)"""
input_tensor = torch.randn(input_size)
flops, params = profile(model, inputs=(input_tensor,), verbose=False)
return flops, params
# Ejemplo: contar el modelo
model = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
nn.Conv2d(64, 128, kernel_size=3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
nn.Conv2d(128, 256, kernel_size=3, padding=1),
nn.ReLU(),
nn.AdaptiveAvgPool2d(1),
nn.Flatten(),
nn.Linear(256, 10)
)
total, trainable = count_parameters(model)
print(f"Parámetros totales: {total:,}")
print(f"Parámetros entrenables: {trainable:,}")
print(f"Tamaño del modelo: {total * 4 / 1024 / 1024:.2f} MB")
# Cálculo de FLOPs
try:
flops, _ = count_flops(model)
print(f"FLOPs: {flops / 1e9:.2f} G")
except ImportError:
print("Por favor instale la biblioteca thop: pip install thop")
6.2 Prueba de velocidad de inferencia
import time
def measure_inference_speed(model, input_size, device='cuda', num_iterations=100):
"""
Medir la velocidad de inferencia
"""
model.eval()
model = model.to(device)
# Calentamiento
dummy_input = torch.randn(input_size).to(device)
with torch.no_grad():
for _ in range(10):
_ = model(dummy_input)
# Cronometrar
start = time.time()
with torch.no_grad():
for _ in range(num_iterations):
_ = model(dummy_input)
if device == 'cuda':
torch.cuda.synchronize()
end = time.time()
avg_time = (end - start) / num_iterations * 1000 # ms
return avg_time
# Ejemplo de uso
model = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=3, padding=1),
nn.ReLU(),
nn.Conv2d(64, 64, kernel_size=3, padding=1),
nn.ReLU(),
nn.AdaptiveAvgPool2d(1),
nn.Flatten(),
nn.Linear(64, 10)
)
# Velocidad de inferencia en CPU
cpu_time = measure_inference_speed(model, (1, 3, 224, 224), device='cpu')
print(f"Tiempo de inferencia en CPU: {cpu_time:.2f} ms/imagen")
# Velocidad de inferencia en GPU (si hay CUDA)
if torch.cuda.is_available():
gpu_time = measure_inference_speed(model, (1, 3, 224, 224), device='cuda')
print(f"Tiempo de inferencia en GPU: {gpu_time:.2f} ms/imagen")
6.3 Análisis de uso de memoria de la GPU
Ejemplo
def analyze_memory(model, input_size):
"""
Analizar el uso de memoria de video del modelo
"""
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
# Crear entrada
x = torch.randn(input_size).to(device)
# Limpiar caché
if torch.cuda.is_available():
torch.cuda.empty_cache()
torch.cuda.reset_peak_memory_stats()
# Propagación hacia adelante
with torch.no_grad():
output = model(x)
# Obtener estadísticas de memoria de video
if torch.cuda.is_available():
allocated = torch.cuda.memory_allocated() / 1024**2 # MB
reserved = torch.cuda.memory_reserved() / 1024**2
max_allocated = torch.cuda.max_memory_allocated() / 1024**2
print(f"Asignado actualmente: {allocated:.2f} MB")
print(f"Ocupación de caché: {reserved:.2f} MB")
print(f"Ocupación máxima: {max_allocated:.2f} MB")
else:
print("Requiere soporte CUDA")
return output
# Ejemplo de uso
model = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=3, padding=1),
nn.ReLU(),
nn.Conv2d(64, 128, kernel_size=3, padding=1),
nn.ReLU(),
nn.Conv2d(128, 256, kernel_size=3, padding=1),
nn.ReLU(),
)
analyze_memory(model, (8, 3, 224, 224))
7. Problemas comunes y técnicas de depuración
7.1 Referencia rápida de problemas de entrenamiento
| Síntoma | Causa posible | Solución |
|---|---|---|
| La pérdida no disminuye | Tasa de aprendizaje demasiado pequeña/grande, problemas de gradientes | Ajustar la tasa de aprendizaje, revisar gradientes |
| La pérdida oscila | Tasa de aprendizaje demasiado grande, tamaño de lote pequeño | Reducir la tasa de aprendizaje, aumentar el lote |
| Aparición de NaN | División por cero, log(0), explosión de gradientes | Añadir epsilon, recorte de gradientes |
| Sobreajuste | Modelo complejo, datos insuficientes | Aumentar datos, añadir regularización |
| Subajuste | Modelo demasiado simple, entrenamiento insuficiente | Aumentar el modelo, entrenar más tiempo |
| Memoria de video insuficiente | Tamaño de lote grande, modelo grande | Reducir el lote, acumulación de gradientes |
7.2 Conjunto de técnicas de depuración
Ejemplo
import random
import numpy as np
def set_seed(seed=42):
"""Establecer la semilla aleatoria para garantizar resultados reproducibles"""
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
def debug_forward(model, x):
"""Depurar la propagación hacia adelante, revisar la salida de cada capa"""
print("=" * 50)
print("Depuración de la propagación hacia adelante")
print("=" * 50)
for name, layer in model.named_children():
x = layer(x)
if hasattr(x, 'shape'):
print(f"{name}: shape={x.shape}, ", end='')
if hasattr(x, 'mean'):
print(f"mean={x.mean().item():.4f}, std={x.std().item():.4f}")
if torch.isnan(x).any():
print(f" ⚠️ ¡Se detectó NaN!")
if torch.isinf(x).any():
print(f" ⚠️ ¡Se detectó Inf!")
print("=" * 50)
def debug_backward(model):
"""Depurar la propagación hacia atrás, revisar los gradientes"""
print("=" * 50)
print("Depuración de la propagación hacia atrás")
print("=" * 50)
for name, param in model.named_parameters():
if param.grad is not None:
grad_norm = param.grad.norm().item()
if torch.isnan(param.grad).any():
print(f"{name}: ⚠️ ¡Gradiente NaN!")
elif torch.isinf(param.grad).any():
print(f"{name}: ⚠️ ¡Gradiente Inf!")
elif grad_norm > 10:
print(f"{name}: ⚠️ ¡Explosión de gradiente! norm={grad_norm:.2f}")
elif grad_norm < 1e-7:
print(f"{name}: ⚠️ ¡Desvanecimiento de gradiente! norm={grad_norm:.2e}")
else:
print(f"{name}: normal norm={grad_norm:.4f}")
print("=" * 50)
# Ejemplo de uso
set_seed(42)
model = nn.Sequential(
nn.Linear(10, 20),
nn.ReLU(),
nn.Linear(20, 20),
nn.ReLU(),
nn.Linear(20, 5)
)
x = torch.randn(2, 10)
y = model(x)
debug_forward(model, x)
loss = y.sum()
loss.backward()
debug_backward(model)
8. Uso del PyTorch Profiler
PyTorch Profiler es una herramienta de análisis de rendimiento oficial que puede analizar el tiempo y el uso de memoria de video de cada parte del modelo.
8.1 Uso básico del Profiler
Ejemplo
import torch.nn as nn
from torch.profiler import profile, ProfilerActivity, schedule
# Modelo simple
model = nn.Sequential(
nn.Conv2d(3, 64, 3, padding=1),
nn.ReLU(),
nn.Conv2d(64, 64, 3, padding=1),
nn.ReLU(),
nn.AdaptiveAvgPool2d(1),
nn.Flatten(),
nn.Linear(64, 10)
).cuda()
optimizer = torch.optim.Adam(model.parameters())
criterion = nn.CrossEntropyLoss()
# Usar profiler
with profile(
activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],
schedule=schedule(wait=1, warmup=1, active=3, repeat=1),
on_trace_ready=torch.profiler.tensorboard_trace_handler('./logs'),
record_shapes=True,
profile_memory=True,
with_stack=True
) as prof:
for step in range(5):
inputs = torch.randn(8, 3, 224, 224).cuda()
labels = torch.randint(0, 10, (8,)).cuda()
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
prof.step()
# Imprimir resultados
print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))
8.2 Visualización de los resultados del Profiler
Ejemplo
# El directorio ./logs generado se puede abrir con el navegador Chrome para verlo
# O imprimir directamente las métricas
print("=" * 80)
print("Tiempo de CPU Top 10:")
print(prof.key_averages().table(sort_by="cpu_time_total", row_limit=10))
print("\n" + "=" * 80)
print("Tiempo de CUDA Top 10:")
print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))
print("\n" + "=" * 80)
print("Uso de memoria de video Top 10:")
print(prof.key_averages().table(sort_by="self_cuda_memory_usage", row_limit=10))