【機械学習】Go言語でゼロから多層パーセプトロン(MLP)を実装する

標準ライブラリのみでニューラルネットワーク、

今回は多層パーセプトロンを実装します。

最後に学習精度をグラフ化していますが、

そこは有志のライブラリを使用します。

今回はシンプルに

排他的論理和を学習させます。

学習データとラベルです。


//learning data + label
var patterns = [][][]float64{
	{{0, 0}, {0}},
	{{0, 1}, {1}},
	{{1, 0}, {1}},
	{{1, 1}, {0}},
}

//learning data + label

var patterns = [][][]float64{

{{0, 0}, {0}},

{{0, 1}, {1}},

{{1, 0}, {1}},

{{1, 1}, {0}},

}

それではLet's go!

1 多層パーセプトロンの概要
2 多層パーセプトロンをゼロから作る！
3 学習結果

多層パーセプトロンの概要

多層パーセプトロンの詳細は他サイトに任せて、

ここでは実装のことを考えて、

命名規則に沿って簡単に話していきます。

まず言葉の定義の基準として、

どの層にまつわる値かすぐにわかるように、

名前にin, hidden, outのいづれかを付けます。

〇〇Input: 入力層の何か
〇〇Hidden: 隠れ層の何か
〇〇Output: 出力層の何か

またそれぞれに対して以下を基にします。

val○○○：　各ノードの値
delta○○○：　各ノードの誤差
wei○○○：　重みの値
node○○○：　該当する層のノード数
lay○○○：　層の数(隠れ層のみ該当)

こんな感じです。


//Multi Layer Perceptron
type Mlp struct {
	layHidden                         int
	nodeInput, nodeHidden, nodeOutput int
	weiInput, weiOutput               [][]float64
	weiHidden                         [][][]float64
	valInput, valOutput               []float64
	valHidden                         [][]float64
	deltaInput, deltaOutput           []float64
	deltaHidden                       [][]float64
}

//Multi Layer Perceptron

type Mlp struct {

layHidden int

nodeInput, nodeHidden, nodeOutput int

weiInput, weiOutput [][]float64

weiHidden [][][]float64

valInput, valOutput []float64

valHidden [][]float64

deltaInput, deltaOutput []float64

deltaHidden [][]float64

}

画像に書き起こすとこんな風になっています。

今回の場合、隠れ層が１層のみなので、

weiHiddenは存在しません。

weiHiddenは隠れ層と隠れ層を結ぶ重みなので、

隠れ層が２層以上のときのみ存在します。

実装に入る前に少し、

多層パーセプトロンについて考えてみます。

なぜ多層になると非線形に分けられるのか？

単層＝線形分離のみ

多層＝非線形分離可能

について考えてみましょう。

そもそも線形分離とは、

線で出力値を区切ることですが、

それを何個に区分けるか、

ということは問ていません。

ここで単純パーセプトロンを

簡単に定義してみましょう。

z = func(1*x + 1*y)

funcは活性化関数です。

活性化関数の中に入るのは、

ノードの値と重みが線形結合された式です。

例えば、sigmoid関数を例に見てみましょう。

分かりやすくするためにxとyを式に入れています。

Sigmoid(x+y) = 1 / (1 + e^{-(x+y)})

Sigmoid関数の形自体は非線形で表されているのに、

なぜ単層パーセプトロンは、

線形分離しかできないのでしょうか？

後述しますがよくSigmoid関数が出てくるのは、

下画像のように出力を２値に、つまり

"ほぼ"一本線ではっきりと分けられるからです。

右上のグラフが先ほどの式をグラフ化したものです。

確かに形自体は非線形になっており、

単層＝線形分離が少し違和感を感じますよね。

では、ノードの値と重みを線形結合した式を

活性化関数に通す意味は何だったのでしょうか？

そうです。sigmoidの場合は0と1ですが、

活性化関数にある入力が来たら０を出力して、

ある入力が来たら１を出力するものでした。

