PyTorch torch.optim オプティマイザーモジュール

オプティマイザーはディープラーニングにおける中核的なコンポーネントであり、損失関数の勾配に基づいてモデルのパラメータを調整し、モデルを徐々に最適解に近づける役割を担います。

PyTorch では、torch.optim モジュールがさまざまな最適化アルゴリズムの実装を提供しており、ニューラルネットワークのトレーニングに欠かせないツールです。


なぜオプティマイザーが必要か

オプティマイザーはディープラーニングにおいて極めて重要な役割を果たしており、パラメータを手動で更新する煩わしさを解消します。

  • パラメータ更新の自動化:各パラメータを手動で計算・更新するのは非常に煩雑ですが、オプティマイザーがこの作業を自動的に行います
  • 収束の加速:最適化アルゴリズムを使用すると、通常の勾配降下法よりも速く最適解を見つけられます
  • 局所最適解の回避:一部のオプティマイザーには局所最適解から脱出する能力があります

一般的なオプティマイザーの種類

オプティマイザーによって適したシナリオが異なり、適切なオプティマイザーを選ぶことでトレーニング効果を大幅に向上させることができます。

オプティマイザー名主な特徴適用シナリオ
SGDシンプルで基礎的、モーメンタム対応基礎教育、シンプルなモデル、CNN
Adam適応的学習率ほとんどのディープラーニングタスク
AdamWAdam + 重み減衰の分離L2正則化が必要なタスク
RMSprop適応的学習率RNNネットワーク、音声認識
Adagradパラメータごとの独立した学習率スパースデータ、テキスト処理
Adadelta適応的学習率長期間のトレーニングタスク

オプティマイザーのコアAPI

オプティマイザーの基本的な使用手順を習得することは、ディープラーニングの第一歩です。

基本的な使用手順

オプティマイザーの使用は一定のパターンに従います:インスタンスの作成 → 勾配のクリア → 逆伝播 → パラメータの更新

例

import torch
import torch.nn as nn
import torch.optim as optim

# 1. シンプルなモデルを定義する
class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Linear(784, 10)

    def forward(self, x):
        return self.fc(x)

model = SimpleNet()

# 2. オプティマイザーのインスタンスを作成する
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 3. トレーニングループ
for epoch in range(epochs):
    # 順伝播
    outputs = model(inputs)
    loss = criterion(outputs, labels)

    # 逆伝播
    optimizer.zero_grad()  # 勾配キャッシュをクリアし、勾配の累積を防ぐ
    loss.backward()        # 勾配を計算する

    # パラメータ更新
    optimizer.step()       # パラメータを更新する

主要メソッドの説明

オプティマイザーはパラメータ更新プロセスを管理するためのいくつかのコアメソッドを提供しています。

  • zero_grad(set_to_none=True):パラメータの勾配キャッシュをクリアします。True に設定すると勾配が None になり、0 に設定するよりもメモリを節約できます
  • step():1回のパラメータ更新を実行し、勾配と学習率に基づいてモデルのパラメータを更新します
  • state_dict():オプティマイザーの状態辞書を取得します。チェックポイントの保存に使用できます
  • load_state_dict(state_dict):オプティマイザーの状態を読み込み、トレーニングを再開するために使用します
  • add_param_group(param_group):パラメータグループを動的に追加します

注意:毎回の逆伝播の前に zero_grad() を呼び出す必要があります。呼び出さないと勾配が累積し、トレーニングが不安定になります。メモリを節約するには zero_grad(set_to_none=True) を使用することをお勧めします。

オプティマイザーの状態の保存と読み込み

トレーニングを再開する際は、モデルとオプティマイザーの両方の状態を保存する必要があります。

例

# チェックポイントを保存(モデル、オプティマイザー、スケジューラーを同時に保存)
checkpoint = {
    'epoch': epoch,
    'model_state_dict': model.state_dict(),
    'optimizer_state_dict': optimizer.state_dict(),
    'scheduler_state_dict': scheduler.state_dict(),
    'loss': loss,
}
torch.save(checkpoint, 'checkpoint.pth')

