【ディープラーニング入門（第5回）】勾配降下法を学んでディープラーニングの学習について理解しよう

# 本連載記事の概要

本連載記事では、全5回でDeepLearning(深層学習)をゼロから実装し、学ぶことを目的としています。

「深層学習」はなんとなく知っているけど使えない方、Pythonで動かせるけど中身がブラックボックスになっていて理解できていない方が、実際の実装を通してプログラムがどういう仕組みで動いているか理解でき、使いこなせるようになることを目指します。

# 連載記事目次
第1回：[入力層・中間層](https://qiita.com/kwi0303/items/e494eeddac4998df2d03)
第2回：[活性化関数](https://qiita.com/kwi0303/items/4fcab8161657ee1550b1)
第3回：[出力層](https://qiita.com/kwi0303/items/d93d8a11d67a6b66563f)
第4回：[勾配降下法](https://qiita.com/kwi0303/items/7bfd7180f80a52296e64)
第5回：誤差逆伝播法（本記事）

# 目次
[1. 誤差勾配の計算](#1-誤差勾配の計算)
[2. 連鎖率](#2-連鎖率)
[3. 誤差逆伝播法](#3-誤差逆伝播法)
[4. Pythonによる実装](#4-Pythonによる実装)
[5. おわりに](#5-おわりに)

#1. 誤差勾配の計算

ディープラーニングでは、誤差関数（E）を最小化するパラメータ（w）を求めて、精度のよい予測モデルを得ることが最終的な目的で、この誤差関数を最小化するパラメータを求めるためには勾配降下法を用いることが有効であることを[第4回](https://qiita.com/kwi0303/items/7bfd7180f80a52296e64)で学びました。

```math
w^{(t+1)}=w^{(t)}-\eta\nabla E\\
```

勾配降下法の式は上記の通りで、誤差関数Eの微分値（∇E）に学習率（η）をかけて重み（w）更新していけば求められることがわかります。ここで、2層のニューラルネットワークの例を考えてみましょう。（※重みを持つ層が2層なので2層ニューラルネットワークと呼んでいます。）

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/063e91ab-e7e9-74cc-0fcc-9ea452e78771.png)

前述したとおり今回最適化したいパラメータは、重み（w）になるので誤差関数(E)のwの偏微分（∂E/∂w）を求めればいいわけですね。2層の重みをもつ場合は、

```math
\nabla E=\frac{\partial E}{\partial \boldsymbol{W}}=\frac{\partial E}{\partial {W^{(1)}}}_,\frac{\partial E}{\partial {W^{(2)}}}
```

の2つの偏微分値を求めてパラメータの最適化を行えばよいわけです。そこで偏微分値を求めていきたいのですが、まずは第1回～3回で学んだように順伝播を模式的に書いてみましょう。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/55f468de-9a6b-594c-4000-573e7579b640.png)

誤差関数Eはyの関数で、yはu(2)の関数で、・・・といった構造になっています。最終的に得られたEはyの関数なのでyで偏微分すると、

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/6e7bcabd-eba7-873d-672c-6224a927b0dd.png)

となり、これだけでは所望の勾配が求められていないことが分かります。そこで活躍するのが誤差逆伝播法です。

#2. 連鎖率

誤差逆伝播法をみていく前に、誤差逆伝播法の基本原理である連鎖率を学んでいきましょう。理解をしやすくするため、次に示すような簡単な関数で説明します。

```math
z=(x+y)^2
```

この関数zは、以下のような合成関数と捉えることができます。

```math
z=t^2\\
t=(x+y)^2
```

## 計算グラフの導入

以降、誤差逆伝播法で勾配を求めるにあたり、計算グラフを導入します。

<参考になる解説記事>
・[計算グラフ](https://qiita.com/edo_m18/items/7c95593ed5844b5a0c3b)

計算グラフでは、ノードに演算の内容を記述し入出力を矢印で表します。

##2.1. 合成関数の計算グラフ標記

前節で導入した計算グラフを導入し、合成関数を表してみます。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/5837c14e-47f1-162d-c548-e852e57131dc.png)

できました。それではこの計算グラフを用いて連鎖率を見ていきましょう。

##2.2. 合成関数の微分

連鎖率とは合成関数の微分についての性質で、次のように定義されます。

>微分法において連鎖律（れんさりつ、英: chain rule）とは、複数の関数が合成された合成関数を微分するとき、その導関数がそれぞれの導関数の積で与えられるという関係式のこと。（※[wikipedia](https://ja.wikipedia.org/wiki/%E9%80%A3%E9%8E%96%E5%BE%8B)より引用）

言葉だけで書かれていると分かりづらいですね。式と計算グラフで確認してみます。

```math
\frac{\partial z}{\partial x}=\frac{\partial z}{\partial t}\frac{\partial t}{\partial x}
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/da98e2d5-d4d0-beb0-8dda-b69e5a34d4a6.png)

合成関数の微分は、合成関数を構成するそれぞれの関数の微分の積で表すことができ、これを連鎖率の原理と呼びます。そのため、∂z/∂xは、

```math
\frac{\partial z}{\partial t}=2t\\
\frac{\partial t}{\partial x}=1\\
\frac{\partial z}{\partial x}=2t \cdot 1 = 2(x+y)
```

連鎖率を使って解くことができました。この連鎖率は、下記のように∂tが互いに打ち消し合っていることも感覚的に分かりやすいですね。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/814a60c1-e2fe-b390-7dd4-6dd0e859921f.png)

##2.3. ニューラルネットワークの計算グラフと連鎖率による微分

1章で示してきた2層ニューラルネットワークの合成関数を計算グラフで表していきます。活性化関数はまずはそのまま関数としておいています。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/18f0736c-be98-a55f-0472-63fa0dee5d41.png)

この計算グラフをもとに連鎖率を使って、合成関数の微分を解いていきます。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/790750b6-7b02-86f1-5c56-1c286cb9ec0b.png)

この連鎖率の計算グラフを解いていくと、所望の勾配（∂E/∂w）を求められていることが分かります。

```math
\frac{\partial E}{\partial {W^{(1)}}}_,\frac{\partial E}{\partial {W^{(2)}}}
```

以上より、順伝播で得られた誤差関数（E）から偏微分を解き、順伝播とは逆向きに流していくことで、勾配降下法に用いる勾配が得られることが分かりました。これを誤差逆伝播法と言います。この誤差逆伝播法を用いることで、数値微分（関数に微小な変化を与えて傾きを調べる方法）をしなくてもよくなり、計算が高速に実行できるようになります。

#3. 誤差逆伝播法の計算

誤差逆伝播法を用いて勾配が得られることが理解できたので、実際の計算に移っていきたいと思います。連鎖率の原理を使って合成関数の微分は、各ノードにおける微分の積で得られるので、ノード毎に確認をしていきます。

##3.1. 入力層～中間層の逆伝播(Affineレイヤ)

ニューラルネットワークで行う行列の積は、幾何学の分野でアフィン変換と呼ばれます。そのためアフィン変換を行う処理をAffineレイヤという名前で実装していきます。

###3.1.1. 内積の逆伝播

ニューラルネットワークにおいて、一番初めに出てくる内積（dot）の逆伝播を見ていきます。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/91ee0a42-e3b6-f675-28bd-073e58b70d09.png)

理解のため、冒頭で示したニューラルネットワークと同様の形状を仮定してWを（3，2）形状、xを（2，1）形状とおくと、W・xは（3，1）形状になります。

```math
\boldsymbol{W}=\begin{bmatrix}
w_{11} & w_{12} \\
w_{21} & w_{22} \\
w_{31} & w_{32}
\end{bmatrix} \quad
\boldsymbol{x} =\begin{bmatrix}
x_1 \\
x_2
\end{bmatrix}\\

\boldsymbol{u} = \boldsymbol{W} \boldsymbol{x} =
\begin{bmatrix}
w_{11} & w_{12} \\
w_{21} & w_{22} \\
w_{31} & w_{32}
\end{bmatrix} \cdot
\begin{bmatrix}
x_1 \\
x_2
\end{bmatrix} =
\begin{bmatrix}
w_{11}x_1 + w_{12}x_2\\
w_{21}x_1 + w_{22}x_2\\
w_{31}x_1 + w_{32}x_2
\end{bmatrix}
```

計算グラフに連鎖率の流れと、行列形状を書き加えています。ここで、出力を流れてくる偏微分値（∂L/∂u）の形状は、行列u（3，1）の偏微分値であるため、uと同様の（3，1）になります。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/a4c386f1-fc66-e8ce-a33b-727592866643.png)

この計算グラフの通り最終的には∂L/∂x、∂L/∂Wを得たいのですが、連鎖率の原理が適用できるのでまずは∂u/∂x、∂u/∂Wを求めていきます。

```math
\begin{align}
\frac{\partial \boldsymbol{u}}{\partial \boldsymbol{x}}
&=\frac{\partial}{\partial \boldsymbol{x}}\begin{bmatrix}
w_{11}x_1 + w_{12}x_2\\
w_{21}x_1 + w_{22}x_2\\
w_{31}x_1 + w_{32}x_2
\end{bmatrix}\\
&=\begin{bmatrix}
\frac{\partial}{\partial x_1}
\begin{bmatrix}
w_{11}x_1 + w_{12}x_2\\
w_{21}x_1 + w_{22}x_2\\
w_{31}x_1 + w_{32}x_2
\end{bmatrix}\\
\frac{\partial}{\partial x_2}
\begin{bmatrix}
w_{11}x_1 + w_{12}x_2\\
w_{21}x_1 + w_{22}x_2\\
w_{31}x_1 + w_{32}x_2
\end{bmatrix}\\
\end{bmatrix}\\
&=\begin{bmatrix}
w_{11}&w_{21}&w_{31}\\
w_{12}&w_{22}&w_{32}
\end{bmatrix}
=\boldsymbol{W} ^\top\
\end{align}
```

```math
\begin{align}
\frac{\partial \boldsymbol{u}}{\partial \boldsymbol{W}}
&=\frac{\partial}{\partial \boldsymbol{W}}
\begin{bmatrix}
w_{11}x_1 + w_{12}x_2\\
w_{21}x_1 + w_{22}x_2\\
w_{31}x_1 + w_{32}x_2
\end{bmatrix}\\
&=\begin{bmatrix}
\frac{\partial}{\partial w_{11}}
\begin{bmatrix}
w_{11}x_1 + w_{12}x_2\\
w_{21}x_1 + w_{22}x_2\\
w_{31}x_1 + w_{32}x_2
\end{bmatrix} &
\frac{\partial}{\partial w_{12}}
\begin{bmatrix}
w_{11}x_1 + w_{12}x_2\\
w_{21}x_1 + w_{22}x_2\\
w_{31}x_1 + w_{32}x_2
\end{bmatrix}\\
\frac{\partial}{\partial w_{21}}
\begin{bmatrix}
w_{11}x_1 + w_{12}x_2\\
w_{21}x_1 + w_{22}x_2\\
w_{31}x_1 + w_{32}x_2
\end{bmatrix} &
\frac{\partial}{\partial w_{22}}
\begin{bmatrix}
w_{11}x_1 + w_{12}x_2\\
w_{21}x_1 + w_{22}x_2\\
w_{31}x_1 + w_{32}x_2
\end{bmatrix}\\
\frac{\partial}{\partial w_{31}}
\begin{bmatrix}
w_{11}x_1 + w_{12}x_2\\
w_{21}x_1 + w_{22}x_2\\
w_{31}x_1 + w_{32}x_2
\end{bmatrix} &
\frac{\partial}{\partial w_{32}}
\begin{bmatrix}
w_{11}x_1 + w_{12}x_2\\
w_{21}x_1 + w_{22}x_2\\
w_{31}x_1 + w_{32}x_2
\end{bmatrix}
\end{bmatrix}\\
&=\begin{bmatrix}
x_1 & x_2
\end{bmatrix}
=\boldsymbol{x} ^\top\
\end{align}
```

ここで、得られた∂u/∂x、∂u/∂Wの形状を考えると、∂u/∂xはWの転値になるので（2，3）、∂u/∂Wはxの転値になるので（1，2）になることがわかります。計算グラフで確認してみましょう。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/07672325-40a6-0ff0-15c3-f318f00e9146.png)

得られた偏微分値を連鎖率に代入するときには、行列の掛け算の決まりごとに注意をしなければなりません。

>A が n × m 行列で、B が m × p 行列ならば、それらの行列の積 AB が n × p 行列として与えられ、その成分は A の各行の m 個の成分がそれぞれ順番に B の各列の m 個の成分と掛け合わされる形で与えられる
>[Wikipedia](https://ja.wikipedia.org/wiki/%E8%A1%8C%E5%88%97%E3%81%AE%E4%B9%97%E6%B3%95)より引用

この引用文から、前からかける行列の列（A）と後ろの行列（B）の行が一致していないといけませんでした。この基本原理に基づいて、連鎖率に解いた偏微分値を代入すると、

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/99159d50-d463-18a0-e052-7c1cd17f0b5f.png)

となります。式が色々あって分かりづらいので、最終的な結果だけを以下に示します。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/67c46004-6db9-5dc0-6ca5-d67ffba67fa8.png)

以上で内積の偏微分値が得られました。

###3.1.2. 加算の逆伝播

加算の式を単純化して計算グラフで連鎖率を表してみます。z=x+yのような簡単な関数を考えると分かりますが、加算ノードは流れてきた微分値をそのまま流すだけになります。

```math
\frac{\partial z}{\partial x}=\frac{\partial (x+y)}{\partial x}=1\\
\frac{\partial z}{\partial y}=\frac{\partial (x+y)}{\partial y}=1
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/cd70d430-8867-8384-e96f-d4fbea3c686e.png)

ここでニューラルネットの入力層～中間層に置き換えて考えてみます。活性化関数に入れる前の出力（u）は、入力（x）と重み（w）の内積に、バイアス（b）を加えた以下の構造になっています。それでは計算グラフにしてみましょう。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/eb55444a-bde2-7612-dbdb-c27540b7c4ae.png)

以上で、入力層～中間層の逆伝播を理解することができました。

##3.2. 中間層の活性化関数の逆伝播

###3.2.1. Sigmoid関数の逆伝播（Sigmoidレイヤ）

引き続いてSigmoid関数の逆伝播を考えていきます。Sigmoid関数は以下の式で表されます。

```math
h(x)=\frac{1}{1+\exp(-a)} \
```

これを計算グラフで表してみましょう。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/56ca9d6f-e0ad-5bfc-4989-10a478a1711f.png)

少し長いですが、表すことができました。逆伝播を順に確認していきます。最初の除算ノードですが、単純化したものを確認すると理解しやすいです。

```math
y=\frac{1}{x}\\
```

```math
\begin{align}
\frac{\partial y}{\partial x}&=\frac{\partial}{\partial x} (\frac{1}{x})\\
&=-\frac{1}{x^2}\\
&=-y^2\\
\end{align}
```

これより、Sigmoid関数の計算グラフとしては

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/99a9661d-0837-8d35-1010-74e57ee91a44.png)

除算ノードの次は加算ノードですが、加算ノードはそのまま流すだけでした。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/dce49ed4-806e-b467-1f91-90ee6df897a5.png)

次は指数関数（exp）ノードですが、その微分は次の式で表されます。

```math
y=\exp(x)\\
```

```math
\frac{\partial y}{\partial x}=exp(x)
```

そのまま入力の指数関数を返します。そのためSigmoid関数の計算グラフは以下の通りです。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/a1aca771-2508-4e4b-4506-fa15b12b3ac3.png)

最後に乗算ノードです。乗算の微分を式で表すと、

```math
z=x×y\\
```

```math
\begin{align}
\frac{\partial z}{\partial x}&=\frac{\partial}{\partial x} (x×y)\\
&=y\\
\frac{\partial z}{\partial y}&=\frac{\partial}{\partial y} (x×y)\\
&=x\\
\end{align}
```

となります。この乗算の逆伝播は、ちょうど入力信号をひっくり返したようになります。そのため計算グラフは次の通りになります。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/1cba5420-e049-1031-5e2c-9ada4c13a28d.png)

以上でSigmoid関数の逆伝播が完了しました。出力の結果だけ確認すると、

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/53f32a76-499e-e4e1-538c-df637cbf7fd1.png)

