HOME > natural science Laboratory > コンピュータ・シミュレーション講座 > ゼロから作るDeep Learning

ゼロから作るDeep Learning
1n1型２層ニューラルネットワークで１変数関数を学習させてみる２：勾配法による学習計算アルゴリズムの実装

文責：遠藤 理平 （2017年4月14日） カテゴリ：ゼロから作るDeep Learning(49)

昨今注目を集めているAI（人工知能）を学びたいと思い立ち、ディープラーニング（Deep Learning、深層学習）と呼ばれるAIの数理モデルである多層構造のニューラルネットワークを書籍「ゼロから作るDeep Learning ―Pythonで学ぶディープラーニングの理論と実装」を参考にを独習していきたいと思います。本書籍ではプログラミング言語としてPythonが利用されていますが、本項ではJavaScriptで実装していきます。

目次


学習のステップ

前項では勾配法による極小値探索の計算アルゴリズムを示しました。 本項では実際にニューラルネットワークで１変数関数を学習させてみましょう（入力値の範囲をx_\min\leq x \leq x_\maxとします）。必要なステップは次のとおりです。

20170413-1.png

（１）重みとバイアスにランダム値を与える ← 区間[-0.5, 0.5]をランダムで与える
（２）x_\min\leq x \leq x_\maxからランダムに取得した1個の入力値に対する損失関数値を計算する
（３）重みとバイアスに対する損失関数の勾配を計算する
（４）（２）と（３）をM回繰り返して勾配の平均を計算する　←　このM個のサンプルのグループはミニバッチと呼ばれる。
（５）（４）で得られた平均勾配を用いて重みとバイアスの値を更新する　←　この１回の値の更新はエポックと呼ばれる
（６）勾配を初期化する（０を与える）
（７）（２）から（６）の操作（エポック）をT回繰り返す
（８）x_\min\leq x \leq x_\maxから等間隔で取得した入力に対するニューラルネットワークの出力値を得て、元の関数と比較してみる。

１次関数、２次関数、３次関数を学習させてた結果

１次関数f(x) = x \ , \ [0\leq x \leq 1]

１変数関数の最も簡単な例である１次関数を学習させた結果です。

初期パラメータがランダムに与えられていますので毎回結果が変化しますが、概ね学習回数300回程度で損失関数が極小値をとり、学習が完了していることがわかります。 学習後のニューラルネットワークの入力に対する出力は概ね元の関数上に乗っていることが確認できます。


２次関数f(x) = x^2 \ , \ [0\leq x \leq 3]

次に曲線である２次関数についてです。デフォルトの学習率を0.03と先の１次関数の場合と比べて1/3の大きさとしました。今回は入力値の区間を広げたことでとりうる関数値の傾きが大きくなった結果、学習率が0.1ではうまく学習することができませんでした。

第１層ニューロン数:10、学習回数:1000、学習率:0.03で概ね元の関数を表現できています。

３次関数f(x) = x^3-2.5x^2 \ , \ [0\leq x \leq 3]

最後に極小値をもつ３次関数についてです。デフォルトの学習回数を3000回としています。概ね表現できていることがわかります。


ニューラルネットワークを生成するNNクラスの拡張

前項で開発したNNクラスに上記のステップ（６）で示した勾配を格納する多重配列の初期化用メソッドを追加します。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
//ニューラルネットワーク
var NN = function( W, B, h, sigma, eta ){
    //重み
    this.W = W;
    //W.length : 層数
    //W[].length : 列（後ニューロン数）
    //W[][].length : 行（前ニューロン数）
 
    //１ステップ前のWを保持する多重配列
    this._W = [];
 
    //バイアス
    this.B = B;
    this._B = [];
 
    //偏微分値を格納する多重配列
    this.dLdW = [];
    this.dLdB = [];
 
    //活性化関数
    this.h = h;
    this.sigma = sigma;
 
    //ニューロンの初期化
    this.X = [];
 
    //学習効率
    this.eta = eta || 0.1;
 
    this.setup();
 
}
 
