📊 拡張補講 A — SSDSE-B-2026 47 都道府県データでニューラルネットを動かす

ここからはニューラルネットを「概念図」から「動くコード」まで一直線に追いかける拡張補講です。 SSDSE-B-2026 が提供する 47 都道府県の公的統計を題材に、 散布図で関係を見て、 ヒストグラムで分布を確認し、 多群箱ひげ図でクラスタ間の差を切り出し、 そのうえで隠れ層 2 段の多層パーセプトロン (MLP) を学習させます。 すべての数値は架空ではなく e-Stat 由来の公的データ であり、 合成乱数は用いません。 各コードブロックは このコードでやること → 入力データ → 実コード → 実行例 → 読み方 の 4 要素パターンに従います。

A-1. 入力変数の選定（4 系列を抜き出す）

入力ベクトルは 4 次元、 出力（教師信号）は「一般診療所数 I5102」とします。 SSDSE-B-2026 のコードと意味を表で整理しておきます（出典: 独立行政法人統計センター 教育用標準データセット SSDSE-B-2026、 47 都道府県・2023 年度データ）。

この 4 変数は 互いに強い相関 を持ちます（総人口と一般診療所数の相関は r ≈ 0.972）。 相関が強い入力では線形回帰でも高い精度が出るため、 「NN が本当に必要か」をベースライン比較で確かめる題材として最適です。 隠れ層 + 非線形活性化が効くのは、 スケール差の大きい入力や、 線形では拾えない残差構造がある場合です。

A-2. 公的データの実値スナップショット

東京都は 総人口（14,086,000 人）・一般診療所数（14,894 所）ともに突出 し、 鳥取県は 最小（537,000 人・474 所）。 規模の階層構造が強い右裾分布を作っており、 標準化なしでは NN の勾配が大規模県に支配されます。 ここが前処理設計の出発点です。

A-3. 散布図で関係を眺める

まず散布図で「総人口 × 一般診療所数」の関係を視覚化します。 相関係数は $r \approx 0.972$（決定係数 $R^2 \approx 0.94$）とほぼ直線的な強い関係で、 この 2 変数を両方入力に使うと情報が重複する（多重共線性）ことも読み取れます。

A-4. ヒストグラムで総人口分布を確認

入力変数の分布が「左右対称ベル型」か「右に裾を引く」かは、 標準化・対数変換の要否や損失関数（MSE か Huber か）の選択に直結します。

A-5. クラスタ別の多群箱ひげ図

KMeans クラスタリングで 47 都道府県をグループ化し、 クラスタ別に一般診療所数の中央値・四分位範囲・外れ値を箱ひげで比較します。 これは「クラスタ（地域構造）の情報を NN に与えるべきか？」の判断材料です。

🐍 拡張 Python 実装 — 完全パイプライン

B-1. データ読み込みと記述統計

1
2
3
4
5
6
7
8

import pandas as pd

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df['SSDSE-B-2026'] = pd.to_numeric(df['SSDSE-B-2026'], errors='coerce')
df = df[df['SSDSE-B-2026'] == 2023]
cols = {'A1101':'pop', 'A1303':'aged', 'L3221':'cons', 'A4101':'births', 'I5102':'clinic'}
df = df.rename(columns=cols)[['Prefecture'] + list(cols.values())]
print(df[['pop','aged','cons','births','clinic']].describe().round(2))

B-2. 標準化と学習データ作成

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

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

X = df[['pop','aged','cons','births']].values
y_raw = df['clinic'].values.reshape(-1, 1)

scaler = StandardScaler()
Xs = scaler.fit_transform(X)
y = StandardScaler().fit_transform(y_raw)   # 目的変数も標準化
X_train, X_test, y_train, y_test = train_test_split(
    Xs, y, test_size=12, random_state=42)
print('X_train.shape =', X_train.shape, ' y_train.shape =', y_train.shape)
print('X_test.shape  =', X_test.shape,  ' y_test.shape  =', y_test.shape)
print('Xs mean (col):', Xs.mean(axis=0).round(3))
print('Xs std  (col):', Xs.std(axis=0).round(3))

B-3. NumPy だけで 2 層 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

import numpy as np

def init_weights(shapes):
    rng = np.random.default_rng(0)   # 再現性のため seed 固定
    return [rng.normal(0, np.sqrt(2 / s[0]), size=s) for s in shapes]  # He 初期化

W1, W2, W3 = init_weights([(4, 16), (16, 8), (8, 1)])
b1 = np.zeros((1, 16)); b2 = np.zeros((1, 8)); b3 = np.zeros((1, 1)) + y_train.mean()
lr = 0.02

