STEP 12：学習率のスケジューリング

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

📉 STEP 12: 学習率のスケジューリング

学習の進行に応じて学習率を調整し、より効率的な学習を実現しよう

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

  • 学習率とは何か？なぜ重要か？
  • 学習率が大きすぎる・小さすぎるとどうなるか？
  • Learning Rate Decay（学習率減衰）の基本
  • Step Decay：階段状に学習率を下げる
  • Exponential Decay：滑らかに学習率を下げる
  • ReduceLROnPlateau：学習状況に応じて自動調整（実務で最推奨）
  • 複数のコールバックを組み合わせる実践的な設定

🎯 1. 学習率の重要性

1-1. 学習率とは何か？

学習率（Learning Rate）は、勾配降下法でパラメータを更新する際の「一歩の大きさ」を決める重要なハイパーパラメータです。

📐 パラメータ更新式（復習）

w_new = w_old – η × ∂L/∂w

η（イータ）= 学習率

この値が「一歩の大きさ」を決めます。
例：η = 0.01 なら、勾配の0.01倍だけ重みを更新

👟 山登りの例え

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

学習率 = 一歩の大きさ

・大きな一歩 → 速く進めるが、谷底を飛び越えてしまう危険
・小さな一歩 → 確実だが、時間がかかりすぎる
・適切な一歩 → 効率よく谷底に到達できる

1-2. 学習率が大きすぎるとどうなる？

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

【学習率が大きすぎる場合】 損失 L ↑ │ │ ╱╲ ╱╲ │ ╱ ╲ ╱ ╲ │ ╱ ╲ ╱ ╲ │╱ ★ ╲ ╱ ╲ │ ↙→ ✕ ←↗ 最適値★を飛び越えてしまう！ │ ↓ │ 発散！ └───────────────────────→ 重み w 【問題点】 ・一歩が大きすぎて、最適値を飛び越える ・左右に振動して収束しない ・最悪の場合、発散してしまう（損失がどんどん大きくなる）

1-3. 学習率が小さすぎるとどうなる？

【学習率が小さすぎる場合】 損失 L ↑ │ │ ╱╲ │ ╱ ╲ │ ╱ ╲ │ ╱ ★ ╲ │ ╱ →→→→→ ╲ ゆっくりすぎる… │ ╱ ╲ │╱ ╲ └───────────────────────→ 重み w 【問題点】 ・一歩が小さすぎて、なかなか最適値に到達しない ・学習に時間がかかりすぎる ・局所最適解から抜け出せない

1-4. 適切な学習率の場合

【学習率が適切な場合】 損失 L ↑ │ │ ╱╲ │ ╱ ╲ │ ╱ ╲ │ ╱ ★↘ ╲ │ ╱ ↘↘ ╲ 効率よく最適値に到達！ │ ╱ ↘ ╲ │╱ ↘ ╲ └───────────────────────→ 重み w 【理想的な状態】 ・適度な速さで最適値に向かう ・振動が少なく安定している ・効率よく学習が進む

1-5. 問題：学習の段階によって最適な学習率は異なる

💡 学習率の選び方の難しさ

実は、学習の初期と後期で適切な学習率は異なります。

学習初期（最適値から遠い）：
→ 大きめの学習率で速く移動したい

学習後期（最適値に近い）：
→ 小さい学習率で細かく調整したい

→ この問題を解決するのが「学習率スケジューリング」です！

📉 2. Learning Rate Decay（学習率減衰）

2-1. 基本的な考え方

Learning Rate Decayは、学習の進行に応じて学習率を徐々に小さくする手法です。

🏃 マラソンの例え

スタート（前半）：
→ 大きく速く走る（大きい学習率）
→ ゴールまで遠いので、効率よく距離を稼ぐ

中盤：
→ ペースを落として調整（中程度の学習率）
→ 体力を温存しながら進む

ゴール手前（終盤）：
→ 細かくペースを調整してゴール（小さい学習率）
→ ぴったりゴールラインを踏むために微調整

2-2. 学習率減衰のイメージ

【学習率の変化のイメージ】 学習率 ↑ │ ● 0.1│ ＼ │ ＼_ │ ＼__ 0.01│ ＼___ │ ＼____ 0.001│ ＼_____ └──────────────────────────→ エポック数 0 10 20 30 40 50 学習が進むにつれて、学習率が徐々に小さくなる
✅ Learning Rate Decayの3つの効果
  • 収束の安定化：最適値の周りでの振動を抑制
  • 精度の向上：最後に細かい調整ができる
  • 学習の効率化：初期は速く、後期は丁寧に学習