//各種プロパティの初期化
NN.prototype.setup = function(  ){
 
    ////////////////////////////////////////////
    // ニューロンの初期化
    ////////////////////////////////////////////
    for( var i = 0; i < this.W.length; i++ ){
 
        this.X[ i ] = [];
 
        for( var j = 0; j < this.W[ i ][ 0 ].length; j++ ){
 
            this.X[ i ][ j ] = 0;
 
        }
 
    }
    //出力層
    this.X[ this.W.length ] = [];
    for( var j = 0; j < this.W[ this.W.length-1 ].length; j++ ){
        this.X[ this.W.length ][ j ] = 0;
    }
 
    ////////////////////////////////////////////
    // 重み格納用多重配列と偏微分値格納多重配列の初期化
    ////////////////////////////////////////////
    for( var i = 0; i < this.W.length; i++ ){
 
        this._W[ i ] =  [];
        this.dLdW[ i ] = [];
 
        for( var j = 0; j < this.W[ i ].length; j++ ){
 
            this._W[ i ][ j ] = [];
            this.dLdW[ i ][ j ] = [];
 
            for( var k = 0; k < this.W[ i ][ j ].length; k++ ){
 
                this._W[ i ][ j ][ k ] = this.W[ i ][ j ][ k ] ;
                this.dLdW[ i ][ j ][ k ] = 0;
 
            }
        }
    }
 
    ////////////////////////////////////////////
    // バイアス格納用多重配列
    ////////////////////////////////////////////
    for( var i = 0; i < this.B.length; i++ ){
 
        this._B[ i ] = [];
        this.dLdB[ i ] = [];
 
        for( var j = 0; j < this.B[ i ].length; j++ ){
 
            this._B[ i ][ j ] = this.B[ i ][ j ];
            this.dLdB[ i ][ j ] = 0;
 
        }
 
    }
 
}
//重みによる勾配をリセット
NN.prototype.resetDLdW = function(  ){
    for( var i = 0; i < this.W.length; i++ ){
        for( var j = 0; j < this.W[ i ].length; j++ ){
            for( var k = 0; k < this.W[ i ][ j ].length; k++ ){
                this.dLdW[ i ][ j ][ k ] = 0;
 
            }
        }
    }
}
//バイアスによる勾配をリセット
NN.prototype.resetDLdB = function(  ){
    for( var i = 0; i < this.B.length; i++ ){
        for( var j = 0; j < this.B[ i ].length; j++ ){
            this.dLdB[ i ][ j ] = 0;
        }
    }
}
 
 
//入力層（０層目ニューロン値）へのインプット
NN.prototype.setInput = function( Input ){
 
    for( var i = 0; i < Input.length; i++ ){
 
        this.X[ 0 ][ i ] = Input[ i ];
    }
 
}
//出力層へのアウトプット
NN.prototype.getOutput = function( ){
 
    //各層ニューロン値の計算
    for( var i = 0; i < this.W.length; i++ ){
 
        this.multiplayMatrixVector ( this.W[ i ], this.X[ i ], this.X[ i+1 ] );
        this.addVectors ( this.X[ i+1 ], this.B[ i ], this.X[ i+1 ] );
 
        //活性化関数の実行
        if( i < this.W.length-1 ){
            //隠れ層
            this.adoptAFh( this.X[ i+1 ], this.X[ i+1 ] );
        } else {
            //出力層
            this.adoptAFsigma( this.X[ i+1 ], this.X[ i+1 ] );
        }
    }
 
    return this.X[ this.X.length -1 ];
}
 
//行列×ベクトルの計算
NN.prototype.multiplayMatrixVector = function( M, V, C ){
    C = C || [];
 
    var Mgyou = M.length;
    var Mretu = M[ 0 ].length;
 
    for( var i = 0; i < Mgyou; i++ ){
 
        C[ i ] =0;
 
        for( var j = 0; j < Mretu; j++ ){
 
            C[ i ] += M[ i ][ j ] * V[ j ];
 
        }
 
    }
 
    return C;
}
//ベクトルの和
NN.prototype.addVectors = function( V1, V2, V3 ){
    V3 = V3 || [];
 
    for( var i = 0; i < V1.length; i++ ){
 
        V3[ i ] = V1[ i ] + V2[ i ];
 
    }
 
    return V3;
}
//活性化関数の実行
NN.prototype.adoptAFh = function( V_in, V_out ){
    V_out = V_out || [];
 
    for( var i = 0; i < V_in.length; i++ ){
 
        V_out[ i ] = this.h( V_in[ i ] );
 
    }
 
    return V_out;
}
NN.prototype.adoptAFsigma = function( V_in, V_out ){
    V_out = V_out || [];
 
    for( var i = 0; i < V_in.length; i++ ){
 
        V_out[ i ] = this.sigma( V_in[ i ] );
 
    }
    return V_out;
}

実行方法

NNクラスを用いて１変数関数を学習するためのプログラムを以下に示します。先の学習ステップ（２）から（８）に対応します。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
//////////////////////////////////
//ニューラルネットワークの生成
//////////////////////////////////
var nn = new NN( W, B, h, sigma, eta );
 
var data1 = [];//グラフ描画用データ
 
