Entrenamiento de precisión mixta en PyTorch (AMP)

El entrenamiento de precisión mixta es una de las técnicas de optimización de rendimiento más importantes en el aprendizaje profundo. Al utilizar simultáneamente números de punto flotante FP32 (precisión simple) y FP16 (precisión media) para el cálculo, puede mejorar significativamente la velocidad de entrenamiento y reducir el uso de memoria de video, casi sin perder precisión del modelo. Esta sección presenta en detalle la tecnología de precisión mixta automática (Automatic Mixed Precision, AMP) en PyTorch.

Versión aplicable:El código de este artículo está basado en latorch.cuda.ampAPI de PyTorch 1.6+. Para PyTorch 2.4+ se recomienda usartorch.amp.autocastytorch.amp.GradScaler, el uso es básicamente el mismo y las diferencias se indicarán en el texto.


1. Fundamentos del entrenamiento de precisión mixta

1.1 Por qué se necesita precisión mixta

El entrenamiento de modelos de aprendizaje profundo implica una gran cantidad de operaciones con matrices. El FP32 tradicional (punto flotante de 32 bits) tiene alta precisión de cálculo, pero ocupa mucha memoria de video y es lento. El FP16 (punto flotante de 16 bits) es rápido y ocupa poca memoria de video, pero su rango numérico es pequeño y es propenso a problemas de subdesbordamiento (underflow) de gradientes.

La idea central del entrenamiento de precisión mixta es:Usar FP32 para operaciones que requieren alta precisión y FP16 para operaciones que no requieren alta precisión. De esta manera se puede disfrutar de la ventaja de velocidad de FP16 y evitar problemas de precisión.

La siguiente figura muestra las diferencias en la distribución de bits de los tres formatos de punto flotante:Bits de exponentedeterminan el rango numérico,los bits de mantisadeterminan la precisión:

Comparación de la distribución de bits de formatos de punto flotante Bit de signo Bits de exponente Bits de mantisa FP32 32 bits S 1 Exponent 8 bits Mantissa 23 bits Rango: ±3.4×10³⁸ Precisión: ~7 dígitos significativos FP16 16 bits S Exp 5 bits Mantissa 10 bits Rango: ±65504 Precisión: ~3.3 dígitos significativos ⚠ Pocos bits de exponente, propenso a desbordamiento BF16 16 bits S Exponent 8 bits (igual que FP32) Mantissa 7 bits Rango: ±3.4×10³⁸ Precisión: ~2.4 dígitos significativos ✓ Mismo rango que FP32 BF16 conserva los bits de exponente de FP32 → mismo rango numérico → entrenamiento más estable, generalmente no necesita GradScaler

1.2 Ventajas de la precisión mixta

Métrica Mejora Descripción
Velocidad de entrenamiento 2-3 veces más rápida Depende del soporte de Tensor Core de la GPU
Uso de memoria de video Reducción de aproximadamente 50% Los valores de activación y resultados intermedios se almacenan en FP16
Ancho de banda de memoria Reducción de aproximadamente 50% Un volumen de datos más pequeño implica menos transferencia
Sobrecarga de comunicación Reducción de aproximadamente 50% La cantidad de gradientes transmitidos en el entrenamiento distribuido se reduce a la mitad

1.3 Principio de aceleración de Tensor Core

El Tensor Core de NVIDIA es una unidad de hardware especializada en operaciones con matrices. Puede completar una operación de multiplicación y suma de matrices de 4×4 (D = A × B + C) en un ciclo de reloj, que es la principal fuente de aceleración del entrenamiento con FP16. En comparación con los núcleos CUDA comunes, que requieren múltiples instrucciones para completar la misma operación, Tensor Core la comprime en una sola instrucción.

Las GPU compatibles con Tensor Core incluyen:

  • Arquitectura Volta(V100) — Primera generación de Tensor Core, solo compatible con FP16
  • Arquitectura Turing(Serie RTX 20) — Compatible con FP16 / INT8 / INT4
  • Arquitectura Ampere(Serie RTX 30, A100) — Nuevo soporte para BF16 / TF32
  • Arquitectura Ada Lovelace(Serie RTX 40) — Nuevo soporte para FP8
  • Arquitectura Hopper(H100) — Nuevo motor Transformer Engine con FP8

