PyTorch 混合精度トレーニング (AMP)

混合精度トレーニングは、ディープラーニングにおいて最も重要な性能最適化技術の1つです。FP32(単精度)と FP16(半精度)の浮動小数点数を同時に使用して計算することで、モデルの精度をほとんど損なうことなく、トレーニング速度を大幅に向上させ、VRAM 使用量を削減できます。このセクションでは、PyTorch の自動混合精度(Automatic Mixed Precision、AMP)技術について詳しく説明します。

対応バージョン:この記事のコードは PyTorch 1.6+ のtorch.cuda.ampAPI に基づいて記述されています。PyTorch 2.4+ では推奨される方式を採用しておりtorch.amp.autocastとtorch.amp.GradScaler、基本的な使い方はほぼ同じです。記事内で差異を明記します。


1. 混合精度トレーニングの基礎

1.1 なぜ混合精度が必要か

ディープラーニングモデルのトレーニングプロセスには、大量の行列演算が含まれます。従来の FP32(32ビット浮動小数点)は計算精度が高い一方、VRAM 使用量が大きく、計算速度が遅いです。FP16(16ビット浮動小数点)は計算速度が速く、VRAM 使用量が少ない一方、数値表現範囲が狭く、勾配アンダーフロー(underflow)が発生しやすいです。

混合精度トレーニングの核となる考え方は次のとおりです:精度要求が高い操作には FP32 を、精度要求が低い操作には FP16 を使用します。これにより、FP16 の速度上の利点を活かしつつ、精度の問題を回避できます。

次の図は、3種類の浮動小数点形式のビットレイアウトの違いを示しています——指数部数値範囲を決定し、仮数部精度を決定します:

浮動小数点形式のビットレイアウト比較 符号部 指数部 仮数部 FP32 32 bits S 1 Exponent 8 bits Mantissa 23 bits 範囲: ±3.4×10³⁸ 精度: ~7桁の有効数字 FP16 16 bits S Exp 5 bits Mantissa 10 bits 範囲: ±65504 精度: ~3.3桁の有効数字 ⚠ 指数部が少ないため、オーバーフローしやすい BF16 16 bits S Exponent 8 ビット(FP32 と同じ) Mantissa 7 bits 範囲: ±3.4×10³⁸ 精度: ~2.4桁の有効数字 ✓ FP32 と同じ範囲 BF16 は FP32 の指数部を保持 → 数値範囲が同じ → トレーニングがより安定し、通常は GradScaler 不要

1.2 混合精度の利点

指標 向上効果 説明
トレーニング速度 2〜3倍の向上 GPU Tensor Core のサポートに依存
VRAM使用量 約50%削減 活性値と中間結果は FP16 で保存
メモリ帯域幅 約50%削減 データサイズが小さいほど転送量が少なくなる
通信オーバーヘッド 約50%削減 分散トレーニングでは勾配の転送量が半分になる

1.3 Tensor Core 高速化の原理

NVIDIA の Tensor Core は、行列演算専用のハードウェアユニットです。1クロックサイクルで 4×4 行列の積和演算(D = A × B + C)を完了できます。これが FP16 トレーニング高速化の主な源泉です。通常の CUDA コアでは同じ演算を完了するために複数の命令が必要なのに対し、Tensor Core はそれを単一の命令に圧縮します。

Tensor Core をサポートする GPU には次のものがあります:

  • 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 を追加

コンシューマー向け RTX GPU も Tensor Core をサポートしています。例えば RTX 3060 以降のモデルはすべて AMP による高速化を利用できます。


2. PyTorch AMP の基本的な使い方

2.1 autocast と GradScaler

PyTorch の AMP API は主に2つのコアコンポーネントで構成されています:

  • autocastautocast:コンテキストマネージャー。領域内の演算を自動的に FP16 に切り替えます(精度に敏感な操作は自動的に FP32 にフォールバックします)
  • GradScalerGradScaler:勾配スケーリング係数を動的に調整し、FP16 勾配を拡大してアンダーフローを防ぎます(FP16 でのみ必要で、BF16 では通常不要です)