//学習回数
for( var t=0; t<T; t++){
 
    //ミニバッチ
    for( var xi = 0; xi<=M; xi++ ){
        //入力値
        var x = x_min + (x_max - x_min) * Math.random();
        var X0 = [ x ];
 
        //入力層へのインプット
        nn.setInput( X0 );
        //出力層へのアウトプット
        var X2 = nn.getOutput();
        var y = X2[0];
        //損失関数値の計算
        var _L = 1.0/2.0*( y-f( x ) )*( y-f( x ) );
 
        //重みの勾配の計算
        for( var i = 0; i < nn.W.length; i++ ){
            for( var j = 0; j < nn.W[ i ].length; j++ ){
                for( var k = 0; k < nn.W[ i ][ j ].length; k++ ){
 
                    nn.W[ i ][ j ][ k ] += d;
                    nn.setInput( X0 );
 
                    var X2 = nn.getOutput();
                    var y = X2[ 0 ];
 
                    var L = 1.0/2.0 * ( y - f( x ) ) * ( y - f( x ) );
 
                    nn.W[ i ][ j ][ k ] -= d;//もとに戻しておく
                    nn.dLdW[ i ][ j ][ k ] += ( L - _L ) / d  /M;
 
                }
            }
        }
 
        //バイアスの勾配の計算
        for( var i = 0; i < nn.B.length; i++ ){
            for( var j = 0; j < nn.B[ i ].length; j++ ){
 
                nn.B[ i ][ j ] += d;
                nn.setInput( X0 );
                var X2 = nn.getOutput();
                var y = X2[ 0 ];
                var L = 1.0/2.0*( y - f( x ) )*( y - f( x ) );
                nn.B[ i ][ j ] -= d;
                nn.dLdB[ i ][ j ] += ( L - _L ) / d /M;
 
            }
        }
    }
    //重みとバイアスを更新
    nn.updateW();
    nn.updateB();
 
    //チェック
    var sumL = 0;
    for( var xi = 0; xi<=M; xi++ ){
        //入力値
        var x = x_min + (x_max - x_min) * xi/M;
        var X0 = [ x ];
 
        nn.setInput( X0 );
        var X2 = nn.getOutput(  );
        var y = X2[0];
        sumL += 1.0/2.0*( y-f( x ) )*( y-f( x ) );
 
    }
    data1.push([ t, sumL ]);
 
    nn.resetDLdW();
    nn.resetDLdB();
}


▲このページのトップ ｜ NPO法人 natural science トップ

関連記事

ゼロから作るDeep Learning

【ニューラルネットワークの基礎研究31】ニューラルネットワークによる関数近似の検証（中間層１層の場合） 2018.08.02 【遠藤 理平｜ゼロから作るDeep Learning】

【ルンゲ・クッタで行こう！】水平自由単振子運動シミュレーション 2018.05.30 【遠藤 理平｜ゼロから作るDeep Learning｜仮想物理実験室】


【ニューラルネットワークの基礎研究30】任意の初期条件に対する運動を学習（重力＋空気抵抗力） 2018.05.26 【遠藤 理平｜ゼロから作るDeep Learning】

【ルンゲ・クッタで行こう！】単振子強制振動運動シミュレーション 2018.05.25 【遠藤 理平｜ゼロから作るDeep Learning｜仮想物理実験室】


【ニューラルネットワークの基礎研究29】放物運動の初期位置と初速度と経過時間から位置と速度を学習 2018.05.23 【遠藤 理平｜ゼロから作るDeep Learning】

【ニューラルネットワークの基礎研究28】放物運動の現在の位置と速度から未来の位置と速度を学習 2018.05.22 【遠藤 理平｜ゼロから作るDeep Learning】


【ニューラルネットワークの基礎研究27】放物運動の粘性抵抗係数と初速度と投射角度から飛距離を学習してみる 2018.05.10 【遠藤 理平｜ゼロから作るDeep Learning】

【ニューラルネットワークの基礎研究26】放物運動の軌跡から粘性抵抗係数と慣性抵抗係数を見積もる 2018.05.08 【遠藤 理平｜ゼロから作るDeep Learning】


【ニューラルネットワークの基礎研究25】放物運動の軌跡から空気抵抗係数を学習してみる 2018.05.07 【遠藤 理平｜ゼロから作るDeep Learning｜仮想物理実験室】

【ニューラルネットワークの基礎研究24】LASSO回帰因子を損失値に応じて小さくしてみる 2018.05.05 【遠藤 理平｜ゼロから作るDeep Learning】



▲このページのトップ ｜ NPO法人 natural science トップ




Warning: mysqli_connect(): (28000/1045): Access denied for user 'xsvx1015071_ri'@'sv102.xserver.jp' (using password: YES) in /home/xsvx1015071/include/natural-science/include_counter-d.php on line 8
MySQL DBとの接続に失敗しました