def forward(self, input_array):
self.input_list.append(input_array)
self.times += 1
current_cell_state = np.dot(self.u, self.cell_state_list[-1]) + np.dot(
self.w, input_array)
element_wise_op(current_cell_state, self.output_activator.forward)
self.cell_state_list.append(current_cell_state)
def backward(self, sensitivity_array):
# 计算delta数组
delta_list = []
for i in range(self.times):
delta_list.append(np.zeros([self.output_size, 1]))
delta_list.append(sensitivity_array)
for t in range(self.times - 1, 0, -1):
state_t = self.cell_state_list[t].copy()
element_wise_op(state_t, self.output_activator.backward)
delta_t = np.dot(self.u.T, delta_list[t + 1]) * state_t
delta_list[t] = delta_t
# 计算梯度
u_grad_list = []
w_grad_list = []
for t in range(self.times, 0, -1):
delta_t = delta_list[t]
previous_cell_state = self.cell_state_list[t - 1]
input_t = self.input_list[t]
u_grad_t = np.dot(delta_t, previous_cell_state.T)
w_grad_t = np.dot(delta_t, input_t.T)
u_grad_list.append(u_grad_t)
w_grad_list.append(w_grad_t)
self.w_grad = reduce(lambda m, n: n + m, w_grad_list,
np.zeros(self.w_grad.shape))
self.u_grad = reduce(lambda m, n: n + m, u_grad_list,
np.zeros(self.u_grad.shape))
def calc_delta_k(self, k, activator):
'''
根据k+1时刻的delta计算k时刻的delta
'''
state = self.state_list[k + 1].copy()
element_wise_op(self.state_list[k + 1], activator.backward)
self.delta_list[k] = np.dot(np.dot(self.delta_list[k + 1].T, self.W),
np.diag(state[:, 0])).T
def calc_delta_k(self, k, activator):
"""
误差传播 : dt-1.T = dt.T * W * diag(f'(St))
"""
state = self.state_list[k + 1].copy()
element_wise_op(self.state_list[k + 1], activator.backward) #f'(St)
self.delta_list[k] = np.dot(np.dot(self.delta_list[k + 1].T, self.W),
np.diag(state[:, 0])).T
def forward(self, input_array):
'''
根据『式2』进行前向计算
'''
self.times += 1
state = (np.dot(self.U, input_array) +
np.dot(self.W, self.state_list[-1]))
element_wise_op(state, self.activator.forward)
self.state_list.append(state)
def forward(self, input_array):
'''
根据『式2』进行前向计算
'''
self.times += 1
state = (np.dot(self.U, input_array) +
np.dot(self.W, self.state_list[-1]))
element_wise_op(state, self.activator.forward)
self.state_list.append(state)
def calc_delta_k(self, k, activator):
'''
根据k+1时刻的delta计算k时刻的delta(公式4)
'''
state = self.state_list[k + 1].copy()
element_wise_op(self.state_list[k + 1], activator.backward) #激活函数求导
self.delta_list[k] = np.dot(
np.dot(self.delta_list[k + 1].T, self.W),
np.diag(state[:, 0])).T #delta[l-1] = delta[l]*U*diag(state)
def forward(self, input_array):
"""
向前传播 : St = f(U * Xt + W * St-1)
"""
self.times += 1
state = (np.dot(self.U, input_array) +
np.dot(self.W, self.state_list[-1]))
element_wise_op(state, self.activator.forward)
self.state_list.append(state)
def forward(self, input_array):
'''
前向计算
'''
self.times += 1 # 时间步
state = (np.dot(self.U, input_array) +
np.dot(self.W, self.state_list[-1])) # 点积（元素对应相乘）
element_wise_op(state, self.activator.forward)
self.state_list.append(state)
def calc_delta_k(self, k, activator):
'''
根据k+1时刻的delta计算k时刻的delta
'''
state = self.state_list[k + 1].copy()
element_wise_op(self.state_list[k + 1],
activator.backward)
self.delta_list[k] = np.dot(
np.dot(self.delta_list[k + 1].T, self.W),
np.diag(state[:, 0])).T
def forward(self, input_aray):
"""
进行前行计算
"""
self.times += 1
ux = np.dot(self.U, input_aray)
ws = np.dot(self.W, self.state_list[-1])
state = ux + ws
element_wise_op(state, self.activator.forward)
self.state_list.append(state)
def calc_delta_k(self, k, activator): #have some problem 应该把加权输入和神经元的输出分别保存，这个公式错了！！！
'''
根据k+1时刻的delta计算k时刻的delta
'''
state = self.state_list[k].copy()
element_wise_op(state,
activator.backward)
self.delta_list[k] = np.dot(
np.dot(self.delta_list[k+1].T, self.W),
np.diag(state[:,0])).T
def calc_delta_k(self, k, activator):
'''
根据k+1时刻的delta计算k时刻的delta
'''
# 讨论k时刻对k+1时刻的影响（权重）
state = self.state_list[k+1].copy() # copy-复制k+1的state
element_wise_op(self.state_list[k+1],
activator.backward)
self.delta_list[k] = np.dot(
np.dot(self.delta_list[k+1].T, self.W),
np.diag(state[:,0])).T # dot-点乘，diag-对角矩阵