次の図は、AMP トレーニングの1ステップ全体のデータフローを示しています:

AMP の1ステップトレーニングフロー 入力データ FP32 autocast 順伝播 FP16/FP32 を自動選択 Loss の計算 FP32 GradScaler スケーリング + 逆伝播 loss × scale_factor 勾配のスケール解除 + 勾配クリッピング grad / scale_factor オプティマイザの更新 FP32 の重み 更新 Scaler scale の調整 autocast 制御 — 精度を自動選択 GradScaler 制御 — 勾配のアンダーフローを防止 FP32 の重み更新 — 精度を維持 ポイント:重みは常に FP32 で保存・更新され、計算時のみ一時的に FP16 に変換されます

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"GPU: {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. loss をスケーリング(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 {epoch+1}: Loss={loss:.4f}, Acc={acc:.4f}")

print(混合精度トレーニングが完了しました!)

API移行のヒント:PyTorch 2.4 はtorch.cuda.amp.autocastを deprecated としてマークし、の使用を推奨しますtorch.amp.autocast('cuda')。両者の使い方は完全に同じで、インポートパスのみが異なります。

2.3 BF16 と FP16 の選択

現代のGPUは2種類の半精度形式をサポートしています。その核心的な違いは、指数部と仮数部の割り当て戦略が異なる点です:

形式 指数部 仮数部 数値範囲 精度 適用シーン
FP16 5 bits 10 bits ±65504 高い(約3.3桁) 旧GPU(V100/RTX 20系)との互換性が必要
BF16 8 bits 7 bits ±3.4×10³⁸ 低い(約2.4桁) 安定性を重視(A100/RTX 30系以降)

選択の推奨:ハードウェアがBF16をサポートしている場合、BF16を優先的に使用します。BF16の数値範囲はFP32と完全に同じで、トレーニング中にオーバーフローが発生することはほとんどなく、GradScalerも不要です。

例

# ── BF16の書き方(PyTorch 1.10+)────────────────────
# BF16はFP32と数値範囲が同じなのでGradScalerは不要

from torch.cuda.amp import autocast

# 方法1:autocast内でdtypeを指定
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の核心的な仕組みは動的損失スケーリング——トレーニング状態に応じてスケーリング係数を自動調整し、勾配のアンダーフローを防ぎつつ、トレーニングが安定したらスケーリングを徐々に下げて精度損失を減らします:

動的損失スケーリング(Dynamic Loss Scaling) Scale × Loss 逆伝播 勾配に存在 Inf / NaN? である scaleを縮小 × backoff (デフォルト0.5) 今回の更新をスキップ 否 Unscale + パラメータ更新 連続成功 +1 連続成功 ≥ growth_interval? (デフォルト2000ステップ) scale × growth に増加 growth_factor デフォルト2.0 · backoff_factor デフォルト0.5 · 精度と安定性を動的にバランス

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. 初期 scale = 65536
# 2. いずれかのstepでInf/NaNが発生 → scale × 0.5(縮小)、そのstepをスキップ
# 3. 連続2000ステップ Inf/NaNなし → scale × 2.0(増加)
# 4. 常に安全な範囲で最大の利用可能なscaleを探す

# 現在のスケーリング係数を確認
print(f現在のスケーリング係数: {scaler.get_scale()})

# scalerが前のステップが成功したとみなすか判定
print(f直近の成功有無: {scaler._found_inf.item() == 0})

3.2 勾配累積における AMP

勾配累積は、限られたGPUメモリでより大きなバッチサイズをシミュレートするために使われます。AMPを使用する際、各サブバッチのlossを累積ステップ数で割る必要があります。割らないと最終的な勾配が増幅されます:

例

