🔖 キーワード索引 — 拡張版

ニューラルネットワークに関する用語を、 構造・学習・正則化・最適化 別に索引化します。

🎨 多層パーセプトロンの世界観

🎨 多層パーセプトロンの世界観

ニューラルネットの最も基本的な形は 多層パーセプトロン (MLP)。 入力ベクトル $\mathbf{x}$ に対し、 各層が 線形変換 → 活性化関数 を繰り返す。 隠れ層を 1 つ持つだけでも、 十分なノード数があれば「任意の連続関数を任意精度で近似できる」（普遍近似定理、 Cybenko 1989, Hornik 1991）。 ただし「近似できる」と「学習できる」は別問題で、 実際には深い層・適切な活性化・正則化・大量データが鍵。

ニューラルネットワークは、入力を何段階もの重み付き変換に通し、途中で非線形関数を挟むことで複雑な関係を近似するモデルです。表形式データでは、人口、所得、産業、医療、教育のような複数指標を同時に読み、最終層で分類や回帰の出力へ変換します。

1. 入力層、隠れ層、出力層の役割を説明できる。
2. 線形変換だけを重ねても表現力が増えない理由を説明できる。
3. 活性化関数、損失関数、最適化手法を区別できる。
4. 過学習を防ぐために、検証データ、正則化、早期終了を使う理由を説明できる。

📐 順伝播・逆伝播の数式

L 層 MLP の順伝播（forward）:

$$ \mathbf{h}^{(l)} = \sigma\left( W^{(l)} \mathbf{h}^{(l-1)} + \mathbf{b}^{(l)} \right),\quad l = 1, \dots, L $$

$\mathbf{h}^{(0)} = \mathbf{x}$, $\hat{\mathbf{y}} = \mathbf{h}^{(L)}$。 $\sigma$ は活性化関数（ReLU: $\max(0, z)$、 sigmoid: $1/(1+e^{-z})$、 tanh: $\tanh z$）。

損失（回帰の場合）:

$$ \mathcal{L} = \frac{1}{n}\sum_{i=1}^n \left( y_i - \hat y_i \right)^2 $$

損失（多クラス分類）:

$$ \mathcal{L} = -\frac{1}{n}\sum_{i=1}^n \sum_{c=1}^C y_{i,c} \log \hat p_{i,c},\quad \hat p_{i,c} = \mathrm{softmax}(\mathbf{h}^{(L)}_i)_c $$

逆伝播（連鎖律）:

$$ \frac{\partial \mathcal{L}}{\partial W^{(l)}} = \delta^{(l)} \left(\mathbf{h}^{(l-1)}\right)^\top,\quad \delta^{(l)} = \left(W^{(l+1)}\right)^\top \delta^{(l+1)} \odot \sigma'\left(\mathbf{z}^{(l)}\right) $$

SGD/Adam の更新（学習率 $\eta$、 momentum $\beta$）:

$$ W^{(l)} \leftarrow W^{(l)} - \eta \cdot \nabla_{W^{(l)}} \mathcal{L} $$

📐 NN の正則化手法

🔬 数式を言葉で読み解く（順伝播・逆伝播）

$\mathbf{h}^{(l)} = \sigma(W^{(l)} \mathbf{h}^{(l-1)} + \mathbf{b}^{(l)})$ は「前層の出力を行列で混ぜ合わせ、 バイアスを足し、 非線形関数を通す」操作。 線形変換だけ重ねても結局 1 つの線形変換になってしまうので、 $\sigma$ の非線形性が「深さの効果」を生む。 ReLU は計算が軽く勾配が消えにくいため、 現代の標準。

逆伝播の式は「連鎖律を行列で書いたもの」。 $\delta^{(l)}$ は層 $l$ での「誤差信号」。 出力側から入力側に向かって順次伝播し、 各層の勾配 $\partial \mathcal{L} / \partial W^{(l)}$ を計算する。 計算量は順伝播とほぼ同じ（深層学習で実用化された理由）。

「数式を言葉で読み解く」と、 cross-entropy 損失は「正解クラスの予測確率の対数を最大化する」と等価。 softmax + cross-entropy の組合せでは、 出力層の勾配が単純に $\hat p - y$（予測 - 正解）になる驚くべき性質があり、 計算と理論の両面で扱いやすい。

SGD の更新 $W \leftarrow W - \eta \nabla \mathcal{L}$ は「損失の坂を下る方向に重みを少し動かす」操作。 $\eta$（学習率）が大きすぎると振動・発散、 小さすぎると遅い。 Adam は過去の勾配の二次モーメントを使って学習率を自動調整するため、 多くのタスクで安定して動く。

🔬 数式を言葉で読み解く（正則化とドロップアウト）

L2 正則化 $\mathcal{L} + \lambda \sum W^2$ は「重みが大きくなりすぎないようにペナルティをかける」。 これは Bayesian 的には「重みに正規事前分布 $W \sim \mathcal{N}(0, 1/\lambda)$ を置く MAP 推定」と等価。 $\lambda$ が大きいほど「重みを 0 に押し付ける力」が強い。

Dropout は学習時に各ノードを確率 $p$ で「無効化」（出力 0 にする）操作。 数式で書けば $\mathbf{h}' = \mathbf{h} \odot \mathbf{m}, \; m_j \sim \mathrm{Bernoulli}(1-p)$。 推論時は全ノード使うが出力を $(1-p)$ 倍する。 効果として「複数の小さなネットワークのアンサンブル」と解釈でき、 過学習を大幅に抑える。

「数式を言葉で読み解く」と、 Batch Normalization $\hat z = (z - \mu_B) / \sqrt{\sigma_B^2 + \epsilon}$ は「mini-batch 単位で出力を標準化」する操作。 これにより層間で活性化の分布が安定し、 大きい学習率が使えて収束が速くなる。 Layer Normalization は同じ発想を「サンプル内の特徴次元」で行うもので、 Transformer で多用される。

Early Stopping は「val loss が改善しなくなった時点で学習を止める」シンプルな正則化。 数式というよりプロトコルだが、 「最適 epoch でモデル容量を実質縮小」と解釈できる。 Dropout や L2 と直交する効果。

🧮 SSDSE-B を使ったニューラルネット回帰 — 実値計算例

