「.NET 開発基盤部会 Wiki」は、「Open棟梁Project」,「OSSコンソーシアム .NET開発基盤部会」によって運営されています。
目次 †
学習の概要 †
ニューラルネットワークにおいては、特徴量を機械が選択し重みを学習(自動獲得)する。
- 構造化データ
- 特徴量を表から選択する。
- 場合によっては次元圧縮したりする。
- 非構造化データ
- 画像
入力画像データから、本質的なデータを抽出できるように設計された変換器を指す。
- 画像データの特徴量は通常、ベクトルを使用して表される。
- SIFT, SURF, HOGなど、人が設計した変換器によって画像データをベクトル化する。
重みの自動獲得 †
学習フェーズでは、信号は逆方向に伝播する。
- 実際のニューラルネットワークの重みパラメタは、
- 数千、数万になるため、手動での設定は不可能。
- 更に層を深めた深層学習(deep learning)では数億にも登る。
- 重みパラメタの自動獲得のため、
- 損失関数という指標を導入する。
損失関数を使用して値が最小(最大)になるような重みパラメタを探す。
- このようなパラメタを探し出すためには、勾配法という手法を用いる。
勾配は、各場所で(損失)関数の値を最も減らす方向を示す。
学習はデータ駆動 †
- MNISTデータセットの様な画像の分類処理を行うアルゴリズムを考え出すのは困難。
しかし、機械にデータを学習させる機械学習を用いれば分類処理が実現可能。
人間が(暗黙的な学習によって、)これらを判別することはできる。
従って、人間の脳も、一部は、このようなデータ駆動で動いているのかもしれない。
- このように、アルゴリズムを捻り出すのではなく、データを有効活用して解決する方法に、
画像から特徴量を抽出し、特徴量のパターンを機械学習の技術で学習するという方法がある。
損失関数(誤差関数) †
- 損失関数は、誤差関数とほぼ同じか、より包括的な概念。
- 予想データと正解データの出力の間に、
どのくらい誤差があるのかを評価する関数。
- 作成した予測モデルの精度を評価する際に使われ、
- 値(誤差)が小さければ小さいほど正確なモデルと言える。
- モデル関数とデータ群の誤差という文脈では誤差関数と呼ばれる。
- 学習の文脈では損失関数と呼ばれ、誤差関数以外にも例えばKL情報量などを含む。
- 深層学習では一つの指標を手がかりに最適なパラメタを探索する。
- この指標を損失関数を呼び、パラメタに対して連続的に変化する関数を用いる。
- これは学習時に、微分によって傾きが0になってパラメタの更新できなくなることを防ぐため。
2乗和誤差 †
回帰の場合(ニューラルネットワークの出力と正解となる教師データの各要素の差の二乗の総和の2分の一。
- 説明
- 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]
Softmax関数の出力(全て足して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))
- 高ければ高いほど、0に近いデータになる。
tkで2が正解の場合、ykで2の確率が一番高いとしたデータの場合のE。
0.0975
- 低ければ低いほど、1に近いデータになる。
tkで2が正解の場合、ykで7の確率が一番高いとしたデータの場合のE。
0.5975
- 前者の損失関数(2乗和誤差)の出力が小さい前者のykがより適合していることを示している。
交差エントロピー誤差 †
多値分類(正解ラベルのykデータの底がeの自然対数 log eを計算する。
- 説明
- log:logは底がeの自然対数 log e
- k:データの次元数
- yk:ニューラルネットワークの出力
- tk:教師データ
- 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))
- 高ければ高いほど、0に近いデータになる。
tkで2が正解の場合、ykで2の確率が一番高いとしたデータの場合のE。
0.510825457099
- 低ければ低いほど、大きいデータになる。
tkで2が正解の場合、ykで7の確率が一番高いとしたデータの場合のE。
2.30258409299
- 前者の損失関数(交差エントロピー誤差)の出力が小さい前者のykがより適合していることを示している。
勾配の計算 †
微分(偏微分)で求めた勾配の示す方向は、
各場所で関数の値を最も減らす方向(である可能性が高い)。
勾配法 †
- 勾配法では、広大なパラメタ空間から、複雑な損失関数が、
最小(最大)値を出力する鞍点(saddle point)を、勾配を使用して探す。
- 勾配降下法 : 最小値を探す。
- 勾配上昇法 : 最大値を探す。
- 注意点
- 勾配の指す方向に最小(最大)値があることは保証されない。
- 複雑な関数の場合は、勾配の指す方向に最小(最大)値が無い可能性が高い。
曲線の勾配計算 †
- 説明
- すべての変数の偏微分をベクトルとしてまとめたものを勾配と呼ぶ。
- 上記の例なら、x0=3, x1=4の場合、勾配は、(6, 8)となる。
- Python
- 実装
"""This is a test program."""
import numpy as np
def numerical_gradient(f, x01):
"""偏微分"""
h = 1e-4 # 微小な値hとして1の-4乗を用いる
grad = np.zeros_like(x01) # x01と同じ形状で要素が0。
for idx in range(x01.size):
tmp_val = x01[idx]
# 前方差分から中心差分にして誤差減
# f(x + h)
fxh1 = f(tmp_val + h)
# f(x - h)
fxh2 = f(tmp_val - h)
# (f(x + h) - f(x - h)) / 2 * h
grad[idx] = (fxh1 - fxh2) / (2 * h)
return grad
def function_2(x):
return np.sum(x**2)
print(numerical_gradient(function_2, np.array([3.0, 4.0])))
print(numerical_gradient(function_2, np.array([0.0, 2.0])))
print(numerical_gradient(function_2, np.array([3.0, 0.0])))
曲面の勾配計算 †
- Python
以下の式の最小値を勾配法で求める。
2 2
f(x0, x1) = x0 + x1
- 実装
import numpy as np
def numerical_gradient(f, x01):
"""偏微分"""
h = 1e-4 # 微小な値hとして1の-4乗を用いる
grad = np.zeros_like(x01) # x01と同じ形状で要素が0。
# print("x01:" + str(x01));
for idx in range(x01.size):
tmp_val = x01[idx]
# 前方差分から中心差分にして誤差減
# f(x + h)
fxh1 = f(tmp_val + h)
# f(x - h)
fxh2 = f(tmp_val - h)
# (f(x + h) - f(x - h)) / 2 * h
grad[idx] = (fxh1 - fxh2) / (2 * h)
return grad
def gradient_descent(f, init_x01, lr, step_num):
print("ln : step_num = " + str(lr) + " : " + str(step_num))
x01 = init_x01
for i in range(step_num):
grad = numerical_gradient(f, x01)
x01 -= lr * grad
return x01
def function_2(x):
return np.sum(x**2)
init_x = np.array([-3.0, 4.0])
print(gradient_descent(function_2, init_x, 0.1, 100))
# 学習率が大きすぎる。
init_x = np.array([-3.0, 4.0])
print(gradient_descent(function_2, init_x, 10.0, 100))
# 学習率が小さすぎる。
init_x = np.array([-3.0, 4.0])
print(gradient_descent(function_2, init_x, 1e-10, 100))
NNに対する勾配 †
ニューラルネットワークの学習における勾配は、
重みパラメタに関する損失関数の勾配となる。
- simpleNetを使って推論/学習
- 実装
import sys, os
sys.path.append(os.pardir) # 親ディレクトリのファイルをインポートするための設定
import numpy as np
from common.functions import softmax, cross_entropy_error
from common.gradient import numerical_gradient
from gradient_simplenet import simpleNet
print("==================================================")
print("==================================================")
net = simpleNet()
print("W:" + str(net.W))
x = np.array([0.6, 0.9])
p = net.predict(x)
print("p:" + str(p))
t = np.array([0, 0, 1])
l = net.loss(x, t)
print("loss:" + str(l))
- simpleNetを使って勾配を求める
- 実装
import sys, os
sys.path.append(os.pardir) # 親ディレクトリのファイルをインポートするための設定
import numpy as np
from common.functions import softmax, cross_entropy_error
from common.gradient import numerical_gradient
from gradient_simplenet import simpleNet
print("==================================================")
print("==================================================")
net = simpleNet()
print("W:" + str(net.W))
x = np.array([0.6, 0.9])
t = np.array([0, 0, 1])
f = lambda w: net.loss(x, t)
dW = numerical_gradient(f, net.W)
print("dW:" + str(dW))
- 出力
==================================================
==================================================
W:[[ 1.83160192 0.4900981 -0.94188042]
[-0.24946104 2.91410946 -0.00695892]]
dW:[[ 0.06708443 0.51711391 -0.58419835]
[ 0.10062665 0.77567087 -0.87629752]]
- w11を h 増やすと、0.06708443 h 増加する。
- w12を h 増やすと、0.10062665 h 増加する。
- w21を h 増やすと、0.51711391 h 増加する。
- w22を h 増やすと、0.77567087 h 増加する。
- w31を h 増やすと、-0.58419835 h 増加する( = 減少する)。
- w32を h 増やすと、-0.87629752 h 増加する( = 減少する)。
- 勾配がプラスならhをマイナス方向に、マイナスならプラス方向に動かす。
見せかけの最適化を防ぐ †
- 停留点は、極大点、極小点、鞍点のいずれかになりうる。
- 鞍点は、ある次元では最小だが、別の次元では最大(最小ではない)など。
- 最小化問題において、極小点は局所最小点または大域的最小点のいずれか。
- (最大化問題において、極大点は局所最大点または大域的最大点のいずれか。)
ミニバッチ学習 †
バッチ、ミニバッチ、オンライン学習 †
- バッチ学習(一括学習)
- 全てのサンプルを一度に用いて勾配を求める手法
- 機械学習のアルゴリズムでは基本的にバッチ学習が採用される。
- ただし、深層学習では、データが多過ぎるため、現実的でない。
- オンライン学習(逐次学習)
- ひとつのサンプルのみを用いて勾配を求める手法
- ノイズや外れ値の影響を受け易く、解が適切な値に収束し難い。
- ミニバッチ学習
データを幾つかの塊に小分けにして、その塊毎に勾配を求める手法。
- 勾配計算に損失関数の平均値を使用しても問題はない。
- バッチ学習とオンライン学習の折衷案で、多くの場合において現実的な方法。
- バッチ学習ほど学習時間がかからず、
- オンライン学習ほど解の収束が不安定にならない。
| バッチ学習(一括学習) | ミニバッチ学習 | オンライン学習(逐次学習) | 効率 | ✕ | ○ | ◎ | 安定性 | ◎ | ○ | ✕ |
ミニバッチ学習を訓練用データセットに適用 †
- ミニバッチ学習では、上記の損失関数を訓練用データセットに対して適用する。
- ここでは、訓練用データセットに対する損失関数の総和を指標とする。
- 説明
- 交差エントロピー誤差の式をN個のデータを含む訓練用データセット用に拡張する。
- 最後に、Nで割って正規化する(データ1個あたりの平均の損失関数を求める)。
- 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件でバッチの回数は5回になる。
- 訓練データサイズとバッチサイズが決まれば自動的に決まる。
- エポック数
- 一つの訓練データを何回繰り返して学習させるか?
- 深層学習ではパラメタが収束するまで同じ訓練データで繰り返し学習。
- 学習回数(エポック数)を一定以上増加させると、過学習が発生
その他 †
実装 †
手順 †
前提 †
- ニューラルネットワークには適応可能な重みとバイアスがある。
- 学習により、この重みとバイアスを訓練データに適応するように調整する。
- ニューラルネットワークの学習は、以下の4つのステップで行われる。
ステップ 1 †
- 訓練データから、ランダムにデータを選択する。
- 1つのデータを選択する場合、確率的勾配降下法(SGD)と呼ぶ。
- 一部の(n個の)のデータの平均のデータを使用する場合、ミニバッチ勾配降下法と呼ぶ。
- 全てのデータの平均のデータを使用する場合、バッチ勾配降下法(最急降下法)
ステップ 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 | 正解ラベル |
学習過程の実装 †
勾配法により(損失)関数を少なくしていく。
- 重みパラメタ
- 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の数字
- 実装
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()
学習結果を確認する実装 †
学習結果を使用して、学習データとテストデータを推論する。
- 出力
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
|