2-3. 主な学習率スケジューリング手法

手法 特徴 推奨度
Step Decay 一定エポックごとに階段状に減少 ★★★☆☆
Exponential Decay 滑らかな曲線で減少 ★★★☆☆
ReduceLROnPlateau 学習状況を見て自動で減少 ★★★★★（最推奨）

⬇️ 3. Step Decay（ステップ減衰）

3-1. Step Decayとは？

Step Decayは、一定のエポック数ごとに学習率を階段状に減少させる手法です。

📐 Step Decayの計算式

η_t = η_0 × drop^floor(epoch / step_size)

各記号の意味：
・η_t：t エポック目の学習率
・η_0：初期学習率（例：0.1）
・drop：減衰率（例：0.5 = 半分にする）
・step_size：何エポックごとに減衰するか（例：10）
・floor()：小数点以下を切り捨て

3-2. 具体例で理解する

【Step Decayの具体例】 設定： ・初期学習率 η_0 = 0.1 ・減衰率 drop = 0.5（半分にする） ・ステップサイズ step_size = 10 計算結果： エポック 0-9 : η = 0.1 × 0.5^0 = 0.1 × 1 = 0.1 エポック 10-19 : η = 0.1 × 0.5^1 = 0.1 × 0.5 = 0.05 エポック 20-29 : η = 0.1 × 0.5^2 = 0.1 × 0.25 = 0.025 エポック 30-39 : η = 0.1 × 0.5^3 = 0.1 × 0.125 = 0.0125 → 10エポックごとに学習率が半分になる！

3-3. 視覚的なイメージ

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

【Step Decayの変化】 学習率 ↑ 0.1│ ●●●●●●●●●● │ ↓ 10エポック経過 0.05│ ●●●●●●●●●● │ ↓ 20エポック経過 0.025│ ●●●●●●●●●● │ ↓ 30エポック経過 0.0125│ ●●●●●●●●●● └──────────────────────────────────────────────→ エポック 0 10 20 30 40 階段状に減少する（急に減って、その後は一定期間維持）

3-4. Kerasでの実装方法

📝 コードの解説（LearningRateSchedulerを使う方法）

LearningRateScheduler

エポックごとに学習率を変更するためのコールバックです。
自分で定義した関数を渡して、学習率の計算方法を指定します。

step_decay(epoch)

現在のエポック数を受け取り、その時点での学習率を返す関数です。

from tensorflow.keras.callbacks import LearningRateScheduler import numpy as np # Step Decay関数を定義 def step_decay(epoch): “”” エポック数に応じて学習率を計算する関数 Parameters: epoch: 現在のエポック数（0から始まる） Returns: lr: そのエポックでの学習率 “”” initial_lr = 0.1 # 初期学習率 drop = 0.5 # 減衰率（0.5 = 半分にする） epochs_drop = 10.0 # 何エポックごとに減衰するか # 学習率を計算 lr = initial_lr * np.power(drop, np.floor(epoch / epochs_drop)) print(f”Epoch {epoch+1}: Learning Rate = {lr}”) return lr # コールバックとして設定 lr_scheduler = LearningRateScheduler(step_decay)
📝 使い方

callbacks=[lr_scheduler]

model.fit()のcallbacksパラメータにリストで渡します。
学習中、各エポックの開始時にstep_decay関数が呼ばれます。

# モデルの学習 model.fit( X_train, y_train, validation_data=(X_val, y_val), epochs=40, batch_size=128, callbacks=[lr_scheduler] # ここでコールバックを指定 )
実行結果（例）： 
Epoch 1: Learning Rate = 0.1
Epoch 2: Learning Rate = 0.1
...
Epoch 10: Learning Rate = 0.1
Epoch 11: Learning Rate = 0.05   ← 10エポック経過で半分に！
Epoch 12: Learning Rate = 0.05
...
Epoch 20: Learning Rate = 0.05
Epoch 21: Learning Rate = 0.025  ← さらに半分に！

📉 4. Exponential Decay（指数減衰）

4-1. Exponential Decayとは？

Exponential Decayは、学習率を指数関数的に滑らかに減少させる手法です。
Step Decayのような「急な変化」がなく、連続的に減少します。

📐 Exponential Decayの計算式