SSDSE-B-2026 の都道府県データから「15歳未満人口(A1301)・65歳以上人口(A1303)・出生数(A4101)」を入力にして「総人口(A1101)」を予測するMLP（多層パーセプトロン）を構築します。

① ネットワーク構造

② 学習プロセス

1. 標準化（入力をz化）
2. 損失関数 = MSE（平均二乗誤差）
3. 最適化 = Adam（solver='adam'）
4. 反復上限 = 2000、 目的変数も標準化
5. 早期終了・ドロップアウト等で過学習を抑制

③ 結果（下の実行例で測定）

検証 R² = 0.979（下の実測値）。 総人口は年齢別人口・出生数とほぼ線形の強い関係にあり、 線形活性化（identity）でも R²=0.933 と十分機能する。
ただしn=47は深層学習には少なすぎ、 過学習リスクが高い。 ドロップアウトと早期終了を併用すべき。 解釈性は線形回帰の方が圧倒的に上で、 状況に応じた使い分けが重要。

🧮 47 都道府県人口を MLP で予測

SSDSE-B-2026 を使って「15歳未満人口・65歳以上人口・出生数 → 総人口」を 3 層 MLP で予測。 sklearn の MLPRegressor は学習も評価も簡潔に書ける。

このコードでやること：47 都道府県の 3 特徴量から総人口を MLP (hidden=(32,16), ReLU, Adam) で回帰し、 train/test の R² と RMSE を確認する。

📥 入力データ (SSDSE-B-2026 抜粋):

 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 pandas as pd
import numpy as np
from sklearn.neural_network import MLPRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.compose import TransformedTargetRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score, root_mean_squared_error

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
year_col = df.columns[0]                       # 先頭列が年度
latest = df[df[year_col] == df[year_col].max()]  # 最新年の47都道府県
# 入力: 15歳未満人口(A1301)・65歳以上人口(A1303)・出生数(A4101)
X = latest[['A1301', 'A1303', 'A4101']].values.astype(float)
y = latest['A1101'].values.astype(float)       # 目的変数: 総人口(A1101)

X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3, random_state=0)
base = Pipeline([('scaler', StandardScaler()),
                 ('mlp', MLPRegressor(hidden_layer_sizes=(32, 16), activation='relu',
                                      solver='adam', max_iter=2000, random_state=0))])
# 目的変数もスケーリング（総人口は桁が大きく、未スケールだと学習が進まない）
model = TransformedTargetRegressor(regressor=base, transformer=StandardScaler())
model.fit(X_tr, y_tr)
mlp = model.regressor_.named_steps['mlp']
print(f'train R\N{SUPERSCRIPT TWO} = {r2_score(y_tr, model.predict(X_tr)):.3f}')
print(f'test  R\N{SUPERSCRIPT TWO} = {r2_score(y_te, model.predict(X_te)):.3f}')
print(f'test RMSE = {root_mean_squared_error(y_te, model.predict(X_te)):,.0f}')
print(f'最終 iter = {mlp.n_iter_},  loss = {mlp.loss_:.2e}')

📤 実行例:

💬 train R²=0.988 / test R²=0.979 と高精度。 ただし n=47 とサンプルが極めて少ないため、 過学習リスクが高い。 線形回帰でもこの程度の精度が出ることに留意（NN を使う必然性は乏しい）。 むしろ NN は サンプル数が多く、 特徴量間の非線形相互作用が強い ときに本領を発揮する。

🧮 数式に値を入れて手で計算する: 単一ニューロンの出力

合成データで w·x + b と sigmoid 適用を計算する。

Step 1: 重みと入力

Step 2: z = w·x + b

Step 3: a = σ(z)

🐍 Python で再現

1
2
3
4
5
6
7
8

import numpy as np
w = np.array([0.5, -0.3, 0.8])
x = np.array([2, 4, 1])
b = -1
z = w @ x + b
a = 1/(1 + np.exp(-z))
print(f"z = {z}")
print(f"a = {a:.3f}")

📤 実行結果

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

🐍 Python 実装バリエーション — scikit-learn / Keras / PyTorch / JAX

① scikit-learn の MLPRegressor（最も手軽）

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

import pandas as pd
from sklearn.neural_network import MLPRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import 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])
latest = df[df[df.columns[0]] == df[df.columns[0]].max()]
X = latest[['A1301', 'A1303', 'A4101']]   # 15歳未満・65歳以上・出生数
y = latest['A1101']                        # 総人口
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3, random_state=0)

base = Pipeline([
    ('scaler', StandardScaler()),
    ('mlp', MLPRegressor(hidden_layer_sizes=(16, 8), activation='relu',
                         max_iter=2000, random_state=0))
])
model = TransformedTargetRegressor(regressor=base, transformer=StandardScaler())
model.fit(X_tr, y_tr)
print('R\N{SUPERSCRIPT TWO}:', model.score(X_te, y_te))

② TensorFlow / Keras（柔軟な構築）

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

import tensorflow as tf
from tensorflow.keras import layers, models, callbacks
import pandas as pd
from sklearn.preprocessing import StandardScaler

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
latest = df[df[df.columns[0]] == df[df.columns[0]].max()]
X = StandardScaler().fit_transform(latest[['A1301', 'A1303', 'A4101']])
y = latest['A1101'].values.astype(float)

model = models.Sequential([
    layers.Input(shape=(3,)),
    layers.Dense(16, activation='relu'),
    layers.Dropout(0.2),
    layers.Dense(8, activation='relu'),
    layers.Dense(1)
])
model.compile(optimizer='adam', loss='mse', metrics=['mae'])

es = callbacks.EarlyStopping(patience=20, restore_best_weights=True)
hist = model.fit(X, y, validation_split=0.3, epochs=300, batch_size=8,
                 callbacks=[es], verbose=0)
print('最小val_loss:', min(hist.history['val_loss']))

③ PyTorch（研究・カスタム実装向け）

 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 torch
import numpy as np
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset

torch.manual_seed(0)

class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(3, 16), nn.ReLU(), nn.Dropout(0.2),
            nn.Linear(16, 8), nn.ReLU(),
            nn.Linear(8, 1)
        )
    def forward(self, x):
        return self.net(x)