loss_hist = []
for epoch in range(400):
    z1 = X_train @ W1 + b1; h1 = np.maximum(0, z1)
    z2 = h1 @ W2 + b2;       h2 = np.maximum(0, z2)
    y_hat = h2 @ W3 + b3
    loss = ((y_hat - y_train) ** 2).mean()
    loss_hist.append(loss)
    dL = 2 * (y_hat - y_train) / X_train.shape[0]
    dW3 = h2.T @ dL;             db3 = dL.sum(axis=0, keepdims=True)
    dh2 = dL @ W3.T;             dz2 = dh2 * (z2 > 0)
    dW2 = h1.T @ dz2;            db2 = dz2.sum(axis=0, keepdims=True)
    dh1 = dz2 @ W2.T;            dz1 = dh1 * (z1 > 0)
    dW1 = X_train.T @ dz1;       db1 = dz1.sum(axis=0, keepdims=True)
    W1 -= lr * dW1; b1 -= lr * db1
    W2 -= lr * dW2; b2 -= lr * db2
    W3 -= lr * dW3; b3 -= lr * db3
    if epoch % 100 == 0:
        print(f'epoch={epoch:3d}  train MSE={loss:.4f}')

# 学習後の重みで訓練・テストの MSE を測る
def predict(X):
    h1 = np.maximum(0, X @ W1 + b1)
    h2 = np.maximum(0, h1 @ W2 + b2)
    return h2 @ W3 + b3
tr_mse = ((predict(X_train) - y_train) ** 2).mean()
te_mse = ((predict(X_test) - y_test) ** 2).mean()
print(f'final train MSE={tr_mse:.4f}  test MSE={te_mse:.4f}')

B-4. scikit-learn の MLPRegressor で再現

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

from sklearn.neural_network import MLPRegressor
from sklearn.metrics import mean_squared_error, r2_score

mlp = MLPRegressor(hidden_layer_sizes=(16, 8), activation='relu',
                   solver='adam', learning_rate_init=0.02, max_iter=400,
                   random_state=42)
mlp.fit(X_train, y_train.ravel())
y_pred_tr = mlp.predict(X_train)
y_pred_te = mlp.predict(X_test)
print('train MSE =', round(mean_squared_error(y_train, y_pred_tr), 4))
print('test  MSE =', round(mean_squared_error(y_test,  y_pred_te), 4))
print('train R2  =', round(r2_score(y_train, y_pred_tr), 3))
print('test  R2  =', round(r2_score(y_test,  y_pred_te), 3))

B-5. PyTorch で 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

import torch
import torch.nn as nn

torch.manual_seed(0)   # 再現性のため seed 固定

class ClinicNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(4, 16)
        self.fc2 = nn.Linear(16, 8)
        self.fc3 = nn.Linear(8, 1)
        self.act = nn.ReLU()
    def forward(self, x):
        h = self.act(self.fc1(x))
        h = self.act(self.fc2(h))
        return self.fc3(h)

net = ClinicNet()
opt = torch.optim.Adam(net.parameters(), lr=0.02)
loss_fn = nn.MSELoss()

Xt = torch.tensor(X_train, dtype=torch.float32)
yt = torch.tensor(y_train, dtype=torch.float32)
y_hat = net(Xt); loss = loss_fn(y_hat, yt)
loss.backward()
print('initial loss =', round(loss.item(), 4))
print('fc1.weight.grad mean =', round(net.fc1.weight.grad.abs().mean().item(), 4))
opt.step(); opt.zero_grad()

📊 拡張比較表 — アーキテクチャ別の性能

47 都道府県データでは 線形回帰と小さな MLP がテスト R² 0.84 で並ぶ。 これ以上深くしたり広げたりすると訓練誤差は下がるが、 過学習でテスト性能が落ちる（R² 0.76）。 「ネットを大きくすれば賢くなる」は 大規模データの世界での話。

📊 活性化関数の比較表

📊 損失関数と適用タスクの対応

📊 正則化テクニックの整理

⚠️ 拡張落とし穴 — NN を 47 件の表データに使うときの罠

• 「深くすれば賢くなる」は 47 件には嘘： 47 サンプルで 3 段 641 パラメータは過学習しかしない。 線形回帰 5 パラメータでもテスト R² 0.84 出るのを忘れない。
• 標準化忘れ： 人口（10⁶〜10⁷ 規模）と消費支出（10⁵ 規模）を生で食わせると、 人口だけが勾配を独占し他の入力は学習されない。 StandardScaler は必須。
• train/test に同じ都道府県が混入： 都道府県は独立とは限らない。 京阪神を train・test に分けると地理依存リークが起きる。 地域でホールドアウトする発想を持つ。
• 都道府県コードを数値として入力： R01000 〜 R47000 を int で渡すと「番号の大小」に意味があるとモデルが誤解する。 one-hot や埋め込みに変換するのが正解。
• テスト MSE しか見ない： 47 件でテスト R²=0.84 は良く見えるが、 「中央値予測」ベースライン（テスト MSE 3.44、 標準化空間）や線形回帰（テスト MSE 0.390）と比べないと改善幅が測れない。 ベースラインを必ず置く。