つまり入力によって0か1を分けるのでした。

ここで↑画像中の右下グラフを見てみましょう。

これはsigmoid関数を上からみたグラフです。

なじみのある言葉で表現すると等高線です。

入力の組み合わせによって、標高が決まります。

標高、その高さが活性化関数の出力になります。

どうですか？線形になっていますでしょう？

真ん中斜めに走っている線が、

まさに０か１かを分ける線になります。

この線が少し広がっているのは、

sigmoid関数が少し滑らかになっているからです。

重みを大きくすると以下のように細くなり、

その変化も急峻になります。

また、重みのバランスを変えても、

０と１に分ける線の方向が変わります。

これが重みを調整する意義です。

ではsigmoid関数以外はどうでしょうか？

cosine、2次関数、ReLuについて見てみましょう。

活性化関数にcosineを使う事例は見かけないですが。。。

重みは１で計算してあります。

見てわかるように、

活性化関数に何を使用しようと、

線形分離の形になっていることが分かります。

但し活性化関数によってはcosineのように、

どの入力の組み合わせによって、

０なのか１なのか視覚的に分かりにくくなります。

加えてSigmoidのようにほぼ一本線でない場合、

n個の線によって０と１以外のグループが入ることで

区分けが細かくなっていきます。

また、ReLu関数のように活性化関数の値域が

０と１の範囲にないものもあります。

いずれにせよ、活性化したい入力が来たら正の値で、

逆は負の値（もしくは０）という２値が基本です。

よく説明でsigmoidの事例が出てくるのは、

綺麗に真っ二つに分けられるからですね。

それでは多層パーセプトロンになると、

グラフはどうなるのでしょうか。

隠れ層を１層追加してみましょう。

活性化関数はsigmoid関数で、

重みはグラフが分かりやすくなるように、

適当に調整しました。

どうでしょうか？

右上のグラフはsigmoid関数の

重ね合わせで表現されています。

単層（sigmoidが１つだけ）だと、

０と１の境界が極端に分かれていましたが、

sigmoidを重ね合わせていくと、

0と1以外の値でも広い領域を持つようになりました。

右下のグラフも形が非線形になっていますね！

これが多層の意義になります。

層を追加していくことで、

より複雑な形で分けることが可能になるというわけです。

それでは実装していきましょう！

多層パーセプトロンをゼロから作る！

※記事最後にgithubへのリンク貼ってあります。

構造はmlp という構造体を定義して、

その中に入力層、隠れ層、出力層それぞれの

重み、伝播する誤差、バイアスを用意します。

つまりmlp構造体がネットワーク絶対の設定を

保持する形になっています。

バイアスはノードの一部としてみなして、

ノード数をセットする際に+１します。

ハイパーパラメータは以下で定義します。


const (
	iteration = 5000
	lRate     = 0.6
)

const (

iteration = 5000

lRate = 0.6

)

エポック数は5千で、学習率は0.6です。

自由に変えてみてください。

今回はこの値で行ってみましょう！

続いてmain文で全体の流れを見ます。


func main() {
	//learning data + label
	var patterns = [][][]float64{
		{{0, 0}, {0}},
		{{0, 1}, {1}},
		{{1, 0}, {1}},
		{{1, 1}, {0}},
	}

	mlp := Set(2, 2, 1, 1) //入力層ノード、隠れ層ノード、出力層ノード、隠れ層数
	mlp.Train(patterns)
	mlp.Test(patterns)
	outputIMG()
}

func main() {

//learning data + label

var patterns = [][][]float64{

{{0, 0}, {0}},

{{0, 1}, {1}},

{{1, 0}, {1}},

{{1, 1}, {0}},

}

mlp := Set(2, 2, 1, 1) //入力層ノード、隠れ層ノード、出力層ノード、隠れ層数

mlp.Train(patterns)

mlp.Test(patterns)

outputIMG()

}

patterns配列のように、