# チェックポイントを読み込む
checkpoint = torch.load('checkpoint.pth')
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
scheduler.load_state_dict(checkpoint['scheduler_state_dict'])
start_epoch = checkpoint['epoch'] + 1

一般的なオプティマイザーの詳細

SGD(確率的勾配降下法)

SGD は最も基本的な最適化アルゴリズムで、単一のサンプルまたはミニバッチのサンプルの勾配を計算してパラメータを更新します。これはディープラーニング最適化の基盤であり、多くの高度なオプティマイザーは SGD を基に発展してきました。

例

# SGD オプティマイザーのパラメータ説明
# params: 最適化するパラメータ(通常は model.parameters() から取得)
# lr: 学習率。パラメータ更新のステップサイズを制御。デフォルトは 0.01
# momentum: モーメンタム係数。収束を加速し振動を減らすために使用。デフォルトは 0
# weight_decay: L2正則化係数。過学習を防ぐために使用。デフォルトは 0
# dampening: モーメンタムの減衰。モーメンタム項の計算を制御。デフォルトは 0
# nesterov: Nesterov モーメンタムを使用するかどうか。デフォルトは False
optimizer = optim.SGD(
    params=model.parameters(),
    lr=0.01,           # 学習率
    momentum=0.9,      # モーメンタム係数
    weight_decay=1e-4, # L2正則化
    nesterov=True      # Nesterov モーメンタムを有効にする
)

コアパラメータの説明:

  • lr (float):学習率。パラメータ更新のステップサイズを制御します
  • momentum (float):モーメンタム係数。収束を加速し振動を減らすために使用。一般的な値は 0.9
  • weight_decay (float):L2正則化係数。過学習を防ぐために使用。一般的な値は 1e-4
  • nesterov (bool):Nesterov モーメンタムを使用するかどうか。有効にすると振動を減らせます

特徴:

  • 実装がシンプルで、ディープラーニング最適化の基礎アルゴリズムです
  • モーメンタム項を追加すると収束が加速し、トレーニングの安定性が向上します
  • 収束速度は遅いですが、最終的な精度は高くなる可能性があります
  • 他のオプティマイザーと比較するベースラインとして適しています

SGD はシンプルですが、適切なハイパーパラメータの下では非常に良い結果が得られることが多く、最適化アルゴリズムを学ぶための良い出発点です。画像分類タスクでは、SGD にモーメンタムを組み合わせたものが今でも主流の選択肢です。

Adam(適応モーメント推定)

Adam は現在最もよく使われるオプティマイザーの1つで、モーメンタムと適応的学習率の利点を組み合わせています。勾配の1次および2次モーメント推定を計算することで、各パラメータの学習率を適応的に調整します。

例

# Adam オプティマイザーのパラメータ説明
# params: 最適化するパラメータ
# lr: 学習率。デフォルトは 0.001(推奨値)
# betas: 勾配と勾配の2乗の移動平均を計算するための係数 (beta1, beta2)
# beta1 は1次モーメント推定(モーメンタム)を制御。デフォルトは 0.9
# beta2 は2次モーメント推定(分散)を制御。デフォルトは 0.999
# eps: 数値安定化項。ゼロ除算エラーを防ぎます。デフォルトは 1e-8
# weight_decay: L2正則化係数。デフォルトは 0
# amsgrad: AMSGrad 変種を使用するかどうか。デフォルトは False
optimizer = optim.Adam(
    params=model.parameters(),
    lr=0.001,                      # 小さめの学習率を推奨
    betas=(0.9, 0.999),            # 一般的なモーメンタムパラメータ
    eps=1e-8,                      # 数値安定化項
    weight_decay=1e-4,             # L2正則化
    amsgrad=False                  # AMSGrad を使用するかどうか
)