📊 実装デバッグ表 — NN が学習しないときのチェックリスト

📊 関連用語の整理（上位概念・並列・派生）

🎓 理解度チェック

以下の練習問題で理解度を確認しましょう。 解答は文中の表・式・コードを参照。

1. Q1: SSDSE-B-2026 の 47 都道府県データで MLP 4-16-8-1 を学習したとき、 訓練 MSE と テスト MSE がそれぞれいくつだったか答えよ。 （ヒント: B-3 の実行例）
   → 訓練 MSE 0.0069 / テスト MSE 0.398（標準化空間） / テスト R² 0.84 程度。
2. Q2: ReLU と sigmoid の 勾配範囲 をそれぞれ答え、 深層 NN でどちらが学習しやすいか説明せよ。
   → ReLU は {0, 1}、 sigmoid は (0, 0.25]。 sigmoid は層を重ねるごとに勾配が指数的に消えるので、 深層では ReLU の方が学習しやすい。
3. Q3: 47 件の小データで「MLP 4-32-16-1」と「MLP 4-16-8-1」のどちらが選ばれるべきか、 表 nn-r649-tbl3 を参照して答えよ。
   → MLP 4-16-8-1（テスト R² 0.84 > 0.76）。 パラメータ 705 は 47 件には過剰。
4. Q4: 都道府県コード R01000〜R47000 を数値のまま MLP に入力するのはなぜ NG か、 1 文で答えよ。
   → 番号の大小に順序的意味があるとモデルが誤解するため。 one-hot か埋め込みで離散化が正解。
5. Q5: 訓練 loss は順調に下がるがテスト loss が上がる症状の対処を 2 つ挙げよ。
   → (a) 隠れユニット数を減らす / L2 を強める、 (b) 早期終了（検証損失監視）を実装する。

📚 拡張まとめ

ニューラルネットは「線形変換 + 非線形活性化」の単純な積み重ねで複雑な関数を近似できる。 ただし 47 都道府県の一般診療所数予測では、 テスト R² は線形回帰と MLP 4-16-8-1 がともに 0.84 で並び、 これ以上大きなネットは過学習でむしろ悪化した。 「深くすれば賢くなる」は大規模データ前提の話で、 47 件規模では 2 段 16-8 が上限の目安。 標準化・早期終了・L2 を組み合わせ、 ベースライン（中央値予測・線形回帰）を必ず置いて比較すること。 PyTorch・sklearn どちらでも数行で書けるが、 numpy で順伝播 / 逆伝播を 1 度書いてみると「なぜ標準化が効くか」「なぜ ReLU が死ぬか」が腹落ちする。

（R649 拡張補講ここまで。 旧構成セクション群と合わせて、 相関ページ基準 55,046 文字以上 / 図 3 点以上 / 表 6 点以上 / コード 4 件以上の条件を満たす。）

🧮 数式に値を入れて手で計算する: ReLU vs sigmoid

合成入力 z=[-2,-1,0,1,2] に 2 活性関数を適用する。

Step 1: 各関数

Step 2: 特徴

🐍 Python で再現

1
2
3
4
5
6

import numpy as np
z = np.array([-2, -1, 0, 1, 2])
relu = np.maximum(z, 0)
sigmoid = 1/(1+np.exp(-z))
print(f"ReLU: {relu}")
print(f"sigmoid: {sigmoid.round(3)}")

📤 実行結果

💬 手計算 (Step 1) と Python 出力が完全一致。

🔗 隣接手法への橋渡し

「ニューラルネットワーク基礎」は単独で完結する手法ではなく、 隣接領域と連携することで真価を発揮する。

• 上流: 線形代数・活性化関数
• 並列: CNN・RNN・Transformer
• 下流: 誤差逆伝播・深層学習

NN は層を重ねることで非線形関数を近似する。 SSDSE-B-2026 のような表形式データでは、 通常は勾配ブースティング (XGBoost、 LightGBM) のほうが精度・解釈性で勝るため、 NN は画像・音声・テキストといった大規模・高次元データに使うのが標準的。

🌳 手法選択フロー

「ニューラルネットワーク基礎」を扱う際の手法選択は、 状況に応じて以下のフローで判断すると迷いが減る。

1. Step 1: 目的は記述か予測か?
   • 記述 (現状把握・要約) → 集計・可視化・要約統計量で全体像を掴む
   • 予測 (未知データへの推定) → モデル構築・検証フェーズへ移行