となります。ここで、逆伝播で得られた式を変形していくと、

```math
\begin{align}
\frac{\partial L}{\partial u} z^2 exp(-u)
&=\frac{\partial L}{\partial u} \frac{1}{(1+exp(-u))^2} exp(-u) \\
&=\frac{\partial L}{\partial u} \frac{1}{1+exp(-u)} \frac{exp(-u)}{1+exp(-u)} \\
&=\frac{\partial L}{\partial u} z(1-z)
\end{align}
```

となり、Sigmoid関数の微分はSigmoid関数だけで表現できることがわかります。以上より、最終的には以下の形になります。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/247dd585-4bde-64d5-a96c-e0dc167b0e3b.png)

###3.2.2. ReLU関数の逆伝播（ReLUレイヤ）

活性化関数として使われるReLU（Rectified Linear Unit）は、次の式で表されました。

```math
y=\left\{
\begin{array}
xx & (x > 0) \\
0 & (x \leqq 0)
\end{array}
\right.
```

この式の微分は、

```math
\frac{\partial y}{\partial x}=\left\{
\begin{array}
x1 & (x > 0) \\
0 & (x \leqq 0)
\end{array}
\right.
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/8a8ced0f-43a9-52fc-14a2-8bbbadd14e1e.png)

3.3. 出力層の逆伝播(Softmax-with-Lossレイヤ)

最後に出力層であるソフトマックス関数と誤差関数をセットでついて説明していきます。

3.3.1. Softmax関数と交差エントロピー誤差の順伝播

Softmax関数は、次の式で表されます。（詳しくは、[第3回](https://qiita.com/kwi0303/items/d93d8a11d67a6b66563f)記事を参照してください。）

```math
y_k(u)=\frac{exp(u_k)}{\sum_{i=1}^{n}exp(u_i)} \
```

このSoftmax関数の順伝播の計算グラフを表します。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/08f3101a-1870-92b6-97d2-2e03a48e6fe2.png)

続いて、交差エントロピー誤差を式で表すと、

```math
y_k(u)=-\sum_{k} t_k\log y_k
```

であるため、計算グラフは

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/68109180-5390-0b41-3904-a0e4169a631d.png)

と表されます。これらをセットにして、逆伝播を見ていきましょう。

3.3.2. Softmax関数と交差エントロピー誤差の逆伝播

まずは交差エントロピー誤差の逆伝播からです。これまで学んできた乗算、加算ノードを使い、logの微分を下記の通りにすれば簡単に計算グラフを作成することができます。

```math
y = \log x\\
\frac{\partial y}{\partial x}=\frac{1}{x}
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/60a86e32-1e46-3e7b-5bef-7d239d3deca5.png)