model = MLP()
opt = torch.optim.Adam(model.parameters(), lr=1e-3, weight_decay=1e-4)
loss_fn = nn.MSELoss()

X_t = torch.tensor(np.asarray(X, dtype='float32'))   # DataFrame は ndarray に直してから渡す
y_t = torch.tensor(np.asarray(y, dtype='float32')).unsqueeze(1)
loader = DataLoader(TensorDataset(X_t, y_t), batch_size=8, shuffle=True)

for epoch in range(200):
    for xb, yb in loader:
        pred = model(xb); loss = loss_fn(pred, yb)
        opt.zero_grad(); loss.backward(); opt.step()

④ Keras Functional API（複雑なネットワーク）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from tensorflow.keras import layers, Model, Input

inp = Input(shape=(3,))
x = layers.Dense(16, activation='relu')(inp)
x = layers.BatchNormalization()(x)
x = layers.Dropout(0.2)(x)
x = layers.Dense(8, activation='relu')(x)
out = layers.Dense(1)(x)
model = Model(inp, out)
model.compile(optimizer='adam', loss='mse')

⑤ JAX/Flax（高速・関数型）

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

import jax, jax.numpy as jnp
from flax import linen as nn

class MLP(nn.Module):
    @nn.compact
    def __call__(self, x):
        x = nn.relu(nn.Dense(16)(x))
        x = nn.relu(nn.Dense(8)(x))
        return nn.Dense(1)(x)

model = MLP()
params = model.init(jax.random.PRNGKey(0), jnp.zeros((1, 3)))
# 以下に optax で最適化ループを書く

🐍 PyTorch で同じ NN を書いてみる

このコードでやること：sklearn の MLPRegressor と同等の 3 層 NN を PyTorch nn.Sequential で構築し、 学習ループを明示的に書く。 内部で何が起きているかを理解するため。

📥 入力データ: 上記と同じ 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
37

import torch
import torch.nn as nn
import numpy as np
from sklearn.metrics import r2_score
# X_tr, X_te, y_tr, y_te は上の calc セクションと同じ分割を使う

torch.manual_seed(0)
# 入力・出力とも標準化（NN は未スケールだと学習が不安定）
mu_x, sd_x = X_tr.mean(0), X_tr.std(0)
mu_y, sd_y = y_tr.mean(), y_tr.std()
xs_tr = (X_tr - mu_x) / sd_x
ys_tr = (y_tr - mu_y) / sd_y
xs_te = (X_te - mu_x) / sd_x
xt = torch.tensor(np.asarray(xs_tr, dtype='float32'))   # DataFrame は ndarray に直してから渡す
yt = torch.tensor(np.asarray(ys_tr, dtype='float32')).unsqueeze(1)

net = nn.Sequential(
    nn.Linear(3, 32), nn.ReLU(),
    nn.Linear(32, 16), nn.ReLU(),
    nn.Linear(16, 1),
)
opt = torch.optim.Adam(net.parameters(), lr=1e-2)
loss_fn = nn.MSELoss()

for epoch in range(2000):
    opt.zero_grad()                # 勾配リセット
    pred = net(xt)                 # 順伝播
    loss = loss_fn(pred, yt)       # 損失
    loss.backward()                # 逆伝播（連鎖律で全勾配を計算）
    opt.step()                     # Adam で重み更新
    if (epoch + 1) % 500 == 0:
        print(f'epoch {epoch+1}: loss = {loss.item():.4f}')

with torch.no_grad():
    pred_te = net(torch.tensor(np.asarray(xs_te, dtype='float32'))).numpy().ravel()
pred_te = pred_te * sd_y + mu_y    # 標準化を戻す
print(f'test R\N{SUPERSCRIPT TWO} = {r2_score(y_te, pred_te):.3f}')

📤 実行例:

💬 PyTorch では 順伝播 → 損失計算 → backward → optimizer.step の 4 ステップが明示。 loss.backward() が連鎖律で全パラメータの勾配を自動計算し、 opt.step() が SGD/Adam の更新を実行。 sklearn と結果がほぼ一致するのは、 数学的に同じ操作をしているから。

🐍 学習曲線で過学習を診断

このコードでやること：訓練損失と検証損失を epoch ごとに記録し、 過学習開始エポックを特定する。 Early Stopping の根拠データになる。

📥 入力データ: 47 県データ（train 32 / val 15 に分割）。

 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
from sklearn.neural_network import MLPRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
latest = df[df[df.columns[0]] == df[df.columns[0]].max()]
# 過学習を起こすため特徴量を6個・大きめの隠れ層(128,64)・正則化なし(alpha=0)
feats = ['A1301', 'A1303', 'A4101', 'B4101', 'A5101', 'A9101']
X = latest[feats].values.astype(float)
y = latest['A1101'].values.astype(float)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.4, random_state=1)
sx = StandardScaler().fit(X_tr)
sy = StandardScaler().fit(y_tr.reshape(-1, 1))

train_losses, val_losses = [], []
mlp = MLPRegressor(hidden_layer_sizes=(128, 64), max_iter=1,
                   warm_start=True, random_state=0, alpha=0.0)
for epoch in range(300):
    mlp.fit(sx.transform(X_tr), sy.transform(y_tr.reshape(-1, 1)).ravel())
    p_tr = sy.inverse_transform(mlp.predict(sx.transform(X_tr)).reshape(-1, 1)).ravel()
    p_te = sy.inverse_transform(mlp.predict(sx.transform(X_te)).reshape(-1, 1)).ravel()
    train_losses.append(mean_squared_error(y_tr, p_tr))
    val_losses.append(mean_squared_error(y_te, p_te))
best_epoch = int(np.argmin(val_losses)) + 1
print(f'最適 epoch = {best_epoch}')
print(f'最終 train MSE = {train_losses[-1]:.2e}')
print(f'最終 val   MSE = {val_losses[-1]:.2e}')
print(f'最小 val   MSE = {min(val_losses):.2e} at epoch {best_epoch}')

📤 実行例:

💬 epoch 73 で val MSE が最小。 それ以降は train MSE は下がり続けるのに val MSE が上がる典型的な過学習。 early_stopping=True, validation_fraction=0.2 を設定すれば自動で止まる。 47 県という極小データでは過学習が起きやすく、 NN 不向き。