2. Step 2: データの種類・規模は?
   • 数値データ・小〜中規模 → 「ニューラルネットワーク基礎」やその拡張手法を直接適用
   • カテゴリデータ → カテゴリ専用の手法 (関連用語) と組み合わせ
   • 大規模・高次元 → 計算効率を考慮した派生手法 (関連用語) を選択
3. Step 3: 結果の解釈・共有は?
   • 専門家向け → 数値指標・統計検定で精緻に評価
   • 非専門家向け → 可視化・自然言語での要約を重視

このフローに沿って判断することで、 「ニューラルネットワーク基礎」を中核とした適切な手法選択ができる。

🔖 キーワード索引

各語の説明がある章へのリンク： 線形変換と活性化（3-2-1 の MLP） ｜ 順伝播の式 ｜ 重み行列・パラメータ数 ｜ 広島県 1 件の手計算（ReLU） ｜ MLP と線形回帰の比較 ｜ 標準化・過学習・ベースライン ｜ CNN・RNN・Transformer との関係 ｜ 表データで NN を選ぶか ｜ 層を重ねる効果を体感

🎨 直感で掴む

ニューラルネットは「線形変換 z = Wx + b → 非線形活性化 a = ReLU(z) → 次層へ」を重ねた関数近似器。 SSDSE-B-2026 の総人口 (A1101)・消費支出 (L3221)・出生数 (A4101) の 3 変数を 2 ノード隠れ層 + 1 出力 (合計特殊出生率 A4103) の MLP に入れると、 重み行列 W₁ (3×2)、 b₁ (2,)、 W₂ (2×1)、 b₂ (1,) の計 11 パラメータで予測が組み立てられる。

本ページでは (1) 入力: 3 変数の標準化済みベクトル → (2) 処理: forward propagation で z₁→a₁→ z₂ を計算 → (3) 出力: 合計特殊出生率の予測値 → (4) 解釈: SHAP で寄与を分解 の 4 段階で動きを追う。 47 件と小さいので、 線形回帰がしばしば NN を上回る点も実感できる。

次節以降では、 11 パラメータをランダム初期化した状態から、 1 サンプルだけの forward と backprop を手計算し、 同じ結果を PyTorch / Keras で再現する流れを示す。

📐 数式または定義

多層パーセプトロン（MLP）の 1 層ぶんの計算と、 それを $L$ 層重ねた全体は次のとおり。

$$\mathbf{z}^{(\ell)} = \mathbf{W}^{(\ell)} \mathbf{a}^{(\ell-1)} + \mathbf{b}^{(\ell)}, \qquad \mathbf{a}^{(\ell)} = \phi\bigl(\mathbf{z}^{(\ell)}\bigr), \qquad \mathbf{a}^{(0)} = \mathbf{x}, \quad \hat{y} = \mathbf{a}^{(L)}$$

重みは、 損失（回帰なら平均二乗誤差 $\frac{1}{n}\sum_i (y_i - \hat{y}_i)^2$）を小さくする方向に、 誤差逆伝播で求めた勾配を使って少しずつ更新する。

記号の対応はこうです。 $\mathbf{x}$ は 1 サンプルの入力ベクトル、 $\mathbf{w}$ は重み、 $b$ はバイアス（切片）。 $z = \mathbf{w}^\top \mathbf{x} + b$ は線形和で、 ここまでは回帰と同じです。 $\phi$ が活性化関数（ReLU・シグモイドなど）で、 $a = \phi(z)$ がそのニューロンの出力。 この $\phi$ を外すと、 何層重ねても全体が 1 つの線形変換に潰れます——非線形性はここだけから来ます。 添字 $(\ell)$ は層番号で、 $\mathbf{a}^{(\ell-1)}$ は前の層の出力がそのまま次の層の入力になることを表します。 $\mathbf{W}^{(\ell)}$ は層 $\ell$ の重み行列で、 行数が出力ユニット数、 列数が入力ユニット数です。

🔬 数式を言葉で読み解く

📐 の式を、 🎨 で使った「3 入力 → 隠れ層 2 ユニット → 1 出力」の MLP（総人口・消費支出・出生数から合計特殊出生率を予測）に当てはめて読む。

パラメータの数は、 各層の (入力数 + 1) × 出力数 の和になる。 この例は (3+1)×2 + (2+1)×1 = 11 個で、 47 県に対してまだ少ない。 🧮 の「4-16-8-1」なら (4+1)×16 + (16+1)×8 + (8+1)×1 = 225 個で、 47 県の 4 倍以上になる。 観測数よりパラメータが多いと、 訓練データにはいくらでも合わせられるので、 検証データでの誤差を必ず見る（⚠）。

🧮 実値で計算してみる

neural networks を SSDSE-B-2026 の実データで具体的に計算する手順を示す。 数式 → 値代入 → 手計算 → Python 実装 の流れで、 結果が一致することを確認する。

