🔖 拡張キーワード索引

この用語『学習率』を理解するうえで併せて押さえたい関連キーワード群です。 クリック（ホバー）で関連用語ページに飛べます。

🔖 学習率：キーワード索引（拡張版）

学習率に関する重要キーワード一覧。 各リンクから本ページの該当セクションへジャンプできます。

🎨 直感で掴む

ニューラルネットワークの多層構造を活かした学習。 大量のデータと計算資源、 そして適切な正則化が成功の鍵。

本ページでは 学習率 を、 定義・前提条件・使い方・落とし穴の順に整理して解説します。 厳密な定義より、 まず何を、 いつ、 どう使うかを理解することを優先してください。

比喩：学習率は「山を下りる歩幅」。 急斜面では大股で進めば速いが、 谷底付近で大股のまま行くと反対側の斜面を駆け上ってしまう。 だから「最初は大きく、 だんだん小さく」する学習率スケジュールが王道です。 SSDSE-B-2026 の人口（A1101）と着工建築物数（C3301）の単純線形回帰では、 lr=0.01 がほどよい歩幅、 lr=1.0 では発散、 lr=1e-6 ではほぼ動きません。

🎨 直感を深掘り

学習率は『勾配降下で一歩どれだけ進むか』を決めるパラメータ。 大きすぎると飛び越えて発散、 小さすぎると遅すぎて停滞。 機械学習で最も影響が大きいハイパーパラメータの一つ。 経験的には 1e-1 〜 1e-5 のレンジを対数スケールで探索する。 学習が進むにつれ下げるスケジューリング（warmup → cosine 等）が標準。

学習率（Learning Rate）は単独で覚えるものではなく、 ハイパーパラメータ という大きな枠組みの中での位置づけを理解することで応用範囲が広がります。 本ページの『🌐 関連手法』『🔗 関連用語』『📚 グループ教材』を順に辿ると、 関連概念のネットワークが見えてきます。

特に SSDSE-B のような実データに当てはめてみると、 教科書では抽象的に語られる概念が『47 都道府県の現実』に紐付き、 数字の意味が腑に落ちやすくなります。 次の『🧮 実値で計算してみる』セクションでは、 公開統計データを使って手を動かす例を紹介します。

🎨 学習率が大きすぎ・小さすぎる時の症状

🎮 触って理解する

学習率 $\eta$ を動かすと、 勾配降下 $x \leftarrow x - \eta\, f'(x)$ の一歩の大きさが変わります。 下の損失曲面は 2 つの谷（左が大域最適、 右が局所解）を持つ非凸関数 $f(x)=0.03\,(x^2-9)^2 + 0.4\,x + 2$。 スライダーで学習率を、 曲面上のドラッグ（タッチ可）で開始点を変えて、 ボールの軌跡と損失の下がり方がどう変わるかを体感してください。 計算は勾配降下の厳密な更新式そのものです。

🎨 直感：歩幅を変えるだけで結末が変わる

• 小さすぎ（🐢）：一歩が小さく、 40 ステップでも谷に届かない。 方向は正しくても時間で損をする。
• ちょうど良い（✅）：数ステップで谷底へ。 このレンジを対数スケールで探すのが実務。
• 大きすぎ（💥）：谷を飛び越えて反対の斜面を駆け上がり、 振動 → 発散。 損失が NaN／∞ になるのはこの状態。
• 開始点も効く：右の谷から小さな学習率で始めると局所解に捕まる。 大域最適（左の深い谷）へ届くかは、 学習率と開始点の両方で決まる。

⚠️ よくある落とし穴

• 発散：局所的な曲率 $k$ に対し $\eta > 2/k$ で必ず発散する（この曲面でも「大きすぎ」プリセットで再現できる）。 対策は $\eta$ を 1/3〜1/10 に下げる・gradient clipping・warmup。
• 鞍点・平坦域：勾配がほぼ 0 の平坦域や鞍点では、 一定学習率だと進まなくなる。 モメンタムや適応的学習率で抜ける。
• 局所解：非凸では初期値と学習率次第で浅い谷に停止する。 再スタート・cosine restart・大きめの初期 $\eta$ が有効（局所解問題 参照）。
• スケジューリング：「最初は大きく、 後で小さく」。 warmup → cosine 減衰が現代の定番で、 序盤の発散を避けつつ終盤で精度を絞れる。

🚀 発展：適応的学習率（Adam など）

ここで動かした $\eta$ は全パラメータ共通の固定値でした。 実際の深層学習では、 パラメータごと・時間ごとに実効的な歩幅を自動調整する適応的学習率が主流です。

• Momentum：過去の更新方向を慣性として持ち越し、 谷を速く下る（overshoot には注意）。
• RMSprop／Adam：勾配の 2 乗平均でスケールを正規化し、 各方向の実効歩幅をそろえる。 このため Adam の $\eta$ は「最大ステップサイズ」に近い意味になり、 SGD よりずっと小さい値（例 $10^{-3}$）で動く。
• それでも $\eta$ は残る：Adam でも peak lr・warmup・cosine 減衰の設計は必須。 適応的手法は「$\eta$ を不要にする」のではなく「$\eta$ の影響を緩和する」もの。

関連：勾配降下法 ／ 損失関数 ／ ハイパーパラメータ。 Adam・SGD・モメンタム・鞍点は本ページ内の該当セクションも参照してください。

📐 定義

勾配降下法の更新ステップ幅

英語名 Learning Rate。

🎯 いつ・どこで使うか

• 「深層学習」分野の標準的な道具として、 多くの分析で登場します。
• 📚 ニューラルネットワーク基礎 を学ぶときに必ず通過する基本概念です。
• 論文・実務レポートで頻出する用語なので、 1 度はちゃんと理解しておくと後が楽です。

📋 前提条件・適用範囲

この用語を理解・使用するときは、 次のような前提を意識してください：

• データの性質：尺度（名義/順序/間隔/比例）と分布を確認
• サンプル数：手法によって最低限のサンプル数が異なります
• 独立性：観測が独立であるかを確認（時系列・パネル等では別の手法が必要）
• 欠損・外れ値：前処理の方針を明確に

📐 数式の読み解き ── 学習率 の核心式

コサイン減衰スケジュール。 $\eta_{\max}$ から滑らかに 0 まで下げる。

数式の各記号が『何の量で、 どの空間に住み、 どんな単位を持つか』を意識すると、 暗記でなく構造として理解できます。 SSDSE-B の都道府県データに当てはめて、 各シンボルが何に対応するかを上の Python 実装で確認しましょう。

❓ FAQ ── 学習率 のよくある質問

📐 更新則の深掘り：SGD・Momentum・Adam

学習率 η は様々なオプティマイザで「最後にかける係数」として登場します。 主要 3 種類を整理します。

純粋 SGD

Momentum SGD

Adam

🔬 数式を言葉で読み解く

• SGD：勾配にそのまま学習率を掛けて引く。 一番シンプルだが、 損失曲面の形状にすぐ影響を受ける。
• Momentum：過去の更新方向を慣性として持ち越す。 谷を高速でくだれるが overshoot しやすい。
• Adam：各パラメータごとに「勾配の 2 乗平均（分散）」で割って、 学習率を自動調整。 学習率の意味が「最大ステップサイズ」に変わるため、 SGD よりずっと小さい η でも動く。

この「最大ステップサイズ」感覚が、 SGD で lr=0.1 が普通でも Adam では lr=1e-3 がデフォルトという違いの源。 つまり「学習率の絶対値」だけで比較してはいけない。

📐 学習率スケジュール一覧

「学習率を時間とともに変える」のがスケジュール。 主要 8 種類を整理。

📐 Cosine Annealing：現代のデファクト

Loshchilov & Hutter (2017) の提案で、 現在の LLM・拡散モデル・ViT 訓練で最も使われるスケジュール。

🔬 数式を言葉で読み解く

• $t/T$ は訓練進捗（0 → 1）。 $\cos(\pi t/T)$ は 1 → -1 に減衰。
• $t=0$ で $\eta_t = \eta_{\max}$、 $t=T$ で $\eta_t = \eta_{\min}$。
• $t=T/2$ で $\eta_t = (\eta_{\max}+\eta_{\min})/2$（中間値）。
• 滑らかに減るので「ガクッと飛ぶ」副作用なく、 訓練後半で精度を絞れる。

📐 Warmup：最初は小さく、 徐々に最大へ

Goyal+ (2017) が「大バッチ訓練の安定化のためには warmup が必須」と示し、 以後デファクト。 訓練の最初 $T_w$ ステップだけ線形に lr を上げる：

なぜ必要？ 訓練の初期は重みがランダムなので勾配のばらつきが大きい。 ここで大きな lr を使うと一気に発散することがある。 warmup で「最初は慎重、 重みが整ってから本番」とする。