η_t = η_0 × decay_rate^(step / decay_steps)

各記号の意味：
・η_t：現在の学習率
・η_0：初期学習率
・decay_rate：減衰率（例：0.96）
・step：現在のステップ数
・decay_steps：何ステップで1回減衰するか

4-2. 視覚的なイメージ

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

【Exponential Decayの変化】 学習率 ↑ 0.1│ ● │ ＼ │ ＼_ │ ＼__ 0.01│ ＼___ │ ＼____ 0.001│ ＼_____ └──────────────────────────→ エポック 滑らかな曲線で減少する（常に少しずつ減っていく）

4-3. Step Decay vs Exponential Decay

📊 2つの手法の比較

学習率
↑
0.1│ ● ← Step Decay（階段状）
│ ＼──────●
│ ＼──────●
│ ＼──────●
│
0.1│ ● ← Exponential Decay（曲線）
│ ＼_
│ ＼__
│ ＼___
└────────────────────→ エポック

項目 Step Decay Exponential Decay
変化の仕方 階段状（急に変化） 滑らかな曲線
特徴 一定期間は学習率が固定 常に少しずつ減少
メリット 理解しやすい、調整しやすい 滑らかな収束
デメリット 段差で不連続 パラメータ調整が微妙

4-4. Kerasでの実装

📝 コードの解説

ExponentialDecay

Kerasに組み込まれた学習率スケジューラです。
オプティマイザに直接渡して使います。

staircase=True/False

True：階段状（Step Decay風）
False：滑らかな曲線（Exponential Decay）

from tensorflow.keras.optimizers.schedules import ExponentialDecay from tensorflow.keras.optimizers import Adam # Exponential Decayのスケジューラを作成 lr_schedule = ExponentialDecay( initial_learning_rate=0.1, # 初期学習率 decay_steps=10000, # 何ステップで1回減衰するか decay_rate=0.96, # 減衰率（0.96 = 4%減少） staircase=False # False = 滑らか、True = 階段状 ) # オプティマイザに学習率スケジュールを渡す optimizer = Adam(learning_rate=lr_schedule) # モデルのコンパイル model.compile( optimizer=optimizer, loss=’categorical_crossentropy’, metrics=[‘accuracy’] )

🎯 5. ReduceLROnPlateau（実務で最推奨！）

5-1. ReduceLROnPlateauとは？

ReduceLROnPlateauは、検証損失が改善しなくなったら自動的に学習率を下げる賢い手法です。
エポック数に基づく機械的な減衰ではなく、実際の学習状況を見て判断します。

💡 なぜReduceLROnPlateauが優れているのか？

Step Decay / Exponential Decay の問題点：

  • エポック数に基づいて機械的に減衰
  • 学習がまだ進んでいるのに減衰してしまうことがある
  • 逆に、もう改善しないのに高い学習率を維持してしまうことも

ReduceLROnPlateauの利点：

  • 実際の学習状況を見て判断する
  • 「損失が改善しない」=「学習率が大きすぎるかも」と判断
  • 自動で最適なタイミングで学習率を下げる

5-2. 動作の仕組み

🔍 ReduceLROnPlateauの動作例

設定：patience=5（5エポック改善なしで学習率を下げる）

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

【ReduceLROnPlateauの動作例】 検証損失 ↑ │ ＼ │ ＼__ │ ＼___ ← 順調に減少中（学習率そのまま） │ ─────── ← 横ばい（改善なし） │ ↓ 5エポック経過！学習率を下げる！ │ ＼__ │ ＼___ ← 再び減少！ │ ─────── ← また横ばい │ ↓ 5エポック経過！また学習率を下げる！ └──────────────────────────────────→ エポック 【タイムライン】 エポック 1-10: 損失が順調に減少 → 学習率 = 0.001（そのまま） エポック 11-15: 損失が横ばい（5エポック改善なし） エポック 16: 学習率を下げる！ → 学習率 = 0.0005（半分に） エポック 17-25: 損失が再び減少 → 学習率 = 0.0005（そのまま） エポック 26-30: 損失が横ばい（5エポック改善なし） エポック 31: 学習率を下げる！ → 学習率 = 0.00025（さらに半分に）

5-3. Kerasでの実装

📝 コードの解説

monitor=’val_loss’

監視する指標を指定します。’val_loss’（検証損失）が最も一般的です。
他には’val_accuracy’（検証精度）なども使えます。

factor=0.5