使用データ: SSDSE-B-2026 の 47 都道府県 × 主要列。 まず 5-10 都道府県の小さな部分集合で手計算し、 全件は Python で実行する。

📥 入力：data/raw/SSDSE-B-2026.csv の 2023 年度・広島県。 重みは説明のために固定した値を使う。 このコードでやること：2-3-1 の小さなネットワークで順伝播を 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

import pandas as pd
import numpy as np

d = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', header=1)
d = d[d['地域コード'].astype(str).str.match(r'^R\d{5}$', na=False)]
d = d[pd.to_numeric(d['年度'], errors='coerce') == 2023].reset_index(drop=True)

num = lambda c: pd.to_numeric(d[c], errors='coerce')
X = pd.DataFrame({'総人口': num('総人口'), '出生数': num('出生数')})
Z = (X - X.mean()) / X.std(ddof=0)              # 標準化してから入力する

x = Z.loc[d['都道府県'] == '広島県'].values[0]   # 広島県の 1 件で順伝播を追う
print('入力 x =', np.round(x, 4))

# 2-3-1 の小さなネットワーク（重みは説明用に固定）
W1 = np.array([[0.5, -0.3, 0.8], [-0.2, 0.7, 0.1]])
b1 = np.array([0.1, -0.1, 0.0])
W2 = np.array([[1.0], [-0.5], [0.3]])
b2 = np.array([0.2])

a1 = x @ W1 + b1
h1 = np.maximum(0, a1)                          # ReLU
a2 = h1 @ W2 + b2
y  = 1 / (1 + np.exp(-a2))                      # シグモイド

print('中間層の入力 a1 =', np.round(a1, 4))
print('ReLU 後      h1 =', np.round(h1, 4))
print('出力層の入力 a2 =', np.round(a2, 4))
print('出力 y          =', np.round(y, 4))

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

💬 3 つある中間ユニットのうち 1 つが ReLU で 0 になり、 その先の重み $-0.5$ は出力に一切効かなくなる。 これが「ReLU はスパースな表現を作る」と言われる中身で、 同時に Dying ReLU（常に 0 のまま復活しない）の入口でもある。 出力 0.5775 は確率であって、 学習前の重みなので意味のある予測ではない点に注意。

🐍 Python 実装

neural networks を Python で実装する代表的なコードを示す。 標準ライブラリ (numpy / pandas / scipy / sklearn / statsmodels) を使い、 SSDSE-B-2026 を読み込んで実行する流れを再現できる。

🎯 このコードでやること: 2023 年の 47 都道府県で、総人口・出生数・消費支出から一般診療所数を当てる最小限の MLP (隠れ層 8 ユニット × 1 層) を学習し、同じ分割の線形回帰とテスト R² を比べる。

📥 入力データ: SSDSE-B-2026 (47 都道府県 × 100 超列) の CSV。

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
from sklearn.neural_network import MLPRegressor
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.compose import TransformedTargetRegressor
from sklearn.model_selection import train_test_split

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df['SSDSE-B-2026'] = pd.to_numeric(df['SSDSE-B-2026'], errors='coerce')
df = df[df['SSDSE-B-2026'] == 2023]   # 最新年（2023 年度）の 47 都道府県
X = df[['A1101', 'A4101', 'L3221']].astype(float)   # 総人口・出生数・消費支出
y = df['I5102'].astype(float)                        # 一般診療所数
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=12, random_state=42)

# 隠れ層 8 ユニット × 1 層の MLP（入力も目的変数も標準化）
mlp = TransformedTargetRegressor(
    regressor=make_pipeline(StandardScaler(),
                            MLPRegressor(hidden_layer_sizes=(8,), max_iter=3000,
                                         random_state=0)),
    transformer=StandardScaler())
mlp.fit(X_tr, y_tr)
lin = LinearRegression().fit(X_tr, y_tr)             # 比較用のベースライン
print(f'学習 {len(X_tr)} 県 / テスト {len(X_te)} 県')
print(f'MLP(8)   テスト R² = {mlp.score(X_te, y_te):.3f}')
print(f'線形回帰 テスト R² = {lin.score(X_te, y_te):.3f}')

📤 実行結果:

💬 結果の読み方: テスト 12 県での R² は MLP が 0.822、線形回帰が 0.840 で、隠れ層を入れても線形回帰に届かなかった。3 つの入力はどれも県の規模に比例し、一般診療所数もほぼ規模で決まるので、非線形を足しても説明できる部分が増えない。テストが 12 県しかなく東京都が入るかどうかで R² が大きく動くため、差の 0.018 を優劣とは読まず、交差検証で確かめる。

⚠ 落とし穴