コアパラメータの説明:

  • betas (Tuple[float, float]):勾配と勾配の2乗の指数移動平均を制御します
  • eps (float):数値安定化項。分母がゼロになるのを防ぎます
  • amsgrad (bool):AMSGrad 変種を使用するかどうか。使用すると収束性が保証されます

特徴:

  • 適応的学習率:パラメータの過去の勾配に基づいて学習率を自動調整します
  • モーメンタムの概念を統合:1次モーメント推定を利用して収束を加速します
  • ロバスト性が高い:ハイパーパラメータの選択に比較的影響を受けません
  • 収束が速く、迅速なプロトタイプ開発に適しています

Adam はほとんどのディープラーニングタスクでデフォルトの選択肢ですが、特定のシナリオ(GAN、強化学習など)では他のオプティマイザーを試す必要がある場合があります。

AdamW(Adam with Weight Decay)

AdamW は Adam の改良版であり、重み減衰と勾配更新を分離することで、理論的に収束しやすくなります。実際の応用では、AdamW は通常 Adam よりも良い結果が得られます。

例

# AdamW オプティマイザー
# Adam との主な違い: weight_decay の実装方法が異なる
# AdamW の重み減衰はより正確で、勾配の計算に影響を与えない
optimizer = optim.AdamW(
    params=model.parameters(),
    lr=0.001,
    betas=(0.9, 0.999),
    weight_decay=0.01,    # 重み減衰係数。通常 Adam よりも大きく設定する
    amsgrad=False
)

# 推奨設定: AdamW は通常 weight_decay を 0.01 にする
# Adam は通常 0.001 を使用する

タスクで重み減衰(L2 正則化)が必要な場合は、Adam ではなく AdamW を強くお勧めします。

RMSprop

RMSprop は適応的学習率オプティマイザーであり、非定常な対象やリカレントニューラルネットワークの処理に特に適しています。

例

# RMSprop オプティマイザー
# 勾配の指数加重平均で割ることにより学習率を正規化する
optimizer = optim.RMSprop(
    params=model.parameters(),
    lr=0.01,               # 学習率
    alpha=0.99,            # 二乗勾配の指数減衰率
    eps=1e-8,              # 数値安定化項
    weight_decay=0,        # L2 正則化
    momentum=0,            # モーメンタム係数
    centered=False         # 勾配をセンタリングするかどうか
)

Adagrad

Adagrad はスパースデータの処理に適しており、各パラメータの学習率を適応的に調整します。

例

# Adagrad オプティマイザー
# スパースデータの最適化に適しており、頻繁に更新されるパラメータにはより小さな学習率を使用する
optimizer = optim.Adagrad(
    params=model.parameters(),
    lr=0.01,               # 学習率
    lr_decay=0,            # 学習率の減衰
    weight_decay=0,       # L2 正則化
    initial_accumulator_value=0  # 初期累積値
)

オプティマイザーの発展的なテクニック

学習率スケジューリング

学習率スケジューリングにより、トレーニング中に学習率を動的に調整でき、通常モデルの収束効果を大幅に向上させることができます。

例:さまざまな学習率スケジューラー

from torch.optim.lr_scheduler import (
    StepLR,                # ステップ減衰
    MultiStepLR,           # マルチマイルストーン減衰
    ExponentialLR,         # 指数減衰
    CosineAnnealingLR,     # コサインアニーリング
    ReduceLROnPlateau,     # メトリクスに基づく自動調整
)

# 方法1: StepLR - 30 エポックごとに減衰
optimizer = optim.SGD(model.parameters(), lr=0.1)
scheduler = StepLR(optimizer, step_size=30, gamma=0.1)

# 方法2: MultiStepLR - 指定したエポックで減衰
optimizer = optim.SGD(model.parameters(), lr=0.1)
scheduler = MultiStepLR(optimizer, milestones=[30, 60, 80], gamma=0.1)

# 方法3: CosineAnnealingLR - コサイン曲線によるアニーリング
optimizer = optim.Adam(model.parameters(), lr=0.001)
scheduler = CosineAnnealingLR(optimizer, T_max=50, eta_min=1e-6)

