ニューラルネットワーク（学習）のバックアップ(No.28)

「.NET 開発基盤部会 Wiki」は、「Open棟梁Project」,「OSSコンソーシアム .NET開発基盤部会」によって運営されています。

戻る
- ニューラルネットワーク（推論）
- ニューラルネットワーク（学習）

目次 †

↑

学習の概要 †

ニューラルネットワークにおいては、特徴量を機械が選択し重みを学習（自動獲得）する。

↑

機械学習の場合 †

↑

特徴量の選択 †

構造化データ
- 特徴量を表から選択する。
- 場合によっては次元圧縮したりする。

非構造化データ
- 画像
  入力画像データから、本質的なデータを抽出できるように設計された変換器を指す。
  - 画像データの特徴量は通常、ベクトルを使用して表される。
  - SIFT, SURF, HOGなど、人が設計した変換器によって画像データをベクトル化する。

↑

特徴量の学習 †

構造化データ
機械学習の様々なアルゴリズムで学習させる。

非構造化データ
- 画像
  ベクトル化された画像データを機械学習のSVMやKNNなどの識別器で学習させる。

↑

深層学習の場合 †

↑

重みの自動獲得 †

学習フェーズでは、信号は逆方向に伝播する。

学習とは、重みパラメタを自動獲得するためのもの。

実際のニューラルネットワークの重みパラメタは、
- 数千、数万になるため、手動での設定は不可能。
- 更に層を深めた深層学習（deep learning）では数億にも登る。

重みパラメタの自動獲得のため、
- 損失関数という指標を導入する。
  損失関数を使用して値が最小（最大）になるような重みパラメタを探す。
- このようなパラメタを探し出すためには、勾配法という手法を用いる。
  勾配は、各場所で（損失）関数の値を最も減らす方向を示す。

↑

学習はデータ駆動 †

MNISTデータセットの様な画像の分類処理を行うアルゴリズムを考え出すのは困難。
しかし、機械にデータを学習させる機械学習を用いれば分類処理が実現可能。
人間が（暗黙的な学習によって、）これらを判別することはできる。
従って、人間の脳も、一部は、このようなデータ駆動で動いているのかもしれない。

このように、アルゴリズムを捻り出すのではなく、データを有効活用して解決する方法に、
画像から特徴量を抽出し、特徴量のパターンを機械学習の技術で学習するという方法がある。

↑

損失関数（誤差関数） †

損失関数は、誤差関数とほぼ同じか、より包括的な概念。
- 予想データと正解データの出力の間に、
  どのくらい誤差があるのかを評価する関数。
- 作成した予測モデルの精度を評価する際に使われ、
- 値（誤差）が小さければ小さいほど正確なモデルと言える。
  - モデル関数とデータ群の誤差という文脈では誤差関数と呼ばれる。
  - 学習の文脈では損失関数と呼ばれ、誤差関数以外にも例えばカルバック・ライブラー(KL)情報量などを含む。

深層学習では一つの指標を手がかりに最適なパラメタを探索する。
この指標を損失関数を呼び、パラメタに対して連続的に変化する関数を用いる。
これは学習時に、微分によって傾きが0になってパラメタの更新できなくなることを防ぐため。

↑

2乗和誤差 †

ニューラルネットワークの出力と正解となる教師データの各要素の差の二乗の総和の２分の一。

式

                 2
E = 1/2 Σ (yk-tk)
         k

説明
- k:データの次元数
- yk:ニューラルネットワークの出力
- tk:教師データ

例(k=10)
- yk:ニューラルネットワークの出力
  =[0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0]
  ソフトマックス関数の出力（全て足して1.0になる。）