Las GPU RTX de gama de consumo también son compatibles con Tensor Core; por ejemplo, RTX 3060 y superiores pueden disfrutar de la aceleración AMP.


2. Uso básico de AMP en PyTorch

2.1 autocast y GradScaler

La API AMP de PyTorch incluye principalmente dos componentes centrales:

  • autocast: administrador de contexto que cambia automáticamente las operaciones dentro de la región a FP16 (las operaciones sensibles a la precisión vuelven automáticamente a FP32)
  • GradScaler: ajusta dinámicamente el factor de escala de gradiente, amplificando los gradientes FP16 para evitar el subdesbordamiento (solo se necesita para FP16; normalmente no se necesita para BF16)

La siguiente figura muestra el flujo de datos de un paso completo de entrenamiento con AMP:

Flujo de entrenamiento de un paso con AMP Datos de entrada FP32 autocast Propagación hacia adelante Selección automática de FP16/FP32 Cálculo de la pérdida FP32 GradScaler Escalado + retropropagación loss × scale_factor Desscalado de gradientes + recorte de gradientes grad / scale_factor Actualización del optimizador Pesos en FP32 Actualización Scaler Ajuste de escala Control de autocast — selección automática de precisión Control de GradScaler — prevención de subdesbordamiento de gradientes Actualización de pesos en FP32 — mantener precisión Clave: los pesos siempre se almacenan y actualizan en FP32, solo se convierten temporalmente a FP16 durante el cálculo

2.2 Ejemplo de uso básico

Ejemplo

import torch
import torch.nn as nn
import torch.optim as optim
from torch.cuda.amp import autocast, GradScaler
# Escritura recomendada para PyTorch 2.4+:
# from torch.amp import autocast, GradScaler

# Comprobar si CUDA está disponible
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Dispositivo usado: {device}")

if torch.cuda.is_available():
    print(f"GPU: {torch.cuda.get_device_name(0)}")
    print(f"BF16 compatible: {torch.cuda.is_bf16_supported()}")

# ── Definición del modelo ──────────────────────────────────────
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(128, 256),
            nn.ReLU(),
            nn.Linear(256, 256),
            nn.ReLU(),
            nn.Linear(256, 10)
        )

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


model = SimpleModel().to(device)

# Función de pérdida y optimizador
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

# ── Componentes clave del entrenamiento de precisión mixta ──────────────────────────
# GradScaler: escala la pérdida para evitar el subdesbordamiento de gradientes FP16
scaler = GradScaler()

# Bucle de entrenamiento
def train_epoch_amp(model, loader, criterion, optimizer, scaler, device):
    model.train()
    total_loss = 0
    correct = 0
    total = 0

    for inputs, labels in loader:
        inputs = inputs.to(device, non_blocking=True)
        labels = labels.to(device, non_blocking=True)

        optimizer.zero_grad()

        # ── Núcleo: usar el administrador de contexto autocast ──────
        # Las operaciones dentro del contexto autocast usan FP16 automáticamente
        # Las operaciones sensibles a la precisión (como softmax, loss) vuelven automáticamente a FP32
        with autocast(device_type='cuda'):
            outputs = model(inputs)
            loss = criterion(outputs, labels)

        # ── Usar scaler para la retropropagación ─────────────
        # 1. Escalar la pérdida (multiplicar por scale_factor)
        # 2. Retropropagación (calcular sobre gradientes ampliados)
        # 3. scaler.step desscala automáticamente los gradientes internamente y verifica Inf/NaN
        scaler.scale(loss).backward()

        # Actualizar parámetros
        scaler.step(optimizer)

        # Actualizar el factor de escala del scaler
        scaler.update()

        # Estadísticas
        total_loss += loss.item() * inputs.size(0)
        _, predicted = outputs.max(1)
        correct += predicted.eq(labels).sum().item()
        total += labels.size(0)

    return total_loss / total, correct / total


# Datos simulados
train_loader = [
    (torch.randn(32, 128), torch.randint(0, 10, (32,))) for _ in range(10)
]

