STEP 11：最適化アルゴリズム

ホーム > ディープラーニング基礎 > STEP 11

⚡ STEP 11: 最適化アルゴリズム

SGD、Momentum、Adam など、効率的な学習を実現する最適化手法を習得しよう

📋 このステップで学ぶこと

  • 最適化アルゴリズムとは何か？なぜ重要か？
  • SGD（確率的勾配降下法）：最も基本的な手法
  • Momentum：慣性を利用して加速する
  • AdaGrad：学習率を自動調整する
  • RMSprop：AdaGradの問題を解決
  • Adam：最も人気のある最適化手法
  • どの最適化手法を選べばいいか？

🎯 1. 最適化アルゴリズムとは？

1-1. 学習の流れを復習

まず、ニューラルネットワークの学習の流れを復習しましょう。

以下の図は横スクロールできます。

【ニューラルネットワークの学習サイクル】 ┌─────────────────────────────────────────────────────────────┐ │ │ │ ① 順伝播：入力データから予測値を計算 │ │ ↓ │ │ ② 損失計算：予測と正解の差（＝間違いの大きさ）を測定 │ │ ↓ │ │ ③ 逆伝播：各パラメータの勾配を計算（STEP 9で学習） │ │ ↓ │ │ ④ パラメータ更新：勾配を使って重みを更新 ← ★今回のテーマ！ │ │ ↓ │ │ ①に戻って繰り返し │ │ │ └─────────────────────────────────────────────────────────────┘ 「最適化アルゴリズム」は④のステップを担当します！

1-2. 最適化アルゴリズムの役割

💡 最適化アルゴリズム（Optimizer）とは？

逆伝播で計算した勾配を使って、重みをどのように更新するかを決める方法です。

目標：損失を最小化する重みを見つけること

1-3. なぜ最適化アルゴリズムが重要なのか？

🗻 山登りの例え

霧が深くて周りが見えない山の頂上から、麓（最低点）を目指すことを考えます。

いろいろな戦略があります：

  • SGD：足元の傾きだけを頼りに、一歩ずつ慎重に下りる
  • Momentum：勢いをつけて走って下りる（小さな谷は越えられる）
  • Adam：地形に応じて歩幅を自動調整しながら効率的に下りる
🎯 最適化手法で結果が大きく変わる

同じネットワーク構造でも、最適化手法が違うだけで：

・学習速度が10倍以上変わることもある
・最終的な精度が大きく異なる
・局所最適解（小さな谷）に陥りにくくなる

🚶 2. SGD（確率的勾配降下法）

2-1. SGDとは？

SGD（Stochastic Gradient Descent）は、最もシンプルで基本的な最適化手法です。
「勾配の方向に重みを少しずつ更新する」というシンプルなアイデアです。

📐 SGDの更新式

w_new = w_old – η × ∂L/∂w

各記号の意味：
・w_new：更新後の重み（新しい値）
・w_old：更新前の重み（古い値）
・η（イータ）：学習率（一歩の大きさ、例：0.01）
・∂L/∂w：損失Lの重みwに関する勾配（逆伝播で計算した値）

2-2. なぜマイナス（−）なのか？

以下の図は横スクロールできます。

【勾配の方向と更新の関係】 損失 L ↑ │ 10 │ ╱╲ │ ╱ ╲ │ ╱ ╲ 5 │ ╱ ★ ╲ ★ = 最小値（目標） │╱ ╲ │ ╲ 0 └──────────────────→ 重み w 2 4 6 【現在位置が左側（w=2）の場合】 ・グラフは右下がり → 勾配 ∂L/∂w < 0（負） ・w_new = w_old - η × (負の値) ・w_new = w_old + 何か → 重みが増える → 右に移動 → ★に近づく！ 【現在位置が右側（w=6）の場合】 ・グラフは右上がり → 勾配 ∂L/∂w > 0（正） ・w_new = w_old – η × (正の値) ・w_new = w_old – 何か → 重みが減る → 左に移動 → ★に近づく！ → マイナスにすることで、常に最小値の方向に移動できる！

2-3. 学習率の役割

👟 学習率 = 一歩の大きさ

学習率が大きすぎる場合（η = 1.0）：
→ 一歩が大きすぎて、最小値を飛び越えてしまう
→ 発散して学習に失敗する

学習率が小さすぎる場合（η = 0.0001）：
→ 一歩が小さすぎて、なかなか最小値に到達しない
→ 学習に時間がかかりすぎる