🐍 活性化関数の比較

このコードでやること：ReLU / tanh / sigmoid / GELU での学習曲線と最終性能を比較し、 ReLU 系が現代の主流である理由を実証する。

📥 入力データ: 47 県データ（標準化済み）。

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

import pandas as pd
from sklearn.neural_network import MLPRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.compose import TransformedTargetRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
latest = df[df[df.columns[0]] == df[df.columns[0]].max()]
X = latest[['A1301', 'A1303', 'A4101']].values.astype(float)
y = latest['A1101'].values.astype(float)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3, random_state=0)

for act in ['relu', 'tanh', 'logistic', 'identity']:
    base = Pipeline([('scaler', StandardScaler()),
                     ('mlp', MLPRegressor(hidden_layer_sizes=(32, 16), activation=act,
                                          max_iter=2000, random_state=0))])
    model = TransformedTargetRegressor(regressor=base, transformer=StandardScaler())
    model.fit(X_tr, y_tr)
    r2 = r2_score(y_te, model.predict(X_te))
    print(f'{act:9s}: test R\N{SUPERSCRIPT TWO} = {r2:.3f}, iter = {model.regressor_.named_steps["mlp"].n_iter_}')

📤 実行例:

💬 ReLU が最高精度。 sigmoid (logistic) は勾配消失で収束遅延。 identity (恒等) は非線形性ゼロ = 線形回帰と同等で、 47 県のような線形関係が強いデータでは十分機能する。 これは「NN の必要性をデータが要求する場合」と「線形でも十分な場合」を見極める重要なシグナル。

⚠️ ニューラルネットワークの落とし穴 — 拡張版（実務で本当に困る5＋件）

1. 入力スケーリングを怠ると学習が爆発・収束しない：入力変数のスケールが大きく異なる（人口[百万]と失業率[%]）と、 勾配が一部の重みだけ大きくなり学習が不安定になる。 必ず StandardScaler や MinMaxScaler で標準化／正規化する。 訓練データで fit、 テストには transform のみ適用するのが鉄則。 scikit-learn の Pipeline でラップすればミス防止になる。
2. 過学習（overfitting）が止まらない：パラメータ数がサンプル数を超えるとほぼ確実に過学習する。 SSDSE のような n=47 で「隠れ層128ユニット」を入れると訓練誤差は0近くまで下がるが、 検証誤差は爆発する。 ドロップアウト（0.2〜0.5）、 L2正則化（weight_decay=1e−4等）、 早期終了、 そして そもそもネットワークを小さく することが対策。
3. 勾配消失・勾配爆発（vanishing / exploding gradients）：シグモイドや tanh を多層で重ねると勾配が指数的に小さくなり、 入力層付近の重みが更新されない。 ReLU 系（ReLU、 Leaky ReLU、 GELU）の利用、 He / Xavier 初期化、 バッチ正規化、 残差接続（ResNet）で緩和する。 RNN では LSTM や GRU で対応。
4. 学習率の設定ミス：学習率が大きすぎると損失が振動・発散し、 小さすぎると学習が遅すぎる。 通常は 1e−3〜1e−4 から始める。 ReduceLROnPlateau や CosineAnnealing で動的に下げる。 LearningRateFinder（fast.ai）のような自動探索ツールも有用。 「動かないからとりあえずlr=0.01」は典型的な失敗。
5. クラス不均衡を無視した分類：陽性事例が1%しかないデータで accuracy を見ても意味がない（全て陰性と予測しても99%）。 損失関数を class_weight で重み付け、 サンプリング（SMOTE等）、 評価指標を precision/recall/F1/AUC に変更するなど対処。 損失関数も BCE → Focal Loss など検討。
6. シード固定なしでの再現性問題：torch.manual_seed、 np.random.seed、 random.seed、 torch.backends.cudnn.deterministic 全てを設定しないと結果が再現しない。 論文発表や業務報告では必須。 GPU では完全に決定論的にできないこともあるので注意。
7. 解釈性の喪失：NN は「ブラックボックス」と呼ばれ、 なぜその予測をしたか説明が難しい。 SHAP、 LIME、 Integrated Gradients、 Permutation Importance などの XAI 手法を併用する。 法律や医療など説明責任のある分野では、 線形モデルや決定木の方が適切なこともある。

⚠️ ニューラルネットの落とし穴（深掘り）

1. 勾配消失・発散 — sigmoid/tanh は深層で勾配が極小・極大になる。 ReLU で大幅改善されたが、 dead ReLU（ずっと 0 になるノード）の問題は残る。 Leaky ReLU, GELU, ELU 等で対処。
2. 過学習 — 表現力が高いため小データでは即過学習。 Dropout, weight decay, early stopping, data augmentation で対処。 サンプル数が少なければ NN ではなく線形・木モデルを優先。
3. 初期化の重要性 — Xavier (Glorot) / He 初期化は活性化の種類に応じた重み初期分散。 全 0 初期化は対称性が崩れず学習しない。 標準ガウス初期化も深層で発散しがち。
4. 学習率の選択 — 大きすぎると振動・発散、 小さすぎると遅い・極小解に留まる。 cosine schedule, warmup, 1cycle policy など実証されたスケジューラを使う。
5. batch size の影響 — 小さい batch は確率的・正則化効果あり、 大きい batch は安定だが汎化が悪化することも（large batch generalization gap）。 学習率と batch size は連動して調整。
6. 標準化忘れ — 入力特徴量がスケール不均一だと勾配バランスが崩れ収束が遅い・解が悪い。 StandardScaler は必須。 出力も標準化すると学習が安定。
7. 解釈性の困難 — 線形回帰や決定木と違い、 個々のニューロンの意味は不明。 SHAP, LIME, Integrated Gradients 等で部分的に解釈可能だが、 完全には程遠い。
8. 再現性の壊れやすさ — random_state, cudnn deterministic, データ順序まで揃えないと結果が再現しない。 論文の追試・本番投入で大問題になりがち。
9. ハイパーパラメータの組合せ爆発 — 層数・幅・活性化・最適化・学習率・正則化と多すぎる。 Optuna 等の Bayesian 最適化で自動化が現実解。

🌐 主要なネットワーク・アーキテクチャ