# Iniciar entrenamiento
for epoch in range(3):
    loss, acc = train_epoch_amp(
        model, train_loader, criterion, optimizer, scaler, device
    )
    print(f"Epoch {epoch+1}: Loss={loss:.4f}, Acc={acc:.4f}")

print(¡Entrenamiento de precisión mixta completado!)

Consejo de migración de API:PyTorch 2.4 marcarátorch.cuda.amp.autocastcomo obsoleto (deprecated), se recomienda usartorch.amp.autocast('cuda'). Ambos tienen exactamente el mismo uso, solo difieren en la ruta de importación.

2.3 Elección entre BF16 y FP16

Las GPU modernas admiten dos formatos de media precisión; su diferencia clave radica en cómo se distribuyen los bits de exponente y mantisa:

Formato Bits de exponente Bits de mantisa Rango numérico Precisión Escenarios de uso
FP16 5 bits 10 bits ±65504 Mayor (~3.3 dígitos) Requiere compatibilidad con GPU antiguas (V100/RTX serie 20)
BF16 8 bits 7 bits ±3.4×10³⁸ Menor (~2.4 dígitos) Busca estabilidad (A100/RTX serie 30+)

Sugerencia: si el hardware es compatible con BF16,priorice el uso de BF16. Su rango numérico es idéntico al de FP32, por lo que casi no hay problemas de desbordamiento durante el entrenamiento y no se necesita GradScaler.

Ejemplo

# ── Sintaxis BF16 (PyTorch 1.10+) ────────────────────
# BF16 no necesita GradScaler, ya que su rango numérico es igual al de FP32

from torch.cuda.amp import autocast

# Método 1: especificar dtype en autocast
with autocast(device_type='cuda', dtype=torch.bfloat16):
    outputs = model(inputs)
    loss = criterion(outputs, labels)

# Método 2: habilitar BF16 globalmente por defecto (si el hardware lo soporta)
# torch.backends.cuda.matmul.allow_bf16_reduced_precision = True
# torch.backends.cudnn.allow_bf16_reduced_precision = True

# ── Verificar soporte de hardware ─────────────────────────────────
print(f"Soporte de hardware para BF16: {torch.cuda.is_bf16_supported()}")
print(f"matmul actual permite BF16: {torch.backends.cuda.matmul.allow_bf16}")
print(f"cuDNN actual permite BF16: {torch.backends.cudnn.allow_bf16}")

# ── Ejemplo completo de entrenamiento con BF16 (sin GradScaler) ──────────
scaler_bf16 = None  # BF16 no necesita scaler

for inputs, labels in train_loader:
    inputs, labels = inputs.to(device), labels.to(device)
    optimizer.zero_grad()

    with autocast(device_type='cuda', dtype=torch.bfloat16):
        outputs = model(inputs)
        loss = criterion(outputs, labels)

    # Retropropagación directa, sin scaler
    loss.backward()
    optimizer.step()

3. Técnicas avanzadas y optimización

3.1 Escalado dinámico de pérdida

El mecanismo central de GradScaler esescalado dinámico de pérdida— ajusta automáticamente el factor de escala según el estado del entrenamiento, previniendo el subdesbordamiento (underflow) de los gradientes y reduciendo gradualmente la escala cuando el entrenamiento es estable para minimizar la pérdida de precisión:

Escalado dinámico de pérdida (Dynamic Loss Scaling) Scale × Loss Retropropagación Los gradientes contienen Inf / NaN? Sí Reducir scale × backoff (por defecto 0.5) Omitir esta actualización no Unscale + actualizar parámetros Éxitos consecutivos +1 ¿Éxitos consecutivos ≥ growth_interval? (por defecto 2000 pasos) Aumentar scale × growth growth_factor por defecto 2.0 · backoff_factor por defecto 0.5 · equilibrio dinámico entre precisión y estabilidad

GradScaler gestiona automáticamente el ciclo de retroalimentación anterior; solo necesita ajustar su comportamiento mediante parámetros:

Ejemplo

from torch.cuda.amp import GradScaler