学習率をどれだけ下げるかを指定します。
0.5 = 半分にする、0.2 = 5分の1にする

patience=5

何エポック改善がなければ学習率を下げるかを指定します。
通常は3〜10の範囲で設定します。

min_lr=1e-7

学習率の最小値です。これ以下には下げません。
0に近すぎると学習が完全に止まってしまうため。

verbose=1

学習率が変更されたときにログを表示します。
1 = 表示する、0 = 表示しない

from tensorflow.keras.callbacks import ReduceLROnPlateau # ReduceLROnPlateauの設定 reduce_lr = ReduceLROnPlateau( monitor=’val_loss’, # 検証損失を監視 factor=0.5, # 学習率を半分にする patience=5, # 5エポック改善なしで減衰 min_lr=1e-7, # 学習率の最小値 verbose=1 # ログを表示 ) # モデルの学習 model.fit( X_train, y_train, validation_data=(X_val, y_val), epochs=100, batch_size=128, callbacks=[reduce_lr] )
実行結果（例）： 
Epoch 1/100
469/469 - loss: 0.5123 - val_loss: 0.4231

...

Epoch 15/100
469/469 - loss: 0.3012 - val_loss: 0.3456

Epoch 16/100
Epoch 16: ReduceLROnPlateau reducing learning rate to 0.0005.
469/469 - loss: 0.2876 - val_loss: 0.3298
↑ 学習率が0.001から0.0005に自動で減少！

Epoch 17/100
469/469 - loss: 0.2654 - val_loss: 0.3156
↑ 損失が再び減少し始めた！

5-4. パラメータの推奨設定

パラメータ 推奨値 説明
monitor ‘val_loss’ 検証損失を監視するのが最も一般的
factor 0.5 または 0.2 0.5（半分）が穏やか、0.2（5分の1）が急激
patience 3 〜 10 小さいと敏感、大きいと鈍感
min_lr 1e-7 これ以下には下げない
verbose 1 変更時にログを表示

🔄 6. 実務で使う！複数コールバックの組み合わせ

6-1. 実務での標準的な設定

実務では、複数のコールバックを組み合わせて使うのが一般的です。
以下の3つを組み合わせるのが標準的な設定です。

🏆 実務の3点セット
  • EarlyStopping：過学習を検知して学習を早期終了
  • ModelCheckpoint：最良のモデルを自動保存
  • ReduceLROnPlateau：学習率を自動調整

6-2. 各コールバックの役割

📌 EarlyStopping（早期終了）

役割：検証損失が改善しなくなったら、学習を途中で止める
効果：過学習を防ぎ、無駄な計算を省く
restore_best_weights=True：最良の状態の重みを復元する

📌 ModelCheckpoint（モデル保存）

役割：学習中に最良のモデルを自動保存
効果：学習が中断しても最良のモデルを失わない
save_best_only=True：最良の時だけ保存（容量節約）

📌 ReduceLROnPlateau（学習率調整）

役割：損失が改善しなくなったら学習率を下げる
効果：学習の効率化、収束の安定化
EarlyStoppingより先に発動：patienceを小さめに設定

6-3. 実装コード（推奨設定）

📝 コードの解説（パート1：コールバックの定義）

patience の設定のコツ

ReduceLROnPlateau の patience（5）を
EarlyStopping の patience（10）より小さくします。

理由：学習率を下げてから様子を見る時間が必要だから

from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau # 1. Early Stopping（過学習を防ぐ） early_stop = EarlyStopping( monitor=’val_loss’, # 検証損失を監視 patience=10, # 10エポック改善なしで停止 restore_best_weights=True, # 最良の重みを復元 verbose=1 ) # 2. Model Checkpoint（最良のモデルを保存） checkpoint = ModelCheckpoint( ‘best_model.h5′, # 保存ファイル名 monitor=’val_accuracy’, # 検証精度を監視 save_best_only=True, # 最良の時だけ保存 verbose=1 ) # 3. Reduce LR On Plateau（学習率を自動調整） reduce_lr = ReduceLROnPlateau( monitor=’val_loss’, # 検証損失を監視 factor=0.5, # 学習率を半分に patience=5, # 5エポック改善なしで減衰 min_lr=1e-7, # 最小学習率 verbose=1 )
📝 コードの解説（パート2：学習の実行）

callbacks=[early_stop, checkpoint, reduce_lr]

3つのコールバックをリストで渡します。
学習中、各エポック終了時に全てのコールバックが実行されます。