データとラベルを用意します。

set関数で各層のノードの数と隠れ層の数を指定し、

ネットワークの全体構造を取得します。

そしてTrainメソッドとTestメソッドを実行します。

最後に誤差をグラフ化をします。

まずは、setを見てみましょう。


func Set(ni, nh, no, lh int) *Mlp {
	rand.Seed(0)
	mlp := &amp;Mlp{
		nodeInput:  ni + 1, //add bais node
		nodeHidden: nh + 1, //add bais node
		nodeOutput: no,
		layHidden:  lh,
	}

	//init weight
	mlp.weiInput = MatrixInit(mlp.nodeInput, mlp.nodeHidden, 0)
	for n := 0; n &lt; mlp.nodeInput; n++ {
		for w := 0; w &lt; mlp.nodeHidden; w++ {
			mlp.weiInput[n][w] = Random(-1, 1)
		}
	}
	if mlp.layHidden &gt; 1 { //if the number of hidden layer is more than 2
		mlp.weiHidden = Tensor3Init(mlp.layHidden-1, mlp.nodeHidden, mlp.nodeHidden, 0)
		for i := 0; i &lt; mlp.layHidden-1; i++ {
			for j := 0; j &lt; mlp.nodeHidden; j++ {
				for k := 0; k &lt; mlp.nodeHidden; k++ {
					mlp.weiHidden[i][j][k] = Random(-1, 1)
				}
			}
		}
	}
	mlp.weiOutput = MatrixInit(mlp.nodeHidden, mlp.nodeOutput, 0)
	for n := 0; n &lt; mlp.nodeHidden; n++ {
		for w := 0; w &lt; mlp.nodeOutput; w++ {
			mlp.weiOutput[n][w] = Random(-1, 1)
		}
	}
	//the value of nodes
	mlp.valInput = VectorInit(mlp.nodeInput, 1)
	mlp.valHidden = MatrixInit(mlp.layHidden, mlp.nodeHidden, 1)
	mlp.valOutput = VectorInit(mlp.nodeOutput, 1)

	fmt.Println("[+]Init Ok")
	//fmt.Printf("%+v\n", mlp)
	return mlp
}