# Personalizar parámetros de GradScaler
scaler = GradScaler(
    init_scale=2**16,        # Factor de escala inicial, por defecto 65536
    growth_factor=2.0,       # Multiplicador de crecimiento del factor de escala, por defecto 2.0
    backoff_factor=0.5,      # Multiplicador de retroceso del factor de escala, por defecto 0.5
    growth_interval=2000,    # Cuántos pasos consecutivos exitosos se necesitan para aumentar
    enabled=True             # Si está habilitado (se puede activar/desactivar dinámicamente)
)

# Flujo de trabajo:
# 1. scale inicial = 65536
# 2. Si en algún paso aparece Inf/NaN → scale × 0.5 (reducir), omitir ese paso
# 3. Si hay 2000 pasos consecutivos sin Inf/NaN → scale × 2.0 (aumentar)
# 4. Buscar siempre el scale máximo utilizable dentro de un rango seguro

# Ver el factor de escala actual
print(f"Factor de escala actual: {scaler.get_scale()}")

# Determinar si el scaler considera que el paso anterior fue exitoso
print(f"Último paso exitoso: {scaler._found_inf.item() == 0}")

3.2 AMP en acumulación de gradientes

La acumulación de gradientes se utiliza para simular un tamaño de batch mayor con memoria de GPU limitada. Al usar AMP, tenga en cuenta que la pérdida de cada sub-batch debe dividirse por el número de pasos de acumulación; de lo contrario, el gradiente final se amplificará:

Ejemplo

# ── Acumulación de gradientes + precisión mixta ──────────────────────────
accumulation_steps = 8

scaler = GradScaler()
model.train()

for batch_idx, (inputs, labels) in enumerate(train_loader):
    inputs, labels = inputs.to(device), labels.to(device)

    with autocast(device_type='cuda'):
        outputs = model(inputs)
        # Clave: dividir la pérdida de cada sub-batch por el número de pasos de acumulación
        # Así, el gradiente acumulado equivale al gradiente promedio de un batch grande
        loss = criterion(outputs, labels) / accumulation_steps

    # Acumular el gradiente escalado (nota: no poner a cero aquí)
    scaler.scale(loss).backward()

    # Actualizar parámetros cada accumulation_steps batches
    if (batch_idx + 1) % accumulation_steps == 0:
        scaler.step(optimizer)
        scaler.update()
        optimizer.zero_grad()

# ── Manejar gradientes al final que no completan un ciclo de acumulación ──────────
remainder = len(train_loader) % accumulation_steps
if remainder != 0:
    # Es necesario reescalar el gradiente acumulado según el número real de pasos
    # Método simple: ejecutar el paso de todos modos, el gradiente será algo mayor pero el impacto suele ser mínimo
    scaler.step(optimizer)
    scaler.update()
    optimizer.zero_grad()

3.3 AMP en validación e inferencia

También se recomienda usar AMP en las fases de validación e inferencia. Como no se necesita retropropagación ni escalado de gradientes, el código es más sencillo:

Ejemplo

# ── Usar autocast en inferencia ──────────────────────────
@torch.no_grad()
def inference_amp(model, inputs, device):
    model.eval()
    # La inferencia usa FP16, sin necesidad de GradScaler
    with autocast(device_type='cuda'):
        outputs = model(inputs.to(device))
    return outputs


# ── inference_mode es más rápido que no_grad ──────────────
# inference_mode desactiva más overhead de seguimiento, ideal para inferencia pura
@torch.inference_mode()
def inference_fast(model, inputs, device):
    model.eval()
    with autocast(device_type='cuda'):
        outputs = model(inputs.to(device))
    return outputs


# ── Ejemplo de inferencia por lotes ─────────────────────────────────
def batch_inference(model, dataloader, device):
    model.eval()
    all_outputs = []

    with torch.inference_mode():
        for inputs in dataloader:
            with autocast(device_type='cuda'):
                outputs = model(inputs.to(device))
            all_outputs.append(outputs.cpu())

    return torch.cat(all_outputs, dim=0)

4. Problemas comunes y soluciones

4.1 Entrenamiento inestable