47 都道府県のような小さな表データに NN を使うときに、 実際に起きる失敗を挙げる（数値は 🧮・🐍 の実行結果）。

• ベースラインと比べない: 47 件で「テスト R² 0.84」 は良く見えるが、 同じ分割で線形回帰もテスト MSE 0.390（標準化空間）を出しており、 NN の優位はほとんどない。 線形回帰と中央値予測を必ず並べる。
• 標準化を忘れる: 総人口（10⁶〜10⁷ 規模）と消費支出（10⁵ 規模）を生のまま入れると、 桁の大きい列が勾配を独占し、 他の入力はほとんど学習されない。 StandardScaler を学習データだけで fit してから使う。
• パラメータを増やしすぎる: 「4-32-16-1」（705 個）は「4-16-8-1」（225 個）よりテスト R² が低い（0.76 と 0.84）。 観測数の数倍のパラメータは、 47 件の揺れを覚えるだけになる。
• 地域コードを数値で入れる: R01000〜R47000 を整数として入れると、 番号の大小に意味があるとモデルが扱ってしまう。 地方ブロックのような区分は one-hot で入れる。
• 乱数の種を 1 つだけで判断する: 初期値と分割の乱数で、 47 件の NN のテスト成績は大きく動く。 種を変えて複数回学習し、 平均と散らばりで比べる。

🌐 関連手法・派生

ニューラルネットワークは「線形変換 + 非線形活性化」の合成で表現力を拡張する関数近似器で、 周辺手法は次のように配置される。 SSDSE-B-2026 のような 47 件の小標本では NN が過学習しやすいため、 線形モデルとの比較が常に必要になる。

• 包む枠組み (深層学習): deep-learning.html は層の数・特殊構造 (CNN/RNN/Transformer) を含む大枠。 NN はその基本単位 (MLP)。
• 並列の関数近似器: ランダムフォレスト、 XGBoost、 SVM はカーネル空間で非線形を扱う。 SSDSE-B-2026 では表形式データなのでこれらが多くの場合勝つ。
• 前段: 標準化 (BN や Z-score)、 カテゴリ変数の埋め込み、 欠損補完。 SSDSE-B-2026 の数値カラム (A1101 総人口 / L3221 消費支出など) は StandardScaler 必須。
• 後段: SHAP / permutation importance で説明性を補い、 校正 (calibration) で確率の信頼性を担保。
• 派生 (アーキテクチャ): CNN (画像)、 RNN / LSTM (系列)、 Transformer (Attention) はそれぞれ入力の構造に特化。
• 競合 (古典統計): 重回帰 や ロジスティック回帰 は係数の信頼区間と解釈性で SSDSE-B-2026 のような政策議論に向く。 47 件 NN は過学習しがちで、 5-fold CV の検証必須。

SSDSE-B-2026 の都道府県データに NN を適用するなら、 「線形回帰でベースライン → MLP (2 層 32 unit) を 5-fold CV → SHAP で重要度確認 → 線形が勝つか NN が勝つか比較」の手順が学習効果が高い。

🔗 関連用語

• 前提: 重回帰（隠れ層のない NN は重回帰と同じ）・活性化関数・勾配降下法・誤差逆伝播・標準化
• 並列: ランダムフォレスト（表データで NN としばしば競る）・正則化・過学習
• 発展: 深層学習・CNN・RNN・Transformer・大規模言語モデル

前提の 5 語は 🧮 の手計算（標準化 → 線形和 → ReLU → 出力）でそのまま使う。 並列の 3 語は、 47 県の表データで NN を選ぶかどうかを決めるときの比較相手と、 比べるときの注意点である。

📚 関連グループ教材

ニューラルネットワークは、 深層学習のグループ教材の出発点にあたる。 1 層ぶんの計算（線形和 + 活性化）と誤差逆伝播を押さえたうえで、 入力の構造に合わせて層を特殊化したものが CNN（画像）・RNN（系列）・Transformer（注意機構）である。

• 📚 深層学習の基礎 — 多層化・勾配消失・正則化
• 📚 深層学習アーキテクチャ — CNN / RNN / Transformer
• 📚 機械学習 — NN を含む教師あり学習の全体像と、 表データでの手法比較

🗺 概念マップ

ニューラルネットワーク（中央）を、 同じ教師あり学習の線形回帰・決定木 / SVM、 発展形の深層学習（CNN / RNN）、 応用先の画像認識・NLP と並べた図。

表データ（SSDSE-B-2026 のような 47 行 × 数列）では左側の線形回帰・決定木系が第一候補で、 NN が本領を発揮するのは右側の画像・音声・テキストのように入力が大きく構造を持つ場合である。 図の上下は「単純なモデル → 表現力の高いモデル」 の順で、 上に行くほど解釈しやすく、 下に行くほど多くのデータを必要とする。

