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 la
torch.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:
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:
2.2 Ejemplo de uso básico
Ejemplo
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
# 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:
GradScaler gestiona automáticamente el ciclo de retroalimentación anterior; solo necesita ajustar su comportamiento mediante parámetros:
Ejemplo
# 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
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
@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
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
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
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
"""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 en
torch.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
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
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