続いてSoftmax関数の逆伝播を見ていきます。最初は交差エントロピー誤差から流れてきた値に、乗算ノードで順伝播の値をひっくり返して乗算します。（※一部記述を省略しています）

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/38f135ed-61d6-15fe-8245-380f6c971bb3.png)

ここで、この乗算ノードで得られた値をよくみると、

```math
\begin{align}
-\frac{t_1}{y_1} × \exp(a_1) &= -t_1 × \frac{S}{\exp (a_1)} × \exp(a_1)\\
&=-t_1S
\end{align}
```

となり、単純化されることがわかりますね。次のステップを確認してみます。除算ノードに-t1S、-t2S、-t3Sまで3つの値が流れるので、この和の微分値を逆伝播します。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/f1bdee45-4893-d51f-8734-8dad7d8930bf.png)

ここで、乗算ノードのため、

```math
y = \frac{1}{x}=x^{-1}\\
\begin{align}
\frac{\partial y}{\partial x}&=-x^{-2}\\
&=-\frac{1}{x^2}\\
\end{align}
```

```math
-(t_1+t_2+t_3)S×(-\frac{1}{S^2}) = \frac{t_1+t_2+t_3}{S}
```

となります。ここで、t1、t2、t3は教師データで、すべてを足すと1になりそれぞれが確率を意味する値でした。そのため、t1、t2、t3の合計は1になるため、逆伝播の値は以下のように簡単な形で表すことができます。

