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 в скорости и избежать проблем с точностью.

На следующем рисунке показаны различия в расположении битов трёх форматов с плавающей запятой —Биты экспонентыопределяют числовой диапазон.Биты мантиссыопределяют точность:

Comparison of floating-point format bit layouts Sign bit Exponent bits Mantissa bits FP32 32 bits S 1 Exponent 8 bits Mantissa 23 bits Range: ±3.4×10³⁸ Precision: ~7 significant digits FP16 16 bits S Exp 5 bits Mantissa 10 bits Range: ±65504 Precision: ~3.3 significant digits ⚠ Fewer exponent bits, prone to overflow BF16 16 bits S Exponent 8 bits (same as FP32) Mantissa 7 bits Range: ±3.4×10³⁸ Precision: ~2.4 significant digits ✓ Same range as FP32 BF16 retains FP32's exponent bits → same numerical range → more stable training, usually no GradScaler needed

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:

AMP single-step training flow Input data FP32 autocast Forward propagation Automatically select FP16/FP32 Compute loss FP32 GradScaler Scaling + backward propagation loss × scale_factor Unscale gradients + gradient clipping grad / scale_factor Optimizer update FP32 weights Update Scaler Adjust scale autocast control — automatically selects precision GradScaler control — prevents gradient underflow FP32 weight update — maintains precision Key: weights are always stored and updated in FP32, and are only temporarily converted to FP16 during computation

2.2 Пример базового использования

Пример

import torch
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 (PyTorch 1.10+) ────────────────────
# 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 градиентов и постепенно уменьшая масштабирование, когда обучение стабилизируется, чтобы минимизировать потерю точности:

Dynamic Loss Scaling Scale × Loss Backward pass Gradients contain Inf / NaN? Yes Reduce scale × backoff (default 0.5) Skip this update no Unscale + update parameters Consecutive successes +1 Consecutive successes ≥ growth_interval? (default 2000 steps) Increase scale × growth growth_factor defaults to 2.0 · backoff_factor defaults to 0.5 · Dynamically balancing precision and stability

GradScaler автоматически управляет вышеописанным циклом обратной связи; вам нужно лишь тонко настроить его поведение с помощью параметров:

Пример

from torch.cuda.amp import 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 также рекомендуется для валидации и инференса. Поскольку обратное распространение и масштабирование градиентов не нужны, код проще:

Пример

# ── Использование autocast для инференса ──────────────────────────
@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 имеет защиту для этих операций, но пользовательские операции могут требовать ручной обработки:

Пример

# ── Метод 1: Обернуть функцию потерь, принудительно использующую FP32 ────────
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 Тест производительности

Пример

import time

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 Сравнение использования памяти

Пример

def compare_memory(model_class, train_loader, device):
    """Сравнить использование памяти 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

Пример

# ── Совместное использование с PyTorch 2.0+ ───────────────────────
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, накоплением градиентов и распределённым обучением
Другие расширения