# ── 勾配累積 + 混合精度 ──────────────────────────
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を累積ステップ数で割る
        # これで累積された勾配は大きなバッチの平均勾配と同等になる
        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:
    # 累積された勾配を実際のステップ数に応じて再スケーリングする必要がある
    # 簡単な方法:そのまま step を実行する。勾配は大きめになるが影響は通常小さい
    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になる 勾配オーバーフロー(scaleが大きすぎる、または学習率が高すぎる) 低くするinit_scale、勾配クリッピングを追加し、学習率を下げる
Lossが下がらない / 振動する 勾配アンダーフロー(scaleが小さすぎて、勾配が0に切り捨てられる) 上げるinit_scale、勾配の統計を確認し、BF16を試す
精度の低下が顕著 一部の層(LayerNorm、Softmaxなど)はFP16に敏感 これらの層を手動でFP32に保つ(4.2参照)
トレーニング後期に不安定 モデルパラメータの値域の変化によりscaleが合わなくなる 適度に増やすgrowth_interval、scale調整をより保守的にする

4.2 精度の手動制御

一部の操作はFP16では精度損失が大きいため、手動でFP32を使用するよう指定する必要があります。PyTorchのautocastはこれらの操作に対する保護を内蔵していますが、カスタム操作では手動処理が必要な場合があります:

例

# ── 方法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])            # Global Average Pooling
        x = self.classifier(x)
        return x

ヒント:PyTorch の autocast は以下の操作を自動的に 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)

    # Step 1: loss をスケーリングして逆伝播
    scaler.scale(loss).backward()

    # Step 2: 勾配のスケーリングを解除(勾配を scale から実際の値に戻す)
    # クリッピングと step の前に呼び出す必要がある
    scaler.unscale_(optimizer)

    # Step 3: 実際の勾配に対してクリッピングを実行
    torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

    # Step 4: パラメータを更新(内部で勾配に Inf/NaN が含まれるかチェック)
    scaler.step(optimizer)

    # Step 5: スケール係数を更新
    scaler.update()

# ── よくある間違い:unscale_ を忘れてクリッピング ──────────────
# 誤り!クリッピング対象は拡大された勾配であり、閾値が scale に干渉される
# 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 VRAM 比較

例

def compare_memory(model_class, train_loader, device):
    """FP32 と AMP のメモリ使用量を比較"""
    def reset():
        torch.cuda.empty_cache()
        torch.cuda.reset_peak_memory_stats()

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

    # ── 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 ピークメモリ: {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 をサポートしていないため、オーバーフロー防止に scaler が必要
RTX 30 系 BF16 優先、FP16 を代替とする Ampere アーキテクチャは BF16 をサポート
大規模モデルトレーニング(メモリが逼迫) AMP + 勾配累積 + 勾配チェックポイント 3つを組み合わせることでメモリ使用効率を最大化できる
推論デプロイ autocast + inference_mode scaler 不要、推論が最速

PyTorch 2.0+ は AMP をtorch.compileに統合しており、自動的に混合精度最適化を適用できます。torch.compile(model)を使用する場合、コンパイラは自動的に FP16 に適した操作を判断します。


6. 他の最適化技術との組み合わせ

6.1 AMP + torch.compile

例

# ── PyTorch 2.0+ との組み合わせ ───────────────────────
model = model.to(device)

# 方法1:先に compile してから 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 は backward で自動的に勾配を同期する
        scaler.scale(loss).backward()

        # 勾配クリッピング(先に 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()

まとめ

混合精度トレーニングは、現在のディープラーニングトレーニングにおける標準的な実践。

核心ポイント:

  • 精度フォーマットの選択:ハードウェアが BF16 をサポートする場合は優先して使用し、それ以外は FP16 + GradScaler を使用
  • autocast の理解:精度の切り替えを自動的に管理し、ほとんどの場合手動介入は不要
  • GradScaler の理解:FP16 の場合のみ必要で、動的スケーリングにより勾配アンダーフローを防止する
  • クリッピングの順序に注意:unscale → clip → step → update、順序は入れ替え不可
  • 組み合わせ最適化を活用:AMP は torch.compile、勾配累積、分散トレーニングとシームレスに組み合わせられる
その他の拡張