適切な学習率（η = 0.01〜0.001）：
→ ちょうどいいペースで最小値に到達できる

2-4. Kerasでの実装

📝 コードの解説

from tensorflow.keras.optimizers import SGD

KerasのSGDオプティマイザをインポートします。

SGD(learning_rate=0.01)

学習率0.01でSGDオプティマイザを作成します。
学習率は問題に応じて調整が必要です。

from tensorflow.keras.optimizers import SGD # SGDオプティマイザの作成 optimizer = SGD(learning_rate=0.01) # モデルのコンパイル時に指定 model.compile( optimizer=optimizer, loss=’categorical_crossentropy’, metrics=[‘accuracy’] )

2-5. SGDの問題点

⚠️ SGDには3つの問題がある

問題1：谷で振動する
細長い谷では、左右に振動してなかなか底に到達できない

問題2：局所最適解に陥る
小さな谷で止まってしまい、より深い谷（真の最適解）に到達できない

問題3：学習率の選択が難しい
大きすぎると発散、小さすぎると遅すぎる

これらの問題を解決するために、様々な改良版が開発されました。
次のセクションから、それらを見ていきましょう。

🏃 3. Momentum（モメンタム）

3-1. Momentumとは？

Momentumは、過去の勾配の情報を利用して「慣性」をつける手法です。
物理学の「運動量（momentum）」から名前が来ています。

🎾 ボールが坂を転がる様子

SGD（慣性なし）：
ボールを手で持って、一歩ずつ慎重に下ろしていく
→ 小さな谷があると、そこで止まってしまう

Momentum（慣性あり）：
ボールを転がす。勢いがついてどんどん加速する
→ 小さな谷は勢いで越えて、より深い谷を見つけられる！

3-2. Momentumの更新式

📐 Momentumの更新式

v = β × v + η × ∂L/∂w　　（速度を更新）
w_new = w_old – v　　　　　（重みを更新）

各記号の意味：
・v：速度（velocity）、過去の勾配の蓄積
・β（ベータ）：モメンタム係数（通常0.9）
・η：学習率
・∂L/∂w：現在の勾配

3-3. なぜβ=0.9なのか？

【β=0.9の意味】 v_new = 0.9 × v_old + 0.1 × 現在の勾配 つまり： ・過去の速度の90%を維持 ・現在の勾配の10%を追加 → 過去の情報を「ゆっくり忘れながら」新しい情報を取り入れる → 一貫した方向には加速、振動方向は打ち消し合う

3-4. Momentumの動作イメージ

以下の図は横スクロールできます。

【Momentumの動き】 時刻1: 勾配が右向き → vが右向きに増える → 右に移動 時刻2: 勾配が右向き → vがさらに右向きに増える → 加速！加速！ 時刻3: 勾配が左向き → vは減速するが、まだ右向き → 慣性で右に移動 時刻4: 勾配が左向き → vがさらに減速 → 方向転換 【ポイント】 ・一貫した方向（ずっと右向き）には、どんどん加速する ・振動方向（左右交互）は、打ち消し合って減衰する → SGDより速く、安定して最小値に到達できる！

3-5. Kerasでの実装

📝 コードの解説

momentum=0.9

モメンタム係数を0.9に設定します。
これが標準的な値で、ほとんどの場合0.9でOKです。

from tensorflow.keras.optimizers import SGD # Momentumを使ったSGD optimizer = SGD( learning_rate=0.01, momentum=0.9 # モメンタム係数（0.9が標準） ) model.compile( optimizer=optimizer, loss=’categorical_crossentropy’, metrics=[‘accuracy’] )
✅ Momentumの効果まとめ
  • 収束が速い：一貫した方向に加速するので、SGDより早く最適解に到達
  • 局所最適解を回避：勢いで小さな谷を越えられる
  • 振動の抑制：谷での左右の振動が減る

📊 4. AdaGrad（適応的勾配法）

4-1. AdaGradとは？

AdaGrad（Adaptive Gradient）は、各パラメータごとに学習率を自動調整する手法です。
「よく更新されるパラメータは学習率を小さく、あまり更新されないパラメータは学習率を大きく」します。

📚 テスト勉強の例え

得意科目（よく勉強した）：
→ すでに十分理解している → 少しだけ復習すればOK（学習率小）

苦手科目（あまり勉強していない）：
→ まだ理解が不十分 → たくさん勉強する必要がある（学習率大）

4-2. AdaGradの更新式

📐 AdaGradの更新式

