PyTorch: обучение со смешанной точностью (AMP)
Обучение со смешанной точностью — одна из важнейших методик оптимизации производительности в глубоком обучении. За счёт одновременного использования чисел с плавающей запятой FP32 (одинарная точность) и FP16 (половинная точность) для вычислений она позволяет значительно повысить скорость обучения и снизить потребление памяти практически без потери точности модели. В этом разделе подробно рассматривается техника автоматической смешанной точности (AMP) в PyTorch.
Применимые версии:Код в этой статье написан с использованием PyTorch 1.6+
torch.cuda.ampAPI. PyTorch 2.4+ рекомендует использоватьtorch.amp.autocastиtorch.amp.GradScaler, а использование практически такое же; различия будут отмечены в статье.
1. Основы обучения со смешанной точностью
1.1 Зачем нужна смешанная точность
Обучение моделей глубокого обучения включает большое количество матричных операций. Традиционный FP32 (32-битное число с плавающей запятой) обладает высокой вычислительной точностью, но занимает больше памяти и работает медленнее. FP16 (16-битное число с плавающей запятой) быстрее и использует меньше памяти, но его числовой диапазон меньше, и он подвержен проблемам с потерей значимости градиентов.
Основная идея обучения со смешанной точностью такова:Использовать FP32 для операций, требующих высокой точности, и FP16 для операций, не требующих высокой точности.. Благодаря этому вы сможете воспользоваться преимуществом FP16 в скорости и избежать проблем с точностью.
На следующем рисунке показаны различия в расположении битов трёх форматов с плавающей запятой —Биты экспонентыопределяют числовой диапазон.Биты мантиссыопределяют точность:
1.2 Преимущества смешанной точности
| Метрика | Улучшение | Описание |
|---|---|---|
| Скорость обучения | Улучшение в 2-3 раза | Зависит от поддержки GPU Tensor Core |
| Использование памяти | Уменьшение примерно на 50% | Активации и промежуточные результаты хранятся в FP16 |
| Пропускная способность памяти | Уменьшение примерно на 50% | Меньший размер данных означает меньший объём передачи данных |
| Накладные расходы на обмен данными | Уменьшение примерно на 50% | Объём передачи градиентов сокращается вдвое при распределённом обучении |
1.3 Принцип ускорения с помощью Tensor Core
Tensor Core от NVIDIA — это аппаратный блок, предназначенный для матричных операций. Он может выполнить операцию умножения с накоплением для матрицы 4×4 (D = A × B + C) за один такт, что является основным источником ускорения обучения с FP16. По сравнению с обычными ядрами CUDA, которым требуется несколько инструкций для выполнения той же операции, Tensor Core сжимает её в одну инструкцию.
GPU, поддерживающие Tensor Core, включают:
- Архитектура Volta(V100) — Tensor Core первого поколения, поддерживает только FP16
- Архитектура Turing(серия RTX 20) — Поддерживает FP16 / INT8 / INT4
- Архитектура Ampere(серия RTX 30, A100) — Добавлена поддержка BF16 / TF32
- Архитектура Ada Lovelace(серия RTX 40) — Добавлена поддержка FP8
- Архитектура Hopper(H100) — Добавлен FP8 Transformer Engine
Потребительские GPU RTX также поддерживают Tensor Core; например, модели RTX 3060 и выше могут пользоваться ускорением AMP.
2. Основы использования PyTorch AMP
2.1 autocast и GradScaler
API AMP в PyTorch в основном включает два ключевых компонента:
autocast: Контекстный менеджер, который автоматически переключает операции в своей области на FP16 (операции, чувствительные к точности, автоматически откатываются к FP32)GradScaler: Динамически регулирует коэффициент масштабирования градиента, чтобы усиливать градиенты FP16 и предотвращать underflow (нужно только для FP16; обычно не требуется для BF16)
На следующем рисунке показан поток данных одного полного шага обучения с AMP:
2.2 Пример базового использования
Пример
import torch.nn as nn
import torch.optim as optim
from torch.cuda.amp import autocast, GradScaler
# Рекомендуемый подход для PyTorch 2.4+:
# from torch.amp import autocast, GradScaler
# Проверить, доступна ли CUDA
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Используется устройство: {device}")
if torch.cuda.is_available():
print(f"Графический процессор: {torch.cuda.get_device_name(0)}")
print(f"BF16 поддерживается: {torch.cuda.is_bf16_supported()}")
# ── Определение модели ──────────────────────────────────────
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)
# Функция потерь и оптимизатор
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)
# ── Ключевые компоненты для обучения со смешанной точностью ──────────────────────────
# GradScaler: масштабирует потери, чтобы избежать потери значимости градиентов FP16
scaler = GradScaler()
# Цикл обучения
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()
# ── Основное: используйте контекстный менеджер autocast ──────
# Операции внутри области autocast автоматически используют FP16
# Операции, чувствительные к точности (например, softmax, loss), автоматически откатываются к FP32
with autocast(device_type='cuda'):
outputs = model(inputs)
loss = criterion(outputs, labels)
# ── Используйте scaler для обратного распространения ─────────────
# 1. Масштабирование потерь (умножение на scale_factor)
# 2. Обратное распространение (вычисляется на масштабированных градиентах)
# 3. scaler.step внутренне снимает масштабирование с градиентов и проверяет на Inf/NaN
scaler.scale(loss).backward()
# Обновить параметры
scaler.step(optimizer)
# Обновление коэффициента масштабирования scaler
scaler.update()
# Статистика
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
# Смоделированные данные
train_loader = [
(torch.randn(32, 128), torch.randint(0, 10, (32,))) for _ in range(10)
]
# Начать обучение
for epoch in range(3):
loss, acc = train_epoch_amp(
model, train_loader, criterion, optimizer, scaler, device
)
print(f"Эпоха {epoch+1}: Потери={loss:.4f}, Точность={acc:.4f}")
print("Обучение со смешанной точностью завершено!")
Примечание о миграции API:PyTorch 2.4 пометит
torch.cuda.amp.autocastкак устаревший; рекомендуется использоватьtorch.amp.autocast('cuda'). Использование точно такое же; отличается только путь импорта.
2.3 Выбор между BF16 и FP16
Современные GPU поддерживают два формата половинной точности. Их основное различие заключается в стратегии распределения битов экспоненты и битов мантиссы:
| Формат | Биты экспоненты | Биты мантиссы | Числовой диапазон | Precision | Сценарий использования |
|---|---|---|---|---|---|
| FP16 | 5 бит | 10 бит | ±65504 | Выше (~3.3 цифры) | Требуется совместимость со старыми графическими процессорами (серии V100/RTX 20) |
| BF16 | 8 бит | 7 бит | ±3.4×10³⁸ | Ниже (~2.4 цифры) | Для стабильности (серии A100/RTX 30+) |
Рекомендация: если оборудование поддерживает BF16,предпочитайте BF16. Его числовой диапазон точно такой же, как у FP32, поэтому проблемы переполнения редко возникают во время обучения, и GradScaler не требуется.
Пример
# BF16 не требует GradScaler, потому что его числовой диапазон такой же, как у FP32
from torch.cuda.amp import autocast
# Способ 1: Укажите dtype в autocast
with autocast(device_type='cuda', dtype=torch.bfloat16):
outputs = model(inputs)
loss = criterion(outputs, labels)
# Способ 2: Глобально включить BF16 по умолчанию (если оборудование это поддерживает)
# torch.backends.cuda.matmul.allow_bf16_reduced_precision = True
# torch.backends.cudnn.allow_bf16_reduced_precision = True
# ── Проверка поддержки оборудования ─────────────────────────────
print(f"Оборудование поддерживает BF16: {torch.cuda.is_bf16_supported()}")
print(f"Текущий matmul позволяет BF16: {torch.backends.cuda.matmul.allow_bf16}")
print(f"Текущий cuDNN позволяет BF16: {torch.backends.cudnn.allow_bf16}")
# ── Полный пример обучения с BF16 (GradScaler не нужен) ──────────
scaler_bf16 = None # BF16 не требует 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)
# Обратное распространение напрямую, scaler не нужен
loss.backward()
optimizer.step()
3. Продвинутые советы и оптимизация
3.1 Динамическое масштабирование потерь
Основной механизм GradScaler — этодинамическое масштабирование потерь— он автоматически регулирует коэффициент масштабирования на основе состояния обучения, предотвращая underflow градиентов и постепенно уменьшая масштабирование, когда обучение стабилизируется, чтобы минимизировать потерю точности:
GradScaler автоматически управляет вышеописанным циклом обратной связи; вам нужно лишь тонко настроить его поведение с помощью параметров:
Пример
# Пользовательские параметры GradScaler
scaler = GradScaler(
init_scale=2**16, # Начальный коэффициент масштабирования, по умолчанию 65536
growth_factor=2.0, # Множитель роста коэффициента масштабирования, по умолчанию 2.0
backoff_factor=0.5, # Множитель резервного уменьшения коэффициента масштабирования, по умолчанию 0.5
growth_interval=2000, # Количество последовательных успешных шагов перед увеличением
enabled=True # Включено ли (можно переключать динамически)
)
# Рабочий процесс:
# 1. Начальный масштаб = 65536
# 2. Если на шаге есть Inf/NaN → масштаб × 0.5 (уменьшить), пропустить этот шаг
# 3. Если 2000 последовательных шагов не содержат Inf/NaN → масштаб × 2.0 (увеличить)
# 4. Всегда находить максимальный допустимый масштаб в безопасном диапазоне
# Просмотреть текущий коэффициент масштабирования
print(f"Текущий коэффициент масштабирования: {scaler.get_scale()}")
# Определить, считает ли scaler последний шаг успешным
print(f"Недавно успешно: {scaler._found_inf.item() == 0}")
3.2 AMP с накоплением градиентов
Накопление градиентов имитирует больший размер батча при ограниченной памяти. При использовании AMP учтите, что значение функции потерь для каждого подбатча необходимо разделить на количество шагов накопления; в противном случае итоговый градиент будет усилен:
Пример
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)
# Ключевой момент: разделите значение функции потерь для каждого подбатча на количество шагов накопления
# Таким образом, накопленный градиент эквивалентен среднему градиенту большого батча
loss = criterion(outputs, labels) / accumulation_steps
# Накапливаем отмасштабированные градиенты (примечание: здесь не обнулять)
scaler.scale(loss).backward()
# Обновляйте параметры каждые accumulation_steps батчей
if (batch_idx + 1) % accumulation_steps == 0:
scaler.step(optimizer)
scaler.update()
optimizer.zero_grad()
# ── Обработка градиентов в конце, когда остаётся меньше полного цикла накопления ──────────
remainder = len(train_loader) % accumulation_steps
if remainder != 0:
# Накопленные градиенты нужно перемасштабировать в соответствии с фактическим количеством шагов
# Простой подход: всё равно выполнить шаг; градиенты будут немного больше, но влияние обычно минимально
scaler.step(optimizer)
scaler.update()
optimizer.zero_grad()
3.3 AMP при валидации и инференсе
AMP также рекомендуется для валидации и инференса. Поскольку обратное распространение и масштабирование градиентов не нужны, код проще:
Пример
@torch.no_grad()
def inference_amp(model, inputs, device):
model.eval()
# Инференс использует FP16, GradScaler не нужен
with autocast(device_type='cuda'):
outputs = model(inputs.to(device))
return outputs
# ── inference_mode быстрее, чем no_grad ──────────────
# inference_mode отключает дополнительные накладные расходы на трассировку, подходит для чистого инференса
@torch.inference_mode()
def inference_fast(model, inputs, device):
model.eval()
with autocast(device_type='cuda'):
outputs = model(inputs.to(device))
return outputs
# ── Пример пакетного инференса ───────────────────────────────
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. Типичные проблемы и решения
4.1 Нестабильное обучение
| Проблема | Причина | Решение |
|---|---|---|
| Loss становится NaN / Inf | Переполнение градиента (слишком большой масштаб или слишком высокая скорость обучения) | Уменьшитьinit_scale, добавить отсечение градиентов, снизить скорость обучения |
| Loss не уменьшается / колеблется | Антипереполнение градиента (слишком маленький масштаб, градиенты усечены до 0) | Увеличьтеinit_scale, проверить статистику градиентов, попробовать BF16 |
| Значительное падение точности | Некоторые слои (например, LayerNorm, Softmax) чувствительны к FP16 | Вручную оставить эти слои в FP32 (см. 4.2) |
| Нестабильность на поздних этапах обучения | Несоответствие масштаба из-за изменений диапазонов значений параметров модели | Увеличьте соответствующим образомgrowth_interval, что делает корректировку масштаба более консервативной |
4.2 Ручное управление точностью
Некоторые операции подвержены значительной потере точности при FP16 и должны быть вручную указаны для использования FP32. Встроенный autocast PyTorch имеет защиту для этих операций, но пользовательские операции могут требовать ручной обработки:
Пример
class FP32Loss(nn.Module):
"""Обёртка функции потерь, принудительно выполняющая вычисления в FP32"""
def __init__(self, base_criterion):
super().__init__()
self.base_criterion = base_criterion
def forward(self, input, target):
# Явно преобразовать в FP32, вне влияния autocast
return self.base_criterion(input.float(), target.float())
# ── Способ 2: локально отключить внутри autocast ──────────────
with autocast(device_type='cuda'):
outputs = model(inputs)
# Для операций, чувствительных к точности, временно отключите autocast
with autocast(enabled=False):
loss = criterion(outputs.float(), labels)
# ── Способ 3: оставить определённые слои в FP32 в модели ────────
class CustomModel(nn.Module):
def __init__(self):
super().__init__()
self.features = nn.Sequential(
nn.Conv2d(3, 64, 3, padding=1),
nn.BatchNorm2d(64), # BN чувствителен к точности
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 (управляется autocast)
x = self.features[1](x.float()) # BN: принудительно FP32
x = self.features[2](x) # ReLU: FP16
x = self.features[3](x)
x = self.features[4](x.float()) # BN: принудительно FP32
x = self.features[5](x)
x = x.mean(dim=[2, 3]) # Глобальное усредняющее пулирование
x = self.classifier(x)
return x
Совет:autocast в PyTorch автоматически оставляет следующие операции в FP32: softmax, log_softmax, cross_entropy, layer_norm, batch_norm и т. д. Обычно только пользовательские операторы требуют ручной обработки.
4.3 Отсечение градиентов и AMP
Отсечение градиентов должно бытьscaler.step()до, иscaler.unscale_()после выполнения. Это потому, что отсечение должно работать систинными значениями градиента, а не с масштабированным градиентом:
Пример
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)
# Шаг 1: Масштабировать потери и выполнить обратное распространение
scaler.scale(loss).backward()
# Шаг 2: Отмена масштабирования градиентов (восстановление градиентов из масштабированных значений в истинные значения)
# Должен вызываться перед клиппингом и шагом
scaler.unscale_(optimizer)
# Шаг 3: Обрезать истинные градиенты
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
# Шаг 4: Обновить параметры (внутри проверяется, содержат ли градиенты Inf/NaN)
scaler.step(optimizer)
# Шаг 5: Обновить коэффициент масштабирования
scaler.update()
# ── Типичная ошибка: клиппинг без unscale_ ──────────────
# Неверно! Клиппинг применяется к усиленным градиентам, а порог зависит от масштаба
# scaler.scale(loss).backward()
# torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) # ← Неверно
# scaler.step(optimizer)
5. Сравнение производительности и лучшие практики
5.1 Тест производительности
Пример
def benchmark_training(model, train_loader, device, use_amp=True,
dtype=torch.float16, num_iterations=100):
"""Сравнение скорости обучения FP32 и 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)
# ── Разогрев (первые 10 шагов не замеряются) ────────────────────
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()
# ── Формальный тест ─────────────────────────────────
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
# ── Запуск сравнения ─────────────────────────────────────
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: {fp32_time*1000:.2f} ms/batch")
print(f"Среднее время FP16: {fp16_time*1000:.2f} ms/batch")
print(f"Ускорение: {fp32_time / fp16_time:.2f}x")
# Если BF16 поддерживается, протестируйте его также
if torch.cuda.is_bf16_supported():
bf16_time = benchmark_training(
model, train_loader, device, use_amp=True, dtype=torch.bfloat16
)
print(f"Среднее время BF16: {bf16_time*1000:.2f} ms/batch")
print(f"Ускорение BF16: {fp32_time / bf16_time:.2f}x")
5.2 Сравнение использования памяти
Пример
"""Сравнить использование памяти GPU для FP32 и AMP"""
def reset():
torch.cuda.empty_cache()
torch.cuda.reset_peak_memory_stats()
# ── Тест памяти FP32 ────────────────────────────
сброс()
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
# ── Тест памяти AMP ─────────────────────────────
сброс()
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: {fp32_peak:.1f} MB")
print(f"Пиковая память AMP: {amp_peak:.1f} MB")
print(f"Экономия памяти: {(fp32_peak - amp_peak) / fp32_peak * 100:.1f}%")
compare_memory(SimpleModel, train_loader, device)
5.3 Сводка лучших практик
| Сценарий | Рекомендуемая конфигурация | Причина |
|---|---|---|
| A100 / H100 / серия RTX 40 | BF16, GradScaler не нужен | Тот же числовой диапазон, что у FP32, самый стабильный |
| V100 / серия RTX 20 | FP16 + GradScaler | Аппаратное обеспечение не поддерживает BF16; для предотвращения переполнения нужен скейлер |
| Серия RTX 30 | Предпочтительно BF16, FP16 как альтернатива | Архитектура Ampere поддерживает BF16 |
| Обучение больших моделей (ограниченная память GPU) | AMP + накопление градиентов + чекпоинтинг градиентов | Совмещение всех трёх максимизирует использование памяти GPU |
| Развёртывание инференса | autocast + inference_mode | Скейлер не нужен, самый быстрый инференс |
PyTorch 2.0+ встроил AMP в
torch.compileнего, который автоматически применяет оптимизацию смешанной точности. При использованииtorch.compile(model)его, компилятор автоматически определяет, какие операции подходят для FP16.
6. Сочетание с другими методами оптимизации
6.1 AMP + torch.compile
Пример
model = model.to(device)
# Метод 1: Сначала скомпилировать, затем обучать с AMP
# torch.compile автоматически объединяет операторы и оптимизирует доступ к памяти
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()
# Метод 2: Включение TF32 (дополнительное ускорение на архитектурах Ampere+)
# TF32 использует 19-битную точность, со скоростью, близкой к FP16, и точностью, близкой к FP32
torch.backends.cuda.matmul.allow_tf32 = True
torch.backends.cudnn.allow_tf32 = True
torch.backends.cudnn.benchmark = True # Ускоряет свёртку при фиксированном размере входа
6.2 AMP + Распределённое обучение
Пример
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 автоматически синхронизирует градиенты во время обратного прохода
scaler.scale(loss).backward()
# Отсечение градиентов (сначала нужно снять масштаб)
scaler.unscale_(optimizer)
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
scaler.step(optimizer)
scaler.update()
dist.destroy_process_group()
Итог
Обучение со смешанной точностью — этостандартная практика。
Ключевые моменты:
- Выберите формат точности: предпочитайте BF16, если аппаратное обеспечение его поддерживает, иначе используйте FP16 + GradScaler
- Разберитесь с autocast: он автоматически управляет переключением точности, и в большинстве случаев ручное вмешательство не требуется
- Понимание GradScaler: требуется только для FP16, предотвращает недополнение градиентов с помощью динамического масштабирования
- Обратите внимание на порядок обрезки: unscale → clip → step → update, порядок нельзя менять
- Используйте комбинированную оптимизацию: AMP можно бесшовно комбинировать с torch.compile, накоплением градиентов и распределённым обучением