tk:教師データ
=[0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
※ 正解ラベルを1、ソレ以外を0とする、one-hot表現

Python

実装

"""This is a test program."""

import numpy as np

def mean_squared_error(yk, tk):
    """損失関数(2乗和誤差)"""
    return 0.5 * np.sum((yk - tk)**2)

tk = np.array([0, 0, 1, 0, 0, 0, 0, 0, 0, 0])
yk = np.array([0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0])
print(mean_squared_error(yk, tk))
yk = np.array([0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0])
print(mean_squared_error(yk, tk))

出力
正解(tk)に対応する確率(yk)が高ければ高いほど、１に近いデータになる。
- tkで２が正解の場合、ykで２の確率が一番高いとしたデータの場合のE。
```
0.0975
```
- tkで２が正解の場合、ykで７の確率が一番高いとしたデータの場合のE。
```
0.5975
```

前者の損失関数(2乗和誤差)の出力Eの方が大きく、
前者のykがより適合していることを示している。

↑

交差エントロピー誤差 †

正解ラベルのykデータの底がeの自然対数 log eを計算する。
y = -log xでは、x=0-1の場合、xが0に近づくほど、yは大きな値になる。

式
```
E = - Σ tk log yk
       k
```

説明
- log:logは底がeの自然対数 log e
- k:データの次元数
- yk:ニューラルネットワークの出力
- tk:教師データ

例(k=10)
同上

Python

実装

"""This is a test program."""

import numpy as np

def cross_entropy_error(yk, tk):
    """損失関数(交差エントロピー誤差)"""
    delta = 1e-7 # log(0)はマイナス∞になるのを微小な値を足して防止。
    return -np.sum(tk * np.log(yk + delta))

tk = np.array([0, 0, 1, 0, 0, 0, 0, 0, 0, 0])
yk = np.array([0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0])
print(cross_entropy_error(yk, tk))
yk = np.array([0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0])
print(cross_entropy_error(yk, tk))

出力
正解(tk)に対応する確率(yk)が低ければ低いほど、大きいデータになる。

tkで２が正解の場合、ykで２の確率が一番高いとしたデータの場合のE。
```
0.510825457099
```
tkで２が正解の場合、ykで７の確率が一番高いとしたデータの場合のE。
```
2.30258409299
```

前者の損失関数(交差エントロピー誤差)の出力Eの方が小さく、
前者のykがより適合していることを示している。

↑

ミニバッチ学習 †

↑

バッチ、ミニバッチ、オンライン学習 †

バッチ学習（一括学習）
- 全てのサンプルを一度に用いて勾配を求める手法
- 機械学習のアルゴリズムでは基本的にバッチ学習が採用される。

オンライン学習（逐次学習）
- ひとつのサンプルのみを用いて勾配を求める手法
- ノイズや外れ値の影響を受け易く、解が適切な値に収束し難い。

ミニバッチ学習
データを幾つかの塊に小分けにして。その塊毎に勾配を求める手法

バッチ学習とオンライン学習の折衷案
- バッチ学習ほど学習時間がかからず、
- オンライン学習ほど解の収束が不安定にならない｡

	バッチ学習（一括学習）	ミニバッチ学習	オンライン学習（逐次学習）
効率	✕	○	◎
安定性	◎	○	✕

↑

ミニバッチ学習を訓練用データセットに適用 †

ミニバッチ学習では、上記の損失関数を訓練用データセットに対して適用する。
ここでは、訓練用データセットに対する損失関数の総和を指標とする。

式
```
E = -1/N ΣΣ tnk log ynk
          n k
```

説明
- 交差エントロピー誤差の式をN個のデータを含む訓練用データセット用に拡張する。
- 最後に、Nで割って正規化する（データ１個あたりの平均の損失関数を求める）。

例（MNISTデータセットを使用する）

Python

実装

one-hot表現の場合

"""This is a test program."""

import numpy as np

def mean_squared_error(ynk, tnk):
    """損失関数(交差エントロピー誤差)"""
    print("tnk:" + str(tnk))
    print("ynk:" + str(ynk))

    batch_size = ynk.shape[0]
    print("batch_size:" + str(batch_size))
    delta = 1e-7 # log(0)はマイナス∞になるのを微小な値を足して防止。
    return - 1 / batch_size * (np.sum(tnk * np.log(ynk + delta)))

TNK = np.array([[0, 0, 1, 0, 0, 0, 0, 0, 0, 0], \
    [0, 0, 1, 0, 0, 0, 0, 0, 0, 0]])
YNK = np.array([[0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0], \
    [0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0]])
print("mean_squared_error:" + str(mean_squared_error(YNK, TNK)))
YNK = np.array([[0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0], \
    [0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0]])
print("mean_squared_error:" + str(mean_squared_error(YNK, TNK)))

one-hot表現でない場合

"""This is a test program."""

import numpy as np

def mean_squared_error(ynk, tnk):
    """損失関数(交差エントロピー誤差)"""
    print("tnk:" + str(tnk))
    print("ynk:" + str(ynk))

    batch_size = ynk.shape[0]
    print("batch_size:" + str(batch_size))

    delta = 1e-7 # log(0)はマイナス∞になるのを微小な値を足して防止。
    ynk = ynk + delta
     
    print("arange:" + str(ynk[np.arange(batch_size), tnk]))
    return - 1 / batch_size * (np.sum(np.log(ynk[np.arange(batch_size), tnk])))

TNK = np.array([2, 2])
YNK = np.array([[0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0], \
    [0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0]])
print("mean_squared_error:" + str(mean_squared_error(YNK, TNK)))
YNK = np.array([[0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0], \
    [0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0]])
print("mean_squared_error:" + str(mean_squared_error(YNK, TNK)))

出力
同上

↑

バッチサイズ、イテレーション数、エポック数 †

バッチサイズ

ミニバッチ勾配降下法のサブセットのサイズ

1,000件のデータセットでバッチサイズを200にすると、
サブセットのサイズは200件でバッチの回数は５回になる。

イテレーション数
- 前述のバッチの回数がイテレーション数
- データセットとバッチサイズが決まれば自動的に決まる。

エポック数
上記のミニバッチのイテレーションを更に何回繰り返すか？

参考
機械学習／ディープラーニングにおける
バッチサイズ、イテレーション数、エポック数の決め方 - Qiita
https://qiita.com/kenta1984/items/bad75a37d552510e4682

↑

実装 †

↑

手順 †

↑

前提 †

ニューラルネットワークには適応可能な重みとバイアスがある。
学習により、この重みとバイアスを訓練データに適応するように調整する。
ニューラルネットワークの学習は、以下の4つのステップで行われる。

↑

ステップ 1 †

訓練データから、ランダムに１つのデータを選択する。
ランダムに選択する場合、確率的勾配降下法（SGD）と呼ぶ。
この選択した訓練データをミニバッチと言う。
ここでは、損失関数の値を減らすことを目的とする。

↑

ステップ 2 †

ミニバッチの損失関数を減らすために、各重みパラメタの勾配を求める。
勾配は、損失関数の値を最も減らす方向を示す。

↑

ステップ 3 †

重みパラメタを勾配の方向に微小量だけ更新する。

↑

ステップ 4 †

ステップ 1, ステップ 2, ステップ 3を繰り返す。

↑

2層NNのクラス †

TwoLayerNet?クラス
https://github.com/oreilly-japan/deep-learning-from-scratch/blob/master/ch04/two_layer_net.py

↑

変数 †

#	変数		説明
1	params		ニューラルネットワークの重みパラメタのディクショナリ変数
1-1		params['W1']	第1層の重み
1-2		params['b1']	第1層のバイアス
1-3		params['W2']	第2層の重み
1-4		params['b2']	第2層のバイアス
2	grads		numerical_gradientで計算された勾配を保持するディクショナリ変数
1-1		params['W1']	第1層の重みの勾配
1-2		params['b1']	第1層のバイアスの勾配
1-3		params['W2']	第2層の重みの勾配
1-4		params['b2']	第2層のバイアスの勾配

↑

メソッド †

#	メソッドシグネチャ	引数	説明
1	__init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):		コンストラクタ
1-1		self	インスタンス
1-2		input_size	入力層のニューロンの数
1-3		hidden_size	隠れニューロンの数
1-4		output_size	出力層のニューロンの数
1-5		weight_init_std	・・・
2	predict(self, x):		推論を行う
2-1		self	インスタンス
2-2		x	画像データ
3	loss(self, x, t):		損失関数の値を求める
3-1		self	インスタンス
3-2		x	画像データ
3-3		t	正解ラベル
4	accuracy(self, x, t):		推論の精度を求める
4-1		self	インスタンス
4-2		x	画像データ
4-3		t	正解ラベル
5	numerical_gradient(self, x, t):		lossを使用し各重みパラメタの勾配を求める
5-1		self	インスタンス
5-2		x	画像データ
5-3		t	正解ラベル
6	gradient(self, x, t):		numerical_gradientの高速版
6-1		self	インスタンス
6-2		x	画像データ
6-3		t	正解ラベル