h = h + (∂L/∂w)²　　　　　　（勾配の二乗を累積）
w_new = w_old – (η / √h) × ∂L/∂w　（重みを更新）

各記号の意味：
・h：勾配の二乗和の累積（過去にどれだけ更新されたかを記録）
・η：基本の学習率
・√h：hの平方根
・η / √h：実効学習率（hが大きいほど小さくなる）

4-3. AdaGradの動作イメージ

【AdaGradの動き】 パラメータA（頻繁に大きな勾配がある）： 時刻1: h = 0 + 10² = 100 時刻2: h = 100 + 10² = 200 時刻3: h = 200 + 10² = 300 → h が大きい → 学習率 η/√300 ≈ 0.058η → 慎重に更新 パラメータB（たまに小さな勾配がある）： 時刻1: h = 0 + 1² = 1 時刻2: h = 1 + 0² = 1 時刻3: h = 1 + 1² = 2 → h が小さい → 学習率 η/√2 ≈ 0.71η → 大胆に更新 → 各パラメータに合わせた学習率になる！

4-4. Kerasでの実装

from tensorflow.keras.optimizers import Adagrad # AdaGradオプティマイザ optimizer = Adagrad(learning_rate=0.01) model.compile( optimizer=optimizer, loss=’categorical_crossentropy’, metrics=[‘accuracy’] )

4-5. AdaGradの問題点

⚠️ AdaGradの致命的な問題

h = h + (∂L/∂w)²
↑ hは単調増加する（減ることがない）

学習が進むと：
→ h がどんどん大きくなる
→ 学習率 η/√h がどんどん小さくなる
→ 最終的に学習率が0に近づいて学習が止まる！

この問題を解決したのが、次に紹介するRMSpropです。

🔄 5. RMSprop

5-1. RMSpropとは？

RMSprop（Root Mean Square Propagation）は、AdaGradの問題（学習率が0に近づく）を解決した手法です。
過去の勾配の影響を徐々に忘れることで、学習率が極端に小さくなるのを防ぎます。

5-2. RMSpropの更新式

📐 RMSpropの更新式

h = γ × h + (1 – γ) × (∂L/∂w)²　（移動平均）
w_new = w_old – (η / √h) × ∂L/∂w

AdaGradとの違い：
・AdaGrad：h = h + (∂L/∂w)²　　←すべて累積
・RMSprop：h = γ×h + (1-γ)×(∂L/∂w)²　←移動平均

γ（ガンマ）= 減衰率（通常0.9）

5-3. なぜ移動平均が良いのか？

📊 AdaGradとRMSpropの比較

【AdaGrad】
h = 0 → 100 → 200 → 300 → 400 → … → ∞
学習率 → どんどん0に近づく → 学習が止まる！

【RMSprop（γ=0.9）】
h = 0.9×h + 0.1×(新しい勾配)²
h = 0 → 10 → 19 → 27 → 34 → … → 一定値に収束
学習率 → 適度な値を維持 → 学習が継続！

5-4. Kerasでの実装

📝 コードの解説

rho=0.9

減衰率γの設定です。0.9が標準的な値です。
「過去の90%を維持し、新しい情報を10%追加」という意味です。

from tensorflow.keras.optimizers import RMSprop # RMSpropオプティマイザ optimizer = RMSprop( learning_rate=0.001, rho=0.9 # 減衰率γ（0.9が標準） ) model.compile( optimizer=optimizer, loss=’categorical_crossentropy’, metrics=[‘accuracy’] )
✅ RMSpropの特徴
  • AdaGradの改良版：学習率が0に近づく問題を解決
  • RNN/LSTMで特に効果的：時系列データの学習に強い
  • 実務でも人気：特にRNN、LSTMを使う場合に推奨される

👑 6. Adam（最も人気の最適化手法）

6-1. Adamとは？

Adam（Adaptive Moment Estimation）は、MomentumとRMSpropの良いところを組み合わせた最適化手法です。
現在、最も人気があり、実務で広く使われているオプティマイザです。

🏆 Adamの特徴

Momentum由来：過去の勾配の情報を使って加速（慣性）
RMSprop由来：各パラメータごとに学習率を自動調整

→ 速く、安定して、効率的に学習できる！

6-2. Adamの更新式

📐 Adamの更新式（4ステップ）

① 1次モーメント（勾配の移動平均）= Momentum的な要素
　 m = β₁ × m + (1 – β₁) × ∂L/∂w

② 2次モーメント（勾配の二乗の移動平均）= RMSprop的な要素
　 v = β₂ × v + (1 – β₂) × (∂L/∂w)²

