🔖 キーワード索引

🔖 拡張キーワード索引

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

🎨 直感で掴む

山下りの比喩：

• 霧で視界ゼロの山頂から谷底に下りたい
• 足元の傾斜（勾配）を測り、 最も下る方向に1歩進む
• それを繰り返す

歩幅 = 学習率。 大き過ぎると崖を越えて反対側に行く、 小さ過ぎると永遠に着かない。

🎨 直感を深掘り

勾配降下法は『目的関数 $L(\theta)$ を最小化するため、 $\theta$ を勾配 $\nabla L$ の逆方向に少しずつ動かす』最適化アルゴリズム。 機械学習の学習はほぼすべてこの方法か、 その発展形（SGD, Adam, AdamW 等）で行われる。 一度に全データを使う Batch GD、 ランダム 1 サンプルの SGD、 中間の Mini-batch GD があり、 後者が深層学習の標準。

勾配降下法は SGD → Momentum (Polyak 1964) → AdaGrad (Duchi 2011) → RMSProp (Hinton 2012) → Adam (Kingma 2014) → AdamW (Loshchilov 2017) と進化し、 現代 DNN は AdamW + cosine decay が標準。 LR を 1e-3〜3e-4 で開始し warmup + decay する設定が ResNet/Transformer 系で安定し、 Llama2 学習も基本この組合せ。