```math
\frac{t_1+t_2+t_3}{S} = \frac{1}{S}
```

次の加算ノードは、値をそのまま流すだけでした。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/ca3c85d6-a983-8187-ed83-a151d9a841d4.png)

それでは、個別の逆伝播の計算グラフに移ります。乗算ノードなので、ひっくりかえして値を流すと、ここも式を簡単にすることができます。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/528fbdc3-a827-c5c6-b0f9-5bd906022821.png)

最後に、expノードです。expノードに2つの逆伝播が流れてくるのでこれを足した値に、expノードの微分値をかけて求めることができます。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1529393/3b0ade38-d3a5-83da-9733-c1eb0fec5ddb.png)

```math
\begin{align}
(\frac{1}{S}-\frac{t_1}{exp(a_1)}) × exp(a_1) &= \frac{1}{S}\\
&=\frac{exp(a_1)}{S}-t_1\\
&=y_1-t_1
\end{align}
```

以上で、Softmax関数と交差エントロピー誤差の逆伝播を解くことができました。

#4. Pythonでの実装

それでは、ここまで学んできた逆伝播をPythonで実装していきます。2層ニューラルネットワーク（入力層2ノード、中間層3ノード、出力層2ノード）で、中間層の活性化関数はReLU、出力層の活性化関数はソフトマックス関数、誤差関数は交差エントロピー誤差を利用します。