③ バイアス補正（初期の偏りを修正）
　 m̂ = m / (1 – β₁ᵗ)
　 v̂ = v / (1 – β₂ᵗ)

④ パラメータ更新
　 w_new = w_old – (η / √v̂) × m̂

6-3. 各パラメータの意味

パラメータ 標準値 意味
η（learning_rate） 0.001 基本の学習率
β₁（beta_1） 0.9 1次モーメントの減衰率（Momentum）
β₂（beta_2） 0.999 2次モーメントの減衰率（RMSprop）
ε（epsilon） 1e-8 0除算を防ぐ小さな値

6-4. Kerasでの実装

📝 コードの解説

Adam(learning_rate=0.001)

Adamはデフォルト設定のままで十分良い性能を発揮します。
迷ったらこの1行で始めましょう！

# 基本的な使い方（推奨！） from tensorflow.keras.optimizers import Adam optimizer = Adam(learning_rate=0.001) model.compile( optimizer=optimizer, loss=’categorical_crossentropy’, metrics=[‘accuracy’] )
# パラメータをカスタマイズする場合 optimizer = Adam( learning_rate=0.001, # 学習率 beta_1=0.9, # 1次モーメントの減衰率 beta_2=0.999, # 2次モーメントの減衰率 epsilon=1e-8 # 0除算防止 )

6-5. Adamの長所と短所

長所 短所
✅ 収束が速い
✅ 学習率の調整がほぼ不要
✅ ノイズに強い
✅ 実務で最も人気
✅ 幅広い問題に対応 		❌ メモリ使用量がやや多い
❌ 一部の問題では汎化性能が劣る
（SGDの方がテスト精度が高いことも）

📊 7. 最適化手法の比較

7-1. 性能比較表

手法 収束速度 安定性 調整難易度 推奨場面
SGD 遅い 中 難しい 汎化性能重視、時間に余裕あり
Momentum 中 良い 中 SGDの改良として
AdaGrad 中 中 易しい 短時間の学習のみ
RMSprop 速い 良い 易しい RNN/LSTM
Adam 速い 非常に良い 非常に易しい 迷ったらこれ！

7-2. 学習曲線の比較イメージ

以下の図は横スクロールできます。

【損失の減少速度のイメージ】 損失 ↑ │\ │ \ │ \ SGD（遅い） │ \＿＿＿＿ │ \ │ \ Momentum │ \＿＿＿ │ \ │ \ RMSprop │ \＿＿ │ \ │ \ Adam（速い） │ ＼＿＿ └────────────────────────→ エポック数 2 4 6 8 10 → Adam、RMSpropが速く収束 → SGDは遅いが、最終的な汎化性能が良いこともある

🎯 8. 最適化手法の選び方

8-1. 選択フローチャート

以下の図は横スクロールできます。

【最適化手法の選択フローチャート】 START ↓ 迷っている？ ├─ YES → Adam を使う！ 🎉 │ optimizer = Adam(learning_rate=0.001) │ └─ NO ↓ RNN/LSTMを使っている？ ├─ YES → RMSprop または Adam │ └─ NO ↓ 汎化性能を最重視？（時間に余裕あり） ├─ YES → SGD + Momentum │ optimizer = SGD(learning_rate=0.01, momentum=0.9) │ └─ NO ↓ 速度を最重視？ └─ Adam または RMSprop

8-2. 問題別の推奨設定

🏆 実務での推奨設定

画像分類（CNN）：

optimizer = Adam(learning_rate=0.001)

時系列予測（RNN/LSTM）：

optimizer = RMSprop(learning_rate=0.001) # または optimizer = Adam(learning_rate=0.001)

自然言語処理（NLP）：

optimizer = Adam(learning_rate=0.001)

うまくいかない場合：

# 学習率を下げてみる optimizer = Adam(learning_rate=0.0001)

8-3. 最適化手法の比較コード

実際に複数の最適化手法で学習を比較してみましょう。

📝 コードの解説（パート1：準備）

optimizers = { … }

4種類のオプティマイザを辞書で定義します。
これをループで回して、それぞれの性能を比較します。