# モデルの学習（3つのコールバックを使用） history = model.fit( X_train, y_train, validation_data=(X_val, y_val), epochs=100, # 最大100エポック（EarlyStoppingで早期終了する可能性あり） batch_size=32, callbacks=[early_stop, checkpoint, reduce_lr] # 3つのコールバック )
実行結果（例）： 
Epoch 1/100
...
Epoch 15/100
Epoch 15: val_accuracy improved from 0.8765 to 0.8823, saving model to best_model.h5
↑ ModelCheckpoint: 最良モデルを保存

Epoch 20/100
Epoch 20: ReduceLROnPlateau reducing learning rate to 0.0005.
↑ ReduceLROnPlateau: 学習率を減少

Epoch 35/100
Epoch 35: val_accuracy improved from 0.8891 to 0.8912, saving model to best_model.h5
↑ ModelCheckpoint: さらに良いモデルを保存

Epoch 50/100
Epoch 50: early stopping
↑ EarlyStopping: 10エポック改善なしで学習終了

Restoring model weights from the end of the best epoch: 40.
↑ 最良のエポック（40）の重みを復元

6-4. 完成コード（コピー用）

from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau # コールバックの設定 early_stop = EarlyStopping( monitor=’val_loss’, patience=10, restore_best_weights=True, verbose=1 ) checkpoint = ModelCheckpoint( ‘best_model.h5′, monitor=’val_accuracy’, save_best_only=True, verbose=1 ) reduce_lr = ReduceLROnPlateau( monitor=’val_loss’, factor=0.5, patience=5, min_lr=1e-7, verbose=1 ) # 学習 history = model.fit( X_train, y_train, validation_data=(X_val, y_val), epochs=100, batch_size=32, callbacks=[early_stop, checkpoint, reduce_lr] )

📊 7. 学習率スケジューリングの選び方

7-1. 各手法の比較

手法 特徴 設定難易度 推奨場面
固定学習率 学習率が一定 非常に簡単 短時間の実験、Adamと併用
Step Decay 階段状に減少 簡単 エポック数が予測可能な場合
Exponential Decay 滑らかに減少 中 滑らかな減衰を重視
ReduceLROnPlateau 状況に応じて自動調整 簡単 実務で最推奨！

7-2. 選択フローチャート

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

【学習率スケジューリングの選択フローチャート】 START ↓ 実務プロジェクト？ ├─ YES → ReduceLROnPlateau を使う！ 🎉 │ + EarlyStopping + ModelCheckpoint │ └─ NO（研究・実験・勉強） ↓ エポック数が明確に決まっている？ ├─ YES → Step Decay を検討 │ └─ NO → ReduceLROnPlateau を使う 【結論】 迷ったら ReduceLROnPlateau + EarlyStopping + ModelCheckpoint の3点セット！

📝 STEP 12 のまとめ

✅ このステップで学んだこと
  • 学習率は「一歩の大きさ」を決める重要なパラメータ
  • 大きすぎると発散、小さすぎると遅すぎる
  • Learning Rate Decayで学習の進行に応じて学習率を調整
  • Step Decay：階段状に減少（シンプル）
  • Exponential Decay：滑らかに減少（連続的）
  • ReduceLROnPlateau：学習状況を見て自動調整（最推奨！）
  • 実務ではEarlyStopping + ModelCheckpoint + ReduceLROnPlateauの3点セット
💡 覚えておくべき実務の鉄則
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau callbacks = [ EarlyStopping(monitor=’val_loss’, patience=10, restore_best_weights=True), ModelCheckpoint(‘best_model.h5′, monitor=’val_accuracy’, save_best_only=True), ReduceLROnPlateau(monitor=’val_loss’, factor=0.5, patience=5, min_lr=1e-7) ] model.fit(X_train, y_train, validation_data=(X_val, y_val), epochs=100, callbacks=callbacks)

この設定で、効率的かつ安定した学習が実現できます！

🚀 次のステップへ

学習率スケジューリングを習得したので、次のSTEP 13ではバッチ正規化（Batch Normalization）を学びます。

バッチ正規化は、学習を安定化・高速化する強力なテクニックです。
学習率スケジューリングと組み合わせることで、さらに効率的な学習が可能になります！

📝 練習問題

問題1 やさしい

学習率の影響