```python
import numpy as np

# 行列をわかりやすく表示するための関数
def print_vec(text, vec):
  print("*** " + text + " ***")
  print(vec)
  #print("shape: " + str(x.shape))
  print("")

# 今回使用する活性化関数、誤差関数の関数を作成（別ファイルで作成して起き、importしてもOK）
# ReLU関数
def relu(x):
  return np.maximum(0, x)

# ソフトマックス関数
def softmax(x):
  if x.ndim == 2:
      x = x.T
      x = x - np.max(x, axis=0)
      y = np.exp(x) / np.sum(np.exp(x), axis=0)
      return y.T

  x = x - np.max(x) # オーバーフロー対策
  return np.exp(x) / np.sum(np.exp(x))

# クロスエントロピー
def cross_entropy_error(d, y):
  if y.ndim == 1:
      d = d.reshape(1, d.size)
      y = y.reshape(1, y.size)
      
  # 教師データがone-hot-vectorの場合、正解ラベルのインデックスに変換
  if d.size == y.size:
      d = d.argmax(axis=1)
            
  batch_size = y.shape[0]
  return -np.sum(np.log(y[np.arange(batch_size), d] + 1e-7)) / batch_size

# 逆伝播用
# ReLU関数の導関数
def d_relu(x):
  return np.where( x > 0, 1, 0)

# シグモイドとクロスエントロピーの複合導関数
def d_softmax_with_loss(t, y):
  return y - t

# ニューラルネットワークを作成する関数を定義
# ウェイトとバイアスを設定
def init_network():
  print("##### ネットワークの初期化 #####")

  network = {}
  network['W1'] = np.array([
      [0.1, 0.3, 0.5],
      [0.2, 0.4, 0.6]
  ])

  network['W2'] = np.array([
      [0.1, 0.4],
      [0.2, 0.5],
      [0.3, 0.6]
  ])

  network['b1'] = np.array([0.1, 0.2, 0.3])
  network['b2'] = np.array([0.1, 0.2])
  
  print_vec("重み1", network['W1'])
  print_vec("重み2", network['W2'])
  print_vec("バイアス1", network['b1'])
  print_vec("バイアス2", network['b2'])

  return network

# 順伝播
def forward(network, x):
  W1, W2 = network['W1'], network['W2']
  b1, b2 = network['b1'], network['b2']
  
  u1 = np.dot(x, W1) + b1
  z1 = relu(u1)
  u2 = np.dot(z1, W2) + b2
  y = softmax(u2)

  # 誤差の算出
  loss = cross_entropy_error(t, y)
  
  print_vec("総入力1", u1)
  print_vec("中間層出力1", z1)
  print_vec("総入力2", u2)
  print_vec("出力1", y)
  print("出力合計: " + str(np.sum(y)))
  print("誤差: " + str(loss))

  return y, z1

#  誤差逆伝播
def backward(x, d, z1, y):
  grad = {}

  W1, W2 = network['W1'], network['W2']
  b1, b2 = network['b1'], network['b2']
  #  出力層でのデルタ
  delta2 = d_softmax_with_loss(t, y)
  #  b2の勾配
  grad['b2'] = np.sum(delta2, axis=0)
  #  W2の勾配
  grad['W2'] = np.dot(z1.T, delta2)
  #  中間層でのデルタ
  delta1 = np.dot(delta2, W2.T) * d_relu(z1)
  # b1の勾配
  grad['b1'] = np.sum(delta1, axis=0)
  #  W1の勾配
  grad['W1'] = np.dot(x.T, delta1)

  return grad
```