# 方法4: ReduceLROnPlateau - モニタリングメトリクスで自動調整
optimizer = optim.Adam(model.parameters(), lr=0.001)
scheduler = ReduceLROnPlateau(
    optimizer, mode='min',     # loss を監視
    factor=0.5,                 # 減衰係数
    patience=5,                 # 待機エポック数
    verbose=True                # 情報を出力
)

# トレーニングループ
for epoch in range(100):
    train_loss = train(...)
    val_loss = validate(...)

    # StepLR などのスケジューラー
    scheduler.step()

    # ReduceLROnPlateau は監視するメトリクスを渡す必要がある
    scheduler.step(val_loss)

学習率スケジューラーはオプティマイザーと組み合わせて使用する必要があり、step() は optimizer.step() の後に呼び出さないと、学習率の更新が異常になる可能性があります。

パラメータグループ別の最適化

パラメータグループ化により、異なる層に異なる学習率を設定できます。これは転移学習で特に役立ちます。

例

# パラメータグループ最適化の例
# 異なる層に異なる学習率を設定する
# 通常: バックボーンネットワークには小さな学習率、分類ヘッドには大きな学習率を使用
optimizer = optim.SGD([
    {'params': model.base.parameters(), 'lr': 1e-3},      # ベース層: 大きな学習率
    {'params': model.classifier.parameters(), 'lr': 1e-2} # 分類層: 大きな学習率
], lr=1e-4)  # グローバルデフォルト学習率(パラメータグループが指定されていない場合に使用)

# 実際のアプリケーションでより一般的な書き方
optimizer = optim.Adam([
    {'params': model.fc.parameters(), 'lr': 1e-3},       # 分類ヘッド
    {'params': [p for n, p in model.named_parameters()    # バックボーンネットワーク
                if not n.startswith('fc')],
     'lr': 1e-5},
])

勾配クリッピング

勾配クリッピングは勾配爆発を防ぎ、トレーニングの安定性を向上させることができます。特に RNN、LSTM などの深層ネットワークで非常に役立ちます。

例

import torch.nn as nn

# 勾配クリッピングの例
# max_norm: 勾配の最大ノルム。この値を超える勾配はスケーリングされる
# norm_type: ノルムの種類。デフォルトは 2(L2 ノルム)
nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

# トレーニングループ内での使用位置
for epoch in range(epochs):
    optimizer.zero_grad()
    outputs = model(inputs)
    loss = criterion(outputs, labels)
    loss.backward()

    # loss.backward() の後、optimizer.step() の前に勾配をクリップする
    nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

    optimizer.step()

# 勾配クリッピングのもう一つの方法: 値によるクリッピング
for param in model.parameters():
    if param.grad is not None:
        param.grad.data.clamp_(min=-1.0, max=1.0)

勾配クリッピングは深層ニューラルネットワーク(特に RNN、LSTM など)をトレーニングする際の一般的なテクニックであり、勾配爆発によるトレーニングの破綻を効果的に防ぐことができます。

勾配の累積

ビデオメモリが不足している場合、勾配累積を使用して大きなバッチサイズのトレーニング効果をシミュレートできます。

例

# 勾配累積の例
# 実際の batch_size = batch_size * accumulation_steps
accumulation_steps = 4   # 4 つの小さなバッチを累積する

optimizer.zero_grad()

for i, (inputs, labels) in enumerate(train_loader):
    outputs = model(inputs)
    loss = criterion(outputs, labels)

    # 損失を累積ステップ数で割って平均化する
    loss = loss / accumulation_steps
    loss.backward()

    # 指定した累積ステップ数ごとにパラメータを更新する
    if (i + 1) % accumulation_steps == 0:
        nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
        optimizer.step()
        optimizer.zero_grad()

# 残りの勾配を処理する
if (i + 1) % accumulation_steps != 0:
    optimizer.step()
    optimizer.zero_grad()

完全なトレーニング例

以下は、オプティマイザーのベストプラクティスを示す完全なトレーニングフローです。

例