学習率が大きすぎる場合に起こる問題として、正しいものを選んでください。

  • A. 学習が遅くなる
  • B. 振動して収束しない、または発散する
  • C. 過学習が起こる
  • D. メモリ使用量が増える
正解：B

学習率が大きすぎる問題

学習率が大きすぎると、最適解の周りで振動して収束しない、または発散してしまいます。

【学習率が大きすぎる場合】 損失 ↑ │ ╱╲ ╱╲ │ ╱ ╲ ╱ ╲ │ ╱ ╲ ╱ ╲ ← 左右に振動 │╱ ←→ ✕ ←→ ╲ │ 最適値 ╲ └──────────────────→ w 一歩が大きすぎて、最適値を飛び越えてしまう！

他の選択肢の解説：

Aが間違い：学習が遅くなるのは、学習率が「小さすぎる」場合です。
Cが間違い：過学習は学習率ではなく、モデルの複雑さやデータ量に関係します。
Dが間違い：メモリ使用量は学習率とは関係ありません。

問題2 やさしい

ReduceLROnPlateauの特徴

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

  • A. エポック数に基づいて機械的に学習率を下げる
  • B. 検証損失が改善しなくなったら自動的に学習率を下げる
  • C. 学習率を常に一定に保つ
  • D. 学習率を徐々に上げていく
正解：B

ReduceLROnPlateauの動作

ReduceLROnPlateauは、検証損失が改善しなくなったら自動的に学習率を下げる賢い手法です。

【動作の例】patience=5の場合 エポック1-10: 損失が順調に減少 → 学習率そのまま エポック11-15: 損失が横ばい（5エポック改善なし） エポック16: 自動で学習率を下げる！ 【Step Decay / Exponential Decayとの違い】 ・Step/Exponential：エポック数で機械的に減衰（学習状況を無視） ・ReduceLROnPlateau：実際の学習状況を見て判断（賢い！）
問題3 ふつう

実務での推奨設定

実務でニューラルネットワークを学習させる際、最も推奨されるコールバックの組み合わせはどれですか？

  • A. EarlyStopping のみ
  • B. ModelCheckpoint のみ
  • C. EarlyStopping + ModelCheckpoint + ReduceLROnPlateau
  • D. コールバックは使わない
正解：C

実務の3点セット

実務では、EarlyStopping + ModelCheckpoint + ReduceLROnPlateauの組み合わせが最も推奨されます。

【各コールバックの役割】 EarlyStopping： → 過学習を検知して学習を早期終了 → 無駄な計算を省く ModelCheckpoint： → 最良のモデルを自動保存 → 学習が中断しても最良のモデルを失わない ReduceLROnPlateau： → 学習率を自動調整 → 学習の効率化、収束の安定化 【3つを組み合わせる効果】 ・過学習を防ぐ ・最良のモデルを保存 ・効率的に学習 → 完璧な設定！
問題4 むずかしい

学習率スケジューリングの理解

以下のReduceLROnPlateauの設定について、学習率が最初に下がるタイミングとして正しいものを選んでください。

reduce_lr = ReduceLROnPlateau( monitor=’val_loss’, factor=0.5, patience=3, min_lr=1e-7 ) 初期学習率 = 0.001
  • A. エポック3の後
  • B. エポック4の後
  • C. 検証損失が3エポック連続で改善しなかった後
  • D. 検証損失が0.5未満になった後
正解：C

ReduceLROnPlateauの動作条件

ReduceLROnPlateauは、検証損失がpatienceエポック連続で改善しなかった後に学習率を下げます。

【具体例】patience=3の場合 エポック1: val_loss = 0.50（ベスト） エポック2: val_loss = 0.48（改善！ベスト更新） エポック3: val_loss = 0.49（改善なし、カウント1） エポック4: val_loss = 0.50（改善なし、カウント2） エポック5: val_loss = 0.51（改善なし、カウント3） エポック6: 学習率を下げる！ 新しい学習率 = 0.001 × 0.5 = 0.0005 【ポイント】 ・「3エポック目の後」ではなく「3エポック連続で改善なし」 ・改善があればカウントはリセット ・エポック数ではなく改善の有無で判断

他の選択肢の解説：

A, Bが間違い：エポック数ではなく、改善の有無で判断します。
Dが間違い：factor=0.5は「学習率を半分にする」という意味で、損失の閾値ではありません。

← 前のステップ
STEP 11: 最適化アルゴリズム 次のステップへ →
STEP 13: バッチ正規化
📝

学習メモ

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

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