from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from tensorflow.keras.optimizers import SGD, Adam, RMSprop from tensorflow.keras.datasets import mnist from tensorflow.keras.utils import to_categorical import matplotlib.pyplot as plt # データ読み込みと前処理 (X_train, y_train), (X_test, y_test) = mnist.load_data() X_train = X_train.reshape(-1, 784) / 255.0 X_test = X_test.reshape(-1, 784) / 255.0 y_train = to_categorical(y_train) y_test = to_categorical(y_test) # 比較する最適化手法 optimizers = { ‘SGD’: SGD(learning_rate=0.01), ‘Momentum’: SGD(learning_rate=0.01, momentum=0.9), ‘RMSprop’: RMSprop(learning_rate=0.001), ‘Adam’: Adam(learning_rate=0.001) }
📝 コードの解説（パート2：学習ループ）

for name, optimizer in optimizers.items():

辞書の各要素（オプティマイザ）に対してループします。

verbose=0

学習中の出力を抑制します（比較のため）。

results = {} for name, optimizer in optimizers.items(): print(f”\n=== {name} で学習 ===”) # モデル構築（毎回新しく作成） model = Sequential([ Dense(128, activation=’relu’, input_shape=(784,)), Dense(64, activation=’relu’), Dense(10, activation=’softmax’) ]) # コンパイル model.compile( optimizer=optimizer, loss=’categorical_crossentropy’, metrics=[‘accuracy’] ) # 学習 history = model.fit( X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=128, verbose=0 ) # 結果を保存 results[name] = history.history # 最終精度を表示 print(f”訓練精度: {history.history[‘accuracy’][-1]:.4f}”) print(f”テスト精度: {history.history[‘val_accuracy’][-1]:.4f}”)
実行結果（例）： 
=== SGD で学習 ===
訓練精度: 0.9543
テスト精度: 0.9521

=== Momentum で学習 ===
訓練精度: 0.9732
テスト精度: 0.9698

=== RMSprop で学習 ===
訓練精度: 0.9891
テスト精度: 0.9801

=== Adam で学習 ===
訓練精度: 0.9912
テスト精度: 0.9823

→ Adamが最も速く、高精度に収束！
📝 コードの解説（パート3：グラフ描画）

plt.subplot(1, 2, 1)

1行2列のグラフの1番目（左側）を描画します。

# 学習曲線のプロット plt.figure(figsize=(12, 4)) # 損失の比較 plt.subplot(1, 2, 1) for name in results: plt.plot(results[name][‘loss’], label=name) plt.xlabel(‘Epoch’) plt.ylabel(‘Loss’) plt.title(‘Training Loss Comparison’) plt.legend() plt.grid(True) # 精度の比較 plt.subplot(1, 2, 2) for name in results: plt.plot(results[name][‘val_accuracy’], label=name) plt.xlabel(‘Epoch’) plt.ylabel(‘Accuracy’) plt.title(‘Validation Accuracy Comparison’) plt.legend() plt.grid(True) plt.tight_layout() plt.show()

📝 STEP 11 のまとめ

✅ このステップで学んだこと
  • SGD：最もシンプル。勾配の方向に一歩ずつ進む
  • Momentum：慣性をつけて加速。局所最適解を回避しやすい
  • AdaGrad：各パラメータごとに学習率を調整。長時間学習に不向き
  • RMSprop：AdaGradの改良版。RNN/LSTMで効果的
  • Adam：MomentumとRMSpropの組み合わせ。最も人気！
  • 迷ったらAdamを使う。RNN/LSTMならRMSpropも検討
💡 覚えておくべき鉄則

1. まずAdamで始める
optimizer = Adam(learning_rate=0.001)

2. うまくいかなければ学習率を下げる
optimizer = Adam(learning_rate=0.0001)

3. RNN/LSTMならRMSpropも試す
optimizer = RMSprop(learning_rate=0.001)

🚀 次のステップへ

最適化アルゴリズムを理解したので、次のSTEP 12では学習率のスケジューリングを学びます。

学習の進行に応じて学習率を動的に調整することで、さらに効率的な学習を実現しましょう！

📝 練習問題

問題1 やさしい

Adamの特徴

Adamについて、正しい説明を選んでください。

  • A. MomentumとAdaGradの組み合わせ
  • B. MomentumとRMSpropの組み合わせ
  • C. SGDとAdaGradの組み合わせ
  • D. RMSpropとAdaGradの組み合わせ
正解：B

Adamの構成要素

Adamは、MomentumとRMSpropの良いところを組み合わせた最適化手法です。

【Adamの2つの要素】 1次モーメント m = β₁×m + (1-β₁)×勾配 → Momentum由来：過去の勾配を使って加速 2次モーメント v = β₂×v + (1-β₂)×勾配² → RMSprop由来：各パラメータの学習率を自動調整 この組み合わせで： ・速く収束する（Momentum効果） ・安定して学習できる（RMSprop効果）
問題2 やさしい