↑

学習過程の実装 †

勾配法により（損失）関数を少なくしていく。

式
コチラと、コチラを参考に、以下のようになる。
- 第1層 (100個のバッチ)
  - x(1) =
```
(100,     784 = 28 * 28 pixel)
```

重みパラメタ
- W(1) =
```
(784,     x = 100)
```
- b(1) =
```
(1,       x = 100)
```

隠れ層 (x = 100)
- A(1) =
```
(100,     x = 100)
```
- = x(2) =
```
(100,     x = 100) 
```

重みパラメタ
- W(2) =
```
(x = 100, 10)
```
- b(2) =
```
(1,       10)
```

第2層
- A(2) =
```
(100,     10) # 0-9の数字
```

Python
https://github.com/oreilly-japan/deep-learning-from-scratch/blob/master/ch04/train_neuralnet.py

実装
C:\deep-learning-from-scratch-master\ch04\train_neuralnetを以下のように編集

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 親ディレクトリのファイルをインポートするための設定
import numpy as np
import matplotlib.pyplot as plt
from dataset.mnist import load_mnist
from two_layer_net import TwoLayerNet

# データの読み込み
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True)

network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)

iters_num = 10000  # 繰り返しの回数を適宜設定する
train_size = x_train.shape[0]
batch_size = 100
learning_rate = 0.1