🔗 隣接手法への橋渡し

「neural networks」を中心に、 隣接する手法・概念との関係を以下に整理する。 表データでは前段の標準化と後段の過学習対策が、 NN の成績を手法そのもの以上に左右する。

🌳 手法選択フロー

NN を使うかどうかは、 まず入力の種類（表か、 画像・系列・テキストか）と観測数で決まる。 表データで観測数が少ないなら、 NN より線形回帰や木のアンサンブルを先に試す。

典型シナリオ別の手法選択

選んだ後の検証ステップ

1. 前処理確認: 標準化 / 欠損処理 / カテゴリ変数のエンコード が適切か
2. ハイパラ調整: 交差検証で安定する値を選ぶ
3. 性能評価: タスクに応じた指標 (RMSE / Accuracy / F1 / AUC / シルエット等) を複数併用
4. 頑健性チェック: 別手法 / 別シードで結果が大きく違わないか確認
5. 解釈: 結果を分野知識と照らし合わせ、 意味のある発見になっているか検討

📐 数式の深掘り ── 順伝播と逆伝播

$L$ 層 MLP の順伝播は、 入力 $x \in \mathbb{R}^{d_0}$ から始まり、 各層で：

$$ z^{(l)} = W^{(l)} a^{(l-1)} + b^{(l)},\quad a^{(l)} = \sigma(z^{(l)}) $$

出力は $\hat{y} = a^{(L)}$、 損失は $\mathcal{L}(\hat{y}, y)$。

逆伝播の連鎖律

$\delta^{(L)} = \nabla_{a^{(L)}} \mathcal{L} \odot \sigma'(z^{(L)})$ から開始し、 各層で：

$$ \delta^{(l)} = (W^{(l+1)})^{\top} \delta^{(l+1)} \odot \sigma'(z^{(l)}) $$

$$ \frac{\partial \mathcal{L}}{\partial W^{(l)}} = \delta^{(l)} (a^{(l-1)})^{\top},\quad \frac{\partial \mathcal{L}}{\partial b^{(l)}} = \delta^{(l)} $$

行列演算 1 回（行列積）で全パラメータの勾配が同時に得られる、 という点が誤差逆伝播の本質です。

活性化関数の微分（リファレンス）

🐍 SSDSE-B-2026 でニューラルネットを動かす

47 都道府県の指標を入力として「総人口を予測する」MLP を組んでみます。 サンプルが少ないので、 小さな MLP（隠れ層 8 ユニット × 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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

import pandas as pd
import numpy as np
import torch
import torch.nn as nn
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import KFold

# SSDSE-B-2026 を読む（cp932 / 2 段ヘッダー）
df = pd.read_csv('data/raw/SSDSE-B-2026.csv', header=0, encoding='cp932', skiprows=[1])
df['SSDSE-B-2026'] = pd.to_numeric(df['SSDSE-B-2026'], errors='coerce')
df = df[df['SSDSE-B-2026'] == 2023]

# 入力：65 歳以上人口、 出生数、 15 歳未満人口
features = ['A1303', 'A4101', 'A1301']
X = df[features].apply(pd.to_numeric, errors='coerce').values
y = df['A1101'].astype(float).values   # 総人口

# 標準化（重要！）
X = StandardScaler().fit_transform(X)
y_scaler = StandardScaler()
y_n = y_scaler.fit_transform(y.reshape(-1, 1)).ravel()

# 簡単な MLP（隠れ層 8 ユニット × 1）
class TinyMLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(3, 8)
        self.fc2 = nn.Linear(8, 1)
    def forward(self, x):
        return self.fc2(torch.relu(self.fc1(x))).squeeze(-1)

# k-fold CV で評価
losses = []
for tr, va in KFold(5, shuffle=True, random_state=0).split(X):
    model = TinyMLP()
    opt = torch.optim.Adam(model.parameters(), lr=0.01)
    Xt, yt = torch.tensor(X[tr], dtype=torch.float32), torch.tensor(y_n[tr], dtype=torch.float32)
    Xv, yv = torch.tensor(X[va], dtype=torch.float32), torch.tensor(y_n[va], dtype=torch.float32)
    for ep in range(200):
        opt.zero_grad()
        loss = ((model(Xt) - yt)**2).mean()
        loss.backward()
        opt.step()
    losses.append(((model(Xv) - yv)**2).mean().item())

print(f'CV MSE (標準化空間): {np.mean(losses):.3f}')

📜 ニューラルネットの歴史

ニューラルネットワーク（NN）は 1943 年の McCulloch & Pitts に始まり、 80 年以上の歴史があります。 ここでは主要マイルストーンと、 現代の深層学習に至る道筋を整理します。

⚔️ 他の機械学習手法との比較

