ゼロから二値分類ニューラルネットワークを書く

行列乗算、ReLU/Sigmoid 活性化、クロスエントロピー損失、バックプロパゲーションを総合的に使用——すべての知識ポイントを一度に結びつける。

このケースを学び終えると、以下のことが理解できます:ニューラルネットワークトレーニングの完全な数学的ループ——行列変換でデータを処理し、活性化で非線形性を導入し、クロスエントロピーで良し悪しを測定し、バックプロパゲーションで勾配を伝播する。


生活からの導入

2種類の果物を区別する——サイズを見るだけでは不十分

リンゴとオレンジが混ざっている。サイズだけでは不十分——小さなリンゴは大きなオレンジとほぼ同じ大きさのものもある。2つの次元(サイズ + 色)が必要であり、「直線ではない」境界線も必要——これがニューラルネットワークの出番だ。単層の線形モデルは直線しか描けないが、隠れ層と非線形活性化関数を追加することで、曲線の境界を描くことができる。


直感的な理解

入力(2)
隠れ層(8)+ReLU
出力(1)+Sigmoid
確率 0〜1

各コンポーネントに対応する数学モジュール:

行列乗算線形代数
ReLU/Sigmoid微分可能関数
クロスエントロピー情報理論
連鎖律微積分
勾配降下法最適化

数学的定義

\[ z_1 = X W_1 + b_1,\ a_1 = \text{ReLU}(z_1),\quad z_2 = a_1 W_2 + b_2,\ a_2 = \sigma(z_2) \]

Sigmoid + クロスエントロピーの勾配は自動的に最も簡潔な形式に簡約される:\(\frac{\partial L}{\partial z_2} = a_2 - y\)


Python で実践

実例

import numpy as np
np.random.seed(42)

def sigmoid(z):
    return 1 / (1 + np.exp(-np.clip(z, -500, 500)))

def relu(z): return np.maximum(0, z)
def relu_derivative(z): return (z > 0).astype(float)


class TwoLayerNN:
    def __init__(self, n_input, n_hidden, lr=0.1):
        self.W1 = np.random.randn(n_input, n_hidden) * 0.5
        self.b1 = np.zeros(n_hidden)
        self.W2 = np.random.randn(n_hidden, 1) * 0.5
        self.b2 = np.zeros(1)
        self.lr = lr
        self.loss_history = []

    def forward(self, X):
        self.z1 = X @ self.W1 + self.b1
        self.a1 = relu(self.z1)
        self.z2 = self.a1 @ self.W2 + self.b2
        self.a2 = sigmoid(self.z2)
        return self.a2

    def compute_loss(self, y_pred, y_true, eps=1e-9):
        y_pred = np.clip(y_pred, eps, 1 - eps)
        return -np.mean(y_true * np.log(y_pred) +
                        (1 - y_true) * np.log(1 - y_pred))

    def backward(self, X, y_true):
        n = X.shape[0]
        y_true = y_true.reshape(-1, 1)
        dz2 = (self.a2 - y_true) / n          # Sigmoid+CE の簡約
        dW2 = self.a1.T @ dz2
        db2 = np.sum(dz2, axis=0)
        da1 = dz2 @ self.W2.T                 # 連鎖律による逆伝播
        dz1 = da1 * relu_derivative(self.z1)
        dW1 = X.T @ dz1
        db1 = np.sum(dz1, axis=0)
        self.W2 -= self.lr * dW2
        self.b2 -= self.lr * db2
        self.W1 -= self.lr * dW1
        self.b1 -= self.lr * db1

    def fit(self, X, y, epochs=1000):
        for epoch in range(epochs):
            y_pred = self.forward(X)
            loss = self.compute_loss(y_pred, y)
            self.loss_history.append(loss)
            self.backward(X, y)
            if epoch % 200 == 0:
                acc = np.mean((y_pred.flatten() > 0.5) == y)
                print(f"サンプル epoch {epoch:4d}  loss={loss:.4f}  acc={acc:.3f}")

    def predict(self, X):
        return (self.forward(X).flatten() > 0.5).astype(int)


# 同心円データ(非線形分離可能)
n = 300
theta = np.random.uniform(0, 2 * np.pi, n)
r_inner = np.random.normal(1.0, 0.15, n // 2)
r_outer = np.random.normal(2.5, 0.15, n // 2)
X = np.vstack([
    np.c_[r_inner * np.cos(theta[:n//2]), r_inner * np.sin(theta[:n//2])],
    np.c_[r_outer * np.cos(theta[n//2:]), r_outer * np.sin(theta[n//2:])],
])
y = np.array([0] * (n // 2) + [1] * (n // 2))

model = TwoLayerNN(n_input=2, n_hidden=8, lr=0.5)
model.fit(X, y, epochs=1000)
print(f"\nサンプル 最終精度: {np.mean(model.predict(X) == y):.2%}")
print(f"損失: {model.loss_history)
サンプル epoch    0  loss=0.6932  acc=0.497
サンプル epoch  200  loss=0.1494  acc=0.930
サンプル epoch  400  loss=0.0615  acc=0.967
サンプル epoch  600  loss=0.0272  acc=0.990
サンプル epoch  800  loss=0.0134  acc=1.000
サンプル epoch 1000  loss=0.0075  acc=1.000

サンプル 最终准确率: 100.00%
损失: 0.6932 -> 0.0075

AI での応用シーン

シーン本ケースとの関係
画像分類CNN = 本ケースの行列乗算を畳み込み演算に置き換えたもの
テキスト分類BERT ファインチューニング = 本ケース + Transformer エンコーダー
異常検知0〜1 の異常確率を出力——これは本ケースの二値分類の特殊ケース
その他の拡張