train_loss_list = []

for i in range(iters_num):
    print(str(i) + " / " + str(iters_num))
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]
    
    # 勾配の計算
    #grad = network.numerical_gradient(x_batch, t_batch)
    grad = network.gradient(x_batch, t_batch)
    
    # パラメータの更新
    for key in ('W1', 'b1', 'W2', 'b2'):
        network.params[key] -= learning_rate * grad[key]
    
    loss = network.loss(x_batch, t_batch)
    train_loss_list.append(loss)

plt.xlabel("Iteration")
plt.ylabel("loss")
plt.plot(range(iters_num), train_loss_list)
plt.show()

実行
フォルダ構成を維持した状態でch04に定義した上記ファイルを実行。
C:\deep-learning-from-scratch-master\ch04>python train_neuralnet

出力
- CMD
```
0 / 10000
...
9999 / 10000
```

グラフ

↑

学習結果を確認する実装 †

学習結果を使用して、学習データとテストデータを推論する。

Python
https://github.com/oreilly-japan/deep-learning-from-scratch/blob/master/ch04/train_neuralnet.py

実装
C:\deep-learning-from-scratch-master\ch04\train_neuralnetのオリジナルを実行

実行
フォルダ構成を維持した状態でch04に定義した上記ファイルを実行。
C:\deep-learning-from-scratch-master\ch04>python train_neuralnet

出力
1バッチ・サイクル毎に学習した重みパラメタを使用した推論結果が表示される。

CMD

train acc, test acc | 0.102183333333, 0.101
train acc, test acc | 0.783416666667, 0.7894
train acc, test acc | 0.874916666667, 0.8791
train acc, test acc | 0.8964, 0.8991
train acc, test acc | 0.907433333333, 0.9092
train acc, test acc | 0.913616666667, 0.9147
train acc, test acc | 0.9184, 0.9185
train acc, test acc | 0.923366666667, 0.9238
train acc, test acc | 0.926316666667, 0.9275
train acc, test acc | 0.9294, 0.9298
train acc, test acc | 0.932666666667, 0.9318
train acc, test acc | 0.9341, 0.9341
train acc, test acc | 0.936816666667, 0.9367
train acc, test acc | 0.940133333333, 0.9382
train acc, test acc | 0.94175, 0.9397
train acc, test acc | 0.943566666667, 0.9417
train acc, test acc | 0.945233333333, 0.9435

グラフ

↑

ハイパーパラメタ †

人間が手動で設定するパラメタ

確率的勾配下降法（SGD）の繰り返し回数
```
iters_num = 10000
```
1回のミニバッチのサイズ
```
batch_size = 100
```
学習率
```
learning_rate = 0.1
```

ニューラルネットワーク（学習） のバックアップ(No.28)