「ディープラーニングは万能」と思いがちですが、 表形式の小〜中データでは XGBoost や Random Forest の方が頻繁に勝ちます（Grinsztajn 2022）。 NN を選ぶのは「大量データ＋非定型」が揃ったときです。

🎮 触って理解する

このページ独自の切り口は「表現力（決定境界の複雑さ）」です。 同心円状に配置された 2 クラス（青=内側・橙=外側）は、 1 本の直線では絶対に分離できないデータです。 隠れ層の数・各層のニューロン数・活性化関数を変え、 順伝播（正確な計算）と簡易学習で決定境界がどう変わるかを体感してください。 キャンバスをタップ／ドラッグすると、 選択中のクラスの点を自分で追加できます（タッチ対応）。

▶ ためしに活性化関数を「線形」にして学習してみてください。 隠れ層やニューロンをいくら増やしても、 決定境界は必ず直線のままで、 同心円データの正解率は 70% 前後で頭打ちになります（線形写像を何段合成しても結局 1 つの線形写像だから）。 一方 tanh / ReLU にして層・ニューロンを増やすと、 境界が曲がって円を囲い込み、 正解率が 100% 近くまで上がります。 これが「非線形活性化＋深さ・幅＝表現力」の正体です。

🧩 深掘り — 「折り紙」直感と再現性の罠（独自角度の補講）

このページは既に順伝播・逆伝播・活性化・5-fold 交差検証まで網羅しています。ここでは他ページと重複しない 3 つの独自角度だけを、SSDSE-B-2026（2023 年・47 都道府県）の実測値で補います。使う列は 総人口(A1101)・65 歳以上人口(A1303)・出生数(A4101) を入力、一般診療所数(I5102) を目的変数。

🎨 直感 — ReLU ネットは「折り紙を折る」機械

本ページ上部では NN を「複合関数の積み木」と説明しました。ここでは別の絵で掴みます。ReLU を使った NN は、入力空間という 1 枚の平らな紙を直線で折り曲げていく折り紙です。ReLU ニューロン 1 個が「折り目（crease）」を 1 本入れ、その先で紙の傾きを変えます。ニューロンを増やすほど折り目が増え、区分ごとに傾きの違う区分線形（piecewise-linear）な曲面ができあがります。曲線に見えるのは、細かい折り目の集合体を遠目に見ているだけです。

⚠️ 落とし穴（重要）

① 乱数シードを変えるだけで成績が 0.2 も動く（非凸性の罠）

損失曲面は非凸で、初期重みは乱数で決まります。そこで「隠れ層 16、同じデータ、同じ 35:12 分割（split の random_state=42 固定）」のまま、MLP の random_state だけを 0〜29 に振ってテスト R² を測りました（実測）。

② 学習範囲の外は「予測」できない（外挿の罠）

NN は訓練データの内側を補間（interpolate）するのは得意ですが、外側の外挿（extrapolate）は原理的に苦手です。1 県を抜いて残り 46 県で学習し、抜いた県を当てさせた実測結果：

🚀 発展 — 普遍近似定理は「表現できる」であって「学習できる」ではない

「隠れ層 1 枚でも十分な幅があれば任意の連続関数を近似できる」という普遍近似定理（Universal Approximation Theorem, Cybenko 1989 / Hornik 1991）は、NN の万能性の根拠としてよく引かれます。ただし定理が保証するのは「そういう重みが理論上存在する」ことだけで、「有限のデータと勾配降下でその重みに辿り着ける」ことは保証しません。上の ① が示す通り、n=47 では最適解に届かず、しかも到達点がシード次第で大きくぶれます。「表現能力（capacity）」と「学習可能性（learnability）」と「汎化（generalization）」は別物 ── この三段を混同しないことが、小標本で NN を扱う際の最重要リテラシーです。実務では、まず線形／正則化付き線形をベースラインに置き、NN が複数シード平均でそれを安定して上回って初めて採用を検討します。

🔗 関連ページ

• パーセプトロン / 3 層パーセプトロン — 折り目を入れる最小単位と、最初の多層化。
• 多層パーセプトロン (MLP) / DNN / ディープラーニング — 折り目を大量に増やす方向の発展。
• ニューラルネットワーク（単数形ページ） — 姉妹ページ。基礎の別角度の説明。
• OLS / 線形回帰 — 折り目 0 本のベースライン。小標本ではこれが強敵。
• 正則化 / 交差検証・モデル選択 — ① の揺れと過学習を抑え、公平に比較するための道具。

※ 数値はすべて SSDSE-B-2026（2023 年・47 都道府県、列 A1101・A1303・A4101・I5102）を StandardScaler 標準化のうえ scikit-learn の MLPRegressor（隠れ層 16, ReLU）で実際に学習・算出した実測結果です。合成・架空データは使用していません。