Problema Causa Solución
Loss se convierte en NaN / Inf Desbordamiento de gradiente (scale demasiado grande o tasa de aprendizaje demasiado alta) Reducirinit_scale, agregar recorte de gradiente, reducir la tasa de aprendizaje
Loss no disminuye / oscila Subdesbordamiento de gradiente (scale demasiado pequeño, gradiente truncado a 0) Aumentarinit_scale, revisar las estadísticas de gradiente, probar BF16
La precisión disminuye notablemente Algunas capas (como LayerNorm, Softmax) son sensibles a FP16 Mantener manualmente esas capas en FP32 (ver 4.2)
Inestabilidad al final del entrenamiento La variación del rango de valores de los parámetros del modelo provoca que scale no coincida Aumentar adecuadamentegrowth_interval, para que el ajuste de scale sea más conservador

4.2 Control manual de precisión

Algunas operaciones pierden mucha precisión en FP16 y es necesario especificar manualmente el uso de FP32. El autocast de PyTorch ya incluye protección para estas operaciones, pero las operaciones personalizadas pueden requerir manejo manual:

Ejemplo

# ── Método 1: envolver una función de pérdida que fuerce FP32 ────────
class FP32Loss(nn.Module):
    """Envoltorio de función de pérdida que fuerza el cálculo en FP32"""
    def __init__(self, base_criterion):
        super().__init__()
        self.base_criterion = base_criterion

    def forward(self, input, target):
        # Convertir explícitamente a FP32, fuera de la influencia de autocast
        return self.base_criterion(input.float(), target.float())


# ── Método 2: deshabilitar localmente en autocast ──────────────
with autocast(device_type='cuda'):
    outputs = model(inputs)

    # Para operaciones sensibles a la precisión, deshabilitar temporalmente autocast
    with autocast(enabled=False):
        loss = criterion(outputs.float(), labels)


# ── Método 3: mantener capas específicas en FP32 en el modelo ──────────────
class CustomModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, 3, padding=1),
            nn.BatchNorm2d(64),  # BN es sensible a la precisión
            nn.ReLU(),
            nn.Conv2d(64, 128, 3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(),
        )
        self.classifier = nn.Linear(128, 10)

    def forward(self, x):
        x = self.features[0](x)           # Conv: FP16 (controlado por autocast)
        x = self.features[1](x.float())   # BN: forzar FP32
        x = self.features[2](x)           # ReLU: FP16
        x = self.features[3](x)
        x = self.features[4](x.float())   # BN: forzar FP32
        x = self.features[5](x)
        x = x.mean(dim=[2, 3])            # Global Average Pooling
        x = self.classifier(x)
        return x

Sugerencia:El autocast de PyTorch mantiene automáticamente las siguientes operaciones en FP32: softmax, log_softmax, cross_entropy, layer_norm, batch_norm, etc. Generalmente solo los operadores personalizados necesitan manejo manual.

4.3 Recorte de gradientes y AMP

El recorte de gradiente debe ejecutarsescaler.step()antes de, yscaler.unscale_()después de ejecutar. Esto se debe a que el recorte debe actuar sobrelos valores de gradiente realessobre estos, no sobre los gradientes escalados:

Ejemplo

# ── Orden correcto para el recorte de gradientes ──────────────────────────
for inputs, labels in train_loader:
    inputs, labels = inputs.to(device), labels.to(device)
    optimizer.zero_grad()

    with autocast(device_type='cuda'):
        outputs = model(inputs)
        loss = criterion(outputs, labels)

    # Paso 1: escalar la pérdida y realizar la retropropagación
    scaler.scale(loss).backward()

    # Paso 2: desescalar los gradientes (restaurar los gradientes desde la escala a sus valores reales)
    # Debe llamarse antes del recorte y del step
    scaler.unscale_(optimizer)

    # Paso 3: recortar los gradientes reales
    torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

    # Paso 4: actualizar los parámetros (internamente comprueba si los gradientes contienen Inf/NaN)
    scaler.step(optimizer)

    # Paso 5: actualizar el factor de escala
    scaler.update()

# ── Error común: olvidar unscale_ antes de recortar ──────────────
# ¡Error! Se recortan gradientes amplificados; el umbral se ve afectado por la escala
# scaler.scale(loss).backward()
# torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) # ← incorrecto
# scaler.step(optimizer)