func Set(ni, nh, no, lh int) *Mlp {

rand.Seed(0)

mlp := &Mlp{

nodeInput: ni + 1, //add bais node

nodeHidden: nh + 1, //add bais node

nodeOutput: no,

layHidden: lh,

}

//init weight

mlp.weiInput = MatrixInit(mlp.nodeInput, mlp.nodeHidden, 0)

for n := 0; n < mlp.nodeInput; n++ {

for w := 0; w < mlp.nodeHidden; w++ {

mlp.weiInput[n][w] = Random(-1, 1)

}

if mlp.layHidden > 1 { //if the number of hidden layer is more than 2

mlp.weiHidden = Tensor3Init(mlp.layHidden-1, mlp.nodeHidden, mlp.nodeHidden, 0)

for i := 0; i < mlp.layHidden-1; i++ {

for j := 0; j < mlp.nodeHidden; j++ {

for k := 0; k < mlp.nodeHidden; k++ {

mlp.weiHidden[i][j][k] = Random(-1, 1)

}

mlp.weiOutput = MatrixInit(mlp.nodeHidden, mlp.nodeOutput, 0)

for n := 0; n < mlp.nodeHidden; n++ {

for w := 0; w < mlp.nodeOutput; w++ {

mlp.weiOutput[n][w] = Random(-1, 1)

}

//the value of nodes

mlp.valInput = VectorInit(mlp.nodeInput, 1)

mlp.valHidden = MatrixInit(mlp.layHidden, mlp.nodeHidden, 1)

mlp.valOutput = VectorInit(mlp.nodeOutput, 1)

fmt.Println("[+]Init Ok")

//fmt.Printf("%+v\n", mlp)

return mlp

}

引数にノードの数と隠れ層の数を受け取ります。

入力層と隠れ層はバイアス分があるので１を足します。

次に入力層、隠れ層、出力層の全ての重みを

-1から１の範囲で初期化します。

今回は隠れ層は１層のみなので隠れ層の重みはなしです。

隠れ層の重み（weiHidden）は隠れ層同士をつなぐ重みです。

最後にノードの値は１をセットして終了です。

バイアスノードの値はずっと１なので、

０をセットするのではなく１をセットします。

続いて、Trainを見てみましょう。


func (mlp *Mlp) Train(patterns [][][]float64) {
	for i := 0; i &lt; iteration; i++ {
		var e float64
		e = 0
		for _, p := range patterns {
			//should be the same
			if len(mlp.valOutput) != len(p[1]) {
				log.Println("[-]The number of labels are invalid. Don't match the number of outputnodes")
				return
			}
			//compute forward
			mlp.Update(p[0])
			//compute backward
			e += mlp.Backpropagate(p[1])
		}
		gred[i] = e
	}
}

func (mlp *Mlp) Train(patterns [][][]float64) {

for i := 0; i < iteration; i++ {

var e float64

e = 0

for _, p := range patterns {

//should be the same

if len(mlp.valOutput) != len(p[1]) {

log.Println("[-]The number of labels are invalid. Don't match the number of outputnodes")

return

}

//compute forward

mlp.Update(p[0])

//compute backward

e += mlp.Backpropagate(p[1])

}

gred[i] = e

}

エポック数を満たすまで、

入力層から順にノードの値を再計算して、

バックプロパゲーションを繰り返します。

ノードの値の再計算は以下になります。


func (mlp *Mlp) Update(inputs []float64) {
	for i, val := range inputs {
		mlp.valInput[i] = val
	}

	var sum float64
	for i := 0; i &lt; mlp.nodeHidden-1; i++ { //最上位隠れ層のみ別で計算
		sum = 0
		for j := 0; j &lt; mlp.nodeInput; j++ {
			sum += mlp.weiInput[j][i] * mlp.valInput[j]
		}
		mlp.valHidden[0][i] = Sigmoid(sum)
	}

	if mlp.layHidden &gt; 1 { //隠れ層が2層以上なら計算
		for l := 1; l &lt; mlp.layHidden; l++ { //l=0は上記(入力層)の計算で格納済み
			sum = 0
			for n := 0; n &lt; mlp.nodeHidden; n++ {
				for w := 0; w &lt; mlp.nodeHidden; w++ {
					sum += mlp.weiHidden[l-1][w][n] * mlp.valHidden[l-1][n] //weiHiddenは隠れ層が２層以上で有効。１層のみならそもそも存在しない。
				}
				mlp.valHidden[l][n] = Sigmoid(sum)
			}
		}
	}

	for i := 0; i &lt; mlp.nodeOutput; i++ {
		sum = 0
		for j := 0; j &lt; mlp.nodeHidden; j++ {
			sum += mlp.weiOutput[j][i] * mlp.valHidden[mlp.layHidden-1][j]
		}
		mlp.valOutput[i] = Sigmoid(sum)
	}
}

func (mlp *Mlp) Update(inputs []float64) {

for i, val := range inputs {

mlp.valInput[i] = val

}

var sum float64

for i := 0; i < mlp.nodeHidden-1; i++ { //最上位隠れ層のみ別で計算

sum = 0

for j := 0; j < mlp.nodeInput; j++ {

sum += mlp.weiInput[j][i] * mlp.valInput[j]

}

mlp.valHidden[0][i] = Sigmoid(sum)

}

if mlp.layHidden > 1 { //隠れ層が2層以上なら計算

for l := 1; l < mlp.layHidden; l++ { //l=0は上記(入力層)の計算で格納済み

sum = 0

for n := 0; n < mlp.nodeHidden; n++ {

for w := 0; w < mlp.nodeHidden; w++ {

sum += mlp.weiHidden[l-1][w][n] * mlp.valHidden[l-1][n] //weiHiddenは隠れ層が２層以上で有効。１層のみならそもそも存在しない。

}

mlp.valHidden[l][n] = Sigmoid(sum)

}

for i := 0; i < mlp.nodeOutput; i++ {

sum = 0

for j := 0; j < mlp.nodeHidden; j++ {

sum += mlp.weiOutput[j][i] * mlp.valHidden[mlp.layHidden-1][j]

}

mlp.valOutput[i] = Sigmoid(sum)

}

入力層→隠れ層→出力層と、

順にfor文回して計算しているだけです。

バックプロパゲーションの実装は以下になります。


func (mlp *Mlp) Backpropagate(label []float64) float64 {
	mlp.deltaHidden = MatrixInit(mlp.layHidden, mlp.nodeHidden, 0)
	mlp.deltaInput = VectorInit(mlp.nodeInput, 0)
	mlp.deltaOutput = VectorInit(mlp.nodeOutput, 0)

	for i := 0; i &lt; mlp.nodeOutput; i++ {
		mlp.deltaOutput[i] = Dsigmoid(mlp.valOutput[i]) * (mlp.valOutput[i] - label[i])
	}

	//入力側(l-1)を固定しながら、出力層側(l)を回していく
	for i := 0; i &lt; mlp.nodeHidden; i++ {
		for j := 0; j &lt; mlp.nodeOutput; j++ {
			mlp.deltaHidden[mlp.layHidden-1][i] += mlp.deltaOutput[j] * Dsigmoid(mlp.valHidden[mlp.layHidden-1][i]) * mlp.weiOutput[i][j]
			mlp.weiOutput[i][j] -= lRate * mlp.deltaOutput[j] * mlp.valHidden[mlp.layHidden-1][i]
		}
	}

	//隠れ層が2層以上なら計算
	for l := mlp.layHidden - 1; l &gt; 0; l-- {
		for i := 0; i &lt; mlp.nodeHidden; i++ {
			for j := 0; j &lt; mlp.nodeHidden; j++ {
				mlp.deltaHidden[l-1][i] += mlp.deltaHidden[l][j] * Dsigmoid(mlp.valHidden[l-1][i]) * mlp.weiHidden[l-1][i][j]
				mlp.weiHidden[l-1][i][j] -= lRate * mlp.deltaHidden[l][j] * mlp.valHidden[l-1][i]
			}
		}
	}

	for i := 0; i &lt; mlp.nodeInput; i++ {
		for j := 0; j &lt; mlp.nodeHidden; j++ {
			mlp.weiInput[i][j] -= lRate * mlp.deltaHidden[0][j] * mlp.valInput[i]
		}
	}

	var e float64
	e = 0
	for i := 0; i &lt; mlp.nodeOutput; i++ {
		e += math.Pow((mlp.valOutput[i] - label[i]), 2)
	}

	return e
}

func (mlp *Mlp) Backpropagate(label []float64) float64 {

mlp.deltaHidden = MatrixInit(mlp.layHidden, mlp.nodeHidden, 0)

mlp.deltaInput = VectorInit(mlp.nodeInput, 0)

mlp.deltaOutput = VectorInit(mlp.nodeOutput, 0)

for i := 0; i < mlp.nodeOutput; i++ {

mlp.deltaOutput[i] = Dsigmoid(mlp.valOutput[i]) * (mlp.valOutput[i] - label[i])

}

//入力側(l-1)を固定しながら、出力層側(l)を回していく

for i := 0; i < mlp.nodeHidden; i++ {

for j := 0; j < mlp.nodeOutput; j++ {

mlp.deltaHidden[mlp.layHidden-1][i] += mlp.deltaOutput[j] * Dsigmoid(mlp.valHidden[mlp.layHidden-1][i]) * mlp.weiOutput[i][j]

mlp.weiOutput[i][j] -= lRate * mlp.deltaOutput[j] * mlp.valHidden[mlp.layHidden-1][i]

}

//隠れ層が2層以上なら計算

for l := mlp.layHidden - 1; l > 0; l-- {

for i := 0; i < mlp.nodeHidden; i++ {

for j := 0; j < mlp.nodeHidden; j++ {

mlp.deltaHidden[l-1][i] += mlp.deltaHidden[l][j] * Dsigmoid(mlp.valHidden[l-1][i]) * mlp.weiHidden[l-1][i][j]

mlp.weiHidden[l-1][i][j] -= lRate * mlp.deltaHidden[l][j] * mlp.valHidden[l-1][i]

}

for i := 0; i < mlp.nodeInput; i++ {

for j := 0; j < mlp.nodeHidden; j++ {

mlp.weiInput[i][j] -= lRate * mlp.deltaHidden[0][j] * mlp.valInput[i]

}

var e float64

e = 0

for i := 0; i < mlp.nodeOutput; i++ {

e += math.Pow((mlp.valOutput[i] - label[i]), 2)

}

return e

}

誤差は最小２乗誤差を基に計算して、

重みの更新はSGD(勾配降下)を適用してあります。

出力層→隠れ層→入力層と、順に計算していきます。

計算は微分した式を基にしていますので、

最小２乗誤差を偏微分した形を知っておく必要があります。

E = 1/2 Σ (z_{i} - l_{i})^{2}

∂E/ {∂z}_{i} = z_{i} - l_{i}

あとは微分の連鎖率を使用して、

該当するノードの偏微分を求めていきます。

次に、Testを見てみましょう。


func (mlp *Mlp) Test(valInput [][][]float64) {
	for _, p := range valInput {
		mlp.Update(p[0])
		fmt.Println(p[0], "-&gt;", mlp.valOutput, " : ", p[1])
	}
}

func (mlp *Mlp) Test(valInput [][][]float64) {

for _, p := range valInput {

mlp.Update(p[0])

fmt.Println(p[0], "->", mlp.valOutput, " : ", p[1])

}

最後にグラフ化するコード（おまけ）です。


func outputIMG() {
	p, err := plot.New()
	if err != nil {
		log.Panic(err)
	}
	p.Title.Text = "MLP_Error"
	p.X.Label.Text = "X"
	p.Y.Label.Text = "Y"
	for i, v := range gred {
		bs, err := plotter.NewScatter(plotter.XYZs{{float64(i), v, 1}})
		if err != nil {
			panic(err)
		}
		bs.Color = color.RGBA{R: 0, G: 0, B: 255, A: 255}
		p.Add(bs)
	}
	if err := p.Save(4*vg.Inch, 4*vg.Inch, "mlp.png"); err != nil {
		panic(err)
	}
}

func outputIMG() {

p, err := plot.New()

if err != nil {

log.Panic(err)

}

p.Title.Text = "MLP_Error"

p.X.Label.Text = "X"

p.Y.Label.Text = "Y"

for i, v := range gred {

bs, err := plotter.NewScatter(plotter.XYZs{{float64(i), v, 1}})

if err != nil {

panic(err)

}

bs.Color = color.RGBA{R: 0, G: 0, B: 255, A: 255}

p.Add(bs)

}

if err := p.Save(4*vg.Inch, 4*vg.Inch, "mlp.png"); err != nil {

panic(err)

}

最後に結果を見てみましょう！

学習結果

誤差の推移をグラフ化しました。

横軸がエポック数で、

以下のグラフは全て5000回です。

学習率=0.2

学習率=0.6

学習率=0.8

0.2だと学習が遅いですが、

0.6と0.8とではほとんど変わらないですね。

0.6も0.8もどちらも1000回学習させると、

誤差が底になる感じですね。

以上になります。

最後まで読んでいただきありがとうございました。

今回紹介したコードはgithub上においてあります。

参考：

以下をベースにしてあります。
↓
オリジナル
https://github.com/goml/gobrain