🌐 主要なネットワーク・アーキテクチャ

• MLP (多層パーセプトロン) — 表データの基本。 表形式ベンチマークでは木モデルに負けることも多い。
• CNN (畳み込みニューラルネット) — 画像、 1D 信号、 局所相関のあるデータ向き。 AlexNet, VGG, ResNet, EfficientNet。
• RNN / LSTM / GRU — 系列データ。 短期記憶。 NLP では Transformer に取って代わられたが、 時系列予測では現役。
• Transformer — Self-Attention で系列・集合データを処理。 BERT, GPT, ViT。 大規模言語モデルの基盤。
• Graph Neural Network (GNN) — グラフ構造データ。 化学物質、 ソーシャルネットワーク、 推薦システム。
• Autoencoder / VAE — 次元削減、 生成モデル。 異常検知、 圧縮。
• GAN — 生成器と識別器の敵対的学習。 画像生成。 近年は Diffusion Model に主流移行。
• Diffusion Model — ノイズ除去過程で生成。 Stable Diffusion, DALL-E 等の画像生成 SOTA。
• Reinforcement Learning + NN (Deep RL) — DQN, PPO, AlphaGo, ChatGPT の RLHF。 報酬最大化。

🔗 関連用語ネットワーク — 前提・並列・発展（各4個以上）

🔻 前提となる用語

• 線形代数（行列演算） — 重み行列と入力ベクトルの積が基本。
• 微分（偏微分、 連鎖律） — 誤差逆伝播の数理的基盤。
• 標準化 — 入力の前処理として必須。
• 線形回帰 — 1層の単純なNN（線形活性化）と等価。
• 勾配降下法 — 学習アルゴリズムの中核。

🔺 並列の用語

• ロジスティック回帰 — 1層NN（シグモイド活性化）と等価。
• サポートベクターマシン — カーネル法による非線形分類。
• ランダムフォレスト — アンサンブル学習の代表。
• XGBoost / LightGBM — 勾配ブースティング系の主力。
• k-近傍法 — シンプルな非線形分類。

🔼 発展的な用語

• 畳み込みニューラルネット（CNN） — 画像処理の主力。
• 再帰型ニューラルネット（RNN/LSTM） — 時系列・自然言語向け。
• Transformer — 自然言語処理のSOTA、 大規模言語モデルの基盤。
• Graph Neural Network（GNN） — グラフ構造データを扱う。
• Diffusion Model — 生成系の最新手法。
• Reinforcement Learning — 報酬最大化のNN応用。

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

📚 統計学習の総合ガイド

📚 統計学習の総合ガイド

🎯 学習目標

このページの概念をマスターすることで、 以下のスキルが身につきます：

• 定義と公式を正確に理解
• 適切な使用場面を判断
• Python で実装し、 結果を可視化
• 仮定の確認と診断
• 結果の解釈と報告
• 限界と注意点の理解
• 関連手法との使い分け

📊 SSDSE-B-2026 データの構造

このコンペの主要データセット（SSDSE-B-2026）の構造：

• 47都道府県 × 過去複数年（パネル形式）
• 112列の社会経済指標
• 人口、 出生、 死亡、 婚姻、 経済、 教育、 環境、 家計など多次元
• 政府統計を統合した信頼性の高いデータ

🔍 主要な変数群

💡 ジャストインタイム型学習

このガイドは「必要なときに必要な知識」を提供する設計：

• 論文中の用語をクリック → 該当の用語解説へジャンプ（ポップアップ）
• 概念マップで関連用語を辿る
• 包含マップで体系を把握
• ツリーマップで全体を俯瞰
• Python コードをコピーして実行
• SSDSE データで実際に試す

🛠️ Python データサイエンス環境

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

# 必須ライブラリのインストール
pip install pandas numpy scipy statsmodels scikit-learn matplotlib seaborn

# 標準的なインポート
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from scipy import stats
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score, mean_squared_error

# 日本語表示の設定（matplotlib）
plt.rcParams['font.family'] = 'Hiragino Sans'
plt.rcParams['axes.unicode_minus'] = False

# データ読み込み（SSDSE は cp932、 2行目の日本語ラベル行は skiprows=[1] で除外）
df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
print(df.shape)
print(df.head())
print(df.describe())

🌟 効果的なEDAテンプレート

 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 matplotlib.pyplot as plt
import seaborn as sns

def quick_eda(df, target=None):
    """探索的データ分析の基本テンプレート"""
    print(f"Shape: {df.shape}")
    print(f"\nColumn types:\n{df.dtypes}")
    print(f"\nMissing values:\n{df.isnull().sum()}")
    print(f"\nBasic stats:\n{df.describe()}")

    # 数値列の可視化
    numeric_cols = df.select_dtypes(include=[np.number]).columns
    df[numeric_cols].hist(bins=20, figsize=(15, 10))
    plt.tight_layout()
    plt.show()

    # 相関ヒートマップ
    if len(numeric_cols) > 1:
        plt.figure(figsize=(12, 10))
        sns.heatmap(df[numeric_cols].corr(), annot=True, fmt='.2f',
                    cmap='RdBu_r', center=0)
        plt.show()

    # ターゲットがあれば散布図行列
    if target and target in df.columns:
        sns.pairplot(df[numeric_cols[:5]], hue=target if df[target].dtype == 'O' else None)
        plt.show()

📈 報告書テンプレート

分析結果を報告する際の標準的な構成：

1. 背景・目的：なぜこの分析が必要か
2. データ：出所、 サンプルサイズ、 期間
3. 方法：使用した統計手法、 仮定
4. 結果：図表、 統計量、 検定結果
5. 解釈：結果が何を意味するか
6. 限界：分析の制約
7. 結論：要点まとめ、 今後の課題

📚 補足参考資料 — DNN と Shallow NN の比較

ニューラルネットワーク（NN）は隠れ層の数に応じて Shallow NN（1 層）と Deep NN（DNN, 2 層以上）に大別されます。 SSDSE-B-2026 のような表形式データでは Shallow NN でも十分な場合が多い一方、 画像・音声・テキストなど高次元・非構造データでは DNN の階層的特徴抽出が威力を発揮します。

🔬 数式を言葉で読み解く — 多層化の効果

