[mathjax]
各地点において関数の値を最大にするベクトル((frac{partial f}{partial x_0},frac{partial f}{partial x_1}))を全地点に対して計算したものを勾配とかいう。
ある地点において、このベクトルの方向に向かうことにより最も関数の値を大きくする。
で、今後のために正負を反転して関数の値を最小にするベクトルを考えることにした。
関数の値を小さくする操作を繰り返していけば、いずれ\"最小値\"が見つかるはず。
というモチベを続けるのが勾配降下法。学習率(eta)を使って以下みたいに書ける。。
begin{eqnarray}
x_0 = x_0 - eta frac{partial f}{partial x_0} \\
x_1 = x_1 - eta frac{partial f}{partial x_1}
end{eqnarray}
ということで(f(x_0,x_1)=x_0^2+x_1^2)の最小値を初期値((3.0,4.0))、
学習率(eta=0.1)に設定して計算してみる。
import numpy as np
def numerical_gradient(f, x):
h = 1e-4
grad = np.zeros_like(x)
for idx in range(x.size):
tmp_val = x[idx]
x[idx] = tmp_val + h
fxh1 = f(x)
x[idx] = tmp_val - h
fxh2 = f(x)
grad[idx] = (fxh1 - fxh2) / (2*h)
x[idx] = tmp_val
return grad
def gradient_descent(f, init_x, lr=0.01, step_num=100):
x = init_x
for i in range(step_num):
grad = numerical_gradient(f,x)
x -= lr * grad
return x
def function2(x):
return x[0]**2 + x[1]**2
init_x = np.array([-3.0, 4.0])
v = gradient_descent(function2, init_x=init_x, lr=0.1, step_num=100)
v
# array([-6.11110793e-10, 8.14814391e-10])
((0,0))に収束した。
ニューラルネットワークの勾配
損失関数を重みパラメータで微分する。以下みたいな感じ。
損失関数の大小を見るとして、例えば(w_{11})以外の重みを固定したとして(w_{11})をわずかに
増やしたときに損失関数の値がどれだけ大きくなるか。
損失関数の値はパラメータ(W)と入力(x)から決まるベクトルだけれども、それぞれ乱数と入力値が設定されている。
begin{eqnarray}
W=
begin{pmatrix}
w_{11} & w_{12} & w_{13} \\
w_{21} & w_{22} & w_{23}
end{pmatrix},
frac{partial L}{partial W}=
begin{pmatrix}
frac{partial L}{partial w_{11}} & frac{partial L}{partial w_{12}} & frac{partial L}{partial w_{13}} \\
frac{partial L}{partial w_{21}} & frac{partial L}{partial w_{22}} & frac{partial L}{partial w_{23}}
end{pmatrix}
end{eqnarray}
重み(W)が乱数で決まるネットワークがあるとする。このネットワークは入力と重みの積を出力
として返す。出力はSoftmaxを経由するとする。
ネットワークの出力と教師データのクロスエントロピー誤差を誤差として使う。
その前に、数値微分関数を多次元対応する。
普通、配列の次元が(n)個になると(n)重ループが必要になるけれども、
Numpy.nditer()を使うと(n)乗ループを1回のループにまとめることができる。
下のmulti_indexが((0,0),(0,1),(0,2),(1,0),(1,1),(1,2))みたいに
イテレータが(n)次のタプルを返す。反復回数はタプルの要素数の直積。
Numpy配列にそのタプルでアクセスすることで晴れて全ての要素にアクセスできる。
def numerical_gradient_md(f, x):
h = 1e-4
grad = np.zeros_like(x)
it = np.nditer(x, flags=[\'multi_index\'], op_flags=[\'readwrite\'])
while not it.finished:
idx = it.multi_index
tmp_val = x[idx]
x[idx] = tmp_val + h
fxh1 = f(x) # f(x+h)
x[idx] = tmp_val - h
fxh2 = f(x) # f(x-h)
grad[idx] = (fxh1 - fxh2) / (2*h)
x[idx] = tmp_val # 値を元に戻す
it.iternext()
return grad
初期値(x=(0.6,0.9))、教師データ(t=(0,0,1))をネットワークに入力する。
predict()は(1 times 3)を返す。
それをSoftmax()を通して、(t)とのクロスエントロピー誤差を求めたものが以下。
import numpy as np
def cross_entropy_error(y, t):
if y.ndim == 1:
t = t.reshape(1, t.size)
y = y.reshape(1,y.size)
batch_size = y.shape[0]
delta = 1e-7
return -np.sum( t * np.log( y + delta)) / batch_size
def softmax(x):
c = np.max(x)
return np.exp(x-c) / np.sum(np.exp(x-c))
import sys, os
sys.path.append(os.pardir)
import numpy as np
class simpleNet:
def __init__(self):
self.W = np.random.randn(2,3)
def predict(self, x):
return np.dot(x, self.W)
def loss(self, x, t):
z = self.predict(x)
y = softmax(z)
loss = cross_entropy_error(y, t)
return loss
net = simpleNet()
x = np.array([0.6, 0.9])
p = net.predict(x)
t = np.array([0, 0, 1])
net.loss(x, t)
# 0.9463818740797788
このlossを(W)で微分したのが以下。
あえてパラメータ(W)を引数にとり損失関数の値を計算する(f(W))を定義することで、
数値微分が何と何の演算なのかをわかりやすくしている。
実際は(f(W))は(W)とは関係なく(x)と(t)だけから結果を返すけれども、
損失関数(f(W))を(W)で微分するという操作が自明になるようにコードを合わせている。
def f(W):
return net.loss(x, t)
dW = numerical_gradient_md(f, net.W)
dW
# array([[ 0.07627371, 0.49923236, -0.57550607],
# [ 0.11441057, 0.74884853, -0.8632591 ]])
結果の解釈
上記の(w),(W),(t)から(frac{partial L}{partial W})が求まった。
損失関数が何か複雑な形をしているという状況で、
(frac{partial L}{partial w_{11}})は(w_{11})がわずかに動いたときに損失関数の値が変化する量を表している。
それが(w_{11})から(w_{32})まで6個分存在する。
begin{eqnarray}
frac{partial L}{partial W} =
begin{pmatrix}
frac{partial L}{partial w_{11}} & frac{partial L}{partial w_{21}} & frac{partial L}{partial w_{31}} \\
frac{partial L}{partial w_{12}} & frac{partial L}{partial w_{22}} & frac{partial L}{partial w_{32}}
end{pmatrix} =
begin{pmatrix}
0.07627371 & 0.49923236 & -0.57550607 \\
0.11441057 & 0.74884853 & -0.8632591
end{pmatrix}
end{eqnarray}