5. Comparación de rendimiento y mejores prácticas

5.1 Pruebas de referencia de rendimiento

Ejemplo

import time

def benchmark_training(model, train_loader, device, use_amp=True,
                       dtype=torch.float16, num_iterations=100):
    """Comparación de la velocidad de entrenamiento entre FP32 y AMP"""
    model = model.to(device)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=1e-3)
    scaler = GradScaler(enabled=use_amp and dtype == torch.float16)

    # ── Calentamiento (los primeros 10 pasos no se cronometran) ────────────────────
    for i, (inputs, labels) in enumerate(train_loader):
        if i >= 10:
            break
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()

        if use_amp:
            with autocast(device_type='cuda', dtype=dtype):
                outputs = model(inputs)
                loss = criterion(outputs, labels)
            scaler.scale(loss).backward()
            scaler.step(optimizer)
            scaler.update()
        else:
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()

    # ── Prueba oficial ─────────────────────────────────
    torch.cuda.synchronize()
    start = time.time()

    for i, (inputs, labels) in enumerate(train_loader):
        if i >= num_iterations:
            break
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()

        if use_amp:
            with autocast(device_type='cuda', dtype=dtype):
                outputs = model(inputs)
                loss = criterion(outputs, labels)
            scaler.scale(loss).backward()
            scaler.step(optimizer)
            scaler.update()
        else:
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()

    torch.cuda.synchronize()
    elapsed = time.time() - start

    return elapsed / num_iterations


# ── Ejecutar la comparación ─────────────────────────────────────
model = SimpleModel()

fp32_time = benchmark_training(model, train_loader, device, use_amp=False)
fp16_time = benchmark_training(model, train_loader, device, use_amp=True, dtype=torch.float16)

print(f"FP32 tiempo promedio: {fp32_time*1000:.2f} ms/batch")
print(f"FP16 tiempo promedio: {fp16_time*1000:.2f} ms/batch")
print(f"Aceleración: {fp32_time / fp16_time:.2f}x")

# Si se admite BF16, también pruébalo
if torch.cuda.is_bf16_supported():
    bf16_time = benchmark_training(
        model, train_loader, device, use_amp=True, dtype=torch.bfloat16
    )
    print(f"BF16 tiempo promedio: {bf16_time*1000:.2f} ms/batch")
    print(f"BF16 aceleración: {fp32_time / bf16_time:.2f}x")

5.2 Comparación de uso de memoria de video

Ejemplo

def compare_memory(model_class, train_loader, device):
    """Comparación del uso de memoria de video entre FP32 y AMP"""
    def reset():
        torch.cuda.empty_cache()
        torch.cuda.reset_peak_memory_stats()

    # ── Prueba de memoria de video FP32 ────────────────────────────
    reset()
    model_fp32 = model_class().to(device)
    optimizer_fp32 = optim.Adam(model_fp32.parameters())

    for inputs, labels in list(train_loader)[:5]:
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer_fp32.zero_grad()
        outputs = model_fp32(inputs)
        loss = nn.CrossEntropyLoss()(outputs, labels)
        loss.backward()
        optimizer_fp32.step()

    fp32_peak = torch.cuda.max_memory_allocated() / 1024**2

    # ── Prueba de memoria de video AMP ─────────────────────────────
    reset()
    model_amp = model_class().to(device)
    optimizer_amp = optim.Adam(model_amp.parameters())
    scaler = GradScaler()

    for inputs, labels in list(train_loader)[:5]:
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer_amp.zero_grad()
        with autocast(device_type='cuda'):
            outputs = model_amp(inputs)
            loss = nn.CrossEntropyLoss()(outputs, labels)
        scaler.scale(loss).backward()
        scaler.step(optimizer_amp)
        scaler.update()

    amp_peak = torch.cuda.max_memory_allocated() / 1024**2

    print(f"FP32 pico de memoria: {fp32_peak:.1f} MB")
    print(f"AMP pico de memoria: {amp_peak:.1f} MB")
    print(f"Ahorro de memoria: {(fp32_peak - amp_peak) / fp32_peak * 100:.1f}%")