$y = f_L(W_L \cdots f_2(W_2 f_1(W_1 x + b_1) + b_2) \cdots + b_L)$ — 各 $f_l$ は活性化関数、 $W_l, b_l$ は層 $l$ の重みとバイアス。 層 $L$ を深くするほど合成関数の表現力が指数的に増加するが、 学習に必要なデータ量・計算量も増えます。

1
2
3

import pandas as pd
df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', header=1)
print(df.shape, df.columns[:5].tolist())

他用語との比較: 深層学習は DNN を中核に置き、 活性化関数が非線形変換を担います。 Shallow NN との違いは「層の深さ」が表現力と訓練難度のトレードオフを決める点にあります。

🗺️ 統計手法選択フローチャート

Q1: 何を知りたい？

• 記述したい → 平均、 分散、 ヒストグラム
• 比較したい → t検定、 ANOVA、 χ²検定
• 関係を見たい → 相関、 回帰
• 予測したい → 回帰、 機械学習
• 分類したい → ロジスティック回帰、 SVM、 RF
• グループ分けしたい → クラスタリング
• 次元を減らしたい → PCA、 因子分析
• 因果関係を知りたい → RCT、 IV、 DiD、 PSM

Q2: データの種類は？

• 連続値 → t検定、 ANOVA、 線形回帰
• カテゴリ → χ²検定、 ロジスティック回帰
• 順序 → ノンパラ検定、 順位回帰
• カウント → ポアソン回帰、 負の二項回帰
• 時系列 → ARIMA、 VAR、 状態空間
• パネル → 固定効果、 ランダム効果

Q3: サンプルサイズは？

• n < 30：ノンパラ、 ベイズ、 ブートストラップ
• 30 ≤ n < 200：古典的検定、 単純な回帰
• n ≥ 200：複雑なモデル、 機械学習
• n ≥ 10000：深層学習も可能

Q4: 仮定は？

• 正規性：満たす → パラメトリック / 満たさない → ノンパラ
• 独立性：必須 / 違反 → クラスター調整、 時系列モデル
• 等分散性：満たす → OLS / 違反 → WLS、 ロバスト

📏 効果量の参照表

p値だけでなく効果量も併記するのが現代統計の標準。 主要な指標と Cohen の解釈基準：

🗺️ 概念マップ — 3つの視点で体系を理解する

ニューラルネットワーク がデータサイエンスの体系の中でどこに位置するかを、 3つの異なる視点で可視化します。 同じ情報でも見方を変えると気付きが変わります。

📍 体系階層のパス

🌐 統計・データサイエンス › 機械学習 › 教師あり学習 › ニューラルネットワーク

① 🔗 関係マップ — 「他の手法とどう繋がっているか」

中心に ニューラルネットワーク を置き、 そこから OLS・分類・重回帰・単回帰・Ridge回帰 計 5 個の用語へ、 前提・兄弟・発展形といった関係を矢印で結んでいます。 線がどちら向きかを見れば、 先に読むべき用語とあとから読む用語が分かります。 ノードはドラッグで動かせ、 ホイールでズーム、 クリックでその用語のページへ遷移します。

② ⭕ 包含マップ — 「どのカテゴリに含まれているか」

大きな円が小さな円を包含する Circle Packing 図。 「ニューラルネットワーク」は緑色でハイライト。

• カテゴリ円をクリック：その内部にズームイン
• 白背景クリック：1階層戻る
• 用語円をクリック：詳細ページへ遷移
• マウスホバー：階層パス表示

③ 🌳 ツリーマップ — 「面積で見るボリューム比較」

長方形を入れ子に分割した Treemap 図。 各分野の規模感を面積で比較。 「ニューラルネットワーク」は緑色でハイライト。

• カテゴリ矩形をクリック：その内部にドリルダウン
• パンくず（上のリンク）クリック：その階層に戻る
• 用語矩形をクリック：詳細ページへ遷移
• マウスホバー：階層パスと値を表示

🎯 3つのマップの使い分け

💡 3 つの図は同じ位置関係を別の角度から描いています。 関係マップは ニューラルネットワーク の隣に何が並ぶかを、 包含マップとツリーマップは 統計・データサイエンス → 教師あり学習 → ニューラルネットワーク という入れ子の位置を示します。 「教師あり学習には他に何があったか」を思い出したいときは包含マップを、 「次に何を読むか」を決めたいときは関係マップを開いてください。

🔗 隣接手法への橋渡し

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

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

ニューラルネットは「線形変換 + 非線形活性化」の合成。 SSDSE-B-2026 (47×16) は小規模すぎてニューラルネットの旨味が出にくく、 通常は線形回帰や勾配ブースティングが勝る。 NN は画像・音声・テキストのような大規模・高次元データで真価を発揮する。

🌳 手法選択フロー

「neural network」を含む手法選択は、 データの性質・分析目的・運用制約の 3 軸で決まる。 以下に典型シナリオと対応する手法の組合せを示す。

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

選んだ後の検証ステップ

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

✅ 理解度チェック — 1 分で答える確認問題

ニューラルネットワークの基本概念が定着しているか、 以下の問いで確認しよう。

1. 順伝播と逆伝播の役割: 順伝播では何が計算され、 逆伝播では何が更新されるか 1 行で説明せよ。
2. 活性化関数の必要性: 活性化関数を入れずに線形変換だけを重ねた場合、 何が起きるか述べよ。
3. SSDSE-B での適用例: 47 都道府県の年齢別人口（15歳未満・65歳以上）や出生数を説明変数、 総人口を目的変数とする回帰タスクで、 隠れ層を増やすと過学習が起こりやすい理由を 1-2 行で説明せよ。
4. 勾配消失: シグモイド関数を深いネットワークで多用すると逆伝播時に何が起きるか、 また ReLU を採用すると何が改善されるか述べよ。
5. 学習率: 学習率を大きくしすぎた場合と小さくしすぎた場合、 損失関数の挙動はそれぞれどうなるか 1 行ずつで答えよ。

解答例は他の用語ページ (誤差逆伝播 / 活性化関数 / 過学習) を読みながら自分で書き出してみよう。 概念マップ (上方) で関連用語の位置関係も再確認すると定着しやすい。

🎮 触って理解する

