在前面的幾篇文章中試着實現了CNN,RNN的一些組件,這裏繼續學習LSTM,也是是實現部分組件,旨在學習其LSTM的原理。
具體參考:
https://www.zybuluo.com/hanbingtao/note/581764
LSTM訓練算法框架
LSTM的訓練算法仍然是反向傳播算法,對於這個算法,我們已經非常熟悉了。主要有下面三個步驟:
- 前向計算每個神經元的輸出值,對於LSTM來說,即 五個向量的值。計算方法已經在上一節中描述過了。
- 反向計算每個神經元的誤差項 值。與循環神經網絡一樣,LSTM誤差項的反向傳播也是包括兩個方向:一個是沿時間的反向傳播,即從當前t時刻開始,計算每個時刻的誤差項;一個是將誤差項向上一層傳播。
- 根據相應的誤差項,計算每個權重的梯度。
下面是代碼實現:
activators.py
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
import numpy as np
class ReluActivator(object):
def forward(self, weighted_input):
#return weighted_input
return max(0, weighted_input)
def backward(self, output):
return 1 if output > 0 else 0
class IdentityActivator(object):
def forward(self, weighted_input):
return weighted_input
def backward(self, output):
return 1
class SigmoidActivator(object):
def forward(self, weighted_input):
return 1.0 / (1.0 + np.exp(-weighted_input))
def backward(self, output):
return output * (1 - output)
class TanhActivator(object):
def forward(self, weighted_input):
return 2.0 / (1.0 + np.exp(-2 * weighted_input)) - 1.0
def backward(self, output):
return 1 - output * output
下面是lstm.py的代碼:
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
import matplotlib.pyplot as plt
import numpy as np
from activators import SigmoidActivator, TanhActivator, IdentityActivator
# element_wise_op函數實現了對numpy數組進行按元素操作,並將返回值寫回到數組中
def element_wise_op(array, op):
for i in np.nditer(array,op_flags=['readwrite']):
i[...] = op(i)
# 在構造函數的初始化中,只初始化了與forward計算相關的變量,與backward相關的變量沒有初始化。
# 這是因爲構造LSTM對象的時候,我們還不知道它未來是用於訓練(既有forward又有backward)
# 還是推理(只有forward)
class LstmLayer(object):
def __init__(self, input_width, state_width,learning_rate):
self.input_width = input_width
self.state_width = state_width
self.learning_rate = learning_rate
# 門的激活函數
self.gate_activator = SigmoidActivator()
# 輸出的激活函數
self.output_activator = TanhActivator()
# 當前時刻初始化爲t0
self.times = 0
# 各個時刻的單元狀態向量c
self.c_list = self.init_state_vec()
# 各個時刻的輸出向量h
self.h_list = self.init_state_vec()
# 各個時刻的遺忘門f
self.f_list = self.init_state_vec()
# 各個時刻的輸入門i
self.i_list = self.init_state_vec()
# 各個時刻的輸出門o
self.o_list = self.init_state_vec()
# 各個時刻的即時狀態c~
self.ct_list = self.init_state_vec()
# 遺忘門權重矩陣Wfh, Wfx, 偏置項bf
self.Wfh, self.Wfx, self.bf = (self.init_weight_mat())
# 輸入門權重矩陣Wfh, Wfx, 偏置項bf
self.Wih, self.Wix, self.bi = (self.init_weight_mat())
# 輸出門權重矩陣Wfh, Wfx, 偏置項bf
self.Woh, self.Wox, self.bo = ( self.init_weight_mat())
# 單元狀態權重矩陣Wfh, Wfx, 偏置項bf
self.Wch, self.Wcx, self.bc = (self.init_weight_mat())
def init_state_vec(self):
'''
初始化保存狀態的向量
'''
state_vec_list = []
state_vec_list.append(np.zeros((self.state_width, 1)))
return state_vec_list
def init_weight_mat(self):
'''
初始化權重矩陣
'''
Wh = np.random.uniform(-1e-4, 1e-4,(self.state_width, self.state_width))
Wx = np.random.uniform(-1e-4, 1e-4,(self.state_width, self.input_width))
b = np.zeros((self.state_width, 1))
return Wh, Wx, b
# forward方法實現了LSTM的前向計算:每次輸入不同的向量,其中權重矩陣是相同的。
def forward(self, x):
'''
根據式1-式6進行前向計算
'''
self.times += 1
# 遺忘門
fg = self.calc_gate(x, self.Wfx, self.Wfh, self.bf, self.gate_activator)
self.f_list.append(fg)
# 輸入門
ig = self.calc_gate(x, self.Wix, self.Wih,self.bi, self.gate_activator)
self.i_list.append(ig)
# 輸出門
og = self.calc_gate(x, self.Wox, self.Woh,self.bo, self.gate_activator)
self.o_list.append(og)
# 即時狀態
ct = self.calc_gate(x, self.Wcx, self.Wch,self.bc, self.output_activator)
self.ct_list.append(ct)
# 單元狀態
c = fg * self.c_list[self.times - 1] + ig * ct # *是對應元素相乘
self.c_list.append(c)
# 輸出
h = og * self.output_activator.forward(c)
self.h_list.append(h)
# 門的計算方法都相同,這裏的calc_gate方法可以複用
def calc_gate(self, x, Wx, Wh, b, activator):
'''
計算門
'''
h = self.h_list[self.times - 1] # 上次的LSTM輸出
net = np.dot(Wh, h) + np.dot(Wx, x) + b
gate = activator.forward(net)
return gate
# backward方法實現了LSTM的反向傳播算法
def backward(self, x, delta_h, activator):
'''
實現LSTM訓練算法
'''
self.calc_delta(delta_h, activator)
self.calc_gradient(x)
def update(self):
'''
按照梯度下降,更新權重
'''
self.Wfh -= self.learning_rate * self.Whf_grad
self.Wfx -= self.learning_rate * self.Whx_grad
self.bf -= self.learning_rate * self.bf_grad
self.Wih -= self.learning_rate * self.Whi_grad
self.Wix -= self.learning_rate * self.Whi_grad
self.bi -= self.learning_rate * self.bi_grad
self.Woh -= self.learning_rate * self.Wof_grad
self.Wox -= self.learning_rate * self.Wox_grad
self.bo -= self.learning_rate * self.bo_grad
self.Wch -= self.learning_rate * self.Wcf_grad
self.Wcx -= self.learning_rate * self.Wcx_grad
self.bc -= self.learning_rate * self.bc_grad
# 計算誤差項
def calc_delta(self, delta_h, activator):
# 初始化各個時刻的誤差項
self.delta_h_list = self.init_delta() # 輸出誤差項
self.delta_o_list = self.init_delta() # 輸出門誤差項
self.delta_i_list = self.init_delta() # 輸入門誤差項
self.delta_f_list = self.init_delta() # 遺忘門誤差項
self.delta_ct_list = self.init_delta() # 即時輸出誤差項
# 保存從上一層傳遞下來的當前時刻的誤差項
self.delta_h_list[-1] = delta_h
# 迭代計算每個時刻的誤差項
for k in range(self.times, 0, -1):
self.calc_delta_k(k)
def init_delta(self):
'''
初始化誤差項
'''
delta_list = []
for i in range(self.times + 1):
delta_list.append(np.zeros(
(self.state_width, 1)))
return delta_list
def calc_delta_k(self, k):
'''
根據k時刻的delta_h,計算k時刻的delta_f、
delta_i、delta_o、delta_ct,以及k-1時刻的delta_h
'''
# 獲得k時刻前向計算的值
ig = self.i_list[k]
og = self.o_list[k]
fg = self.f_list[k]
ct = self.ct_list[k]
c = self.c_list[k]
c_prev = self.c_list[k-1]
tanh_c = self.output_activator.forward(c)
delta_k = self.delta_h_list[k]
# 根據式9,10,11,12計算delta_f、delta_i、delta_o、delta_ct
delta_o = (delta_k * tanh_c *
self.gate_activator.backward(og))
delta_f = (delta_k * og *
(1 - tanh_c * tanh_c) * c_prev *
self.gate_activator.backward(fg))
delta_i = (delta_k * og *
(1 - tanh_c * tanh_c) * ct *
self.gate_activator.backward(ig))
delta_ct = (delta_k * og *
(1 - tanh_c * tanh_c) * ig *
self.output_activator.backward(ct))
# k-1時刻的delta_h
delta_h_prev = (
np.dot(delta_o.transpose(), self.Woh) +
np.dot(delta_i.transpose(), self.Wih) +
np.dot(delta_f.transpose(), self.Wfh) +
np.dot(delta_ct.transpose(), self.Wch)
).transpose()
# 保存全部delta值
self.delta_h_list[k-1] = delta_h_prev
self.delta_f_list[k] = delta_f
self.delta_i_list[k] = delta_i
self.delta_o_list[k] = delta_o
self.delta_ct_list[k] = delta_ct
def calc_gradient(self, x):
# 初始化遺忘門權重梯度矩陣和偏置項
self.Wfh_grad, self.Wfx_grad, self.bf_grad = (
self.init_weight_gradient_mat())
# 初始化輸入門權重梯度矩陣和偏置項
self.Wih_grad, self.Wix_grad, self.bi_grad = (
self.init_weight_gradient_mat())
# 初始化輸出門權重梯度矩陣和偏置項
self.Woh_grad, self.Wox_grad, self.bo_grad = (
self.init_weight_gradient_mat())
# 初始化單元狀態權重梯度矩陣和偏置項
self.Wch_grad, self.Wcx_grad, self.bc_grad = (
self.init_weight_gradient_mat())
# 計算對上一次輸出h的權重梯度
for t in range(self.times, 0, -1):
# 計算各個時刻的梯度
(Wfh_grad, bf_grad,
Wih_grad, bi_grad,
Woh_grad, bo_grad,
Wch_grad, bc_grad) = (self.calc_gradient_t(t))
# 實際梯度是各時刻梯度之和
self.Wfh_grad += Wfh_grad
self.bf_grad += bf_grad
self.Wih_grad += Wih_grad
self.bi_grad += bi_grad
self.Woh_grad += Woh_grad
self.bo_grad += bo_grad
self.Wch_grad += Wch_grad
self.bc_grad += bc_grad
# 計算對本次輸入x的權重梯度
xt = x.transpose()
self.Wfx_grad = np.dot(self.delta_f_list[-1], xt)
self.Wix_grad = np.dot(self.delta_i_list[-1], xt)
self.Wox_grad = np.dot(self.delta_o_list[-1], xt)
self.Wcx_grad = np.dot(self.delta_ct_list[-1], xt)
def init_weight_gradient_mat(self):
'''
初始化權重矩陣
'''
Wh_grad = np.zeros((self.state_width,
self.state_width))
Wx_grad = np.zeros((self.state_width,
self.input_width))
b_grad = np.zeros((self.state_width, 1))
return Wh_grad, Wx_grad, b_grad
def calc_gradient_t(self, t):
'''
計算每個時刻t權重的梯度
'''
h_prev = self.h_list[t-1].transpose()
Wfh_grad = np.dot(self.delta_f_list[t], h_prev)
bf_grad = self.delta_f_list[t]
Wih_grad = np.dot(self.delta_i_list[t], h_prev)
bi_grad = self.delta_f_list[t]
Woh_grad = np.dot(self.delta_o_list[t], h_prev)
bo_grad = self.delta_f_list[t]
Wch_grad = np.dot(self.delta_ct_list[t], h_prev)
bc_grad = self.delta_ct_list[t]
return Wfh_grad, bf_grad, Wih_grad, bi_grad, \
Woh_grad, bo_grad, Wch_grad, bc_grad
def reset_state(self):
# 當前時刻初始化爲t0
self.times = 0
# 各個時刻的單元狀態向量c
self.c_list = self.init_state_vec()
# 各個時刻的輸出向量h
self.h_list = self.init_state_vec()
# 各個時刻的遺忘門f
self.f_list = self.init_state_vec()
# 各個時刻的輸入門i
self.i_list = self.init_state_vec()
# 各個時刻的輸出門o
self.o_list = self.init_state_vec()
# 各個時刻的即時狀態c~
self.ct_list = self.init_state_vec()
def data_set():
x = [np.array([[1], [2], [3]]),
np.array([[2], [3], [4]])]
# 這裏的d是作爲最後一個時刻的誤差項
d = np.array([[1], [2]])
return x, d
def gradient_check():
'''
梯度檢查
'''
# 設計一個誤差函數,取所有節點輸出項之和
error_function = lambda o: o.sum()
lstm = LstmLayer(3, 2, 1e-3)
# 計算forward值
x, d = data_set()
lstm.forward(x[0])
lstm.forward(x[1])
# 求取sensitivity map
sensitivity_array = np.ones(lstm.h_list[-1].shape,dtype=np.float64)
# 計算梯度
lstm.backward(x[1], sensitivity_array, IdentityActivator())
# 檢查梯度
epsilon = 10e-4
for i in range(lstm.Wfh.shape[0]):
for j in range(lstm.Wfh.shape[1]):
lstm.Wfh[i,j] += epsilon
lstm.reset_state()
lstm.forward(x[0])
lstm.forward(x[1])
err1 = error_function(lstm.h_list[-1])
lstm.Wfh[i,j] -= 2*epsilon
lstm.reset_state()
lstm.forward(x[0])
lstm.forward(x[1])
err2 = error_function(lstm.h_list[-1])
expect_grad = (err1 - err2) / (2 * epsilon)
lstm.Wfh[i,j] += epsilon
print 'weights(%d,%d): expected - actural %.4e - %.4e' % (
i, j, expect_grad, lstm.Wfh_grad[i,j])
return lstm
def test():
# input_width, state_width,learning_rate
l = LstmLayer(3, 2, 1e-3)
x, d = data_set()
l.forward(x[0])
#print 'Wfx..1:',l.Wfx
l.forward(x[1])
#print 'Wfx..2:',l.Wfx
l.backward(x[1], d, IdentityActivator())
return l
if __name__ == '__main__':
test()
gradient_check()
運行結果:
weights(0,0): expected - actural 1.2801e-09 - 1.2802e-09
weights(0,1): expected - actural -2.0909e-09 - -2.0909e-09
weights(1,0): expected - actural -2.0909e-09 - -2.0909e-09
weights(1,1): expected - actural 3.4151e-09 - 3.4150e-09
這裏多了一個梯度檢查的步驟,原理參考:
https://www.zybuluo.com/hanbingtao/note/476663,這裏有其代碼原理。
lstm有幾點需要注意的地方:
- 這裏僅是組件,不是完整的實現lstm的所有流程,比如僅僅反向傳播了關於時間的梯度,也即是隻更新了 的權重,還有 也需要更新,這裏的代碼沒有給出。
- 公式推到中的矩陣元素對應相乘需要注意下,還有文章中的後續對其求全導也需要留意。
- 這裏的運行結果是對所求梯度的驗證
總之,通過代碼和理論公式推到相結合,對lstm的原理和運行機制有了更進一步的理解,當然這只是最基礎的架構,還有其他的很多變體,後面繼續努力。