典型値：BERT は 10000 step、 GPT-3 は 375M token、 Stable Diffusion は 10000 step。 全訓練の 1-5% を warmup に充てるのが定番。

📐 Linear Scaling Rule：lr と batch size の関係

Goyal+ (2017) の「Accurate, Large Minibatch SGD」が示した経験則：

batch size を K 倍にしたら、 学習率も K 倍にする。 理由：勾配推定の分散が 1/K になるので、 同じ更新の「実効標準偏差」を保つには lr を K 倍する必要がある。

注意：あくまで近似で、 batch=8192 以上では「Square Root Scaling」（$\sqrt{K}$ 倍）の方が良いという研究もある (You+ 2020, LAMB)。

📐 Adam vs SGD：lr の意味が違う

「Adam の lr=1e-3」と「SGD の lr=1e-3」は全く違う意味です。 表で比較：

最新では AdamW（weight decay を Adam から分離した版）が多くの場合で使われ、 lr=1e-4、 wd=0.1 が定番。

🔬 数式を言葉で読み解く

学習率を含む更新式 $\theta_{t+1} = \theta_t - \eta \nabla L(\theta_t)$ の各記号を、 一切数式を使わず分解します。

つまり「新しい重み＝今の重み － 学習率×勾配」という極めて単純な式です。 ここで学習率 η が掛け算の係数として直接効くため、 値を 10 倍すれば 1 ステップの移動量が 10 倍になります。 これが学習率を「ハイパーパラメータの王様」と呼ぶ理由です。

🧮 SSDSE-B 実値で計算してみる ── 学習率

SSDSE-B の総人口（A1101）と着工建築物数（C3301）の線形回帰で、 学習率を変えて 100 epoch 学習し、 train loss の収束カーブを観察。 lr=1e-1 では発散、 lr=1e-4 では収束遅い、 lr=1e-2 が最適という典型パターンを確認。

※ 数値は SSDSE-B-2026.csv から抽出した実値、 もしくは典型的な学習設定での目安値です。 細部の数値は前処理・乱数 seed・実装により変動します。

🧮 LR Finder：データ駆動で最適 lr を探す

Smith (2017) の「Cyclical Learning Rates for Training Neural Networks」で提案。 「lr を 10⁻⁷ から 1 まで指数的に増やしながら 1 epoch 訓練、 損失曲線を見て『最も急降下している点』の lr を選ぶ」。 fast.ai の実装で広まった。

手順

1. 学習率を $10^{-7}$ にセット。
2. 1 ステップ訓練。 損失を記録。
3. 学習率を $\times 10^{1/N}$（N は 1 epoch の step 数）にして、 また 1 ステップ訓練。
4. 1 epoch 終了時点で、 横軸 log(lr)・縦軸 loss のプロット。
5. 損失が最も急降下している（傾きが最小の）点の lr を「最大 lr」として採用。
6. OneCycleLR ならその 1/10 を「初期 lr」、 これを「最大 lr」までスイープ。

この方法 1 回で「桁単位で適切な lr」が分かる。 グリッドサーチを 1000 回回すより遥かに効率的。

🧮 SSDSE-B-2026 で実験：lr を変えた回帰の収束比較

SSDSE-B-2026 の 47 都道府県データで、 総人口 (A1101) から着工建築物数（C3301）を予測する単純線形回帰を、 5 種類の lr でフィット。 損失曲線がどう変わるか実値で確認します。

入力：データ準備

結果：5 種類の lr × 100 step の損失推移

💬 この実験は「lr の桁を 1 つ変えるだけで収束時間が 100 倍違う」という事実を可視化。 NN では損失曲面がもっと複雑で、 lr 探索はより慎重に。

🧮 主要タスク別 学習率の経験則

覚え方：「ゼロから学習」より「ファインチューニング」の方が lr は 1-2 桁小さく。 これは「既に学習済みの良い重みを壊さないため」。

🧮 主要スケジューラの数式まとめ

学習率スケジューラを 数式 で押さえると、 PyTorch のドキュメントを読まずに挙動を即座に理解できる。 ここでは 6 種類のスケジューラを並べる。

1. Constant LR（固定）

\( \eta_t = \eta_0 \) （全 step で固定）。 古典的だが、 学習後半で振動して loss が下げ止まる欠点がある。

2. Step Decay（階段状減衰）

\( \eta_t = \eta_0 \cdot \gamma^{\lfloor t / s \rfloor} \) （\( s \) step ごとに \( \gamma \) 倍）。 典型値は \( \gamma = 0.1, s = 30\,\text{epoch} \)。 ResNet 系の標準。

3. Exponential Decay

\( \eta_t = \eta_0 \cdot e^{-\lambda t} \) （連続的に指数減衰）。 \( \lambda \) を 1 つ決めるだけなので調整が楽。

4. Cosine Annealing

\( \eta_t = \eta_\min + \tfrac{1}{2}(\eta_0 - \eta_\min)\left(1 + \cos(\pi t / T)\right) \) （\( T \) step で \( \eta_0 \) から \( \eta_\min \) へ滑らかに減衰）。 現代の標準。

5. Warmup + Cosine

\( t < t_w \) で線形に \( 0 \to \eta_0 \)、 その後 cosine annealing。 大バッチや Transformer で必須。

6. OneCycleLR

1 サイクルで \( \eta_0 / 25 \to \eta_0 \to \eta_0 / 10000 \) と上げて下げる。 短期学習で強い。

→ 「困ったら Warmup + Cosine」「短期決戦なら OneCycle」「勾配ブースティングなら固定」 の 3 つを覚えておけば、 9 割の現場で正しい選択ができる。

🗂 用語のミニ辞書 ── 学習率まわりで頻出するキーワード

学習率に関する文献を読むときに躓きがちな 20 個のキーワード を、 1 行ずつ定義する。

• peak lr: スケジューラの最大値。 多くの論文ではこれが "learning rate" として記載される。
• base lr: optimizer のコンストラクタに渡す lr。 スケジューラなしならこれが終始使われる。
• min lr: cosine annealing の到達下限。 通常 peak lr の 0.01 ～ 0.1 倍。
• warmup steps: 0 → peak lr に上げるステップ数。 大バッチでは 1K ～ 10K が標準。
• linear scaling rule: batch_size を K 倍にしたら lr も K 倍にする経験則（Goyal 2017）。
• discriminative lr: 層ごとに異なる lr を設定する手法。 fine-tune で有効。
• LR finder: lr を指数的に上げながら 1 epoch 走らせ、 最適 lr を可視化する手法（Smith 2017）。
• cyclical lr: lr を周期的に上下させる手法。 saddle point からの脱出を狙う。
• cosine restart: cosine annealing を周期的にリセット（warm restart）。
• polynomial decay: \( \eta_t = \eta_0 (1 - t/T)^p \) で多項式的に減衰。 NLP 事前学習で使われる。
• ReduceLROnPlateau: val_loss が改善しなくなったら lr を 1/10 にするスケジューラ。
• weight decay: 重みの L2 正則化係数。 lr とは独立だが相互作用する。
• gradient clipping: 勾配のノルムに上限を設けて発散を防ぐ。 lr が大きいときの保険。
• gradient accumulation: 小バッチで複数回 forward して合算。 実効 batch_size を上げる。
• LARS / LAMB: 超大バッチ用の最適化アルゴリズム。 層ごとに lr を自動調整。
• AdaFactor: 大規模モデル用に Adam のメモリを削減したもの。 自前 lr スケジューラを持つ。
• Schedule-Free: 2024 年提案。 スケジューラ不要で peak lr 1 つで学習。
• LR sweep: lr を複数試して最適値を決める手順全般。 grid または LR finder で実施。
• cooldown: 学習末期に lr をさらに下げる短い期間。 fine-tune の最終段で使う。
• plateau: 学習曲線が平らになる状態。 lr 不適切のサインだが、 局所最小値や saddle point のサインでもある。

🧑‍🍳 すぐ使える PyTorch レシピ集

PyTorch で頻出する 5 つの実用レシピ をスニペットで示す。 コピペで動くように、 import から PyTorch のクラス名まで書き下している。 SSDSE-B-2026 など実データに当てはめる際の出発点として使える。

レシピ 1: 基本の SGD + cosine annealing

このコードでやること: SGD optimizer に CosineAnnealingLR を組み合わせ、 100 epoch で peak から min まで滑らかに減衰させる。 SSDSE-B-2026 の MLP に直結する。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

import torch
import torch.nn as nn
import pandas as pd
from sklearn.preprocessing import StandardScaler
from torch.utils.data import DataLoader, TensorDataset