本ページでは SSDSE-B-2026 を使った線形回帰を勾配降下法で解く例を示す: L(θ) = (1/2n)Σ(yᵢ - θ₀ - θ₁xᵢ)² を θ₀, θ₁ で偏微分し、 47 都道府県の (総人口, 出生数) で標準化のうえ学習率 η を変えながら損失曲線が収束する様子を観察する。 これにより、 closed-form 解 (X'X)⁻¹X'y と勾配降下解が一致することを実体験できる。

🎮 学習率を変えて降下を見る

損失関数の曲線の上で、 勾配降下法がどう動くかを自分の手で動かして確かめられる。 学習率 η スライダーを動かし、 グラフをクリック（タップ）して開始点を決め、 「▶ ステップ実行」または「⏯ 自動再生」で更新式 x_t+1 = x_t − η · L′(x_t) の 1 歩ずつを観察しよう。 η が小さい=遅い、 適度=収束、 大きすぎ=振動/発散 を目で体感できる。

🔎 動かして分かること
・凸関数 f(x)=0.25x²+0.5（勾配 L′=0.5x）は数学的に厳密で、 更新は x_t+1 = x_t(1 − 0.5η) となる。 よって η<2 で単調に谷へ、 2<η<4 で反対側へ飛び越えつつ収束、 η=4 で一定振幅の振動、 η>4 で発散。 これは凸・L-平滑な問題の収束条件 0<η<2/L（ここでは L=0.5）そのもの。
・多峰性では、 開始点の位置で落ちる谷が変わる。 浅い谷に捕まると勾配が 0 でも大域的最小には届かない ── これが 局所最適解 と 大域的最適解 の違い。 右側からスタートすると局所解に停留しやすい。

📐 定義／数式

📐 数式の読み解き ── 勾配降下法 の核心式

勾配降下法。 $\eta$ は学習率、 $L$ は損失関数。

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

❓ FAQ ── 勾配降下法 のよくある質問

📐 GD の収束保証：凸性と滑らかさの条件

GD には数学的な収束保証がある。 関数の性質によって「何 iteration で目標精度 ε に到達するか」が定理化されている。

深層学習が「理論なしで動く」のは、 非凸であるにも関わらず 1 次法でうまく収束するから。 この理由は active な研究分野（loss landscape, neural tangent kernel, mean field theory）。 SSDSE の線形回帰は強凸なので GD の理論保証が完全に成立する例。

📝 章末まとめ：勾配降下法を 8 つの命題で復習

1. GD は「損失関数の坂を負勾配方向に下る」反復解法。 凸関数なら大域最適、 非凸なら局所最適に収束。
2. 更新式 $\theta_{t+1} = \theta_t - \eta \nabla L(\theta_t)$。 学習率 η が最重要パラメータ。
3. η が大きすぎ → 発散、 小さすぎ → 収束遅延。 「ちょうど良い」は二次曲率の逆数オーダ。
4. Batch / Mini-batch / SGD の使い分けはデータサイズと計算資源で決まる。 大規模では Mini-batch が標準。
5. Momentum / Nesterov / Adam などの派生は「振動抑制」「適応的学習率」「先読み」で収束を加速。
6. 局所最適・鞍点・勾配消失 / 爆発は実装時の三大ハマりどころ。 初期化・正則化・スケーリングで対処。
7. 特徴量のスケール統一（StandardScaler 等）は必須前処理。 これなしで GD は動かないことも多い。
8. 線形モデルなら解析解 / L-BFGS、 深層学習なら Adam が現代の標準。 GD は基礎であり万能薬ではない。

🔬 数式を言葉で読み解く

🧮 実値で計算してみる

1次元の例：$L(\theta) = (\theta - 3)^2$

• 勾配 $\nabla L = 2(\theta - 3)$
• 初期 $\theta = 0$、 $\eta = 0.2$
• ステップ1：$\theta \leftarrow 0 - 0.2 \times 2(0-3) = 1.2$
• ステップ2：$1.2 - 0.2 \times 2(1.2-3) = 1.92$
• …継続して 3 に収束

🧮 SSDSE-B 実値で計算してみる ── 勾配降下法

都道府県データで線形回帰モデル『就業者数 = w × 人口 + b』を勾配降下で学習。 SSDSE-B の人口（A1101）と就業者数（C3301）を使い、 ミニバッチ（10 県ずつ）で w, b を更新していく。

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

🧮 補足: vanilla GD / SGD / Momentum / Adam の収束比較 (SSDSE-B-2026)

勾配降下法には多数の派生があるが、 何が違うのかは 同じデータで損失曲線を重ね描き しないと体感できない。 SSDSE-B-2026 の総人口 → 出生数の単回帰を題材に、 4 手法を PyTorch optim で並行訓練し、 反復ごとの損失を比較する。

数式を言葉で読み解く: 4 つの更新則の差分

Vanilla GD は θ ← θ - η∇L。 SGD は同式だがミニバッチで ∇L を近似。 Momentum は v ← βv + ∇L、 θ ← θ - ηv で過去勾配を引きずる。 Adam は m, v の 1 次・2 次モーメントを推定し θ ← θ - η m̂/(√v̂+ε) で各次元の学習率を自動調整する。 SSDSE-B-2026 のように特徴量スケールが百万〜千万のとき、 Adam の自動スケーリングが効く。

 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
import torch
import torch.nn as nn

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

def train(opt_name, lr=0.05, epochs=200):
    torch.manual_seed(0)
    model = nn.Linear(1, 1)
    if opt_name == 'GD':       opt = torch.optim.SGD(model.parameters(), lr=lr)
    if opt_name == 'SGD':      opt = torch.optim.SGD(model.parameters(), lr=lr)
    if opt_name == 'Momentum': opt = torch.optim.SGD(model.parameters(), lr=lr, momentum=0.9)
    if opt_name == 'Adam':     opt = torch.optim.Adam(model.parameters(), lr=lr)
    losses = []
    for _ in range(epochs):
        pred = model(X); loss = ((pred - y) ** 2).mean()
        opt.zero_grad(); loss.backward(); opt.step()
        losses.append(loss.item())
    return losses

for name in ['GD', 'SGD', 'Momentum', 'Adam']:
    hist = train(name)
    print(f'{name:9s}: final loss = {hist[-1]:.6f}, '
          f'epoch_to_loss<0.05 = {next((i for i,v in enumerate(hist) if v<0.05), -1)}')

🎯 このコードでやること: SSDSE-B-2026 の (A1101, A4101) で 4 つの optimizer を 200 epoch 学習し、 最終損失と収束 epoch を比較する。

📥 入力データ (SSDSE-B-2026 の 2023 年 47 都道府県、 標準化済み):

📤 実行結果:

💬 結果の読み方: 47 県の単回帰は線形で凸なので、 どの optimizer も最終損失はほぼ同じ 0.0091 付近（$1-r^2$、 相関 $r=0.995$）に収束する。 違いは「収束速度」。 Momentum は 5 epoch で損失 0.05 を切り、 vanilla GD と SGD は 17 epoch、 Adam は 19 epoch とやや慎重に進む。 高次元・非凸（ニューラルネット）になると Adam の優位が顕著になる。

⚠️ 落とし穴: Adam なら何でも勝てるは誤り

• Adam は汎化が SGD+Momentum に劣ることが知られる（Wilson et al. 2017）。 画像分類の SOTA は今も SGD+Momentum 多い（80-150 文字）
• 学習率 0.05 は線形回帰では十分だが、 深層モデルでは 0.001 〜 3e-4 が標準。 桁を 2 つ間違えると発散する
• SSDSE-B-2026 のように特徴量スケールが 10⁶ オーダーのまま GD に投げると勾配爆発。 必ず standardize する
• Adam の weight decay は L2 正則化と等価ではない。 正しくは AdamW を使う（Loshchilov & Hutter 2017）

🧭 勾配降下法の総合理解 ── 体系的拡張パート

ここでは勾配降下法（Gradient Descent, GD）の挙動を、 単に「重みを更新するアルゴリズム」として暗記するのではなく、 損失曲面の幾何・更新ベクトルの方向と大きさ・学習率の役割・確率的サンプリングの効果という 4 つの軸で再構成する。 SSDSE-B-2026（47 都道府県の社会経済指標）を用いて、 線形回帰・ロジスティック回帰・浅い MLP の 3 タスクに対し、 同一の初期値から GD/SGD/Mini-batch/Momentum/Adam を走らせ、 収束速度・最終損失・パラメータの最終位置を直接比較する。 これにより、 抽象的な「最適化アルゴリズムの選択」が、 具体的な数値挙動として腹落ちすることを目指す。

🔖 拡張キーワード索引

📐 勾配降下法の 4 つの軸を再定義する

勾配降下法を理解する上で押さえるべき軸は次の 4 つである。 教科書では「式を覚えろ」とだけ書かれがちだが、 それぞれの軸が独立に効くので、 まずは分けて整理する。

軸 1：方向。 損失 $L(\theta)$ を局所的に最も急に減らす方向は 負の勾配 $-\nabla L(\theta)$ である。 これは線形近似 $L(\theta+\Delta) \approx L(\theta) + \nabla L(\theta)^\top \Delta$ から、 $\|\Delta\|$ を固定したときに右辺を最小化する $\Delta$ が $-\nabla L(\theta)/\|\nabla L(\theta)\|$ になることから導かれる。 これは「下りる方向の選択」であり、 凸でも非凸でも局所的には成立する。

軸 2：歩幅。 一歩あたりの移動量を決めるのが学習率 $\eta$ である。 大きすぎれば発散し、 小さすぎれば収束が遅い。 凸かつ $L$ が $L$-平滑（リプシッツ勾配定数 $L_{\rm smooth}$）であれば $\eta \le 1/L_{\rm smooth}$ が安全な選択であることが知られる。 実務ではこの理論値を直接使わず、 学習率探索（LR Range Test）や warmup + cosine schedule で代替する。

軸 3：サンプリング。 損失 $L(\theta) = \frac{1}{n} \sum_{i=1}^n \ell(\theta; x_i, y_i)$ の勾配を毎ステップ全データで計算するのがバッチ GD、 1 サンプルだけで近似するのが SGD、 数十〜数百サンプルで近似するのがミニバッチ GD である。 サンプリングはノイズを導入するが、 そのノイズが鞍点脱出やフラットミニマ選好に寄与することが近年わかってきた。

軸 4：履歴。 過去の勾配情報をどう活かすか。 Momentum は速度ベクトルを慣性として保ち、 Adam は各座標ごとに勾配の二乗和で歩幅を正規化する。 履歴を持つことで「過去に何度も同じ方向に押された座標は今回も同じ方向に大きく動く」「ノイズで激しく振動する座標は歩幅を縮める」といった適応的挙動が可能になる。

📊 主要最適化アルゴリズムの比較表（軸ごとの位置づけ）

読み方：「バッチ GD → Mini-batch GD → Momentum → Adam」は、 軸 3（サンプリング）→ 軸 4（履歴）の順に高度化していく流れになっている。 Adam だけを覚えても理解は深まらない。 各軸ごとに何が追加されたかを意識する。

🎨 直感を絵で掴む ── 3 枚の図で勾配降下法を見る

勾配降下法は「数値が動く軌跡」「分布」「グループ間の違い」の 3 視点で観察すると、 動作原理が腹落ちする。 ここでは SSDSE-B-2026 の都道府県データを使って 3 つの異なる視点を提示する。

上の散布図は、 GD が解くべき「線形回帰タスクそのもの」を視覚化したものである。 各点までの垂直距離の二乗平均を損失 $L(w, b) = \frac{1}{n}\sum_i (y_i - (w x_i + b))^2$ として、 $(w, b)$ 空間で滑り降りるのが GD だ。 損失関数は $(w, b)$ について凸放物面になるので、 学習率さえ間違えなければ必ず大域最小に達する。

ヒストグラムから読み取れるのは「データのスケール」である。 GD の学習率はデータのスケールに依存するため、 標準化（zero mean, unit variance）またはスケーリング（min-max）が事前に必要だ。 47 都道府県のような小規模データでも、 1 特徴量で 10⁶ 倍のスケール差は普通にある。 標準化前のスケールを把握するためにヒストグラムは必須の前処理ツールである。

箱ひげ図は、 同じ optimizer を複数回走らせたときの「結果の安定性」を可視化するのに最適だ。 SGD のように確率的要素を持つ optimizer は、 ミニバッチサンプルの順序によって最終損失が異なる。 箱の高さが安定性、 中央値が平均的性能、 ひげの長さが最悪ケースを意味する。 「中央値が低くて箱も小さい」optimizer が実務的に最強だ。

🧮 SSDSE-B-2026 で 47 都道府県の線形回帰を GD で解く

SSDSE-B-2026 のうち A1101（総人口）と A4101（出生数）を選び、 標準化したうえで $y = w \cdot x + b$ の最小二乗フィットを GD で解く。 手計算と Python 実装を並べて、 学習率を 0.001 / 0.01 / 0.1 / 0.5 と変えた場合の挙動を比較する。

読み方：47 県の単回帰（特徴量 1 個、 サンプル 47 個、 標準化済み）の場合、 損失 $L=\mathrm{mean}(\mathrm{err}^2)$ のヘッセ行列は $2\cdot\mathrm{Var}(x)=2$ なので、 収束条件は $\eta < 2/2 = 1$。 表でも $\eta = 0.5$ までは高速に収束し（10 epoch で損失 0.009）、 $\eta = 1.0$ で損失が 1.0 のまま下がらず発散していることが見て取れる。 凸かつ平滑な問題は理論値で安全領域を計算できる。

🐍 Python 実装 1 ── 純粋 numpy で GD ループを書く

🎯 このコードでやること：SSDSE-B-2026 の A1101（総人口） と A4101（出生数） を読み込み、 標準化後に GD ループを numpy 手書きで実装する。 ライブラリに頼らず、 勾配計算と更新式が一致するかを確認する。

📥 入力データ (SSDSE-B-2026 の 2023 年 47 都道府県、 標準化前):

 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

import numpy as np
import pandas as pd

# SSDSE-B-2026 を読み込む（cp932、 単位行をスキップ）
df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026'] == df['SSDSE-B-2026'].max()]

x_raw = df['A1101'].values.astype(float)  # 総人口
y_raw = df['A4101'].values.astype(float)  # 出生数

# 標準化（GD には必須の前処理）
x = (x_raw - x_raw.mean()) / x_raw.std()
y = (y_raw - y_raw.mean()) / y_raw.std()

# 初期パラメータ
w, b = 0.0, 0.0
eta = 0.05
n = len(x)

# GD ループ
history = []
for epoch in range(200):
    pred = w * x + b
    err = pred - y
    loss = (err ** 2).mean()
    # 勾配は ∂L/∂w = 2/n Σ err_i * x_i、 ∂L/∂b = 2/n Σ err_i
    grad_w = 2.0 * (err * x).mean()
    grad_b = 2.0 * err.mean()
    w -= eta * grad_w
    b -= eta * grad_b
    history.append(loss)

print(f'最終パラメータ: w = {w:.4f}, b = {b:.4f}')
print(f'最終損失: {history[-1]:.6f}')
print(f'損失推移: epoch 0 → {history[0]:.4f}, '
      f'epoch 50 → {history[50]:.4f}, epoch 200 → {history[-1]:.4f}')

📤 実行結果:

💬 結果の読み方：標準化済みデータでは正解 $w = \mathrm{Cov}(x,y)/\mathrm{Var}(x) = \rho(x,y) \approx 0.995$、 $b \approx 0$ となる。 GD は学習率 0.05・200 epoch で $w = 0.9954$ に到達し、 最小二乗の解析解（$w = 0.995425$、 閉形式で求まる）とほぼ一致する。 この問題は凸なので GD は解析解へ収束するが、 学習率が小さすぎれば（表の $\eta=0.001$ を参照）200 epoch では届かない ── 「学習率と epoch 数のトレードオフ」は常につきまとう。 解析解が存在しない非線形モデルでは GD が唯一の選択肢になる。

🐍 Python 実装 2 ── 学習率を変えて挙動を比較する

🎯 このコードでやること：同じデータに対し $\eta \in \{0.001, 0.01, 0.05, 0.1, 0.5, 1.0\}$ で GD を走らせ、 表 R642-1 の数値を再現する。 学習率が大きすぎると発散する現象を直接観察できる。

📥 入力データ: 直前のコードと同じ標準化済み $(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
27
28
29

import numpy as np
import pandas as pd

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

def run_gd(eta, epochs=200):
    w, b = 0.0, 0.0
    history = []
    for _ in range(epochs):
        pred = w * x + b
        err = pred - y
        loss = (err ** 2).mean()
        if not np.isfinite(loss):
            history.append(float('nan'))
            break
        history.append(loss)
        w -= eta * 2.0 * (err * x).mean()
        b -= eta * 2.0 * err.mean()
    return history

for eta in [0.001, 0.01, 0.05, 0.1, 0.5, 1.0]:
    h = run_gd(eta)
    vals = [h[i] if i < len(h) else float('nan') for i in [9, 49, 199]]
    print(f'eta={eta:5.3f} | 10ep={vals[0]:.4f} | 50ep={vals[1]:.4f} | 200ep={vals[2]:.4f}')

📤 実行結果:

💬 結果の読み方：表 R642-1 と一致する。 $\eta = 0.5$ は安定限界 $\eta < 1$ の内側なので 10 epoch で損失 0.009 まで一気に収束する。 一方 $\eta = 1.0$ では更新が対称点へ跳ね返り、 損失が 1.0 のまま 200 epoch を通じて一度も下がらない。 GD 実装では「損失曲線が下がっているか」を全 epoch にわたって確認し、 理論的な安定境界 $\eta < 1$ を超えないことが重要である。

🐍 Python 実装 3 ── ミニバッチ SGD と Adam を比較する

🎯 このコードでやること：47 県を 8 サンプルずつのミニバッチに分け、 SGD / Momentum / Adam の 3 通りで 100 epoch 学習。 各 epoch の最終損失を記録し、 収束パターンを比較する。

📥 入力データ: 標準化済みの (A1101, A4101) 47 県、 ミニバッチサイズ 8。

 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 numpy as np
import pandas as pd
np.random.seed(0)   # 実行のたびに同じ結果が出るようにする

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026'] == df['SSDSE-B-2026'].max()]
x = df['A1101'].values.astype(float); y = df['A4101'].values.astype(float)
x = (x - x.mean()) / x.std()
y = (y - y.mean()) / y.std()
n = len(x)
batch = 8
eta = 0.05

def sgd_step(w, b, xb, yb):
    err = (w * xb + b) - yb
    return w - eta * 2.0 * (err * xb).mean(), b - eta * 2.0 * err.mean()

def momentum_step(w, b, xb, yb, vw, vb, mu=0.9):
    err = (w * xb + b) - yb
    gw = 2.0 * (err * xb).mean(); gb = 2.0 * err.mean()
    vw = mu * vw + gw; vb = mu * vb + gb
    return w - eta * vw, b - eta * vb, vw, vb

def adam_step(w, b, xb, yb, t, mw, mb, vw, vb, beta1=0.9, beta2=0.999, eps=1e-8):
    err = (w * xb + b) - yb
    gw = 2.0 * (err * xb).mean(); gb = 2.0 * err.mean()
    mw = beta1 * mw + (1 - beta1) * gw; mb = beta1 * mb + (1 - beta1) * gb
    vw = beta2 * vw + (1 - beta2) * gw ** 2; vb = beta2 * vb + (1 - beta2) * gb ** 2
    mhw = mw / (1 - beta1 ** t); mhb = mb / (1 - beta1 ** t)
    vhw = vw / (1 - beta2 ** t); vhb = vb / (1 - beta2 ** t)
    return (w - eta * mhw / (vhw ** 0.5 + eps),
            b - eta * mhb / (vhb ** 0.5 + eps), mw, mb, vw, vb)

results = {}
for name in ['SGD', 'Momentum', 'Adam']:
    w, b, vw, vb, mw, mb = 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
    losses = []
    t = 0
    for epoch in range(100):
        idx = np.random.RandomState(epoch).permutation(n)
        for start in range(0, n, batch):
            t += 1
            ix = idx[start:start + batch]
            xb, yb = x[ix], y[ix]
            if name == 'SGD':
                w, b = sgd_step(w, b, xb, yb)
            elif name == 'Momentum':
                w, b, vw, vb = momentum_step(w, b, xb, yb, vw, vb)
            else:
                w, b, mw, mb, vw, vb = adam_step(w, b, xb, yb, t, mw, mb, vw, vb)
        # epoch 終了時の全体損失
        losses.append(((w * x + b - y) ** 2).mean())
    results[name] = losses

for name, h in results.items():
    print(f'{name:9s}: 1ep={h[0]:.4f}, 10ep={h[9]:.4f}, 50ep={h[49]:.4f}, 100ep={h[-1]:.4f}')

📤 実行結果:

💬 結果の読み方：3 つの optimizer の最終損失はほぼ同じ（約 0.009）に到達するが、 初期の収束速度が異なる。 Momentum は 1 epoch で既に損失 0.044 まで下がり最速、 SGD は 0.285、 Adam は 0.514 と最初に出遅れる（バイアス補正の初期挙動）。 ここで重要なのは「Adam は万能ではない」点だ。 線形回帰のような単純な凸問題では Momentum の方が速い。 Adam が真価を発揮するのは、 勾配のスケールが座標ごとに大きく異なる非凸問題（深層学習）である。

🐍 Python 実装 4 ── 学習率スケジュールの効果

🎯 このコードでやること：固定学習率 vs cosine annealing スケジュールの比較。 同じデータ、 同じ初期値、 同じアルゴリズムで、 スケジュール導入だけで収束精度がどう変わるかを観察。

📥 入力データ: 標準化済み (A1101, A4101)、 200 epoch、 初期学習率 0.1。

 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

import numpy as np
import pandas as pd

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026'] == df['SSDSE-B-2026'].max()]
x = df['A1101'].values.astype(float); y = df['A4101'].values.astype(float)
x = (x - x.mean()) / x.std()
y = (y - y.mean()) / y.std()
eta0 = 0.1
epochs = 200

def cosine_lr(epoch, eta0, T):
    return 0.5 * eta0 * (1.0 + np.cos(np.pi * epoch / T))

results = {}
for sched in ['fixed', 'cosine']:
    w, b = 0.0, 0.0
    losses = []
    for ep in range(epochs):
        eta = eta0 if sched == 'fixed' else cosine_lr(ep, eta0, epochs)
        pred = w * x + b
        err = pred - y
        losses.append((err ** 2).mean())
        w -= eta * 2.0 * (err * x).mean()
        b -= eta * 2.0 * err.mean()
    results[sched] = (w, b, losses)

for sched, (w, b, h) in results.items():
    print(f'{sched:7s}: w={w:.6f}, b={b:.6f}, '
          f'final loss={h[-1]:.6f}')
print(f'最小二乗解析解: w=0.995425, b=0.000000')

📤 実行結果:

💬 結果の読み方：この凸問題では、 学習率 $\eta = 0.1$ は十分小さく安全な領域なので、 fixed でも 200 epoch あれば解析解に到達する。 cosine スケジュールの真価は「最初は大きな歩幅で広い領域を探索し、 後半は小さな歩幅で精密フィット」という点にあるため、 学習率を 0.5 のような大きな値から開始した場合に最も効く。 深層学習では cosine + warmup が標準だ。

📊 SSDSE-B-2026 都道府県別の勾配の大きさ

SGD では「1 サンプル」を選んで勾配を計算する。 SSDSE-B-2026 のように都道府県をサンプルとする場合、 どの県を選ぶかで勾配の大きさが大きく異なる。 標準化済み線形回帰モデル $L = (wx + b - y)^2$ の勾配は、 県ごとに次のようになる。

読み方：東京都の勾配は他県の数倍〜数十倍（$|2xy|\approx34.5$）。 SGD で東京都を引いた回には大きく動き、 平均に近い茨城・広島を引いた回はほとんど動かない（$|2xy|\approx0$）。 ミニバッチ化（複数県を一度に処理）するとこの偏りが平均化され、 学習が安定する。 これがミニバッチ SGD が SGD より好まれる理由の一つ。

📊 損失曲面の幾何 ── 凸 vs 非凸

勾配降下法の挙動を決める最大の要因は「損失曲面の形」である。 凸関数では局所最小 = 大域最小なので、 GD は必ず最良解に到達する。 非凸関数では局所最小・鞍点・プラトーが存在し、 初期値とサンプリング戦略次第で異なる解に収束する。

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

📊 ハイパーパラメータの典型値（実務目安）

⚠️ 追加の落とし穴 ── GD 実装でハマる 8 パターン

• 標準化忘れ：SSDSE-B-2026 の人口は 10⁴〜10⁷ オーダー。 そのまま GD に突っ込むと、 学習率 0.05 でも勾配が 10⁶ オーダーになり即座に発散する。 必ず (x - x.mean()) / x.std() で zero mean unit variance に。
• バッチサイズと学習率の不一致：バッチサイズを倍にしたら学習率も倍にするのが定石（Linear Scaling Rule）。 これを知らずバッチサイズだけ増やすと収束が遅くなる。
• 最初の数 epoch で判断：$\eta = 0.5$ では最初 10 epoch は損失が下がっているように見えるが、 50 epoch で発散する。 必ず 100 epoch 以上観察すること。
• 勾配計算ミス：$\partial L/\partial w$ と $\partial L/\partial b$ の因子 2 を忘れる、 平均化（÷ n）を忘れる、 などの実装バグは初心者の典型。 autograd を使わない場合は、 必ず数値微分（finite difference）で検算する。
• 初期値依存：非凸問題では初期値次第で全く異なる解になる。 必ず複数シードで実験し、 結果のばらつきを確認する。
• 固定 epoch 数の盲信：「100 epoch 走らせれば OK」と決めつけず、 検証損失が増加に転じた時点で早期停止（Early Stopping）するのが基本。
• 勾配クリッピング忘れ：RNN のように勾配爆発が起きやすいモデルでは torch.nn.utils.clip_grad_norm_ で勾配ノルムを上限 1.0 程度に切る。
• Adam の lr を SGD と同じに設定：Adam は内部で勾配を二乗 EMA で正規化するため、 SGD の lr=0.1 と Adam の lr=0.001 が同等のオーダー。 SGD から Adam に変えるときは lr を 100 倍くらい下げるのが目安。

❓ FAQ ── 勾配降下法の素朴な疑問

🗺 勾配降下法の概念マップ

勾配降下法は「最適化」という大樹の幹であり、 そこから多くの枝が伸びている。 上位概念・並列概念・派生概念をツリー状に整理する。

🎯 理解度チェック ── 勾配降下法

1. Q1：標準化していない SSDSE-B-2026 の人口（A1101、 値域 10⁴〜10⁷）に GD を直接適用したらどうなるか？ 学習率 0.05 で予想される結果を述べよ。
   （答えの方向：勾配が 10⁵〜10⁶ オーダーになり、 1 ステップで重みが巨大な値に飛ぶ。 損失が NaN/Inf に発散。 標準化が必須）
2. Q2：凸問題で「学習率 0.5 では 10 epoch まで順調に下がっていたのに 50 epoch で発散した」という観察から何が分かるか？
   （答えの方向：振動が成長していた可能性が高い。 損失曲線全体を見るべきで、 序盤だけでは判断できない）
3. Q3：バッチサイズ 32 を 256 に増やすとき、 学習率はどう調整するべきか？
   （答えの方向：Linear Scaling Rule により、 lr も 8 倍にするのが定石。 ただし warmup を入れて急増を緩和する）
4. Q4：SGD + Momentum 0.9 と Adam、 どちらが線形回帰に向いているか。 理由とともに述べよ。
   （答えの方向：Momentum の方が速く収束する。 線形回帰の損失曲面は凸放物面で、 座標ごとに勾配スケールが大きく違わないので、 Adam の正規化機構の恩恵が少ない）
5. Q5：「Adam のデフォルト lr=0.001 を 0.1 にしたら学習が爆発した」という現象を説明せよ。
   （答えの方向：Adam は勾配を二乗 EMA で正規化するので、 実効的な歩幅は lr に比例する。 0.001 と 0.1 は 100 倍違い、 多くの問題では発散する範囲）
6. Q6：SSDSE-B-2026 で東京都だけを抜いて GD を学習すると、 結果はどう変わるか？
   （答えの方向：東京都は標準化値の絶対値が大きい外れ値的存在で、 勾配への寄与が大きい。 抜くと最小二乗解が変わる。 ただし方向は変わらず、 傾きがやや小さくなる程度）
7. Q7：「学習率を毎 epoch 半分にする」スケジュールは何と呼ばれるか。 利点・欠点を述べよ。
   （答えの方向：Exponential decay または Step decay の一種。 利点は実装が単純。 欠点は減衰が速すぎて後半は実質ゼロ学習率になり、 微調整できない）
8. Q8：GD と進化計算系手法（GA, CMA-ES）の最大の違いは何か？
   （答えの方向：GD は勾配（一次情報）を使う、 進化計算は使わない。 GD は非微分可能な目的関数では使えないが進化計算は使える。 一方、 GD は大規模問題（数百万パラメータ）で圧倒的に速い）

🧭 GD 関連の重要論文・歴史

📚 関連用語と学習の次の一歩

勾配降下法を理解した次に学ぶべきトピックを、 前提・並列・発展の 3 区分で整理する（実在する用語ページはリンク済み、 未整備のものは href="#" プレースホルダ）。

• 前提となる概念：偏微分（partial-derivative）、 ヘッセ行列（hessian）、 凸関数（convex-function）、 リプシッツ連続（lipschitz）、 標準化（standardization）
• 並列に位置する概念：Newton 法（newton-method）、 BFGS（bfgs）、 進化計算（evolutionary-computation）、 ベイズ最適化（bayesian-optimization）、 線形計画（linear-programming）
• 発展する概念：誤差逆伝播（backpropagation）、 確率的最適化理論（stochastic-optimization）、 学習率スケジューラ（lr-scheduler）、 勾配クリッピング（gradient-clipping）、 二次最適化（second-order-optimization）

🧪 まとめ ── 勾配降下法を腹落ちさせるための再整理

勾配降下法は「損失の偏微分の符号反転方向に少しだけ動く」という極めてシンプルな原理を持つ。 しかし、 この単純さに次の 4 つの工夫が乗ることで、 GPT・Stable Diffusion・AlphaGo といった現代 AI の学習を可能にしている。

1. サンプリング：全件 GD → ミニバッチ → SGD と段階的にサンプル数を減らし、 計算効率とノイズ導入を両立。
2. 履歴の活用：Momentum で速度を保ち、 RMSProp/Adam で座標別歩幅を正規化。 過去情報の二段階利用。
3. 学習率スケジュール：warmup で安定起動、 cosine で滑らかに終息。 単一の固定 lr では届かない領域に到達。
4. 標準化と正規化：データ前処理（標準化）、 内部レイヤー正規化（BatchNorm, LayerNorm）、 重み正則化（weight decay）の三位一体。

SSDSE-B-2026 のような 47 サンプル × 数百列の小さなデータセットでも、 GD の挙動・学習率の感度・サンプリングノイズの効果はすべて観察できる。 数値を一度自分の手で動かすことが、 GD という概念を腹落ちさせる最短ルートである。

🧮 数式に値を入れて手で計算する: 勾配降下 3 ステップ

f(x) = (x-3)² の勾配降下で 3 ステップ更新する。

Step 1: 初期値と微分

Step 2: 更新

🐍 Python で再現

1
2
3
4
5
6
7

def f(x): return (x-3)**2
def df(x): return 2*(x-3)
x = 0.0
lr = 0.3
for i in range(3):
    x = x - lr * df(x)
    print(f"x_{i+1} = {x:.3f}, f = {f(x):.4f}")

📤 実行結果

💬 手計算 (Step 2) x₃ = 2.808 と Python 出力が完全一致。

🐍 Python 実装

最小限のスニペットで動作確認できる例。 公的データ（SSDSE 等）を想定しています。

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

import numpy as np

# シンプルな勾配降下
def gd(theta=0.0, lr=0.2, n_steps=20):
    for _ in range(n_steps):
        grad = 2 * (theta - 3)
        theta -= lr * grad
    return theta

print(gd())  # 約 3.0

# PyTorch の SGD
import torch
theta = torch.zeros(1, requires_grad=True)
optim = torch.optim.SGD([theta], lr=0.2)
for _ in range(20):
    loss = (theta - 3) ** 2
    optim.zero_grad(); loss.backward(); optim.step()
print(theta.item())

🐍 SSDSE-B を使った Python 実装

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

 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 pandas as pd
import numpy as np

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', skiprows=[1], encoding='cp932')
df = df[df['SSDSE-B-2026'] == 2023]   # 2023年の47都道府県のみ
X = df[['A1101', 'A4101']].astype(float).values
y = df['C3301'].astype(float).values

# 正規化
X = (X - X.mean(0)) / X.std(0)
y = (y - y.mean()) / y.std()

w = np.zeros(2)
b = 0.0
lr = 0.01

for ep in range(300):
    pred = X @ w + b
    err = pred - y
    grad_w = 2 * X.T @ err / len(y)
    grad_b = 2 * err.mean()
    w -= lr * grad_w
    b -= lr * grad_b
    if ep % 50 == 0:
        print(f'ep {ep}: loss={(err**2).mean():.4f}')
print('最終 w:', w, 'b:', b)

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

⚠️ よくある落とし穴

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

⚠️ 落とし穴：GD で実装するときに必ず踏む 8 つの地雷

🏔 最適化の階層：GD は数ある手法の一つ

「最適化アルゴリズム」の世界で GD はどの位置にいるか。 階層構造で整理する。

最適化問題 min f(θ)
├── 解析解が存在
│    ├── 線形回帰 → 正規方程式
│    ├── ロジスティック回帰（小規模） → IRLS
│    └── 主成分分析 → 固有値分解
└── 反復解法
     ├── 0 次法（勾配を使わない）
     │    ├── グリッドサーチ
     │    ├── ベイズ最適化
     │    └── 進化的アルゴリズム
     ├── 1 次法（勾配を使う） ★ GD はここ
     │    ├── Batch GD / SGD / Mini-batch SGD
     │    ├── Momentum / Nesterov
     │    └── Adam / AdaGrad / RMSProp / LION
     ├── 2 次法（ヘッセ行列を使う）
     │    ├── Newton 法
     │    ├── 準ニュートン法 (BFGS, L-BFGS)
     │    └── 信頼領域法
     └── 制約付き最適化
          ├── 投影 GD（projected GD）
          ├── 交互方向乗数法 (ADMM)
          └── 内点法

深層学習では 1 次法（特に Adam 系）が定番。 2 次法は精度高いが行列計算が O(n²) で大規模 NN に向かない。 L-BFGS は古典的 ML で根強い人気。 ベイズ最適化はハイパーパラメータ探索の主役。

🌐 関連手法・派生

• Momentum — 慣性で局所最小／鞍点回避
• Adam — 適応的学習率＋Momentum、 現代標準
• RMSProp — 適応的学習率の先駆
• AdamW — Adamに正則化を分離
• Newton法 — 2次情報利用、 高速だが高コスト

🌐 二次法：Newton 法と準ニュートン法

GD は勾配（1 次微分）だけ使う「1 次法」。 2 次微分（Hessian 行列）まで使えば、 学習率を選ばずに収束方向と歩幅を同時に決められる。 これが Newton 法。

$$\theta_{t+1} = \theta_t - H^{-1}(\theta_t)\, \nabla L(\theta_t)$$

数式を言葉で読み解く：勾配 $\nabla L$ を Hessian $H$（2 次偏微分の行列）の逆で「変換」する。 各方向の曲率を考慮して、 ちょうど良い歩幅を自動算出する。 凸 2 次関数なら 1 ステップで最適に到達。 ただし $H$ の計算が O(n²)、 逆行列が O(n³) と高コスト。

⚙️ Newton 法の限界と準ニュートン法

• $H$ が非正定値だと「峠を上ってしまう」 → 修正必要
• $H$ 計算コストが大きすぎ → BFGS, L-BFGS が代替
• L-BFGS は過去 m 回の勾配から $H^{-1}$ を近似 → 中規模問題で 1 次法より速い
• 深層学習では Hessian-vector product のみ使う Hessian-Free 法（Martens 2010）

🐍 SSDSE で scipy の L-BFGS と GD を比較

このコードでやること：先ほどの 2 変数最適化を、 GD と scipy の L-BFGS で解き、 必要な関数評価回数を比較する。

📥 入力：オリジナルスケールの x, y

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

# L-BFGS で 2 変数最適化
import pandas as pd, numpy as np
from scipy.optimize import minimize

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026'] == df['SSDSE-B-2026'].max()]
x = df['A1303'].values.astype(float) / 1e6
y = df['A1101'].values.astype(float) / 1e6

def loss(params):
    w, b = params
    return ((w*x + b - y)**2).mean()

res = minimize(loss, x0=[0.0, 0.0], method='L-BFGS-B')
print(f'L-BFGS: w={res.x[0]:.4f}, b={res.x[1]:.4f}, loss={res.fun:.4f}, nfev={res.nfev}')

📤 実行結果（例）：

💬 結果の読み方：L-BFGS はわずか 21 回の関数評価で最適（loss=0.1376、 解析解 w=3.9956, b=-0.4341）に到達。 GD は 500 反復でもまだ届かなかった。 「2 次情報を使うと収束が劇的に速い」が体感できる。 ただし深層学習では Hessian の計算コストが膨大なため、 Adam 系の 1 次法が主流。 中規模の凸最適化（線形 / ロジ回帰）では L-BFGS が黄金標準。

⏰ 学習率スケジュール：時間で η を変える

η を全反復で同じにする必要はない。 序盤は大きく速く進み、 終盤は小さく精密に着地する「スケジュール」が深層学習で標準。

PyTorch の torch.optim.lr_scheduler モジュールに上記すべてが実装済み。 ReduceLROnPlateau のように「検証 loss が改善しなくなったら自動的に下げる」適応型もよく使われる。

🔧 自動微分（autodiff）：手で微分を書かなくてよくなった理由

深層学習の革命の半分は 自動微分（automatic differentiation, autodiff）。 損失関数を Python で書くだけで、 PyTorch / TensorFlow / JAX が連鎖律 (chain rule) を使って勾配を自動計算してくれる。 これで GD を「手で微分する」苦行から解放された。

⚙️ 連鎖律と逆伝播

$$\frac{\partial L}{\partial \theta} = \frac{\partial L}{\partial z_n} \cdot \frac{\partial z_n}{\partial z_{n-1}} \cdots \frac{\partial z_1}{\partial \theta}$$

数式を言葉で読み解く：複雑な合成関数の微分は「各層の偏微分の積」で計算できる（chain rule）。 NN は層の連続なので、 出力側から入力側へ遡って積を計算する（backpropagation = 逆伝播）。 これを計算グラフ上で自動化したのが autodiff。 1 回の forward pass と 1 回の backward pass で全パラメータの勾配が得られる（メモリ O(N)、 時間 O(N)）。

🐍 PyTorch で autodiff を使った GD

このコードでやること：PyTorch のテンソルと backward() だけで、 手で gradient を計算せずに線形回帰を GD で解く。 「定義 → forward → loss → backward → step」のループは深層学習の基本パターン。

📥 入力：SSDSE-B-2026 の x, y を PyTorch テンソルに変換

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

# PyTorch の autodiff で線形回帰を GD 学習
import torch
import pandas as pd

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026'] == df['SSDSE-B-2026'].max()]
x = torch.tensor(df['A1303'].values / 1e6, dtype=torch.float32)
y = torch.tensor(df['A1101'].values / 1e6, dtype=torch.float32)
xn = (x - x.mean()) / x.std(); yn = (y - y.mean()) / y.std()

w = torch.tensor(0.0, requires_grad=True)
opt = torch.optim.SGD([w], lr=0.1)

for t in range(50):
    opt.zero_grad()
    loss = ((w*xn - yn)**2).mean()
    loss.backward()         # 自動微分で w.grad を計算
    opt.step()              # w -= lr * w.grad
    if t in [0, 9, 49]:
        print(f'iter {t+1:3d}: w={w.item():.4f}, loss={loss.item():.4f}')

📤 実行結果：

💬 結果の読み方：後述の自前 GD と収束先 $w=0.9910$ がほぼ一致する（同じ学習率 0.1・同じ標準化データなので当然）。 ただし PyTorch では loss.backward() 一行で勾配が自動計算される。 これを「100 万層の Transformer」「分岐のある計算」「動的グラフ」でも自動で処理できるのが autodiff の威力。 GD を理論として理解した次のステップは、 autodiff フレームワークの内部実装を学ぶこと。

💰 計算コスト：データサイズと反復数のトレードオフ

「N サンプル、 P パラメータ、 T 反復、 K ミニバッチ」で計算コストはどうなるか。

SGD は 1 反復が安いが、 必要反復数 T' が大きい（ノイジーで収束遅）。 Mini-batch SGD は両者の中庸で、 さらに GPU/SIMD 並列化が効くため実用的に最速。 Batch サイズは「メモリ容量 / 並列度」で決まる。 一般に：n=10⁴〜 → Mini-batch SGD、 n=10²〜10⁴ → L-BFGS や Newton、 n=10² 以下 → 解析解または scipy.optimize。

🧠 物理学的解釈：GD はエネルギー散逸ダイナミクス

GD は「エネルギー（損失）を散逸させながら平衡点（最適）に向かう物理系」と見ることができる。 連続極限での GD は ODE：

$$\frac{d\theta}{dt} = -\nabla L(\theta)$$

これは粘性が強い物体が斜面を滑り降りる運動（gradient flow）。 Momentum は質量を持つ物体の運動方程式：

$$\frac{d^2\theta}{dt^2} + \mu \frac{d\theta}{dt} = -\nabla L(\theta)$$

「ボールが斜面を転がる」古典力学そのもの。 確率的勾配降下法 SGD はランダムな揺動を含むため、 Langevin 方程式（熱平衡へ向かう拡散）と等価：

$$\frac{d\theta}{dt} = -\nabla L(\theta) + \sqrt{2T}\, \eta(t)$$

温度 T = 学習率 × バッチノイズ。 高温（大学習率）では大域探索、 低温（小学習率）で局所微調整 — まさに焼きなまし法 (simulated annealing) の構造。 「学習率を徐々に下げる」のは物理的に「冷却」している。

✅ 実務 cheat-sheet：困ったらこの設定

「とりあえず Adam(lr=1e-3) で始める」が深層学習の現代的デフォルト。 動かない場合は ① 学習率を 1/10 にする ② 標準化を確認する ③ gradient clipping を入れる、 の順で対処。

🌌 GD と汎化：なぜ深層学習は過学習しないのか

古典的統計学習理論では「パラメータ数 ≫ サンプル数」のモデルは過学習する。 しかし深層 NN は数千万パラメータでもうまく汎化する。 この謎の解明には GD の特性が深く関わる。

⚙️ 暗黙的正則化 (implicit regularization)

GD（特に SGD）は、 同じ訓練 loss を達成する無数のモデルから「特定の解」を選ぶ。 経験的には「flat minimum（平らな谷の底）」を好む傾向があり、 flat minima は汎化が良いことが知られている (Keskar 2017, Hochreiter & Schmidhuber 1997)。

⚙️ Double descent（二重降下）

パラメータ数を増やしていくと、 ① 過学習で誤差が増える ② さらに増やすと誤差が再び下がる、 という不思議な U 字 → 二重降下 (Belkin 2019)。 過パラメータ化レジームでは GD が「最小ノルム解」を選び、 これが滑らかな関数になるため汎化する。

⚙️ Neural Tangent Kernel (NTK)

無限幅 NN の GD は、 NTK と呼ばれる固定カーネルでのカーネル回帰と等価 (Jacot 2018)。 これにより深層学習の理論的振る舞いが部分的に解明されつつある。

🔄 GD と再現性：「同じコードで違う結果」が出る理由

「論文の実験結果を再現できない」問題の多くは GD の確率的な性質に起因する。 再現性確保のチェックリスト：

1. 乱数シード固定：np.random.seed(0), torch.manual_seed(0), random.seed(0) を全部設定。
2. GPU 演算の決定論性：torch.backends.cudnn.deterministic = True（速度低下と引き換え）。
3. データロード順序：DataLoader の worker_init_fn で各 worker のシードも固定。
4. 並列処理の非決定性：CUDA の reduction は非決定論的なことがある（atomic add の順序問題）。
5. 環境依存：CUDA バージョン、 PyTorch バージョン、 ハードウェア差で微妙に結果が変わる。
6. ハイパーパラメータの記録：学習率・バッチサイズ・初期化・スケジュール、 すべて明示的にログ。
7. seed の sweep：シードを 3-5 個変えて平均 ± 標準偏差で報告（単一 seed の結果は信頼できない）。

🔗 GD が顔を出す意外な分野

🏎 SSDSE で 4 種の optimizer をベンチマーク

同じ問題（人口減少フラグ予測のロジ回帰）を SGD / Adam / RMSProp / SGD+Momentum で学習し、 各反復の loss を記録。

🐍 PyTorch で 4 optimizer を一発比較

このコードでやること：総人口・高齢者人口・若者人口の 3 特徴量から「人口増加フラグ（前年より総人口が増えたか）」を予測するロジ回帰を、 4 つの optimizer で学習。 各 epoch の loss を比較し、 「適応的手法 (RMSProp / Adam) と Momentum が Plain SGD より速い」を実値で確認。

📥 入力：47 県、 3 特徴量、 2 値ラベル

 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

# 4 optimizer を比較 (PyTorch、 SSDSE-B-2026)
import pandas as pd
import torch
import torch.nn as nn

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
y_max = df['SSDSE-B-2026'].max()
now = df[df['SSDSE-B-2026']==y_max][['Prefecture','A1101','A1303','A1301']]
prev = df[df['SSDSE-B-2026']==y_max-1][['Prefecture','A1101']].rename(columns={'A1101':'prev_pop'})
m = now.merge(prev, on='Prefecture')

X = torch.tensor(m[['A1101','A1303','A1301']].values / 1e6, dtype=torch.float32)
y = torch.tensor((m['A1101'] > m['prev_pop']).astype(int).values, dtype=torch.float32)

def train(opt_cls, **kw):
    torch.manual_seed(0)
    model = nn.Linear(3, 1)
    opt = opt_cls(model.parameters(), **kw)
    losses = []
    for _ in range(200):
        opt.zero_grad()
        l = nn.BCEWithLogitsLoss()(model(X).squeeze(), y)
        l.backward(); opt.step(); losses.append(l.item())
    return losses

for name, oc, kw in [('SGD',torch.optim.SGD,{'lr':0.05}), ('Momentum',torch.optim.SGD,{'lr':0.05,'momentum':0.9}), ('RMSProp',torch.optim.RMSprop,{'lr':0.05}), ('Adam',torch.optim.Adam,{'lr':0.05})]:
    L = train(oc, **kw)
    print(f'{name:9s}: loss[1]={L[0]:.3f}, loss[50]={L[49]:.3f}, loss[200]={L[-1]:.3f}')

📤 実行結果（例）：

💬 結果の読み方：全手法とも同一初期値なので loss[1]=0.542 から出発する。 Plain SGD は 200 epoch でも loss 0.186 と最も高く収束が遅い。 Momentum (0.034)、 Adam (0.031)、 RMSProp (0.015) は適応的・慣性的な更新で大きく先行し、 このデータでは RMSProp が最速だった。 スケールの偏った特徴量では適応的 optimizer が効きやすく、 深層 NN でも Adam が定番。 「困ったらまず Adam」は経験則として有効。

🛠 GD が動かない時のチェックリスト

これらは経験的トラブルシューティング。 「まず学習曲線（train/valid の loss と accuracy を epoch ごとにプロット）」を必ず作る習慣で、 90% の問題は瞬時に診断できる。

🔗 関連用語（前提・並列・発展）

役割で色分け：前提／上位／並列／発展／応用

🔗 拡張関連用語

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

📚 関連グループ教材

この用語の全体像を学ぶには、 横断的な教材で文脈を掴むのが効率的です。

• 📚 深層学習基礎
• 📚 最適化概論

🔎 深掘り解説

主要最適化アルゴリズム

学習率スケジュール

• StepDecay：一定エポック毎に1/10
• ExponentialDecay：指数関数的減衰
• CosineAnnealing：cos関数で滑らかに減衰
• Warmup：最初はゆっくり、 途中から本格学習
• OneCycle：1サイクルで上昇→下降

✅ 使う前のチェックリスト

• ☐ 勾配降下法 が今のタスクに本当に適切か再確認した
• ☐ 前提条件（独立性、 正規性、 サンプル数等）を満たしているか確認した
• ☐ データの尺度・分布・欠損・外れ値を確認した
• ☐ 結果だけでなく「不確実性」（CI、 標準誤差）も把握した
• ☐ 解釈と限界を区別して文書化した
• ☐ 関連する別の手法と比較したうえで本手法を選んだ
• ☐ 落とし穴（このページの ⚠️ セクション）に該当しないか確認した
• ☐ 関連グループ教材で全体像と位置付けを把握した

📖 さらに学ぶには

本サイト内

• 論文一覧に戻る — 勾配降下法 を実際に使った再現論文をハンズオン形式で読む
• このページ上部の「🔗 関連用語」から派生概念へ
• 「📚 関連グループ教材」で横断的な学習教材へ

外部リソース

• scikit-learn 公式ドキュメント — 標準実装と例
• StatQuest with Josh Starmer (YouTube) — 直感的な統計／ML 解説
• Cross Validated (Stack Exchange) — 統計／ML の質問サイト
• arXiv — 最新の手法論文プレプリント

困ったときは

1. データの可視化（散布図、 ヒストグラム、 箱ひげ図）で異常を確認
2. サンプルサイズ・欠損・外れ値を確認
3. 仮定が満たされているか診断（正規性検定、 等分散性検定など）
4. 類似研究での標準的な手法を確認
5. 結果を複数手法でクロスチェック（頑健性確認）

🔗 同カテゴリの他用語

📚 参考文献・原典

• Cauchy (1847) "Méthode générale pour la résolution des systèmes d'équations simultanées" — 最急降下法の原典。
• Robbins & Monro (1951) "A Stochastic Approximation Method" — SGD の理論的祖先。
• Polyak (1964) "Some methods of speeding up the convergence of iteration methods" — Momentum。
• Nesterov (1983) 加速勾配法。
• Rumelhart, Hinton, Williams (1986) "Learning representations by back-propagating errors" — NN への適用。
• Duchi, Hazan, Singer (2011) AdaGrad。
• Kingma & Ba (2014) "Adam: A Method for Stochastic Optimization"。
• Loshchilov & Hutter (2017) "Decoupled Weight Decay Regularization" — AdamW。
• Chen et al. (2023) "Symbolic Discovery of Optimization Algorithms" — LION。
• Goodfellow, Bengio, Courville (2016) "Deep Learning" 8 章 — 最適化全般の教科書。

🗺 勾配降下法 の概念マップ

『勾配降下法』は『最適化』カテゴリに属する重要概念で、 以下の関連概念群と密接につながっています。

最適化
  ├── 前提
  │   └── 数学・統計の基礎
  ├── 勾配降下法  ← このページ
  │   ├── 派生 1
  │   ├── 派生 2
  │   └── 応用
  └── 並列・対比される手法
      ├── 別アプローチ A
      └── 別アプローチ B
  

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

📋 学習チェックリスト ── 勾配降下法 を使いこなすために

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

📜 歴史と発展

Cauchy (1847) の最急降下法に起源。 ニューラルネットでは Rosenblatt (1958), Rumelhart (1986) で確立。 SGD (Robbins-Monro 1951), Momentum (Polyak 1964), AdaGrad (Duchi 2011), RMSProp (Tieleman 2012), Adam (Kingma 2014) と派生多数。 近年は LION (2023) など二次情報を擬似的に使う手法も。

原典は Cauchy (1847)で、 ニューラルネットどころかコンピュータより 100 年早い手法です。 Cauchy の動機は天体力学の連立方程式を解くことでした。 一方 SGD の原典 Robbins & Monro (1951) は「確率近似」という別分野の論文で、 ノイズのある観測から根を求める逐次法として提案されています。 今日の深層学習の中核 2 つが、どちらも機械学習と無関係な文脈で生まれたのは知っておく価値があります。

🧭 拡張解説：SSDSE-B-2026 で勾配降下法を「動かして」理解する

「坂を下る」の比喩は分かりやすいが、 実装すると 学習率・収束・鞍点・過学習といった現実問題に直面する。 ここでは SSDSE-B-2026 の人口データを使い、 「高齢者人口から総人口を予測する線形回帰モデル」を勾配降下法で学習し、 ① 手作り GD、 ② 学習率の比較、 ③ scikit-learn の SGDRegressor との比較を通して、 実務で起きるすべての問題を体験する。

📌 題材：高齢者人口から総人口を予測する線形回帰

47 都道府県の高齢者人口 A1303 から総人口 A1101 を予測する単純な線形回帰 $y = wx + b$ を、 平均二乗誤差を最小化する勾配降下法で学習する。 解析解（最小二乗法）が存在するため、 GD で同じ答えに到達できるかを比較できる。

⚙️ 数式：MSE 損失とその勾配

$$L(w, b) = \frac{1}{N}\sum_{i=1}^{N} (wx_i + b - y_i)^2$$

$$\frac{\partial L}{\partial w} = \frac{2}{N}\sum_{i=1}^{N} (wx_i + b - y_i)\, x_i, \quad \frac{\partial L}{\partial b} = \frac{2}{N}\sum_{i=1}^{N} (wx_i + b - y_i)$$

$$w_{t+1} = w_t - \eta\, \frac{\partial L}{\partial w}, \quad b_{t+1} = b_t - \eta\, \frac{\partial L}{\partial b}$$

数式を言葉で読み解く：L はモデルの予測 $\hat{y} = wx+b$ と真値 $y$ の誤差を 2 乗して平均したもの（MSE）。 $\partial L/\partial w$ は「w を少し増やすと損失がどう変わるか」の感度。 GD は「損失を最も減らす方向」（負の勾配）に学習率 $\eta$ だけ進む。 学習率が大きすぎると振動・発散、 小さすぎると収束が遅い、 がトレードオフ。

🐍 自前 GD 実装：50 iteration で MSE がどう減るか

このコードでやること：SSDSE-B-2026 の標準化したデータで、 numpy のみで GD を実装。 各ステップの loss を記録し、 学習率 0.1 で収束する様子を観察。 最後に解析解（polyfit）と比較。

📥 入力：標準化済み x_n, y_n（47 点）、 初期値 w=0, b=0、 学習率 η=0.1

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

# 自前で勾配降下法を実装 (numpy のみ)
import pandas as pd
import numpy as np

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

w, b, eta = 0.0, 0.0, 0.1
for t in range(50):
    err = (w*xn + b) - yn
    gw = (2/len(xn)) * (err*xn).sum()
    gb = (2/len(xn)) * err.sum()
    w -= eta*gw; b -= eta*gb
    if t in [0, 4, 9, 49]:
        print(f'iter {t+1:3d}: w={w:.4f}, b={b:.4f}, loss={(err**2).mean():.4f}')

# 解析解 (最小二乗の公式)
m, c = np.polyfit(xn, yn, 1)
print(f'解析解  : w={m:.4f}, b={c:.4f}')

📤 実行結果：

💬 結果の読み方：GD は 50 反復で w=0.991 に収束し、 解析解（polyfit）と一致。 loss は 1.0 → 0.0180 へ 55 倍減少。 b は標準化のため 0 に張り付く（intercept の自由度が消える）。 「単純な GD でも解析解と同じ答えに到達できる」が確認できる。 ただし学習率 0.1 が適切だったため安定したのであり、 これを 1.5 に上げると発散、 0.001 に下げると 50 反復では遠く及ばない。

⚡ 学習率 η を 4 段階で比較：発散・低速・最適・振動

学習率は GD の最重要ハイパーパラメータ。 同じ問題でも η を変えると収束パターンが劇的に変わる。

🐍 4 種類の学習率で 30 反復の loss を比較

このコードでやること：η = 0.001, 0.1, 1.0, 1.5 の 4 段階で同じデータを学習し、 各 iter の loss を記録。 「小さすぎ → 進まない / 大きすぎ → 発散 / ちょうど良い → 収束」のパターンを実値で確認する。

📥 入力：先の標準化済み xn, yn を再利用

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

# 学習率を 4 段階で比較 (同じデータ、 同じ初期値)
import pandas as pd, numpy as np

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

def gd(eta, T=30):
    w = 0.0; losses = []
    for _ in range(T):
        err = w*xn - yn
        w -= eta * (2/len(xn)) * (err*xn).sum()
        losses.append((err**2).mean())
    return losses

for eta in [0.001, 0.1, 1.0, 1.5]:
    L = gd(eta)
    print(f'η={eta:5.3f}: loss[1]={L[0]:.3f}, loss[15]={L[14]:.3f}, loss[30]={L[29]:.3f}')

📤 実行結果：

💬 結果の読み方：η=0.001 では 30 反復で loss が 0.892、 約 11% しか減らない（収束遅い）。 η=0.1 はちょうど良く 30 反復で loss 0.018、 98% 削減。 η=1.0 は安定限界（この単変数問題では更新係数 $|1-2\eta|=1$）ちょうどで更新が符号反転を繰り返し、 loss が 1.0 のまま下がらない。 η=1.5 は 発散し loss が 10^17 まで爆発。 「学習率 = 二次関数の曲率の逆数」程度が安全圏で、 ハイパーパラメータサーチが必須。 Adam などの適応的最適化は、 この調整を自動化したもの。

🚀 派生手法：SGD / Momentum / AdaGrad / Adam の使い分け

🐍 SSDSE で SGDRegressor と LinearRegression を比較

このコードでやること：scikit-learn の SGDRegressor（SGD ベース）と LinearRegression（解析解）で同じデータを学習し、 係数と R² を比較する。 GD の実装上のディテール（収束判定、 学習率スケジュール）が sklearn でどう自動化されているかが分かる。

📥 入力：47 県の X=[A1303], y=A1101（オリジナルスケール）

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

# SGDRegressor と LinearRegression の比較
import pandas as pd
from sklearn.linear_model import SGDRegressor, LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026'] == df['SSDSE-B-2026'].max()]
X = df[['A1303']].values
y = df['A1101'].values

sgd = make_pipeline(StandardScaler(), SGDRegressor(max_iter=1000, tol=1e-5, random_state=0))
ols = LinearRegression()
sgd.fit(X, y); ols.fit(X, y)

print(f'SGD     R² = {sgd.score(X, y):.4f}, coef={sgd[-1].coef_[0]:.3f}')
print(f'OLS     R² = {ols.score(X, y):.4f}, coef={ols.coef_[0]:.3f}')
print(f'SGD intercept = {sgd[-1].intercept_[0]:.0f}')
print(f'OLS intercept = {ols.intercept_:.0f}')

📤 実行結果（例）：

💬 結果の読み方：R² は両者ほぼ同じ 0.982（GD でも解析解とほぼ同精度）。 ただし係数は標準化の有無で異なる：SGD は内部で StandardScaler により X を標準化しているため coef は「X の 1 標準偏差あたり」の値（約 274 万）、 OLS は「1 人あたり」の傾き 3.996。 「線形回帰なら解析解が速くて正確、 GD は標準化スケールでの解釈」 — この区別が重要。 大規模データ（n > 10^6）では解析解が遅すぎるため SGD 一択になる。

🗺 多変数の GD：等高線地図と勾配ベクトル

1 変数の損失は単純な放物線、 多変数は「お椀の底に向かう斜面」。 視覚化には「等高線（等しい loss の線）」とその上の「勾配ベクトル（最急上昇方向）」を描くのが定番。 GD はその真逆方向に進む。

🔬 言葉で読み解く：等高線と勾配の関係

数式を言葉で読み解く：等高線（level set）は loss が同じ値を持つ点の集合。 勾配 $\nabla L$ は等高線に垂直な方向（最急上昇）を指す。 GD はその逆 $-\nabla L$ に進むので、 等高線を直角に横切る軌跡を描く。 鋭く伸びた楕円（細長い谷）では、 谷を直進せず壁を交互に蹴る「ジグザグ運動」になり収束が遅れる。 これが Momentum や Adam が必要な理由。

🐍 2 変数 GD を SSDSE で動かす（w と b を同時学習）

このコードでやること：先ほどは intercept b を 0 固定にしたが、 今度はオリジナルスケールで w と b を同時に学習する。 軌跡 (w_t, b_t) と loss を記録し、 2 次元最適化のジグザグ性を観察する。

📥 入力：47 県の x = A1303 (百万人), y = A1101 (百万人)

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

# 2 変数 GD: w と b を同時最適化、 軌跡を記録
import pandas as pd, numpy as np

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df[df['SSDSE-B-2026'] == df['SSDSE-B-2026'].max()]
x = df['A1303'].values.astype(float) / 1e6
y = df['A1101'].values.astype(float) / 1e6

w, b, eta = 0.0, 0.0, 0.01
for t in range(500):
    yhat = w*x + b
    err = yhat - y
    gw = (2/len(x)) * (err*x).sum()
    gb = (2/len(x)) * err.sum()
    w -= eta*gw; b -= eta*gb
    if t in [0, 9, 99, 499]:
        print(f'iter {t+1:4d}: w={w:.4f}, b={b:.4f}, loss={(err**2).mean():.4f}')

m, c = np.polyfit(x, y, 1)
print(f'解析解        : w={m:.4f}, b={c:.4f}')

📤 実行結果（例）：

💬 結果の読み方：500 反復でも解析解（w=3.9956, b=-0.4341）には完全に届かず、 w=3.8403, b=-0.2721（loss 0.1509）で足踏みしている。 w と b は別々のスケールを持つため、 b の収束が遅い（最初に大きく+方向に振れて戻ってくる）。 これが「特徴量の標準化なしで GD を回すと収束が遅い」典型例。 学習率 η=0.01 は b にとっては大きく、 w にとっては小さい — 両者を満たす η を選ぶのが難しい。 StandardScaler を入れれば数十反復で収束する。

🔗 隣接手法への橋渡し

「勾配降下法」は単独で完結する手法ではなく、 隣接領域と連携することで真価を発揮する。

• 上流: 入力データの前処理・整備 — 偏微分・勾配ベクトル ・ 損失関数
• 並列: 類似目的を持つ代替手法 — ニュートン法 ・ 共役勾配法
• 下流: 出力結果の評価・解釈 — Adam (Kingma & Ba 2014) ・ 確率的勾配降下法 (SGD)

上流の偏微分・チェインルールで勾配を計算し、 並列のニュートン法・準ニュートン法 (BFGS) と収束速度を比較し、 下流の SGD・モメンタム・Adam で深層学習の実装に接続する。 勾配降下は単一アルゴリズムではなく、 学習率設計・バッチサイズ・最適化アルゴリズム選択の体系の核として位置づける。

🌳 手法選択フロー

「勾配降下法」を実際の課題に当てはめるとき、 状況別に何を選ぶかを 3 段階で判定する。

1. バッチサイズは? 小規模 → 完全勾配 (バッチ GD)、 大規模 → ミニバッチ SGD、 オンライン → SGD (1 サンプル)
2. 学習率はどう決めるか? 固定 → グリッドで探索、 適応 → Adam・RMSprop、 大規模事前学習 → ウォームアップ + コサイン減衰
3. 収束が遅い場合は? モメンタム追加 → Nesterov、 損失振動 → 学習率減衰、 鞍点 → ノイズ注入・SGD の確率性を活用

勾配降下は「学習率 × バッチサイズ × モメンタム」の三軸で挙動が変わる。 学習曲線を必ず可視化し、 振動・停滞・発散を見分けてからハイパーパラメータを調整する。

🔬 解説深化 ── スケール条件数の視点で勾配降下を捉え直す

このページの他パートでは「学習率・バッチ・モメンタム」の三軸で勾配降下法を整理した。ここでは角度を変え、「勾配降下がなぜOLSの閉形式解と一致するのか」「なぜ特徴量のスケールが収束の生死を分けるのか」を、SSDSE-B-2026 の実測値だけで検証する。学習率そのものの設計論は 学習率、連続最適化の一般論は 連続最適化 に譲り、ここではスケーリングと解の一致という一点に絞る。

🎨 直感 ── 勾配降下は「閉形式解を数値的に再発見する装置」

線形回帰 y = b₀ + b₁x の二乗誤差は完全な凸放物面なので、最小点は連立方程式（正規方程式）で一発で解ける（＝閉形式解）。勾配降下は同じ谷を、勾配の逆向きに一歩ずつ下って近づいていくだけ。だから両者は理屈上「同じ底」に到達する。これを SSDSE-B-2026 で実際に突き合わせてみる。

使用データ（実測・2023年・47都道府県）: 説明変数 x = A1303（65歳以上人口）、目的変数 y = A4200（死亡数）。両者の相関は r = 0.99903 とほぼ直線。高齢人口が多い県ほど死亡数が多いという、当たり前だが極めて強い関係だ。

②は勾配降下という反復アルゴリズムなのに、①の閉形式解と 12 桁一致した。凸問題では「解き方（代数 vs 反復）」が変わっても行き着く底は同じ、という事実を実データで確かめられる。

⚠️ 落とし穴（重要）── 未標準化だと「使える学習率」が消滅する

上の一致は標準化した後の話である。生の特徴量（総人口・高齢人口は 10⁶ オーダー）のまま勾配降下を回すと、同じアルゴリズム・同じデータでも破綻する。実測で確かめた学習率の挙動が下表だ。

核心: 標準化すると学習率 0.3〜0.9 が問題なく使えるのに、生スケールでは安定して回せる上限が 約 5×10⁻¹³ まで押し下がる。同じデータ・同じ式なのに、標準化の有無だけで「安全な学習率」が約 12 桁ずれる。しかも生スケールでは唯一ギリギリ動く学習率でも最適解（OLS残差MSE 1,602,908）に届かない。これは特徴量スケールが損失曲面の条件数を悪化させ、全方向で同時に安定する歩幅が存在しなくなるためだ。教訓は単純で、勾配降下の前に標準化は「推奨」ではなく「前提」。詳しい変換手順は 標準化 を参照。

🚀 発展 ── 「なぜ 5×10⁻¹³ で頭打ちか」を条件数で説明する

二乗損失の勾配降下が安定する学習率の上限は理論上 η < 2/L（L はヘッセ行列の最大固有値＝損失曲面の最急な曲率）で与えられる。特徴量を c 倍すると設計行列 XᵀX の成分は概ね c² 倍になり、L も跳ね上がる。高齢人口は 10⁶ オーダーなので c² ≈ 10¹² 前後、これが標準化時の安定上限 約 0.9 を 約 5×10⁻¹³ へ押し下げた実測倍率（およそ 10¹²）とほぼ一致する。つまり上表の「12 桁ずれ」は偶然ではなく、スケールの二乗が条件数を通じて学習率上限に効くという理論の実データ確認になっている。

この視点は次に自然につながる:

• 曲率 L が方向ごとに大きく違う（＝条件数が大きい）と、大きい方向に合わせて歩幅を絞る必要が出て、小さい方向の収束が遅くなる → 学習率スケジューリングやモメンタムの動機。
• 方向ごとに歩幅を自動調整するのが Adam・RMSprop の適応学習率。標準化はその「前処理版」に相当する。
• 正規方程式（連続最適化の閉形式）は条件数の悪さに一見無縁だが、実は XᵀX の逆行列計算が数値的に不安定になる形で同じ問題が現れる。

🔗 関連ページ

• 学習率 ── 本節は「スケールが学習率上限を決める」までを扱う。学習率そのものの探索・減衰・ウォームアップはこちら。
• 連続最適化 ── 勾配降下を含む連続最適化アルゴリズム全体の地図。閉形式解 vs 反復解法の一般論。
• 標準化 ── 本節の「前提」である z 標準化の定義と手順。
• 確率的勾配降下法 (SGD) ── フルバッチ勾配降下をミニバッチ化した実務版。
• 損失関数 ── ここで最小化した二乗誤差の性質と代替損失。
• 線形回帰 ── 本節で GD と閉形式解を突き合わせた対象モデル。
• 特徴量スケーリング（feature scaling）── 独立ページは未整備。当面は 標準化 を参照。

※ 本節の数値は SSDSE-B-2026（data/raw、2023年・47都道府県、A1303・A4200 列）を pd.read_csv(encoding='cp932', skiprows=[1]) で読み込み、Python で実際に勾配降下・正規方程式を回して得た実測値。合成データは使用していない。