ニューラルネットワーク入門
はじめに
本記事は「Pythonで学ぶデータ分析実践」シリーズの補足記事として、ニューラルネットワークの基礎を解説します。
第10回のクラス分類で学んだロジスティック回帰やSVMは強力な手法ですが、複雑な非線形パターンを持つデータには対応が困難な場合があります。ニューラルネットワークは人間の脳の構造を模倣したモデルで、こうした複雑なパターンを学習する能力を持っています。
本記事では、パーセプトロンから多層パーセプトロン、活性化関数、損失関数、最適化手法まで、ニューラルネットワークの基本概念をscikit-learnによる実装とともに解説します。
1. ニューラルネットワークとは
ニューラルネットワークは、人間の脳における神経細胞（ニューロン）のネットワーク構造を模倣した機械学習モデルです。無数のニューロンが繋がり情報伝達を行う仕組みをコンピュータ上で再現し、データからパターンを学習します。
ニューラルネットワークの位置づけ
| 手法 | 特徴 | 適用場面 |
|---|---|---|
| 線形回帰 | 線形関係のみ | 単純な予測 |
| SVM | カーネルで非線形対応 | 中規模データの分類 |
| ニューラルネットワーク | 複雑な非線形パターンを学習 | 画像認識、音声認識、自然言語処理 |
2. パーセプトロン
パーセプトロンはニューラルネットワークの基礎となるアルゴリズムで、複数の入力から1つの出力を返します。出力は「1」（肯定）または「0」（否定）の2値です。
パーセプトロンの仕組み
入力 x₁ ──(重み w₁)──┐
入力 x₂ ──(重み w₂)──┼──→ Σ(重み付き和) ──→ 活性化関数 ──→ 出力(0 or 1)
入力 x₃ ──(重み w₃)──┘ + バイアス b
数式：
$$y = f\left(\sum_{i=1}^{n} w_i x_i + b\right)$$
- $x_i$: 入力値
- $w_i$: 重み（各入力の重要度）
- $b$: バイアス（閾値）
- $f$: 活性化関数
具体例：チョコレートを買うかどうかの意思決定
| 入力 | 条件 | 値 |
|---|---|---|
| $x_1$ | 空腹か | 1（空腹）/ 0（満腹） |
| $x_2$ | 懐に余裕があるか | 1（余裕あり）/ 0（余裕なし） |
| $x_3$ | 甘いもの好きか | 1（好き）/ 0（そうでもない） |
重み付き和が閾値を超えれば「買う（1）」、超えなければ「買わない（0）」と判断します。
import numpy as np
def perceptron(inputs, weights, bias):
"""単純パーセプトロン"""
weighted_sum = np.dot(inputs, weights) + bias
return 1 if weighted_sum > 0 else 0
# チョコレートを買うかの判断
# 甘いもの好きな人の重み設定
weights = np.array([0.3, 0.2, 0.8]) # 空腹, 懐事情, 甘いもの好き
bias = -0.5
# ケース1: 空腹で余裕あり、甘いもの好き
inputs1 = np.array([1, 1, 1])
print(f"ケース1(空腹,余裕あり,甘党): {perceptron(inputs1, weights, bias)} → 買う")
# ケース2: 満腹で余裕なし、甘いもの好き
inputs2 = np.array([0, 0, 1])
print(f"ケース2(満腹,余裕なし,甘党): {perceptron(inputs2, weights, bias)} → {'買う' if perceptron(inputs2, weights, bias) else '買わない'}")
# ケース3: 空腹だが余裕なし、甘いもの好きでもない
inputs3 = np.array([1, 0, 0])
print(f"ケース3(空腹,余裕なし,普通): {perceptron(inputs3, weights, bias)} → {'買う' if perceptron(inputs3, weights, bias) else '買わない'}")
パーセプトロンの限界：XOR問題
単一のパーセプトロンは線形分離可能な問題のみ解けます。XOR（排他的論理和）のような非線形な問題は解けません。
import numpy as np
import matplotlib.pyplot as plt
import japanize_matplotlib
fig, axes = plt.subplots(1, 2, figsize=(12, 4))
# AND（線形分離可能）
x_and = np.array([[0,0],[0,1],[1,0],[1,1]])
y_and = np.array([0, 0, 0, 1])
axes[0].scatter(x_and[y_and==0,0], x_and[y_and==0,1], s=100, marker='o', label='0')
axes[0].scatter(x_and[y_and==1,0], x_and[y_and==1,1], s=100, marker='x', label='1')
axes[0].plot([0.5, 0.5, 1.5], [1.5, 0.5, 0.5], 'r--', linewidth=2)
axes[0].set_title("AND（線形分離可能）")
axes[0].legend()
axes[0].set_xlim(-0.5, 1.5)
axes[0].set_ylim(-0.5, 1.5)
# XOR（線形分離不可能）
x_xor = np.array([[0,0],[0,1],[1,0],[1,1]])
y_xor = np.array([0, 1, 1, 0])
axes[1].scatter(x_xor[y_xor==0,0], x_xor[y_xor==0,1], s=100, marker='o', label='0')
axes[1].scatter(x_xor[y_xor==1,0], x_xor[y_xor==1,1], s=100, marker='x', label='1')
axes[1].set_title("XOR（線形分離不可能 → 多層パーセプトロンが必要）")
axes[1].legend()
axes[1].set_xlim(-0.5, 1.5)
axes[1].set_ylim(-0.5, 1.5)
plt.tight_layout()
plt.show()
3. 多層パーセプトロン（MLP）
XOR問題を解決するために、パーセプトロンを階層化するアプローチが提案されました。複数のパーセプトロンを重ね、出力を次の層の入力として連携させる**多層パーセプトロン（MLP: Multi-Layer Perceptron）**が、一般にニューラルネットワークと呼ばれるモデルです。
多層パーセプトロンの構造
入力層 中間層（隠れ層） 出力層
┌─ ニューロン ─┐
入力x₁ ──────┤ ├──────→ 出力y
入力x₂ ──────┤ ニューロン ├
入力x₃ ──────┤ ├
└─ ニューロン ─┘
| 層 | 役割 |
|---|---|
| 入力層 | データを受け取る（特徴量の数 = ニューロン数） |
| 中間層（隠れ層） | データのパターンを学習する |
| 出力層 | 予測結果を出力する |
学習のポイント
ニューラルネットワークが正しく動作するかは重みの値にかかっています。学習とは、予測と正解の誤差が最小になるように重みを調整するプロセスです。
プログラミング時のポイント：
- どのように入力層にデータを渡すか
- どのように中間層を配置するか（層数、ニューロン数）
- どのように出力するか（活性化関数の選択）
- どのように誤差を計算するか（損失関数の選択）
- どのように学習するか（最適化手法の選択）
ディープラーニングとの関係
中間層を複数（深く）積み重ねたニューラルネットワークを**ディープニューラルネットワーク（ディープラーニング）**と呼びます。画像認識、音声認識、自然言語処理などで高い精度を実現しています。
4. 活性化関数
活性化関数は、ニューロンの入力値を変換して出力する関数です。非線形な活性化関数を使うことで、ネットワークが非線形なパターンを学習できるようになります。
主な活性化関数
| 関数 | 出力範囲 | 特徴 | 用途 |
|---|---|---|---|
| Step（ステップ） | 0 or 1 | 閾値を超えたら1、超えなければ0 | 初期のパーセプトロン |
| Sigmoid（シグモイド） | 0〜1 | 滑らかな曲線、確率として解釈可能 | 2値分類の出力層 |
| tanh（ハイパボリックタンジェント） | -1〜1 | 0中心で対称、勾配消失を緩和 | 中間層 |
| ReLU（ランプ関数） | 0〜∞ | 計算が高速、最もよく使われる | 中間層（標準） |
| Softmax（ソフトマックス） | 0〜1（合計1） | 確率分布として出力 | 多クラス分類の出力層 |
活性化関数の可視化
import numpy as np
import matplotlib.pyplot as plt
import japanize_matplotlib
x = np.linspace(-5, 5, 200)
fig, axes = plt.subplots(2, 3, figsize=(15, 8))
# Step関数
axes[0,0].plot(x, np.where(x > 0, 1, 0), linewidth=2, color='steelblue')
axes[0,0].set_title("Step（ステップ関数）", fontsize=11)
axes[0,0].set_ylim(-0.1, 1.1)
axes[0,0].grid(alpha=0.3)
axes[0,0].axhline(0, color='gray', linewidth=0.5)
axes[0,0].axvline(0, color='gray', linewidth=0.5)
# Sigmoid関数
sigmoid = 1 / (1 + np.exp(-x))
axes[0,1].plot(x, sigmoid, linewidth=2, color='steelblue')
axes[0,1].set_title("Sigmoid（シグモイド関数）", fontsize=11)
axes[0,1].grid(alpha=0.3)
axes[0,1].axhline(0.5, color='red', linestyle='--', alpha=0.5)
axes[0,1].axvline(0, color='gray', linewidth=0.5)
# tanh関数
axes[0,2].plot(x, np.tanh(x), linewidth=2, color='steelblue')
axes[0,2].set_title("tanh（ハイパボリックタンジェント）", fontsize=11)
axes[0,2].grid(alpha=0.3)
axes[0,2].axhline(0, color='gray', linewidth=0.5)
axes[0,2].axvline(0, color='gray', linewidth=0.5)
# ReLU関数
axes[1,0].plot(x, np.maximum(0, x), linewidth=2, color='steelblue')
axes[1,0].set_title("ReLU（ランプ関数）", fontsize=11)
axes[1,0].grid(alpha=0.3)
axes[1,0].axhline(0, color='gray', linewidth=0.5)
axes[1,0].axvline(0, color='gray', linewidth=0.5)
# Softmax（概念的表示）
softmax_vals = np.exp(x) / np.sum(np.exp(x))
axes[1,1].bar(range(5), [0.05, 0.1, 0.6, 0.15, 0.1], color='steelblue', alpha=0.8)
axes[1,1].set_title("Softmax（出力例: 合計=1）", fontsize=11)
axes[1,1].set_xlabel("クラス")
axes[1,1].set_ylabel("確率")
axes[1,1].grid(axis='y', alpha=0.3)
# 比較
axes[1,2].plot(x, sigmoid, linewidth=2, label='Sigmoid')
axes[1,2].plot(x, np.tanh(x), linewidth=2, label='tanh')
axes[1,2].plot(x, np.maximum(0, x), linewidth=2, label='ReLU')
axes[1,2].set_title("活性化関数の比較", fontsize=11)
axes[1,2].legend()
axes[1,2].grid(alpha=0.3)
axes[1,2].set_ylim(-1.5, 5)
plt.tight_layout()
plt.show()
5. 損失関数
損失関数は、モデルの予測値と正解値の誤差を数値化する関数です。学習の目的は、この損失関数の値を最小化することです。
主な損失関数
| 損失関数 | 用途 | 計算方法 |
|---|---|---|
| 平均二乗誤差（MSE） | 回帰問題 | 予測値と実際の値の差の2乗の平均 |
| 平均二乗平方根誤差（RMSE） | 回帰問題 | MSEの平方根 |
| 二値交差エントロピー | 2値分類 | 予測確率と正解の対数尤度 |
| カテゴリカル交差エントロピー | 多クラス分類 | 各クラスの予測確率と正解の対数尤度 |
損失関数の選択指針
タスクの種類は？
├── 回帰（連続値を予測） → MSE or RMSE
├── 2値分類（0/1） → 二値交差エントロピー
└── 多クラス分類 → カテゴリカル交差エントロピー
6. 最適化手法
損失関数の値を最小化するために重みを更新するプロセスを最適化と呼びます。最適化手法は「どのように重みを更新するか」を決定します。
勾配降下法の基本
重みの更新は以下の式で行われます。
$$w_{new} = w_{old} - \eta \cdot \frac{\partial L}{\partial w}$$
- $\eta$: 学習率（ハイパーパラメータ）— 更新量の大きさを制御
- $\frac{\partial L}{\partial w}$: 損失関数の勾配（微分値）
学習率の影響：
- 大きすぎる → 最小値を飛び越えてしまう（発散）
- 小さすぎる → 学習が遅くなる、局所最小値に陥りやすい
確率的勾配降下法（SGD）
全データではなくランダムに選んだ一部データで勾配を計算し重みを更新する手法です。大規模データでも効率的に学習可能です。
主な最適化手法の比較
| 手法 | 特徴 | 適用場面 |
|---|---|---|
| SGD | シンプル、学習率の設定が重要 | 基本的な学習 |
| Adam | SGD + モーメンタム、最もよく使われる | 大規模データ、汎用的 |
| RMSprop | 勾配の移動平均で学習率を自動調整 | RNN（再帰型NN） |
| L-BFGS | 準ニュートン法ベース | 小規模データ |
| Adagrad | パラメータごとに学習率を自動調整 | スパースデータ |
誤差逆伝搬法（バックプロパゲーション）
誤差逆伝搬法は、出力層で計算された誤差を入力層に向かって逆方向に伝搬し、各層の重みを更新する手法です。
順伝搬: 入力 → 中間層 → 出力（予測値を計算）
↓
誤差計算: 予測値と正解の差（損失）を計算
↓
逆伝搬: 出力層 → 中間層 → 入力層（勾配を計算）
↓
重み更新: 勾配に基づいて全ての重みを更新
↓
繰り返し（損失が十分小さくなるまで）
7. scikit-learnによるニューラルネットワーク
scikit-learnではsklearn.neural_network.MLPClassifierクラスを使って多層パーセプトロンを実装できます。
MLPClassifierの主要パラメータ
| パラメータ | デフォルト値 | 意味 |
|---|---|---|
| hidden_layer_sizes | (100,) | 中間層の構成。例: (100,200) → 2層で各100,200ニューロン |
| activation | 'relu' | 活性化関数 [identity, logistic, tanh, relu] |
| solver | 'adam' | 最適化手法 [sgd, lbfgs, adam] |
| alpha | 0.0001 | L2正則化パラメータ |
| learning_rate_init | 0.001 | 初期学習率（SGD, Adamの場合） |
| max_iter | 200 | 最大エポック数 |
| tol | 1e-4 | 収束判定の閾値 |
| random_state | None | 乱数シード |
| verbose | 0 | 1で詳細ログを表示 |
MLPClassifierの属性・メソッド
| 属性/メソッド | 意味 |
|---|---|
| classes_ | クラスラベル |
| loss_ | 現在の損失値 |
| loss_curve_ | 学習中の損失の推移 |
| fit(X, y) | モデルの学習 |
| predict(X) | 予測の実行 |
| predict_proba(X) | 各クラスの確率を出力 |
| score(X, y) | 正解率を返す |
実装例：Irisデータの分類
import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.neural_network import MLPClassifier
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, accuracy_score
import matplotlib.pyplot as plt
import japanize_matplotlib
# データ準備
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
iris.data, iris.target, test_size=0.2, random_state=42, stratify=iris.target
)
# スケーリング（ニューラルネットワークでは必須）
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# MLPモデルの構築
mlp = MLPClassifier(
hidden_layer_sizes=(50, 30), # 中間層: 50ニューロン + 30ニューロン
activation='relu', # 活性化関数: ReLU
solver='adam', # 最適化: Adam
alpha=0.001, # 正則化パラメータ
max_iter=1000, # 最大エポック数
tol=0.00001, # 収束判定
random_state=42,
verbose=False
)
# 学習
mlp.fit(X_train_scaled, y_train)
# 予測と評価
y_pred = mlp.predict(X_test_scaled)
print(f"=== ニューラルネットワーク（MLP）による分類結果 ===")
print(f"正解率: {accuracy_score(y_test, y_pred):.4f}")
print(f"\n分類レポート:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))
学習曲線（損失関数の推移）
# 損失関数の推移を可視化
plt.figure(figsize=(10, 5))
plt.plot(mlp.loss_curve_, color='steelblue', linewidth=2)
plt.xlabel("エポック", fontsize=12)
plt.ylabel("損失（Loss）", fontsize=12)
plt.title("学習曲線（損失関数の推移）", fontsize=14)
plt.grid(alpha=0.3)
plt.show()
print(f"最終損失: {mlp.loss_:.6f}")
print(f"学習エポック数: {mlp.n_iter_}")
実装例：手書き数字の分類
from sklearn.datasets import load_digits
from sklearn.neural_network import MLPClassifier
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
# 手書き数字データの読み込み
digits = load_digits()
print(f"=== 手書き数字データセット ===")
print(f"データ数: {digits.data.shape[0]}")
print(f"特徴量数: {digits.data.shape[1]}（8×8ピクセル）")
print(f"クラス数: {len(digits.target_names)}（0〜9）")
# データのサンプル表示
fig, axes = plt.subplots(2, 5, figsize=(10, 4))
for i, ax in enumerate(axes.ravel()):
ax.imshow(digits.images[i], cmap='gray')
ax.set_title(f"ラベル: {digits.target[i]}")
ax.axis('off')
plt.suptitle("手書き数字データのサンプル", fontsize=13)
plt.tight_layout()
plt.show()
# データ分割とスケーリング
X_train, X_test, y_train, y_test = train_test_split(
digits.data, digits.target, test_size=0.2, random_state=42
)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# MLPモデルの構築と学習
mlp_digits = MLPClassifier(
hidden_layer_sizes=(128, 64),
activation='relu',
solver='adam',
max_iter=500,
random_state=42
)
mlp_digits.fit(X_train_scaled, y_train)
# 評価
y_pred = mlp_digits.predict(X_test_scaled)
print(f"\n正解率: {accuracy_score(y_test, y_pred):.4f}")
# 混同行列
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
xticklabels=digits.target_names, yticklabels=digits.target_names)
plt.xlabel("予測ラベル")
plt.ylabel("正解ラベル")
plt.title(f"混同行列（正解率: {accuracy_score(y_test, y_pred):.4f}）")
plt.tight_layout()
plt.show()
ハイパーパラメータの調整
from sklearn.model_selection import GridSearchCV
# グリッドサーチでパラメータ最適化
param_grid = {
'hidden_layer_sizes': [(50,), (100,), (50, 30), (100, 50)],
'activation': ['relu', 'tanh'],
'alpha': [0.0001, 0.001, 0.01],
}
grid_search = GridSearchCV(
MLPClassifier(max_iter=500, random_state=42),
param_grid,
cv=3,
scoring='accuracy',
n_jobs=-1,
verbose=0
)
grid_search.fit(X_train_scaled, y_train)
print(f"=== グリッドサーチ結果 ===")
print(f"最適パラメータ: {grid_search.best_params_}")
print(f"最高スコア（CV）: {grid_search.best_score_:.4f}")
print(f"テストスコア: {grid_search.score(X_test_scaled, y_test):.4f}")
8. 学習の終了条件
ニューラルネットワークの学習は、以下の条件で終了します。
| パラメータ | 意味 |
|---|---|
| max_iter | 最大エポック数を超えた場合に終了 |
| tol | 損失関数の改善量がこの値を下回るエポックが連続した場合に収束と判断 |
# 学習の終了条件の例
mlp = MLPClassifier(
hidden_layer_sizes=(100,),
max_iter=10000, # 最大10000エポック
tol=0.00001, # 損失の改善が0.00001未満が続いたら収束
random_state=42
)
mlp.fit(X_train_scaled, y_train)
print(f"実際のエポック数: {mlp.n_iter_}")
print(f"最終損失: {mlp.loss_:.6f}")
if mlp.n_iter_ < 10000:
print("→ tolの条件で収束して学習終了")
else:
print("→ max_iterに達して学習終了（収束していない可能性あり）")
まとめ
本記事では、ニューラルネットワークの基礎として以下の内容を解説しました。
| 項目 | ポイント |
|---|---|
| パーセプトロン | 入力の重み付き和と閾値で2値分類。線形分離のみ対応 |
| 多層パーセプトロン | 層を重ねて非線形パターンを学習。ディープラーニングの基盤 |
| 活性化関数 | 非線形性を導入。ReLUが中間層の標準、Softmaxが多クラス出力 |
| 損失関数 | 予測と正解の誤差を数値化。回帰→MSE、分類→交差エントロピー |
| 最適化手法 | 重みの更新方法。Adamが最も汎用的 |
| 誤差逆伝搬法 | 誤差を逆方向に伝搬して全層の重みを更新 |
| scikit-learn実装 | MLPClassifierで手軽に実装可能 |
ニューラルネットワーク実装のチェックリスト
- データの前処理（スケーリング）を行ったか
- 適切な中間層の構成（層数、ニューロン数）を設定したか
- 活性化関数を適切に選択したか
- 最適化手法と学習率を設定したか
- 学習曲線で収束を確認したか
- 過学習していないか確認したか（学習/テストの精度差）
- ハイパーパラメータの調整を行ったか