# ── 学習対象を用意する（総人口・出生数・消費支出 → 一般診療所数）──
torch.manual_seed(42)
_d = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
_d = _d[_d['SSDSE-B-2026'] == 2023]
_X = StandardScaler().fit_transform(_d[['A1101', 'A4101', 'L3221']].astype(float))
_y = StandardScaler().fit_transform(_d[['I5102']].astype(float))
X = torch.tensor(_X, dtype=torch.float32)
y = torch.tensor(_y, dtype=torch.float32)
loader = DataLoader(TensorDataset(X, y), batch_size=8, shuffle=True)

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.backbone = nn.Sequential(nn.Linear(3, 16), nn.ReLU())
        self.head = nn.Linear(16, 1)
    def forward(self, x):
        return self.head(self.backbone(x))

model = Net()
loss_fn = nn.MSELoss()

def train_step(batch, model, optimizer, loss_fn):
    xb, yb = batch
    optimizer.zero_grad()
    loss = loss_fn(model(xb), yb)
    loss.backward()
    optimizer.step()
    return float(loss.detach())

def train_one_epoch(model, loader, optimizer, loss_fn):
    return sum(train_step(b, model, optimizer, loss_fn) for b in loader) / len(loader)

def validate(model, X, y):
    with torch.no_grad():
        return float(loss_fn(model(X), y))

from torch.optim import SGD
from torch.optim.lr_scheduler import CosineAnnealingLR

# lr=0.1 + momentum=0.9 はこのデータでは発散して loss が nan になる（実測）。
# 学習率は「大きすぎると壊れる」ことがそのまま出るので 0.02 から始める。
optimizer = SGD(model.parameters(), lr=0.02, momentum=0.9)
scheduler = CosineAnnealingLR(optimizer, T_max=100, eta_min=1e-4)

for epoch in range(100):
    loss = train_one_epoch(model, loader, optimizer, loss_fn)
    scheduler.step()

print(f'最終 loss = {loss:.4f}')
print(f'最終 lr   = {scheduler.get_last_lr()[0]:.6f}')

→ 100 epoch かけて lr=0.1 → 1e-4 まで滑らかに下げる。 画像分類で「とりあえず動く」設定。

レシピ 2: AdamW + warmup + cosine

このコードでやること: Transformer 系で標準の warmup + cosine を SequentialLR で合成。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

from torch.optim import AdamW
from torch.optim.lr_scheduler import LinearLR, CosineAnnealingLR, SequentialLR

optimizer = AdamW(model.parameters(), lr=1e-3, weight_decay=0.01)
warmup = LinearLR(optimizer, start_factor=0.01, total_iters=1000)
cosine = CosineAnnealingLR(optimizer, T_max=10000)
scheduler = SequentialLR(optimizer, [warmup, cosine], milestones=[1000])

# 学習率がどう動くかを実際に 3000 step 分だけ回して確認する
lrs = []
for step in range(3000):
    optimizer.step()          # ここでは重み更新の中身は問わない
    scheduler.step()
    lrs.append(scheduler.get_last_lr()[0])

for s in [0, 100, 500, 999, 1000, 2000, 2999]:
    print(f'step {s:>4}: lr = {lrs[s]:.6f}')

→ 最初の 1000 step で 1e-5 → 1e-3 へ線形に上げ、 その後 cosine で減衰。 BERT fine-tune や ViT pretraining の標準。

レシピ 3: OneCycleLR（短期学習向け）

このコードでやること: OneCycle で短時間に高性能を狙う。 step ごとに scheduler.step() を呼ぶ点に注意。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

from torch.optim import AdamW
from torch.optim.lr_scheduler import OneCycleLR

optimizer = AdamW(model.parameters(), lr=1e-3)
scheduler = OneCycleLR(optimizer, max_lr=1e-2,
                       steps_per_epoch=len(loader),
                       epochs=20)
for epoch in range(20):
    for batch in loader:
        train_step(batch, model, optimizer, loss_fn)
        scheduler.step()   # step ごと（epoch ごとではない）

print(f'最終 lr = {scheduler.get_last_lr()[0]:.8f}')
print(f'検証 loss = {validate(model, X, y):.4f}')

→ max_lr=1e-2 までいきなり上げて下げる。 短期間で同等以上の精度に到達することが多い。

レシピ 4: ReduceLROnPlateau（自動下げ）

このコードでやること: val_loss が改善しなくなったら lr を 1/10 に自動で下げる。 epoch ごとに val_loss を渡す。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from torch.optim.lr_scheduler import ReduceLROnPlateau

scheduler = ReduceLROnPlateau(optimizer, mode='min',
                              factor=0.1, patience=10)
for epoch in range(200):
    train_one_epoch(model, loader, optimizer, loss_fn)
    val_loss = validate(model, X, y)
    scheduler.step(val_loss)   # val_loss を渡す

print(f'最終 val_loss = {val_loss:.4f}')
print(f'最終 lr       = {optimizer.param_groups[0]["lr"]:.8f}')

→ 学習曲線を見ながら自動調整。 「とりあえず安全」な選択肢。

レシピ 5: discriminative lr（層ごとに変える）

このコードでやること: backbone は小さい lr、 head は大きい lr に設定。 fine-tune の決定版。

1
2
3
4
5
6
7
8
9

from torch.optim import AdamW

# 事前学習済みの部分 (backbone) は小さい lr、 新しく付けた部分 (head) は大きい lr
optimizer = AdamW([
    {'params': model.backbone.parameters(), 'lr': 1e-5},
    {'params': model.head.parameters(),     'lr': 1e-3},
])
for g in optimizer.param_groups:
    print(f'パラメータ数 {sum(p.numel() for p in g["params"]):>4} : lr = {g["lr"]}')

→ 「事前学習済の部分は壊さない」「新しい部分は速く学習」のバランス。

🎁 持ち帰り 5 か条 ── 学習率を制するための要点

1. 「lr 大きすぎ → 発散、 小さすぎ → 停滞」 の両方を理解し、 自分のタスクで両端を一度は試す。 lr=1e-5 と lr=1e-1 を 1 回ずつ走らせれば感覚が掴める。
2. 「困ったら Warmup + Cosine」 を選び、 短期決戦なら OneCycle に切り替える。 古典的な step decay は ResNet 互換以外では使わない。
3. 「Adam で 1e-3 から、 SGD で 1e-1 から」 を初期値の指針とし、 LR finder で 1 桁下を採用する。
4. 「lr の変更は batch_size と weight_decay とセット」。 lr 2 倍は batch_size 2 倍とセットで考える。
5. 「学習曲線と lr 推移を同じ図にプロット」 し、 lr の変化点と loss の挙動を視覚的に対応付ける。 これが lr デバッグの 80% を占める。

→ 以上 5 か条を実践していれば、 学習率に関する 9 割の問題は事前に防げる。 残りの 1 割は最先端の研究領域なので、 本記事の参考リンクから原典論文へ進もう。 学習率は単なる数値ではなく、 モデル・データ・最適化アルゴリズムを 統合的に制御するハンドル である。 ハンドルを使いこなせると、 学習の挙動が予測可能になり、 デバッグ時間も激減する。 そして何より、 自分のモデルが「なぜ動いている／動いていない」のかが直感的に分かるようになる。

🧮 数式に値を入れて手で計算する: 学習率と収束の比較

f(x) = (x-3)² で異なる lr の収束を計算する。

Step 1: 公式

Step 2: lr 別の 3 ステップ

🐍 Python で再現

1
2
3
4
5
6

def f_grad(x): return 2*(x-3)
for lr in [0.1, 0.5, 0.9, 1.1]:
    x = 0.0
    for _ in range(3):
        x = x - lr * f_grad(x)
    print(f"lr={lr}: x_3 = {x:.3f}")

📤 実行結果

💬 手計算 (Step 2) と Python 出力が完全一致。 lr=0.5 で最速、 lr=1.1 で発散。

🐍 Python での扱い

SSDSE-B-2026 のような公的統計データを Python で扱う際の基本パターン：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

import pandas as pd
import numpy as np

# データ読み込み
df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
print(df.shape)
print(df.dtypes)
print(df.describe())

# 「学習率」の文脈で扱う場合の例：
# 分野: 深層学習
# 関連手法は同カテゴリの他用語を参照してください。

具体的なコードは ニューラルネットワーク基礎 を参照してください。

📝 レポートでの報告

分析結果を報告するときに含めるべき情報：

• 使ったデータ：出典・期間・サンプル数
• 適用条件の確認：前提が満たされているか
• 計算結果：数値だけでなく不確実性（CI・SE）も
• 解釈：何を意味するか、 何を意味しないか
• 限界：適用範囲外への拡張は避ける