下のミニ・ニューラルネット（入力2 → 隠れ層3ニューロン → 出力1）で、 重み・バイアスのスライダーを動かすと、 各ニューロンの活性化と決定境界（2D平面の色塗り）がリアルタイムに更新されます。 左の平面をクリック／タップ（ドラッグも可）すると、 その点を入力 $(x_1, x_2)$ として順伝播した数値（隠れ層の活性値 $\mathbf{h}$ と出力 $o$）を表示します。 隠れ層の活性化関数（sigmoid / ReLU / tanh）も切り替えられます。 順伝播は $h_j=\sigma(W^{(1)}_j\!\cdot\!\mathbf{x}+b^{(1)}_j)$、 $o=\mathrm{sigmoid}(W^{(2)}\!\cdot\!\mathbf{h}+b^{(2)})$ を正確に計算しており、 すべてブラウザ内で完結・外部通信は一切ありません。

$W^{(1)}_{j,i}$ は第 $j$ 隠れニューロンが受ける第 $i$ 入力の重み、 $b^{(1)}_j$ はそのバイアス、 $W^{(2)}_j$ は第 $j$ 隠れニューロンから出力への重み、 $b^{(2)}$ は出力のバイアスです。

🧭 直感 — なぜ「層の合成」で曲がった境界が作れるのか

1つの隠れニューロンは 重み付き和 → 活性化 により、 平面をおおよそ1本の（活性化で曲がった）境界で「半分に折る」働きをします。 隠れ層に複数ニューロンを置くと、 複数の折り目が重なり合い、 出力層がそれらを線形結合することで 直線1本では表せない非線形な決定境界が生まれます。 実際に上のスライダーで隠れニューロンの重みを大きくすると境界が鋭くなり、 符号を変えると折り目の向きが反転するのが見えます。 ここで活性化関数を sigmoid に固定したまま線形結合だけを重ねても、 合成はまた線形写像に戻ってしまう——だからこそ非線形な活性化関数が不可欠です（活性化を外すと、 どうスライダーを動かしても境界は必ず直線のままになります）。

🚧 触りながら気づく落とし穴

• ReLU の dead neuron：ReLU 選択時、 ある隠れニューロンの重み・バイアスが負側に振れると出力が常に0になり、 そのニューロンは境界に一切寄与しなくなります（図でノードが白く固まる）。
• sigmoid/tanh の飽和：重みを極端に大きくすると活性値が0/1（または±1）に張り付き、 境界が階段状になって中間の勾配情報が失われます。 これは学習時の勾配消失の直感的な姿です。
• スケール依存：入力を $[-3,3]$ に取っていますが、 実データでは特徴量のスケールがバラバラだと一部の重みだけが効いてしまいます。 だから前処理での標準化が重要になります。
• 表現力≠汎化：境界をいくらでも複雑にできますが、 それは同時に過学習のリスクでもあります。 少数データでは単純な境界のほうが良いことが多いです。

🚀 発展 — ここから先へ

• この遊び場では重みを手で動かしましたが、 実際は誤差逆伝播で損失の勾配を求め、 勾配降下法が重みを自動更新します。 「良い境界を探す」作業をアルゴリズムに任せたものが学習です。
• 隠れニューロンを増やす・層を深くすると、 折り目がさらに増えて任意の連続関数に近づけます（普遍近似定理）。 発展形は深層学習へ。
• 活性化の選び方そのものが1つの設計判断です。 詳しくは活性化関数・ReLU・シグモイドを参照。 tanh の専用ページは未整備のため、 ここではリンクなしのテキストのみとします。
• 境界が複雑になりすぎたと感じたら、 過学習と正則化の観点で見直します。

🧠 直感をもう一段深める — 「重み付き和＋活性化」を層で積む

1つのニューロン（パーセプトロン）は、 入力ベクトルに重みを掛けて足し合わせ（重み付き和 $z = \mathbf{w}\cdot\mathbf{x} + b$）、 そこに活性化関数 $\sigma$ を通すだけの素朴な部品です。 この部品を横に並べて「層」を作り、 層を縦に積む（前の層の出力を次の層の入力にする）と、 単純な部品の合成だけで複雑な入出力関係＝関数を近似できます。 これが多層パーセプトロンの直感であり、 ニューラルネットワークの核です。

学習とは、 「望ましい出力との誤差」を測り、 その誤差を出力側から入力側へ連鎖律で逆算し（誤差逆伝播）、 各重みを誤差が減る向きに少しずつ動かすこと。 人が手で重みを調整する代わりに、 勾配降下法がこれを自動で行います。 上の🎮ウィジェットで手で決定境界を作った作業を、 アルゴリズムに丸ごと任せたものが「学習」だと考えると腑に落ちます。

「脳のニューロンの模倣」と言われますが、 これは発想の由来であって生物学的に正確な模型ではありません。 本質は「線形変換と非線形変換を交互に積むと表現力が跳ね上がる」という数学的事実です。 活性化 $\sigma$ を外して線形変換だけを積むと、 合成はまた1つの線形変換に戻り、 層を深くする意味が消えます（非線形性こそが「深さの効果」の源泉）。 ReLU が現代の標準活性化なのは、 計算が軽く勾配が消えにくいからです。

層を積むもう1つの意味は「特徴の階層」を自動で学ぶ点にあります。 浅い層は素朴な特徴（単純な組合せ）、 深い層はそれらを束ねた抽象的な特徴を表し、 人手の特徴設計を機械が肩代わりします。 これが深層学習が画像・音声・テキストで強い理由です。

⚠️ 落とし穴をもう一段深める — n=47 でNNはCVで崩れる（実測）

ニューラルネットは強力な反面、 失敗のしかたも多彩です。 特に重要な落とし穴を先に整理します。