compare_memory(SimpleModel, train_loader, device)

5.3 Resumen de mejores prácticas

Escenario Configuración recomendada Razón
A100 / H100 / serie RTX 40 BF16, no se necesita GradScaler Mismo rango numérico que FP32, el más estable
V100 / serie RTX 20 FP16 + GradScaler El hardware no admite BF16, se necesita scaler para evitar desbordamiento
serie RTX 30 BF16 como prioridad, FP16 como alternativa La arquitectura Ampere admite BF16
Entrenamiento de modelos grandes (memoria de video limitada) AMP + acumulación de gradientes + checkpointing de gradientes La combinación de los tres maximiza la utilización de la memoria de video
Despliegue de inferencia autocast + inference_mode No se necesita scaler, la inferencia es la más rápida

PyTorch 2.0+ ha integrado AMP entorch.compileel cual puede aplicar automáticamente la optimización de precisión mixta. Al usartorch.compile(model)el compilador determinará automáticamente qué operaciones son adecuadas para FP16.


6. Combinación con otras técnicas de optimización

6.1 AMP + torch.compile

Ejemplo

# ── Uso combinado con PyTorch 2.0+ ───────────────────────
model = model.to(device)

# Opción 1: compilar primero, luego entrenar con AMP
# torch.compile fusiona automáticamente operadores y optimiza el acceso a memoria
model_compiled = torch.compile(model, mode="reduce-overhead")

scaler = GradScaler()
for inputs, labels in train_loader:
    inputs, labels = inputs.to(device), labels.to(device)
    optimizer.zero_grad()

    with autocast(device_type='cuda'):
        outputs = model_compiled(inputs)
        loss = criterion(outputs, labels)

    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()

# Opción 2: habilitar TF32 (aceleración adicional en arquitecturas Ampere+)
# TF32 usa 19 bits de precisión, velocidad cercana a FP16, precisión cercana a FP32
torch.backends.cuda.matmul.allow_tf32 = True
torch.backends.cudnn.allow_tf32 = True
torch.backends.cudnn.benchmark = True  # Acelera las convoluciones cuando el tamaño de entrada es fijo

6.2 AMP + entrenamiento distribuido

Ejemplo

# ── Entrenamiento distribuido + precisión mixta ────────────────────────
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP

def setup(rank, world_size):
    dist.init_process_group("nccl", rank=rank, world_size=world_size)
    torch.cuda.set_device(rank)

def train_ddp_amp(rank, world_size):
    setup(rank, world_size)
    device = torch.device(f"cuda:{rank}")

    model = SimpleModel().to(device)
    model = DDP(model, device_ids=[rank])

    optimizer = optim.Adam(model.parameters(), lr=1e-3)
    scaler = GradScaler()

    for inputs, labels in train_loader:
        inputs = inputs.to(device, non_blocking=True)
        labels = labels.to(device, non_blocking=True)

        optimizer.zero_grad()

        with autocast(device_type='cuda'):
            outputs = model(inputs)
            loss = criterion(outputs, labels)

        # DDP sincroniza automáticamente los gradientes en el backward
        scaler.scale(loss).backward()

        # Recorte de gradientes (primero se debe hacer unscale)
        scaler.unscale_(optimizer)
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

        scaler.step(optimizer)
        scaler.update()

    dist.destroy_process_group()

Resumen

El entrenamiento de precisión mixta es lapráctica estándar del entrenamiento de aprendizaje profundo actual.。

Puntos clave:

  • Seleccionar el formato de precisión: si el hardware admite BF16, úsalo preferentemente; de lo contrario, usa FP16 + GradScaler
  • Entender autocast: gestiona automáticamente el cambio de precisión; en la mayoría de los casos no se requiere intervención manual
  • Entender GradScaler: solo es necesario para FP16; previene el subdesbordamiento de gradientes mediante el escalado dinámico
  • Prestar atención al orden del recorte: unscale → clip → step → update, el orden no se puede invertir
  • Aprovechar las optimizaciones combinadas: AMP se puede integrar sin problemas con torch.compile, acumulación de gradientes y entrenamiento distribuido
Otras extensiones