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 matplotlib.pyplot as plt
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 matplotlib.pyplot as plt
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
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 torch
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

import numpy as np

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

from sklearn.metrics import classification_report

# 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
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

< h2 class="example">Ejemplo
import torch
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
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
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

< h2 class="example">Ejemplo
import torch
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

import torch

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 torch
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" &#x26a0;&#xfe0f; ¡Se detectó NaN!")
            if torch.isinf(x).any():
                print(f" &#x26a0;&#xfe0f; ¡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}: &#x26a0;&#xfe0f; ¡Gradiente NaN!")
            elif torch.isinf(param.grad).any():
                print(f"{name}: &#x26a0;&#xfe0f; ¡Gradiente Inf!")
            elif grad_norm > 10:
                print(f"{name}: &#x26a0;&#xfe0f; ¡Explosión de gradiente! norm={grad_norm:.2f}")
            elif grad_norm < 1e-7:
                print(f"{name}: &#x26a0;&#xfe0f; ¡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
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

# Exportar archivo de rastreo de Chrome
# 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))
Otras extensiones