import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim.lr_scheduler import CosineAnnealingLR

# 設定
DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
EPOCHS = 100
BATCH_SIZE = 32
LR = 1e-3

# モデルを作成してデバイスに移動
model = SimpleNet().to(DEVICE)

# 損失関数とオプティマイザー
criterion = nn.CrossEntropyLoss()
optimizer = optim.AdamW(model.parameters(), lr=LR, weight_decay=0.01)

# 学習率スケジューラー(コサインアニーリング)
scheduler = CosineAnnealingLR(optimizer, T_max=EPOCHS, eta_min=1e-6)

# トレーニングループ
best_acc = 0.0
for epoch in range(EPOCHS):
    model.train()
    total_loss = 0.0
    correct = 0

    for inputs, labels in train_loader:
        inputs = inputs.to(DEVICE)
        labels = labels.to(DEVICE)

        # 勾配をクリア(set_to_none=True を使用することを推奨)
        optimizer.zero_grad(set_to_none=True)

        # フォワード伝播
        outputs = model(inputs)
        loss = criterion(outputs, labels)

        # バックワード伝播
        loss.backward()

        # 勾配クリッピング(勾配爆発の防止)
        nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

        # パラメータの更新
        optimizer.step()

        # 統計
        total_loss += loss.item()
        correct += (outputs.argmax(1) == labels).sum().item()

    # 学習率の更新
    scheduler.step()

    # トレーニング情報の出力
    avg_loss = total_loss / len(train_loader)
    accuracy = correct / len(train_loader.dataset)
    current_lr = scheduler.get_last_lr()[0]
    print(f"Epoch {epoch+1}/{EPOCHS} | Loss: {avg_loss:.4f} | "
          f"Acc: {accuracy:.4f} | LR: {current_lr:.6f}")

    # 最良のモデルを保存
    if accuracy > best_acc:
        best_acc = accuracy
        torch.save({
            'epoch': epoch,
            'model_state_dict': model.state_dict(),
            'optimizer_state_dict': optimizer.state_dict(),
            'scheduler_state_dict': scheduler.state_dict(),
            'best_acc': best_acc,
        }, 'best_model.pth')

print(f"トレーニング完了、最高精度: {best_acc:.4f}")

オプティマイザー選択ガイド

適切なオプティマイザーの選択は、具体的なタスク、データの特性、トレーニング段階に基づいて決定する必要があります。

タスク別の選択

タスクの種類によって、推奨されるオプティマイザーが異なります。

タスクの種類推奨オプティマイザー推奨学習率備考
画像分類(CNN)SGD + Momentum0.01 ~ 0.1収束は遅いが精度が高い
画像分類(CNN)AdamW0.001収束が速い
NLP / TransformerAdamW1e-5 ~ 1e-4より小さな学習率
RNN / LSTMRMSprop / Adam0.001適応的学習率
GANAdam (G) / Adam (D)0.0001より小さな学習率
強化学習Adam / RMSprop0.0001 ~ 0.001タスクによる
高速実験Adam / AdamW0.001収束が速い

性能比較

オプティマイザー収束速度メモリ使用量ハイパーパラメータ感度最終精度
SGD + Momentum慢低高高
Adam快中低中
AdamW快中低高
RMSprop中中中中
Adagrad中高中低

よくある問題と解決策

  • トレーニングが不安定(Loss が振動): 学習率を下げ、勾配クリッピングを追加する
  • 収束が遅すぎる: Adam または AdamW を使用し、学習率を上げる
  • 過学習: weight_decay を増やし、正則化を使用する
  • ビデオメモリ不足: batch_size を減らし、勾配累積を使用する

オプティマイザーの選択は絶対的なものではありません。Adam または AdamW から試すことをお勧めします。効果が不十分な場合は、他のオプティマイザーを検討してください。特定のタスクでは、実験を通じて最適な選択を決定する必要がある場合があります。

より詳細な情報が必要な場合は、以下を参照してくださいPyTorch 公式ドキュメント。

その他の拡張