少し長いですが、使用する各関数の定義、ニューラルネットワークの初期化、順伝播、逆伝播の関数を作成しました。

それでは実際に動かしていきます。まずは、入力と教師データを準備し、順伝播を流して学習前の誤差をみましょう。

```python
# 訓練データ
x = np.array([[5.0, 1.0]])
# 目標出力
t = np.array([[0, 1]])
#  学習率
learning_rate = 0.01
network =  init_network()
y, z1 = forward(network, x)

> ##### ネットワークの初期化 #####
  *** 重み1 ***
  [[0.1 0.3 0.5]
   [0.2 0.4 0.6]]

  *** 重み2 ***
  [[0.1 0.4]
   [0.2 0.5]
   [0.3 0.6]]

  *** バイアス1 ***
  [0.1 0.2 0.3]

  *** バイアス2 ***
  [0.1 0.2]

  *** 総入力1 ***
  [[0.8 2.1 3.4]]

  *** 中間層出力1 ***
  [[0.8 2.1 3.4]]

  *** 総入力2 ***
  [[1.62 3.61]]

  *** 出力1 ***
  [[0.12025686 0.87974314]]

  出力合計: 1.0
  誤差: 0.12812518961618194
```

求めることができました。出力を見ると分類ラベルはクラス1の確率が88%でクラス1を出力しているため結果は合っていますが、クラス0の確率が10%くらい残されていますね。これを誤差逆伝播を用いて学習させていきます。

