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種類の浮動小数点形式のビットレイアウトの違いを示しています——指数部数値範囲を決定し、仮数部精度を決定します:
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ステップ全体のデータフローを示しています:
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"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は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の核心的な仕組みは動的損失スケーリング——トレーニング状態に応じてスケーリング係数を自動調整し、勾配のアンダーフローを防ぎつつ、トレーニングが安定したらスケーリングを徐々に下げて精度損失を減らします:
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の使用を推奨します。逆伝播と勾配スケーリングが不要なため、コードはより簡潔になります:
例
@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はこれらの操作に対する保護を内蔵していますが、カスタム操作では手動処理が必要な場合があります:
例
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 性能ベンチマークテスト
例
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 比較
例
"""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
例
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、勾配累積、分散トレーニングとシームレスに組み合わせられる