3層ニューラルネットワークを理解する

# はじめに
AIや機械学習に興味を持ち始めた頃、線形代数の知識やpython独特の記法やライブラリを使った解説ではいまいち腹落ちしなかった記憶があります。
本記事では**線形代数の知識が無い方、python初心者**向けになるべく平易に3層ニューラルネットワークの実現方法を解説したつもりです。

::: note
私も**機械学習は勉強中&pythonは[progate](https://prog-8.com)のみで実務経験なし**なので、至らない点がございましたらお気軽に編集リクエスト頂けますと幸いです。
:::

# 3層ニューラルネットワークのアイデア
脳の中には**ニューロン**と呼ばれる細胞が無数にあり、ニューロンどうしはお互いに**シナプス**によってつながり合って巨大なネットワークを作っています。

外界からの刺激を受けて、ニューロンは電気刺激を他のニューロンに伝えます。受け取ったニューロンは、その刺激がある閾値を超えると発火してさらに次のニューロンに刺激を伝えます。この連続で、ニューラルネットワークは複雑な情報処理を行っています。

![68747470733a2f2f71696974612d696d6167652d73746f72652e73332e61702d6e6f727468656173742d312e616d617a6f6e6177732e636f6d2f302f323838353431392f33353466623839382d666363322d343430322d333864652d3432623236336436373866362e706e67-2.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2885419/da07cc92-3909-3ebc-844f-6045184a8e2a.png)

ニューロンは、電気刺激の入力を受け取る樹状突起、出力を他のニューロンに伝えるシナプス、刺激を伝送する軸索から構成されます。ニューロンに伝わる電気刺激の合計が閾値を超えた場合は後続のニューロンに電気刺激を伝達します。出力する刺激の強さは入力値にかかわらずほぼ一定となります。このことを**全か無かの法則**と呼びます。

![スクリーンショット 2024-06-16 15.43.01.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2885419/a76c2bb9-ecea-c1bc-908d-5a2cbd9ef03c.png)


米国の心理学者[Frank Rosenblatt](https://ja.wikipedia.org/wiki/フランク・ローゼンブラット)がこの仕組みを数理モデル化して、**単純パーセプトロン**と呼ばれるシンプルなニューラルネットワークを考案しました。
単純パーセプトロンは、一つのニューロンを数式で模したもので、下記の数式で表されます。
$$ y = \sum_{ i=1 }^{ n } x_i w_i $$

```math
f(y) = \left\{
\begin{array}{ll}
1 & (y \gt \theta) \\
0 & (y \leq \theta)
\end{array}
\right.
```

各入力$x_i$の値に、それぞれの樹状突起の太さに見立てた$w_i$を掛けた値が閾値$\theta$を超えると1が出力され、超えないと0が出力されます。

その後、単純パーセプトロンを組み合わせた形の3層構造を持つニューラルネットワークが考案されました。

![スクリーンショット 2024-06-16 12.52.59.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2885419/8c272493-9438-2566-5e67-00074e1d7880.png)

単純パーセプトロンは簡単な問題しか解けないことが判明していますが、<font color=red>3層構造を持つニューラルネットワークは任意の連続関数を近似できることが証明されています。</font>

> 普遍近似定理 (Cybenko (1989)など)
ニューラルネットワークは、⼗分な数のパラメタがあれば、連続関数を任意の精度で近似できる。

普遍性定理について詳しく知りたい方は下記の記事で詳しく解説されているので読んでみてください。

https://qiita.com/mochimochidog/items/ca04bf3df7071041561a

# まずは2層のニューラルネットから
3層ニューラルネットワークから隠れ層(2層目)を取り除いた形のモデルです。3層ニューラルネットワークよりシンプルで理解がしやすいため、まずは2層のニューラルネットモデルを理解していきます。

下記の図のような構成のモデルです。

![スクリーンショット 2024-06-10 8.18.22.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2885419/5d9f4ce4-8993-ace1-4e9c-7dd0d0ce5886.png)

## 数式の理解
### 1. 入力値と重みの積の合計uを求める
```math
u = \sum_{i=0}^{n} x_iw_i \quad \cdots \quad 全てのiに対して入力x_iと重みw_iをかけたものを足す
```
通常、Xは入力データの次元数より一つ多い次元数で用意しておき、余った一つには1を設定します。これにより、ニューラルネットのバイアス（入力データに依存しないパラメータ）を作成することが出来ます。

```math
u = x_0w_0 + x_1w_1 + x_2w_2 \quad \cdots \quad 上記の図に合わせて書くとこんな感じ
```

### 2. uを活性化関数f(u)に入れる
```math
yp = f(u) \quad \cdots \quad 得られたypは入力がx_0...x_nだった時の予測される出力
```

活性化関数と呼ばれる非線形な関数を使うことで、モデルの表現力を上げることが出来ます。

### 3. 教師データytとypの二乗誤差Lを計算する
```math
L = \frac{1}{2} (yp - yt)^2 \quad \cdots \quad ypとytの差を二乗して2で割った値を二乗誤差Lとする
```
モデルによる予測値ypと真の値ytが近ければLは小さくなる。2乗しているため、Lの最小値は0になる。
一般的なニューラルネットワークモデルでは、この二乗誤差を小さくしていくことでだんだんとypをytに近づけていく。

https://qiita.com/kz-halfmoon/items/db337fa2077fe3b5d53b

### 4. 二乗誤差Lを各ニューロンの重みwで微分する
```math
\displaylines{
\frac{\partial L}{\partial w_i} =
\frac{\partial L}{\partial yp} \cdot \frac{\partial yp}{\partial w_i} \\
= \frac{\partial L}{\partial yp} \cdot \frac{\partial yp}{\partial w_i} \\
= (yp - yt) \cdot x_i \cdot f^{\prime}(u)
}
```
::: note
#### 勾配降下法
$y = f(x)$がある$x$で極小値を取るとします。
$f(x)$を$x=a$の点で微分した$f^{\prime}(a)$が正の場合、$f(x)$は点$a$で正の傾き(右肩上がりの傾き)を持つことになります。
ということは、$a$を少し左に移動したとき$f(a - dx)$は$f(a)$より少し小さい値になります。これを繰り返すことで$f(x)$が極小値を取るときの$x$を得ることが出来ます。
:::

二乗誤差Lを極小化したいので、Lに勾配降下法を適用します。
Lはn個の$w_i$をパラメータとする関数なので、Lをi番目の$w_i$のみをパラメータとする関数と考え、その他のwを定数と考えるとLを$w_i$で微分できます。この考え方を、偏微分といいます。

### 5. wを更新する
```math
w_i = w_i - \alpha * \frac{\partial L}{\partial w_i}
```

前述の勾配降下法に従って$w_i$を更新します。$\alpha$は**学習率**と呼ばれる値で、一回の学習で修正される量を決定しています。$\alpha$は大きすぎると正確な結果を得るのが難しくなり、小さすぎると学習完了までにかかる時間が増えていきます。
手順1~5を繰り返し、二乗誤差が一定の値以下になるか、あらかじめ決めておいたステップ数繰り返した後手順を終了します。

# 2層のニューラルネットワークの実装

行列積やライブラリを使うともっとシンプルに実装できますが、理解を妨げないためになるべく数式そのままに実装しています。

```python
import numpy as np
from matplotlib import pyplot

# 活性化関数(シグモイド関数)
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 活性化関数の微分
def sigmoid_derivative(x):
    return (1 - sigmoid(x))*sigmoid(x)

# 学習ステップ数
STEP = 1000
# 学習率
alpha = 0.5

# 入力データ
data = [
    [0, 0],
    [1, 0],
    [0, 1],
    [1, 1],
]

# 教師データ(ANDゲート)
yt = [0, 0, 0, 1]

# 入力データ末尾にダミー変数を追加
x = np.insert(data, 2, 1, axis=1)

# ニューロンの重みをランダムに初期化
w1 = np.random.rand(3)

# 各ステップごとの二乗誤差を格納する配列
L = np.zeros(STEP)

# 学習
for step in range(STEP):
    # 各入力データに対してループ
    for k in range(4):
        u = 0.0

        # 入力値と重みの積の合計uを求める
        for i in range(3):
            u += x[k][i]*w1[i]

        # uを活性化関数f(u)に入れる
        yp = sigmoid(u)

        # 各ステップごとの二乗誤差を格納
        L[step] += ((yp - yt[k])**2)/2
        
        # 二乗誤差Lを各ニューロンの重みwで微分し、wを更新する
        for i in range(3):
            w1[i] -= alpha * (yp - yt[k]) * sigmoid_derivative(u) * x[k][i]

# 学習結果の確認
for k in range(4):
    u = 0.0
    for i in range(3):
        u += x[k][i]*w1[i]

    yp = sigmoid(u)
    print(f'入力: {data[k]}, 予測値: {yp:.2f}, 真の値: {yt[k]}')

# STEPごとの誤差の出力
pyplot.plot(L)
pyplot.show()
```

### 実行結果
```
入力: [0, 0], 予測値: 0.00, 真の値: 0
入力: [1, 0], 予測値: 0.08, 真の値: 0
入力: [0, 1], 予測値: 0.08, 真の値: 0
入力: [1, 1], 予測値: 0.90, 真の値: 1
```
入力データに合わせた予測値が出力できています。

x1, x2を0から1まで変化させた時のypを3Dグラフにしてみると下の図のようになります。

<details><summary>3Dグラフを描画するコード<font color=red>（折りたたまれています）</font></summary>

```python
from matplotlib import pyplot as plt

def predict(x1, x2):
    print(x1)
    u = x1*w1[0] + x2*w1[0] + w1[2]
    return sigmoid(u)

# Figureと3DAxeS
fig = plt.figure()
ax = fig.add_subplot(111, projection="3d")

# (x,y)データを作成
x = np.linspace(0, 1, 50)
y = np.linspace(0, 1, 50)

# 格子点を作成
X, Y = np.meshgrid(x, y)

# 各x1,x2に対応するypの計算
Z = predict(X, Y)

# 曲面を描画
ax.plot_surface(X, Y, Z, cmap = "summer")

# 軸ラベルを設定
ax.set_xlabel('x1')
ax.set_ylabel('x2')
ax.set_zlabel('yp')

plt.title('3D Plot of Neural Network Output')
plt.show()
```

</details>


![スクリーンショット 2024-06-12 0.08.07.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2885419/ef81ed69-59c3-aba5-5118-31726db05061.png)

# 3層ニューラルネットワーク

2層のニューラルネットワークの入力層と出力層の間に、隠れ層と呼ばれる層を一層追加したモデルです。

![スクリーンショット 2024-06-13 0.00.10.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2885419/114cd9e4-1d37-9f56-9aec-0c885126a487.png)

## 数式の理解
### 1. 入力値と重みの積の合計を求める
```math
u_j = \sum_{i=0}^{n} x_iw^{first}_{ij}
```
隠れ層のノードの内、j番目のノードの値は上記の式で決まります。$w^{first}_{ij}$は一層目と二層目の間の重みのうち、i番目の入力$x_i$とj番目の隠れ層$u_j$の間にあるものです。全ての隠れ層の値を上記の式で求めたら手順2に移ります。

### 2. uを活性化関数f(u)に入れる
```math
h_j = f(u_j)
```
### 3. hを入力にして二層目と三層目の間にある重みとの積の和を求める

```math
v = \sum_{j=0}^{m} h_jw^{second}_{j}
```
$w^{second}_{j}$は二層目と三層目の間の重みです。
### 4. vを活性化関数f(v)に入れる
```math
yp = f(v)
```
### 5. 教師データytとypの二乗誤差Lを計算する
```math
L = \frac{1}{2} (yp - yt)^2
```
### 6. 二乗誤差Lを各ニューロンの二層目と三層目の間の重みで微分する
```math
\displaylines{
\frac{\partial L}{\partial w^{second}_j} =
\frac{\partial L}{\partial yp} \cdot \frac{\partial yp}{\partial w^{second}_j} \\
= (yp - yt) \cdot x_i \cdot f^{\prime}(u)
}
```

### 7. 二乗誤差Lを各ニューロンの一層目と二層目の間の重みで微分する
```math
\displaylines{
\frac{\partial L}{\partial w^{first}_{ij}} =
\frac{\partial L}{\partial yp} \cdot \frac{\partial yp}{\partial w^{first}_{ij}} \\
= \frac{\partial L}{\partial yp} \cdot \frac{\partial yp}{\partial h_j} \cdot \frac{\partial h_j}{\partial w^{first}_{ij}}\\
= (yp - yt) \cdot f^{\prime}(v) \cdot w^{second}_j \cdot x_i \cdot f^{\prime}(u_j)
}
```

### 8. 全てのwを更新する
```math
w^{second}_j = w^{second}_j - \alpha * \frac{\partial L}{\partial w^{second}_j}
```

```math
w^{first}_{ij} = w^{first}_{ij} - \alpha * \frac{\partial L}{\partial w^{first}_{ij}}
```
# 3層のニューラルネットワークの実装
```python
import numpy as np
from matplotlib import pyplot as plt

STEP = 2000
alpha = 0.5
# 隠れ層の数
hidden_layers = 3

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    return (1 - sigmoid(x))*sigmoid(x)

data = [
    [0, 0],
    [1, 0],
    [0, 1],
    [1, 1],
]

yt = [0, 1, 1, 0]

x = np.insert(data, 2, 1, axis=1)
u = np.zeros(hidden_layers-1)
h = np.ones(hidden_layers)

# ニューロンの重みをランダムに初期化
w1 = np.random.rand(3, hidden_layers-1)
w2 = np.random.rand(hidden_layers)

L = np.zeros(STEP)

for step in range(STEP):
    for k in range(4):
        # 入力層→隠れ層
        for j in range(hidden_layers - 1):
            u[j] = 0.0
            for i in range(3):
                u[j] += x[k][i]*w1[i][j]
            h[j] = sigmoid(u[j])

        # 隠れ層→出力層
        v = 0.0
        for j in range(hidden_layers):
            v += h[j]*w2[j]
        y = sigmoid(v)

        L[step] += (y - yt[k])**2
        
        # 重みの更新
        delta_output = (y - yt[k]) * sigmoid_derivative(v)
        for j in range(hidden_layers):
            w2[j] -= alpha * delta_output * h[j]
        for j in range(hidden_layers-1):
            delta_hidden = delta_output * w2[j] * sigmoid_derivative(u[j])
            for i in range(3):
                w1[i][j] -= alpha * delta_hidden * x[k][i]

# 学習結果の確認
for k in range(4):
    for j in range(hidden_layers - 1):
        u[j] = 0.0
        for i in range(3):
            u[j] += x[k][i]*w1[i][j]
        h[j] = sigmoid(u[j])

    v = 0.0
    for j in range(hidden_layers):
        v += h[j]*w2[j]
    yp = sigmoid(v)
    
    print(f'入力: {data[k]}, 予測値: {yp:.2f}, 真の値: {yt[k]}')

# STEPごとの誤差の出力
plt.plot(L)
plt.show()
```
### 実行結果

入力データに合わせた予測値が出力できています。

```
入力: [0, 0], 予測値: 0.08, 真の値: 0
入力: [1, 0], 予測値: 0.92, 真の値: 1
入力: [0, 1], 予測値: 0.92, 真の値: 1
入力: [1, 1], 予測値: 0.07, 真の値: 0
```

x1, x2を0から1まで変化させた時のypを3Dグラフにしてみると下の図のようになります。

![スクリーンショット 2024-06-13 0.15.56.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2885419/4b17993e-ecde-1138-8d25-8d4a48558340.png)

# 参考文献

[赤石 雅典 著 『最短コースで分かる ディープラーニングの数学』 日経BP (2019/4/15)](https://www.amazon.co.jp/s?k=ディープラーニングの数学&i=stripbooks&adgrpid=128170672973&hvadid=679023192403&hvdev=c&hvlocphy=1009308&hvnetw=g&hvqmt=e&hvrand=16429868216872480985&hvtargid=kwd-680568739356&hydadcr=27265_14738572&jp-ad-ap=0&tag=googhydr-22&ref=pd_sl_q5ks7p26e_e)

https://qiita.com/masatomix/items/42b322a8db61e5b4d65f

https://www.ccs1981.jp/blog/neural-network-389/

https://www.gifu-nct.ac.jp/elec/deguchi/sotsuron/makino/node4.html#:~:text=ニューロン（neuron）とは、,あるといわれている%E3%80%82