• 過学習：表現力が高いので少数データでは訓練誤差を0近くまで落としつつ検証誤差が悪化する。 対策＝正則化（L2/weight decay）・ドロップアウト・早期終了・そもそもネットを小さく。 → 過学習
• 勾配消失／爆発：sigmoid/tanh を多層で重ねると勾配が指数的に減衰・発散する。 ReLU 系・He/Xavier 初期化・バッチ正規化・残差接続で緩和。
• 大量データ・計算が必要：パラメータが多く、 少データでは学習しきれない。 大規模データとGPU計算が前提になりがち。
• 局所最適・初期化依存：損失が非凸で、 初期値やシードで結果が変わる。 全0初期化は対称性が崩れず学習不能。
• ハイパーパラメータが多い：層数・幅・活性化・学習率・正則化・バッチサイズと組合せ爆発。 Optuna 等の自動探索が現実解。
• 小データ・表形式ではGBDTに劣る：表形式ベンチマークでは勾配ブースティング（XGBoost/LightGBM）がNNに勝ることが多い（下の実測参照）。
• ブラックボックス：なぜその予測かを説明しにくい。 SHAP/LIME 等のXAIで部分的に補うが、 説明責任のある場面では線形・木モデルが適切なことも。

これらの多くは n=47（SSDSE-B-2026 の47都道府県） のような小さな表形式データで一気に噴出します。 上の「実値計算例」では train/test 分割1回で test R²=0.979 と好成績でしたが、 それは1つの分割の運を含んだ値です。 5分割交差検証（CV）で honest に評価すると、 NNの脆さが見えてきます（以下はすべて SSDSE-B-2026・2023年・n=47 の実測値）。

💬 読み解き：(1) 総人口は年齢別人口・出生数とほぼ線形なので、 NNを丁寧にチューニングしても線形回帰に「並ぶ」のが精一杯で、 超えない。 しかも fold 間のばらつき（std=0.025）は線形（0.010）の約2.5倍で不安定。 (2) 決定的なのは最終行——目的変数（総人口＝数百万の桁）の標準化を1つ忘れるだけで、 MLPは損失が桁の大きい方に引きずられて学習が進まず、 CV R²が負値（＝平均を予測するより悪い）に崩壊する。 線形回帰・GBDTは目的変数のスケールに不変なので、 この失敗自体が起きない。

📥 再現コード（data/raw/SSDSE-B-2026.csv、 cp932、 skiprows=[1]、 最新年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
37

import pandas as pd, numpy as np, warnings
warnings.filterwarnings('ignore')
from sklearn.neural_network import MLPRegressor
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.compose import TransformedTargetRegressor
from sklearn.model_selection import cross_val_score, KFold

# 英字の項目コード（A1101 など）を使うので、2 行目の日本語名は読み飛ばす
nn_df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
yc = nn_df.columns[0]
latest = nn_df[nn_df[yc] == nn_df[yc].max()]   # 最新年 2023 の47都道府県 (n=47)
X = latest[['A1301', 'A1303', 'A4101']].values.astype(float)
y = latest['A1101'].values.astype(float)       # 総人口
cv = KFold(n_splits=5, shuffle=True, random_state=0)

def mlp(hidden, alpha, scale_y):
    # hidden_layer_sizes= は必ずキーワードで渡す（位置引数だと別の引数に入る）
    base = Pipeline([('s', StandardScaler()),
                     ('m', MLPRegressor(hidden_layer_sizes=hidden, activation='relu',
                                        solver='adam', max_iter=2000, alpha=alpha,
                                        random_state=0))])
    return TransformedTargetRegressor(base, transformer=StandardScaler()) if scale_y else base

models = {
    'Linear':             LinearRegression(),
    'GBDT':               GradientBoostingRegressor(random_state=0),
    'MLP(32,16) y標準化':   mlp((32, 16), 1e-4, True),
    'MLP(32,16) y未標準化':  mlp((32, 16), 1e-4, False),   # 前処理を1つ忘れるだけ
}
for name, m in models.items():
    s = cross_val_score(m, X, y, cv=cv, scoring='r2')
    note = '' if s.mean() > 0 else '  ← 平均を答えるより悪い（目的変数の標準化を忘れた結果）'
    print(f'{name:20s} CV 決定係数 {s.mean():+.3f} '
          f'(std {s.std():.3f}, 最悪 {s.min():+.3f}){note}')

📤 実行例:

🎯 教訓：n=47 のような小・表形式データでは、 NNは(1)うまくいってもGBDT/線形を超えず、 (2)前処理の些細なミスで簡単に崩れる。 まず線形回帰やGBDTを基準にし、 NNは「大規模・高次元・強い非線形相互作用」があるときに使うのが定石です。

📝 補足（より正確な分析）：ページ上部の実値計算例（train/test 1分割で test R²=0.979）は誤りではありませんが、 1つの分割の運を含みます。 少数データでは分割の当たり外れが大きいため、 単一分割の高スコアを過信せず、 上のように交差検証で fold 間のばらつき（std・最小fold）まで見ると、 モデルの脆さをより正確に評価できます。

🚀 発展をもう一段深める — 定理・最適化・アーキテクチャ

• 普遍近似定理：隠れ層1つでもノード数が十分なら、 任意の連続関数を任意精度で近似できる（Cybenko 1989, Hornik 1991）。 ただし「近似できる」と「有限データから学習できる」は別問題。 深さは、 同じ表現力をより少ないパラメータで得るための効率化と理解するとよい。
• 活性化関数：非線形性の源。 ReLU（標準）、 Leaky ReLU/GELU/ELU（dead neuron 対策）、 sigmoid/tanh（出力層・ゲート用）。 選び方自体が設計判断。 → 活性化関数
• 誤差逆伝播と最適化：連鎖律で勾配を効率計算し（バックプロパゲーション）、 SGD・モメンタム・Adam 等で重みを更新（勾配降下法）。 Adam は勾配の一次・二次モーメントで学習率を自動調整し、 多くのタスクで安定して動く。
• 正則化：L2（weight decay）・L1・ドロップアウト・早期終了・バッチ正規化・データ拡張。 表現力を抑えて汎化を稼ぐ。 → 正則化 / 過学習
• 発展アーキテクチャ：CNN（画像・局所相関）、 RNN/LSTM/GRU（系列）、 Transformer（self-attention、 大規模言語モデルの基盤）。 これらを積み重ねて深くしたものが 深層学習。
• 表形式でのGBDT比較：表形式データでは XGBoost/LightGBM のような勾配ブースティングがNNを上回ることが多い（上の実測でも確認）。 NNの優位は画像・音声・テキストなど非構造・高次元データ。 比較対象として ランダムフォレスト / 決定木 も押さえておくとよい。