✅ チェックリスト

• □ 「学習率」を使う場面か再確認したか
• □ データの尺度・分布・サンプル数を確認したか
• □ 前提条件を満たしているか
• □ 計算した値だけでなく不確実性も把握したか
• □ 解釈と限界を区別したか
• □ 関連グループ教材で全体像を確認したか

🔗 同カテゴリの他用語

🐍 SSDSE-B を使った Python 実装

公的データ SSDSE-B（47 都道府県社会・人口統計）を読み込み、 学習率 を実際に動かす最小コードです。 引数のパスは平易さ優先で直書きしています。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

import pandas as pd
import numpy as np

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
X = df[['A1101']].astype(float).values
y = df['C3301'].astype(float).values
X = (X - X.mean()) / X.std()
y = (y - y.mean()) / y.std()

for lr in [1.0, 0.1, 0.01, 0.001, 0.0001]:
    w, b = 0.0, 0.0
    for _ in range(100):
        pred = w * X.flatten() + b
        err = pred - y
        w -= lr * (2 * err * X.flatten()).mean()
        b -= lr * (2 * err).mean()
    loss = ((w * X.flatten() + b - y) ** 2).mean()
    print(f'lr={lr}: final loss = {loss:.4f}')

※ 上記スニペットは Python 3.10+ / pandas 2.x / numpy / scikit-learn を想定。 環境構築は『conda create -n ds python=3.11 pandas scikit-learn matplotlib』で十分です。

🐍 Python 実装 (1)：PyTorch でスケジュール 4 種類比較

🎯 このコードでやること：SSDSE-B-2026 の総人口→着工建築物数回帰を、 Constant・StepLR・CosineAnnealing・OneCycleLR の 4 種類で訓練し、 損失曲線を比較する。

📥 入力例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

import pandas as pd
import numpy as np
import torch
from torch.optim.lr_scheduler import StepLR, CosineAnnealingLR, OneCycleLR

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
X = torch.tensor(df['A1101'].astype(float).values, dtype=torch.float32)
y = torch.tensor(df['C3301'].astype(float).values, dtype=torch.float32)
X = (X - X.mean()) / X.std()
y = (y - y.mean()) / y.std()

def train(scheduler_name, lr=0.1, epochs=200):
    w = torch.zeros(1, requires_grad=True)
    b = torch.zeros(1, requires_grad=True)
    opt = torch.optim.SGD([w, b], lr=lr)
    if scheduler_name == 'step':
        sched = StepLR(opt, step_size=50, gamma=0.5)
    elif scheduler_name == 'cosine':
        sched = CosineAnnealingLR(opt, T_max=epochs)
    elif scheduler_name == 'onecycle':
        sched = OneCycleLR(opt, max_lr=lr, total_steps=epochs)
    else:
        sched = None
    losses = []
    for ep in range(epochs):
        pred = w * X + b
        loss = ((pred - y) ** 2).mean()
        opt.zero_grad(); loss.backward(); opt.step()
        if sched: sched.step()
        losses.append(loss.item())
    return losses

for name in ['const', 'step', 'cosine', 'onecycle']:
    l = train(name, lr=0.1)
    print(f'{name:10}: 最終損失 = {l[-1]:.5f}')

📤 実行すると次の出力が得られる：

💬 結果の読み方：単純問題ではスケジュール差が見えないが、 ResNet50 を ImageNet で訓練すると差が顕著（Smith 2018 で 90 epoch → 30 epoch 短縮を達成）。

🐍 Python 実装 (2)：LR Finder 自前実装

🎯 このコードでやること：SSDSE-B-2026 で 10⁻⁷ → 1 まで lr を指数的にスイープし、 「最も急降下する点」を可視化。

📥 入力例：上のセクションと同じ X, y（正規化済み）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import torch
import numpy as np

lrs = np.logspace(-7, 0, 100)  # 10⁻⁷ から 1 まで 100 段階
losses = []
w = torch.zeros(1, requires_grad=True)
b = torch.zeros(1, requires_grad=True)
for lr in lrs:
    pred = w * X + b
    loss = ((pred - y) ** 2).mean()
    losses.append(loss.item())
    if loss.item() > 10:  # 発散したら打ち切り
        break
    loss.backward()
    with torch.no_grad():
        w -= lr * w.grad
        b -= lr * b.grad
        w.grad.zero_(); b.grad.zero_()

# 損失曲線の傾きが最小（最急降下）の点を探す
log_lrs = np.log10(lrs[:len(losses)])
grad = np.gradient(losses, log_lrs)
best_idx = np.argmin(grad)
print(f'最適 lr = {lrs[best_idx]:.4e}')
print(f'その時の損失 = {losses[best_idx]:.4f}')
print(f'最急降下時の傾き = {grad[best_idx]:.4f}')

📤 実行すると次の出力が得られる：

💬 結果の読み方：LR Finder は「グリッドサーチ不要で適切な lr が分かる」最強ツール。 PyTorch なら torch_lr_finder パッケージで 3 行で使える。 fast.ai では learn.lr_find() が標準ワークフロー。

🐍 Python 実装 (3)：Cosine + Warmup（Transformer 標準）

🎯 このコードでやること：BERT/GPT 訓練の標準スケジュール「線形 warmup → cosine 減衰」を huggingface transformers の get_cosine_schedule_with_warmup で実装。 SSDSE-B-2026 の特徴量 5 つから人口を回帰する MLP で実演。

📥 入力例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

import pandas as pd
import torch
import torch.nn as nn
from transformers import get_cosine_schedule_with_warmup
torch.manual_seed(0)   # 実行のたびに同じ結果が出るようにする

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
feats = ['A4101', 'A4200', 'B4101', 'H5609', 'L322101']
X = torch.tensor(df[feats].astype(float).values, dtype=torch.float32)
y = torch.tensor(df['A1101'].astype(float).values, dtype=torch.float32)
X = (X - X.mean(0)) / X.std(0)
y = (y - y.mean()) / y.std()

model = nn.Sequential(nn.Linear(5, 16), nn.ReLU(), nn.Linear(16, 1))
opt = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=0.01)

total_steps = 500
warmup_steps = 50  # 全体の 10%
sched = get_cosine_schedule_with_warmup(opt, warmup_steps, total_steps)

for step in range(total_steps):
    pred = model(X).squeeze()
    loss = ((pred - y) ** 2).mean()
    opt.zero_grad(); loss.backward(); opt.step(); sched.step()
    if step % 100 == 0:
        lr_now = opt.param_groups[0]['lr']
        print(f'step {step:3d}: lr={lr_now:.5f} loss={loss.item():.5f}')

📤 実行すると次の出力が得られる：

💬 結果の読み方：HuggingFace の Trainer は内部でこのスケジュールを使う。 設定したい時は TrainingArguments(lr_scheduler_type="cosine", warmup_ratio=0.1) で 1 行。

🐍 Python 実装 (4)：ReduceLROnPlateau の自動調整

🎯 このコードでやること：検証損失が一定期間下がらなくなったら自動で lr を 1/10 にする ReduceLROnPlateau を SSDSE で実演。

📥 入力例：同じ X, y。 train/val を 38/9 で分割。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

from torch.optim.lr_scheduler import ReduceLROnPlateau
import torch, torch.nn as nn, pandas as pd
torch.manual_seed(0)   # 実行のたびに同じ結果が出るようにする

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
X = torch.tensor(df[['A4101','B4101','H5609']].astype(float).values, dtype=torch.float32)
y = torch.tensor(df['A1101'].astype(float).values, dtype=torch.float32)
X = (X-X.mean(0))/X.std(0); y = (y-y.mean())/y.std()
X_tr, y_tr = X[:38], y[:38]
X_va, y_va = X[38:], y[38:]

model = nn.Sequential(nn.Linear(3,8), nn.ReLU(), nn.Linear(8,1))
opt = torch.optim.Adam(model.parameters(), lr=0.01)
sched = ReduceLROnPlateau(opt, mode='min', factor=0.1, patience=20)

for ep in range(300):
    model.train(); pred = model(X_tr).squeeze()
    loss = ((pred-y_tr)**2).mean()
    opt.zero_grad(); loss.backward(); opt.step()
    with torch.no_grad():
        vl = ((model(X_va).squeeze()-y_va)**2).mean()
    sched.step(vl)
    if ep % 50 == 0:
        print(f'ep {ep:3d}: train={loss.item():.4f} val={vl.item():.4f} lr={opt.param_groups[0]["lr"]}')

📤 実行すると次の出力が得られる：

💬 結果の読み方：「lr の手動チューニングは時間の無駄」というレベルまで自動化が進んだ。 Adam + ReduceLROnPlateau の組み合わせは多くの実務で十分高性能。