```python
iters_num = 100 # 学習を100回更新する

for i in range(iters_num):
  grad = backward(x, t, z1, y)
  
  for key in ('W1', 'W2', 'b1', 'b2'):
    network[key]  -= learning_rate * grad[key]

print("##### 結果表示 #####")    
print("##### 更新後パラメータ #####") 
print_vec("重み1", network['W1'])
print_vec("重み2", network['W2'])
print_vec("バイアス1", network['b1'])
print_vec("バイアス2", network['b2'])

> ##### 結果表示 #####
  ##### 更新後パラメータ #####
  *** 重み1 ***
  [[0.33765368 0.6307148  0.92377592]
   [0.24753074 0.46614296 0.68475518]]

  *** 重み2 ***
  [[ 0.00379451  0.49620549]
   [-0.05253941  0.75253941]
   [-0.10887333  1.00887333]]

  *** バイアス1 ***
  [0.14753074 0.26614296 0.38475518]

  *** バイアス2 ***
  [-0.02025686  0.32025686]

# 学習モデルでの再計算
# 訓練データ
x = np.array([[1.0, 5.0]])
# 目標出力
t = np.array([[0, 1]])
# 順伝播と誤差の計算
y, z1 = forward(network, x)

> *** 総入力1 ***
  [[1.72283809 3.22757256 4.73230703]]

  *** 中間層出力1 ***
  [[1.72283809 3.22757256 4.73230703]]

  *** 総入力2 ***
  [[-0.69851633  8.3783125 ]]

  *** 出力1 ***
  [[1.14270386e-04 9.99885730e-01]]

  出力合計: 1.0
  誤差: 0.00011417690406179714
```