最適化手法の選択

初めてディープラーニングに取り組む際、最も推奨される最適化手法はどれですか？

  • A. SGD
  • B. Momentum
  • C. AdaGrad
  • D. Adam
正解：D（Adam）

「迷ったらAdam」が鉄則

【Adamが推奨される理由】 ✅ チューニングがほぼ不要 → デフォルト設定で十分良い性能 ✅ 幅広い問題に対応 → 画像、テキスト、音声など ✅ 収束が速い → 短時間で良い結果が得られる ✅ 実務で最も人気 → 多くの研究・プロジェクトで使用 【使い方】 optimizer = Adam(learning_rate=0.001)

この1行で始められます！

問題3 ふつう

Momentumの効果

MomentumがSGDより優れている点として、最も適切なものを選んでください。

  • A. メモリ使用量が少ない
  • B. 実装がシンプル
  • C. 局所最適解を回避しやすい
  • D. 学習率の調整が不要
正解：C

Momentumの効果

Momentumは、過去の勾配に基づく慣性をつけることで、局所最適解を回避しやすくなります。

【Momentumの動き】 ボールが坂を転がるイメージ： SGD（慣性なし）： 小さな谷で止まってしまう ↓ [山]↘[小さな谷]　[深い谷] ↑止まる Momentum（慣性あり）： 勢いで小さな谷を越える！ ↓ [山]↘↘↘[小さな谷]↘↘[深い谷] ↑ここまで到達！

他の選択肢の解説：

Aが間違い：Momentumは速度vを保存するため、SGDよりメモリを使います。
Bが間違い：SGDの方がシンプルです（Momentumは速度の計算が追加）。
Dが間違い：Momentumでも学習率の調整は必要です。

問題4 ふつう

RNN/LSTMの最適化

RNNやLSTMを使った時系列予測の際、特に推奨される最適化手法はどれですか？

  • A. SGD
  • B. Momentum
  • C. RMSprop または Adam
  • D. AdaGrad
正解：C（RMSprop または Adam）

RNN/LSTMでの推奨

RNN/LSTMでは、RMSprop または Adamが特に効果的です。

【RNN/LSTMでの選択理由】 RMSprop： ・RNN/LSTMのために開発された側面がある ・時系列データの学習に強い ・勾配消失・爆発問題に対処しやすい Adam： ・汎用性が高い ・RNN/LSTMでも優れた性能 ・チューニングが簡単 【コード例】 # オプション1：RMSprop optimizer = RMSprop(learning_rate=0.001) # オプション2：Adam optimizer = Adam(learning_rate=0.001)

まずAdamを試し、うまくいかなければRMSpropを試すのが一般的です。

問題5 むずかしい

AdaGradの問題点

AdaGradの問題点と、それを解決する手法の組み合わせとして、正しいものを選んでください。

  • A. 学習率が大きくなりすぎる → Momentumで解決
  • B. 学習率が0に近づく → RMSpropで解決
  • C. メモリ使用量が多い → SGDで解決
  • D. 収束が遅い → Adamで解決
正解：B

AdaGradの問題と解決策

AdaGradの問題点は、学習率が単調減少して0に近づくことです。

【AdaGradの問題】 更新式： h = h + (∂L/∂w)² ← hは増え続ける（減らない） 学習率 = η / √h ← hが増えると学習率は減る 長時間学習すると： h → ∞（無限大） 学習率 → 0 → 学習が止まる！ 【RMSpropによる解決】 更新式： h = γ×h + (1-γ)×(∂L/∂w)² ← 移動平均（古い値を忘れる） γ = 0.9の場合： ・過去の情報は徐々に減衰 ・hが無限大にならない ・学習率が0に近づかない → 長時間学習しても学習が継続！

他の選択肢の解説：

Aが間違い：AdaGradの問題は「大きくなる」ではなく「0に近づく」です。
Cが間違い：メモリ使用量は主要な問題ではありません。
Dが間違い：収束速度ではなく、学習率が0になることが問題です。

← 前のステップ
STEP 9: 逆伝播の理論 次のステップへ →
STEP 12: 学習率のスケジューリング
📝

学習メモ

ディープラーニング基礎 - Step 11

💾 自動保存 · 0文字
📋 過去のメモ一覧 ▼
#artnasekai #学習メモ
LINE
ホーム
ディープラーニング基礎