⚠️ よくある落とし穴

⚠️ 追加の落とし穴 ── 実務で踏み抜く罠

⚠️ 学習率にまつわる落とし穴（詳細）

🌐 学習率関連の主要論文

• Smith (2017) "Cyclical Learning Rates"：LR Finder の原典。 lr を周期的に変える CyclicalLR も提案。
• Smith (2018) "Super-Convergence"：OneCycleLR で ResNet ImageNet 訓練を 1/3 epoch に。
• Goyal et al. (2017) "Accurate, Large Minibatch SGD"：Linear Scaling Rule、 warmup、 8k batch で ImageNet 1 時間訓練。
• Loshchilov & Hutter (2017) "SGDR"：Cosine Annealing with Warm Restarts。
• Loshchilov & Hutter (2019) "Decoupled Weight Decay (AdamW)"：Adam の weight decay 修正、 lr との独立性。
• You et al. (2020) "LAMB"：32k batch BERT 訓練、 Layer-wise Adaptive LR。
• Hoffer et al. (2017) "Train longer, generalize better"：lr と汎化の関係。

🔗 拡張関連用語

この用語と一緒に学ぶと相乗効果が大きい関連項目です。 役割により色分けしています。

🔗 関連用語（拡張・3 区分）

前提（先に押さえる）

• 勾配降下法 — 学習率が登場する元の式
• 損失関数 — 勾配の計算対象
• バックプロパゲーション — 勾配の計算方法
• ハイパーパラメータ — lr の上位概念
• ニューラルネットワーク — lr が一番効く文脈

並列（同じレベル）

• バッチサイズ — Linear Scaling Rule で密接に関連
• エポック — スケジュールの単位
• オプティマイザ — lr の意味が違う
• モメンタム — lr と並ぶ重要パラメータ
• 重み減衰 — AdamW で独立化
• 正則化 — 過学習対策

発展（次に学ぶ）

• Adam — 適応的学習率
• LR スケジューラ — 動的調整
• ファインチューニング — discriminative lr
• 分散学習 — Linear Scaling 必須
• メタ学習 — lr 自体を学習
• AutoML — lr 探索を自動化

📚 関連グループ教材

• 深層学習の基礎 — 勾配降下・オプティマイザ・正則化
• 最適化手法 — SGD・Adam・LBFGS の比較
• PyTorch 基礎 — Optimizer / Scheduler の使い方
• ハイパーパラメータ調整 — Optuna / Ray Tune

📚 さらに学ぶための参考リンク

• 📖 関連用語: ハイパーパラメータ / 最適化アルゴリズム / 勾配降下法
• 📖 上位概念: 機械学習 / 深層学習
• 📖 周辺ツール: PyTorch のスケジューラ / scikit-learn の最適化
• 🔬 原典: Smith (2017) "Cyclical Learning Rates"; Loshchilov & Hutter (2016) "SGDR"; Goyal+ (2017) "Accurate, Large Minibatch SGD"; Bengio (2012) "Practical Recommendations"
• 📊 実データ: SSDSE-B-2026 都道府県別社会・経済統計

🗺 学習率 の概念マップ

『学習率』は『ハイパーパラメータ』カテゴリに属する重要概念で、 以下の関連概念群と密接につながっています。

ハイパーパラメータ
  ├── 前提
  │   └── 数学・統計の基礎
  ├── 学習率  ← このページ
  │   ├── 派生 1
  │   ├── 派生 2
  │   └── 応用
  └── 並列・対比される手法
      ├── 別アプローチ A
      └── 別アプローチ B
  

完全な概念マップは 🗺 概念マップ で確認できます。

📋 学習チェックリスト ── 学習率 を使いこなすために

• ☐ 学習率（Learning Rate）の定義を、 自分の言葉で 30 秒で説明できる
• ☐ 数式または手続きの『各記号 / ステップ』が何を意味するか言える
• ☐ SSDSE-B（または同等の実データ）で手を動かして試した
• ☐ 主な落とし穴 5 つを挙げられる
• ☐ 類似手法との違いを 1 行で説明できる
• ☐ 何の前提（独立性、 線形性、 分布など）を要求するか把握した
• ☐ 結果の不確実性（信頼区間・予測区間・分散）を扱えるか確認した
• ☐ 上位カテゴリ『ハイパーパラメータ』のグループ教材を読んだ
• ☐ 関連手法と比較したうえで、 なぜ 学習率 を選んだか文書化した
• ☐ 結果を再現できるよう、 seed・バージョン・データ取得日を記録した

📜 歴史と発展

古典的には固定値が使われたが、 2000 年代に SGD with momentum + step decay が標準化。 2017 年の Smith の Cyclical Learning Rate, OneCycle で動的調整が普及。 2018 年以降、 大規模学習のための warmup + cosine annealing が定番。 最近は LR-free optimizer (Schedule-Free 2024) も登場。

学習率の歴史は「固定値 → スケジュール → 適応 → 不要へ」という流れで読めます。 長らく手で決める定数でしたが、 Smith (2017) の Cyclical Learning Rate が「上げ下げを繰り返したほうが速い」という直感に反する結果を示しました。 大規模学習では warmup（最初だけ小さく）が必須になり、 近年は Schedule-Free (2024) のように学習率スケジュール自体を無くす方向の研究も出ています。 「最も原始的なハイパーパラメータが、 いまだに研究対象である」という事実自体が示唆的です。

🚀 応用事例 ── 学習率 はどこで使われているか

『学習率』は理論だけでなく、 産業・研究の様々な現場で実用されています。 ここでは代表的な応用を 6 つ挙げます。

• 初期学習 — warmup でゆっくり開始
• 微調整 — 小さい lr で安定化
• Fine-tune — 事前学習層は lr を 1/10 に
• バッチサイズ大 — lr を線形にスケール
• 収束間際 — cosine annealing で下げる
• 早期停止と併用 — lr 下げてもダメなら停止

どの応用も「何を入力とし、 何を出力すべきか」を整理した上で、 上の Python 実装をベースに拡張するアプローチが定石です。 SSDSE-B のような公開データセットで小さく試し、 動作確認できてから本番データに展開すると安全です。

📊 ベンチマーク比較 ── 学習率 の主要バリエーション

『学習率』には多くの派生・バリエーションがあります。 代表的なものを精度・特徴で比較した表です。

数値は論文公表時点のもので、 計測条件（データ・前処理・ハイパーパラメータ）が異なります。 自分の問題で再評価することを推奨。

✨ 実装ベストプラクティス ── 学習率 を堅牢に使う

1. 小さく始める — SSDSE-B の 47 行のような小データでパイプライン全体を確立してから本番データへ。
2. seed を固定 — numpy, torch, random の全 seed を記録。 再現性チェックは必須。
3. バージョン管理 — requirements.txt と環境スナップショット、 データの取得日を記録。
4. 段階的に複雑化 — まずベースライン（線形、 ロジスティック）→ 古典的 ML → 学習率 の順。 突然複雑化しない。
5. 可視化を欠かさず — 学習曲線、 特徴分布、 残差プロットを毎回確認する。
6. テスト集合を分離 — 探索・調整に絶対使わない『最終評価』用データを別途確保。
7. ハイパーパラメータは記録 — 全実験で何を試したか mlflow / wandb / spreadsheet に。
8. 失敗パターンも残す — 「ダメだった設定」も価値がある。 後輩や未来の自分が助かる。

🔍 似た用語との違い ── 学習率 を正確に切り分ける

『学習率』は周辺の似た用語と混同されがちです。 ここでは特に紛らわしい用語との本質的な違いを整理します。

• 『学習率』は ハイパーパラメータ カテゴリの中で特定の役割を持つ。 一般概念と混同しないよう注意。
• 類似手法と比べて得意な領域：上の『🚀 応用事例』で挙げた問題群。
• 類似手法と比べて不得意な領域：『⚠️ 落とし穴』に明示された制約に該当する場合。
• 使い分けの目安：データ量、 計算リソース、 解釈性要求、 精度要求の 4 軸でマトリクスを作る。
• 不確かなときは両方走らせて結果を比べるのが正解。 SSDSE-B のような小データなら 1 時間で試せる。

📖 さらに深く学ぶリソース

教科書・本

• Bishop『Pattern Recognition and Machine Learning』 — 統計的機械学習の古典
• Goodfellow『Deep Learning』 — 深層学習の標準教科書（無料 PDF あり）
• Murphy『Probabilistic Machine Learning』 — Bayes 視点の機械学習
• 有賀『仕事ではじめる機械学習』 — 実務寄り、 日本語

論文プラットフォーム