誤差がかなり小さくなりました。出力もクラス1の確率がほぼ100%ですね。以上で、順伝播から誤差逆伝播までの実装が完了しました。


#5. おわりに
本連載では、ニューラルネットワークの入力層から出力層で行われている計算と、誤差を小さくする誤差逆伝播法に触れながら、Pythonでの実装を行い実践的に身に着けて学びました。Pythonライブラリを使えばだれでも使えますが、中身を理解しながら使用するのと、理解せず使用するのでは、見方が大きく変わると思います。
今後も引き続き、ディープラーニング、機械学習に関する記事を書いていくので、参考にしてください。

# 連載記事目次
第1回：[入力層・中間層](https://qiita.com/kwi0303/items/e494eeddac4998df2d03)
第2回：[活性化関数](https://qiita.com/kwi0303/items/4fcab8161657ee1550b1)
第3回：[出力層](https://qiita.com/kwi0303/items/d93d8a11d67a6b66563f)
第4回：[勾配降下法](https://qiita.com/kwi0303/items/7bfd7180f80a52296e64)
第5回：誤差逆伝播法（本記事）

# 参考文献
この記事は以下の情報を参考にして執筆しました。
参考：[ゼロから作るDeepLearning](https://www.amazon.co.jp/%E3%82%BC%E3%83%AD%E3%81%8B%E3%82%89%E4%BD%9C%E3%82%8BDeep-Learning-%E2%80%95Python%E3%81%A7%E5%AD%A6%E3%81%B6%E3%83%87%E3%82%A3%E3%83%BC%E3%83%97%E3%83%A9%E3%83%BC%E3%83%8B%E3%83%B3%E3%82%B0%E3%81%AE%E7%90%86%E8%AB%96%E3%81%A8%E5%AE%9F%E8%A3%85-%E6%96%8E%E8%97%A4-%E5%BA%B7%E6%AF%85/dp/4873117585/ref=sr_1_1?__mk_ja_JP=%E3%82%AB%E3%82%BF%E3%82%AB%E3%83%8A&dchild=1&keywords=%E3%82%BC%E3%83%AD%E3%81%8B%E3%82%89%E4%BD%9C%E3%82%8B&qid=1622723947&sr=8-1), O'REILLY社