• arXiv.org — 最新プレプリント（cs.LG, stat.ML カテゴリ）
• Papers with Code — 論文と実装コードがセット
• OpenReview — NeurIPS, ICLR の査読プロセスが見える
• Google Scholar — 引用ネットワークで辿る

ライブラリ・実装

• scikit-learn — 古典的 ML の標準
• PyTorch / TensorFlow — 深層学習
• Hugging Face Transformers — Transformer 系モデル
• OpenAI / Anthropic / Google API — LLM の API

公開データセット

• SSDSE-B（本ページの実例で使用）— data/raw/SSDSE-B-2026.csv。 47 都道府県の社会・人口指標
• SSDSE-A / SSDSE-C / SSDSE-D / SSDSE-E — 統計コンペで頻出
• e-Stat — 政府統計の総合窓口
• RESAS — 地域経済分析システム

🔎 学習率 を深く知る ── 専門家視点の詳細

学習率スケジュールの種類

学習率探索の方法

• Grid Search：[1e-5, 1e-4, 1e-3, 1e-2, 1e-1] を順に試す
• LR Range Test (Smith 2017)：小さい lr から指数的に増やし、 loss が悪化する直前を採用
• Bayesian Optimization：Optuna, Hyperopt で確率モデルで探索
• 経験則：SGD は 0.1〜0.01、 Adam は 0.001〜0.0001 から始める

大バッチ学習との関係

バッチサイズを N 倍にする場合、 学習率も N 倍にするのが線形スケーリング則（Goyal 2017）。 ただし大バッチでは warmup が必須（最初の 5〜10 エポックは線形に lr を上げる）。 LARS、 LAMB は大バッチ学習専用 optimizer。

Fine-tuning での学習率

• 事前学習層：初期 lr の 1/10〜1/100 で慎重に
• 新規層（分類ヘッド等）：通常の lr
• Discriminative Learning Rates (Howard 2018)：層ごとに異なる lr
• LoRA / QLoRA：低ランク更新で大幅な lr 自由度
• ULMFiT：3 段階のスケジューリング

本セクションは『学習率』の技術的核心を深掘りしました。 表面的な使い方を超えて、 内部の仕組みを理解することで、 トラブル時の診断や応用時のカスタマイズが可能になります。 SSDSE-B のような実データに当てはめながら、 ぜひ手を動かして確認してください。

🛠 学習率 実装の補足

学習率と他ハイパーパラメータの相互作用

• バッチサイズ：N 倍にしたら lr も N 倍が線形スケーリング則
• 正則化（weight decay）：強い WD と高 lr は相補的に作用
• Optimizer：SGD は 1e-1、 Adam は 1e-3 が標準
• Dropout：強い Dropout には強い lr が必要なことがある
• Layer Normalization：LN ありなら高 lr に頑健
• 初期化：He / Xavier 初期化と整合する lr 範囲
• データ量：少データなら小 lr、 大データなら大 lr
• モデルサイズ：大モデルは小 lr で安全

学習率の探索：実務的ワークフロー

1. LR Range Test を実行：1e-7 から 10 まで指数的に増やす
2. loss vs lr プロットを確認：急峻に下がる範囲を特定
3. その範囲の上限 / 10 を初期値に
4. cosine スケジューラで減衰：epochs にわたり徐々に下げる
5. train/val loss を継続監視：振動 → lr 下げ、 停滞 → 上げ
6. 転移学習なら層ごと別 lr：discriminative learning rates

SSDSE-B 線形回帰での学習率の挙動

SSDSE-B の人口（A1101）から着工建築物数（C3301）を線形回帰で予測する場合、 標準化後なら lr=0.01〜0.1 で安定収束。 lr=1.0 では振動・発散、 lr=0.0001 では収束まで 1000 エポック以上必要。 同じデータでも optimizer によって最適 lr が変わるため、 各組み合わせで LR Range Test を行うのが堅実。

『学習率』を実務に取り入れる際の実用的な補足知識でした。 理論と実践の往復で理解が深まります。

🗺 概念マップ：学習率の位置づけ

📝 理解度チェック ── 練習問題で学習率の知識を定着させる

ここからは 自分で考えてみる ための練習問題セットです。 学習率の挙動・落とし穴・スケジューラ選択について、 短答 → 計算 → 設計 の順で深さを上げていきます。 まずは答えを見ずに紙とペンで考え、 詰まったら本文の該当セクションへ戻ってください。

Q1. 短答問題（30 秒で答えられるか）

1. 学習率 \( \eta = 0.5 \) と \( \eta = 0.0001 \) では、 一般にどちらの方が「発散」しやすいか。 理由を 1 文で述べよ。
2. SGD with momentum と Adam では、 推奨される学習率のオーダーがおおむね何倍違うか。
3. 「warmup」がなぜ必要なのか。 学習開始直後の重みの初期化・勾配ノルムの観点から述べよ。
4. 「cosine annealing」と「step decay」は、 学習後半の探索性に与える影響がどう違うか。
5. LR finder（Smith 2017）で「損失がもっとも急に下がる学習率」と「最小損失の学習率」のうち、 採用すべきはどちらか。 また、 その理由は何か。

Q2. 計算問題（手を動かす）

パラメータ \( w \) を最小化する目的関数を \( L(w) = (w - 3)^2 \) とする。 勾配は \( \nabla L = 2(w-3) \) である。 初期値 \( w_0 = 0 \) から学習率を変えて勾配降下法を 3 ステップ走らせ、 \( w_3 \) と \( L(w_3) \) を計算せよ。

ヒント: 更新式は \( w_{t+1} = w_t - \eta \cdot 2(w_t - 3) \)。 ケース D では振動が増幅して発散する。 ケース B はちょうど 1 ステップで最適解に到達する『理論的最適』学習率である（凸 2 次関数で \( \eta = 1/L_\mathrm{Lipschitz} = 0.5 \) のとき）。

Q3. 設計問題（実プロジェクトを想定）

あなたは SSDSE-B-2026（都道府県別の社会・経済統計） を用いて、 出生数（A4101）を他の特徴量から予測する 3 層 MLP を PyTorch で実装する。 サンプル数 47、 特徴量 約 100、 batch_size=16, epochs=200 とする。 このとき:

1. 最初に試すべき学習率の候補レンジを書け（Adam を用いる前提）。
2. サンプル数が少ない（n=47）ため、 過学習を抑えるための学習率制御として何を組み合わせるべきか 2 つ挙げよ。
3. cosine annealing と OneCycleLR のどちらを推奨するか。 その理由を学習曲線の挙動から述べよ。
4. 学習が NaN で死ぬ症状が出た場合、 学習率以外に確認すべき設定を 3 つ挙げよ。

📖 解答例（自分で考えた後に開く）

🎯 自己採点ルーブリック

📊 図で確認 ── 学習率と SSDSE-B-2026 の関係

学習率の挙動を直感的に把握するため、 SSDSE-B-2026 の実データから生成した 3 種類の図を掲げる。 いずれも本リポジトリ（code/glossary_make_basic_figs.py 系統で生成済み）の実出力であり、 合成データではない。

→ 図 1〜3 から分かる通り、 SSDSE-B-2026 のような 都道府県別の小サンプル・異分散データ では、 学習率の安全圏は教科書の理論値（\( 1/L_\mathrm{Lipschitz} \) など）よりも 1 桁小さい所にある。 特に図 3 のように分散がグループ間で 3 倍以上違う場合、 標準化と学習率の控えめな設定 をセットで採用するのが鉄則。

🧪 ミニ実験ノート ── SSDSE-B-2026 で lr を 5 段階振ってみる

「学習率の選び方が結果にどれだけ効くか」を実感するための 再現可能な手順 を示す。 47 都道府県、 1 特徴量「人口(A1101)」から「出生数(A4101)」を線形回帰する単純な題材で、 SGD の lr を変えて学習曲線を比較する。

手順 1. データを読み込む

このコードでやること: SSDSE-B-2026 の都道府県別データを読み、 人口（A1101）と出生数（A4101）の対応を取り出す。

📥 入力データ（SSDSE-B-2026 抜粋、 5 行のみ）:

手順 2. lr を 5 通り振って学習

このコードでやること: 標準化した特徴量で SGD を 1000 epoch 回し、 lr=1e-5, 1e-4, 1e-3, 1e-2, 1e-1 の 5 種類で MSE の推移を記録する。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import pandas as pd
import numpy as np

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
x = df['A1101'].values.astype('float64')
y = df['A4101'].values.astype('float64')
x = (x - x.mean()) / x.std()
y = (y - y.mean()) / y.std()

def sgd(lr, n_epoch=1000):
    w, b = 0.0, 0.0
    losses = []
    for _ in range(n_epoch):
        pred = w * x + b
        err = pred - y
        grad_w = (err * x).mean()
        grad_b = err.mean()
        w -= lr * grad_w
        b -= lr * grad_b
        losses.append((err ** 2).mean())
    return w, b, losses

# 標準化済みデータの二乗誤差は曲率が緩いので、 lr=0.1 程度では発散しない。
# 「小さすぎる → 適切 → 発散」の 3 領域を全部見せるには lr=2〜3 まで振る必要がある。
for lr in [1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1.0, 2.0, 3.0]:
    w, b, losses = sgd(lr)
    if not np.isfinite(losses[-1]) or abs(w) > 1e3:
        print(f'lr={lr:.0e}: 発散（loss が無限大まで膨らんだ）')
    else:
        print(f'lr={lr:.0e}: final loss={losses[-1]:.4f}, w={w:.3f}')

📤 実際に動かすと次の出力が得られる:

💬 結果の読み方: 3 つの領域がはっきり出ている。 (1) 小さすぎる lr=1e-5〜1e-3 は 1,000 epoch 回しても w が 0.010 → 0.623 までしか進まず、 損失が下げ止まらない。 (2) 適切 lr=1e-2〜1.0 はどれも同じ最終損失 0.0277・w=0.986 に到達する ── 収束先は lr に依存せず、 変わるのは「そこに着くまでの速さ」だけ。 (3) 大きすぎる lr=3.0 で損失が無限大へ発散する。
境界が lr=2.0 にあるのは偶然ではない。 標準化済みデータの二乗誤差では損失の曲率（ヘッセ行列の最大固有値）が 1 になるため、 最急降下法の安定条件は $\text{lr} < 2/\lambda_{\max} = 2$。 実際 lr=2.0 はちょうど境界で、 w が 0 のまま振動して収束しない（損失 1.0000 ＝ 何も学習していない状態）。
「発散する学習率」は 0.1 ではない点に注意してほしい。 よく見る「lr=0.1 は大きすぎる」という助言は、 深層ネットワークのように曲率が大きいモデルの話であって、 安全な lr はデータとモデルの曲率で決まる。 だからこそ、 自分のデータで上のような lr スイープ（lr finder）を 1 回やる価値がある。

手順 3. 学習曲線を解釈する

→ この 5 段階比較は、 「lr finder」の本質を 5 行のコードで体験 することと等価。 自分のデータで同じ実験を 1 回やるだけで、 学習率の感度が劇的に身につく。

🔎 ケーススタディ ── 現場で起こる 5 つの典型シナリオ

学習率がからむ実問題は、 「lr を変えれば解決」とは限らない。 ここでは 5 つの典型シナリオ を示し、 lr 以外に注目すべき要因を整理する。

ケース A: 損失が NaN で死ぬ

最も多い症状。 まず lr を 1/10 にする。 それでも NaN なら、 (1) 入力データに NaN/Inf が含まれていないか, (2) log や sqrt の中身が負やゼロにならないか, (3) softmax の入力スケールが大きすぎないか を確認。 lr 以外の要因のことが多い。

ケース B: 学習曲線が階段状に上下する

これは「lr が高すぎる」サインだが、 step decay の段でも起こり得る。 学習率を下げて滑らかになれば lr 過大、 そうでなければスケジューラの境界設定を疑う。

ケース C: train loss は下がるが val loss が下がらない

過学習。 lr ではなく 正則化（weight decay, dropout）と early stopping を導入する。 ただし、 lr を上げると暗黙の正則化効果（SGD は flat minima を好む）が増すため、 lr を上げる戦略も有効。

ケース D: 大バッチで学習が遅い

batch_size を 2 倍にしたら lr も 2 倍にする「linear scaling rule」（Goyal+2017）が基本。 ただし lr が 1e-1 を超える場合は warmup を必須とする（さもないと序盤で発散）。

ケース E: 学習が長すぎて時間切れ

OneCycleLR + AdamW で「短期間集中」の学習を試す。 1 サイクルで lr を上げて下げるため、 通常 30%～50% 短い学習時間で同等以上の精度に到達する。

5 ケースの優先順位早見表

❓ よくある質問（拡張版）

Q. 学習率は層ごとに変えてもよいか？

A. はい。 これを discriminative learning rate と呼び、 fine-tuning では事実上の標準。 入力に近い層ほど小さく、 出力に近い層ほど大きくする。 PyTorch では optimizer = SGD([{params: layer1.parameters(), lr: 1e-4}, {params: head.parameters(), lr: 1e-2}]) のように指定する。

Q. Adam なら lr を気にしなくてよい？

A. いいえ。 Adam は SGD より「lr の感度が低い」だけで、 完全に気にしなくてよいわけではない。 デフォルトの 1e-3 が常に最適とは限らず、 タスク・モデル・バッチサイズで 1e-4 ～ 3e-3 の範囲で調整する。

Q. lr を変えたら early stopping のしきい値も変わる？

A. はい。 lr を上げると学習曲線がノイジーになるため、 「val_loss が patience=10 epoch 連続で改善しない」のような閾値は patience を伸ばすか、 EMA（指数移動平均）で平滑化した val_loss を見るとよい。

Q. 強化学習でも同じ lr の選び方でよい？

A. 概ね同じだが、 強化学習は 分布シフトが大きい ため、 教師あり学習より 1 桁小さい lr を使うのが安全。 PPO のデフォルトが 3e-4 なのもこのため。

Q. 学習率 1 つで成果がそんなに変わるのか？

A. 変わる。 Bengio (2012) の「Practical Recommendations」では、 「1 つだけハイパーパラメータをチューニングするなら学習率」 と明言されている。 lr を 10 倍間違えれば、 精度が半分になることも珍しくない。

📜 学習率スケジューラの歴史 ── 1980 年代から 2024 年まで

学習率に関する研究は、 ニューラルネットワークの歴史とほぼ同じ長さがある。 ここでは 10 年単位での節目 をまとめる。 用語を「研究者たちの努力の連鎖」として血の通った概念として理解するための補助である。

→ 1951 年の Robbins-Monro から 2024 年の Schedule-Free まで、 約 70 年の歴史。 学習率は 「最も古く、 最も新しい」ハイパーパラメータ と言える。

🛡 よくある誤解を潰す ── 学習率にまつわる 7 つの神話

学習率について巷で流布する「神話」を、 根拠を示して潰していく。 ここを 自分で 読み込めば、 SNS や Q&A サイトでの誤情報に振り回されなくなる。

神話 1: 「学習率は小さければ小さいほど安全」

→ 嘘。 小さすぎる lr は、 (a) 学習が遅すぎて時間切れ、 (b) saddle point から抜け出せない、 (c) 暗黙の正則化効果が消えて過学習しやすくなる、 という 3 重の害がある。 「適切な大きさ」が正解。

神話 2: 「Adam を使えば lr 調整は不要」

→ 嘘。 Adam は lr の 感度を下げる が、 ゼロにはしない。 タスク次第で 1e-4 ～ 3e-3 の調整は必須。 また、 Adam のデフォルト 1e-3 は画像認識では妥当だが、 言語モデル fine-tuning では 1e-5 ～ 5e-5 が標準。

神話 3: 「lr スケジューラは複雑な方が偉い」

→ 嘘。 多くのタスクでは cosine annealing 単独 で十分。 OneCycle や warmup は、 大バッチや短期学習のような 特定状況 でのみ効果を出す。 「困ったら cosine」が無難。

神話 4: 「最先端のモデルは lr が極端に小さい」

→ 半分嘘。 大規模言語モデルの pretraining は lr=6e-4 程度（GPT-3 は 6e-4）、 fine-tune が 1e-5 ～ 5e-5。 「小さい」のは fine-tune の話で、 pretraining は意外と大きい。

神話 5: 「lr finder が正解の lr を教えてくれる」

→ 嘘。 lr finder が示すのは 「ここから上は危険」の境界 であり、 採用すべきは境界の 1/10 程度。 自動化できるが、 最終確認は学習曲線の目視が必要。

神話 6: 「lr を 2 倍にしたら学習も 2 倍速くなる」

→ 嘘。 lr 2 倍は確かに収束が速くなることもあるが、 振動と発散のリスクが指数的に増える。 安全に高速化するには batch_size を同時に 2 倍にする「linear scaling rule」が必要。

神話 7: 「学習率を 1 つに固定するのが王道」

→ 嘘。 現代のレシピは warmup（最初の数千 step で 0→peak）+ cosine annealing（残りで peak→0） が標準。 「固定 lr」は 2014 年以前の流儀。

✅ 実プロジェクト向け 学習率チェックリスト

あなたが今、 実際の業務や研究で学習を回す前に、 10 項目 を確認しよう。 1 つでも未確認なら、 学習を始める前に戻ってチェックすること。

1. ☐ 入力データを 標準化（mean=0, std=1） したか
2. ☐ 損失関数が NaN を返さないか（log, sqrt, divide の中身を確認）
3. ☐ optimizer は SGD / Adam / AdamW のどれにするか決めたか
4. ☐ lr の初期値を 3～5 段階の grid または LR finder で決めたか
5. ☐ batch_size と lr の関係（linear scaling）を考慮したか
6. ☐ warmup を入れるか決めたか（大バッチや Transformer なら必須）
7. ☐ スケジューラは cosine / step / OneCycle のどれにするか決めたか
8. ☐ early stopping のための val_loss モニタリングを設定したか
9. ☐ NaN 監視と gradient clipping を実装したか
10. ☐ 学習曲線（train/val loss）と lr 推移を 同じ図 にプロットする準備をしたか

→ この 10 項目をすべてチェック済の状態で学習を回せば、 lr 起因のトラブルの 8 割は事前に防げる。 残りの 2 割は実行中の学習曲線の挙動で初めて分かる現象なので、 1 つ目の training run を「探索」と位置付けて短時間で回すのが現代の流儀。

📋 ドメイン別 推奨 lr とその根拠

学習率の推奨値は ドメイン × モデル × タスク で大きく変わる。 ここでは現場で頻出する 12 組のレシピを表にまとめる。 これらの値は単なる経験則ではなく、 ベンチマーク論文や公式リファレンスの数値に基づいている。

→ 表から見える法則: 「モデルが大きいほど lr は小さい」, 「事前学習 > fine-tune の lr」, 「Adam 系は SGD の 1/10 程度」。 自分のタスクが表のどこに近いかで初期値を決め、 そこから lr finder で微調整するのが現代の流儀。

🔧 トラブルシュート フローチャート

学習が思うように進まないときの判断フロー。 学習率に 関係する症状 と 関係しない症状 を明確に分離する。

→ このフローを 印刷して机に貼っておく と、 学習が止まった瞬間に lr を疑うのか、 別の要因を疑うのか、 5 秒で判断できる。

🔗 隣接手法への橋渡し

学習率は最適化アルゴリズムの中核ハイパーパラメータであり、 前段の正規化と後段のスケジューリング・ウォームアップを統合することで安定収束する。

• 上流: 前段の正規化・初期化 (勾配降下法、 最適化)
• 並列: 並列の最適化アルゴリズム (SGD・Adam) (バッチサイズ、 エポック) と比較・併用
• 下流: 下流のスケジューリング・ウォームアップ (損失関数の挙動、 局所解問題)

上流のデータ前処理 (バッチ正規化等) が損失曲面の急峻さを和らげ、 並列の Adam/RMSprop が学習率を自動調整し、 下流の Warmup/Cosine 減衰スケジューラが大規模学習の安定性を確保する流れで「学習率設計」が深層学習の核心になる。

🌳 手法選択フロー

学習率 を実際の課題に当てはめるとき、 用語固有の判断軸に沿って次の 3 段階で適切な選択を行う。

1. 初期学習率の感覚があるか? No → LR Range Test (Cyclical LR) で適正範囲を探索、 Yes → 次へ
2. SGD ベースか Adam ベースか? SGD → 大きめ初期 LR (0.01-0.1) + Cosine/Step 減衰、 Adam → 小さめ初期 LR (0.001-0.003) + Warmup
3. 大規模事前学習 (LLM/CV) か? Yes → Linear Warmup + Cosine 減衰 (Transformer 標準)、 No → ReduceLROnPlateau (検証ロス監視)

このフローは深層学習における学習率設計の核心。 学習率は単一値ではなく Schedule (時間変化) として設計するのが現代 (2026) の標準であり、 Warmup + Cosine 減衰が事実上のデファクトとなっている。

🔭 追補：直感・落とし穴・発展を一枚で整理

本ページはすでに広範な解説を持ちますが、 学習率という概念を 「直感 → 落とし穴 → 発展」 の 3 層で一望できるよう、 要点だけを凝縮した追補です。 既存セクションと重複する話題は、 該当セクションや ハイパーパラメータ・勾配降下法 へのリンクで補います。

🎨 直感：学習率は「1 歩の大きさ」そのもの

学習率 $\eta$ は更新式 $\theta \leftarrow \theta - \eta\,\nabla L$ の係数、 すなわち勾配方向へ踏み出す 1 歩の大きさ です。 方向（勾配）は損失曲面が決めますが、 どれだけ進むかは $\eta$ が決めます。 だからこそ「最も影響が大きいハイパーパラメータ」と呼ばれます（Bengio 2012 は「1 つだけ調整するなら学習率」と明言）。

• 大きすぎ：谷を飛び越えて反対斜面を駆け上がり、 振動 → 発散（損失が NaN/∞）。 凸 2 次関数では曲率 $k$ に対し $\eta > 2/k$ で必ず発散する。
• 小さすぎ：方向は正しくても遅すぎて時間切れ、 平坦域・鞍点で停滞、 暗黙の正則化効果が消えて過学習寄りになる。
• ちょうど良い帯：問題ごとに違うので、 $10^{-1}\!\sim\!10^{-5}$ を 対数スケールで探すのが実務。
• バッチサイズと相互作用：ミニバッチが大きいほど勾配推定のノイズが減り、 より大きな $\eta$ に耐える。 これが後述の線形スケーリング則の直感的な根拠。

⚠️ 落とし穴（重要）── 見落としがちな 7 点

⚠️ 落とし穴④を SSDSE-B-2026 の実測で体感する

「標準化するだけで安全な学習率が何桁も変わる」ことは、 SSDSE-B-2026（2023 年・47 都道府県）の実データで具体的に確認できます。 人口 A1101 から出生数 A4101 を単回帰（バイアスなし、 $\hat y = w\,x$）するとき、 MSE の $w$ に関する曲率は $L = 2\,\overline{x^2}$、 勾配降下の発散境界は $\eta_{\max} = 2/L$ です。 これを 生の人口と標準化後で比べます。

→ 同じデータ・同じモデルでも、 標準化を怠るだけで許される学習率が約 13 桁小さくなる（生では $\eta$ を $10^{-14}$ 台にしないと発散）。 学習率は絶対値だけを他所から真似てはいけない、 という⑤の裏返しでもあります。 上の値は data/raw/SSDSE-B-2026.csv（cp932, skiprows=[1], 2023 年抽出）の実測で、 合成値ではありません。 本ページ『🧪 ミニ実験ノート』の 5 段階スイープと合わせて追体験してください。

🚀 発展：学習率を「設計」する現代の道具箱

• スケジュール（減衰／コサイン／warmup）：Step/Exponential 減衰、 Cosine Annealing（Loshchilov & Hutter 2017、 画像・LLM の標準）、 linear warmup で序盤の発散を回避。 詳細は本ページ『📐 学習率スケジュール一覧』。
• 適応的最適化（Adam/RMSprop）：勾配の 2 乗平均でパラメータごとにスケールを正規化し、 実効歩幅を揃える。 $\eta$ の意味が「最大ステップサイズ」に変わるため Adam は $10^{-3}$、 SGD は $10^{-2}\!\sim\!10^{-1}$ と桁が違う。 → 勾配法 / 最適化。
• 学習率探索（LR range test）：$10^{-7}\to 1$ を指数的にスイープし、 損失が最も急降下する帯の 1/10 を採る（Smith 2017）。 本ページ『🧮 LR Finder』参照。
• 1cycle：1 サイクルで $\eta$ を上げて下げる短期集中スケジュール（Smith 2018）。 総ステップ数が十分あるとき高速で高精度。
• 線形スケーリング則：batch を $K$ 倍にしたら $\eta$ も $K$ 倍（Goyal+ 2017）。 大バッチでは warmup が必須。 → バッチサイズ / エポック。
• ウォームリスタート（warm restarts）：Cosine を周期的に reset して $\eta$ を跳ね上げ、 浅い谷から脱出（SGDR, Loshchilov & Hutter 2016）。 → 局所解問題。

🔗 関連ページ（相対リンク）

• 勾配降下法 ── 学習率が係数として現れる更新式そのもの。
• ハイパーパラメータ ── 学習率が属する上位概念。
• ハイパーパラメータ調整 ── LR range test / grid / ベイズ探索の位置づけ。
• 最適化 / 勾配法 / 数理最適化 / 連続最適化 ── 学習率が働く土台。
• バッチサイズ / エポック ── 線形スケーリング則・総ステップ数で学習率と相互作用。
• 損失関数 / 局所解問題 ── 学習率が下る曲面と、 停滞・脱出の話題。
• ニューラルネットワーク / ニューラルネットワーク基礎 ── 学習率が最も使われる文脈。