[PyTorch][chapter 46][LSTM -1]

前言：

长短期记忆网络（LSTM，Long Short-Term Memory）是一种时间循环神经网络，是为了解决一般的RNN（循环神经网络）存在的长期依赖问题而专门设计出来的。

背景简介
LSTM Cell
LSTM 反向传播算法
为什么能解决梯度消失
LSTM 模型的搭建

一背景简介：

1.1 RNN

RNN 忽略 $o_t,L_t,y_t$ 模型可以简化成如下

　图中Rnn Cell 可以很清晰看出在隐藏状态 $h_t=f(x_t,h_{t-1})$ 。

得到 $h_t$ 后:

一方面用于当前层的模型损失计算，另一方面用于计算下一层的 $h_{t+1}$

　　　　由于RNN梯度消失的问题，后来通过LSTM 解决

1.2 LSTM 结构

二 LSTM Cell

LSTMCell(RNNCell) 结构

前向传播算法 Forward

2.1 更新： forget gate 忘记门

$f_t=\sigma(W_fh_{t-1}+U_{t}x_t+b_f)$

将值朝0 减少，激活函数一般用sigmoid

输出值[0,1]

2.2 更新： Input gate 输入门

$i_t=\sigma(W_ih_{t-1}+U_ix_t+b_i)$

决定是不是忽略输入值

2.3 更新：候选记忆单元

$a_t=\widetilde{c_t}=tanh(W_a h_{t-1}+U_ax_t+b_a)$

2.4 更新：记忆单元

$c_t=f_t \odot c_{t-1}+i_t \odot a_t$

2.5 更新：输出门

决定是否使用隐藏值

$o_t=\sigma(W_oh_{t-1}+U_ox_t+b_0)$

2.6. 隐藏状态

$h_t=o_t \odot tanh(c_t)$

2.7 模型输出

$\hat{y_t}=\sigma(Vh_t+b)$

LSTM 门设计的解释一：

输入门，遗忘门，输出门不同取值组合的时候，记忆单元的输出情况

三 LSTM 反向传播推导

3.1 定义两个 $\delta_t$

$\delta_h^t=\frac{\partial L}{\partial h_t}$

$\delta_c^t=\frac{\partial L}{\partial C_t}$

3.2 定义损失函数

损失函数 $L(t)$ 分为两部分:

时刻t的损失函数 $l(t)$

时刻t后的损失函数 $L(t+1)$

$L(t)=\left\{\begin{matrix} l(t)+L(t+1), if: t<T\\ l(t), if: t=T \end{matrix}\right.$

3.3 最后一个时刻 $\tau$ 的

这里面要注意这里的 $o^{\tau}= Vh_{\tau}+c$

证明一下第二项，主要应用到微分的两个性质,以及微分和迹的关系：

$dl= tr((\frac{\partial L^{\tau}}{\partial h^{\tau}})^Tdh^{\tau})$ ... 公式1：微分和迹的关系

$=tr((\delta_h^{\tau})^Tdh^{\tau})$

因为

$h^{\tau}=o^{\tau} \odot tanh(c^{\tau})$

$dh_T=o^{\tau}\odot(d(tanh (c^{\tau})))$

$=o^{\tau} \odot (1-tanh^2(c^{\tau})) \odot dc^{\tau}$

带入上面公式1：

$dl= tr((\delta_h^{\tau})^T (o^{\tau}\odot(1-tanh^2(c^{\tau}))\odot dc^{\tau})$

$=tr((\delta_h^{\tau} \odot o^{\tau} \odot(1-tanh^2(c^{\tau}))^Tdc^{\tau})$

所以

3.4 链式求导过程

求导结果：

这里详解一下推导过程：

这是一个符合函数求导：先把h 写成向量形成

$h=\begin{bmatrix} o_1*tanh(c_1)\\ o_2*tanh(c_2) \\ .... \\ o_n*tanh(c_n) \end{bmatrix}$

------------------------------------------------------------

第一项：

$h_{t+1}=o_{t+1}\odot tanh(c_{t+1})$

$o_{t+1}=\sigma(W_oh_t+U_ox_{t+1}+b_0)$

设 $a_{t+1}=W_oh_t+U_ox_{t+1}+b_0$

则    $\frac{\partial h_{t+1}}{\partial h_{t}}=\frac{\partial h_{t+1}}{\partial o_{t+1}}\frac{\partial o_{t+1}}{\partial a_{t+1}}\frac{\partial a_{t+1}}{\partial h_{t}}$

其中：（利用矩阵求导的定义法分子布局原理）

   $\frac{\partial h_{t+1}}{\partial o_{t+1}}=diag(tanh(c^{t+1}))$ 是一个对角矩阵

   $o=\begin{bmatrix} \sigma(a_1)\\ \sigma(a_2) \\ .... \\ \sigma(a_n) \end{bmatrix}$

$\frac{\partial o_{t+1}}{\partial a_{t+1}}=diag(o_{t+1}\odot(1-o_{t+1}))$

$\frac{\partial a_{t+1}}{\partial h_{t}}=W_o$

几个连乘起来就是第一项

第二项

$c_{t+1}=f_{t+1}\odot c_t+i_{t+1}\odot a_{t+1}$

$f_{t+1}=\sigma(W_fh_t+U_tx_{t+1}+b_f)$

$i_{t+1}=\sigma(W_ih_t+U_i x_{t+1}+b_i)$

$a_{t+1}=tanh(W_a h_t +U_ax_t +b_a)$

参考：

$h=\begin{bmatrix} o_1*tanh(c_1)\\ o_2*tanh(c_2) \\ .... \\ o_n*tanh(c_n) \end{bmatrix}$

其中：

$\frac{\partial h_{t+1}}{\partial c^{t+1}}=diag(o^{t+1}\odot (1-tanh^2(c^{t+1}))$

$\frac{\partial h_{t+1}}{\partial h_{t}}=\frac{\partial h_{t+1}}{\partial c_{t+1}}\frac{\partial c_{t+1}}{\partial f_{t+1}}\frac{\partial f_{t+1}}{\partial h_{t}}$

$\frac{\partial c_{t+1}}{\partial f_{t+1}}=diag(c^{t})$

$\frac{\partial a_{t+1}}{\partial h_{t}}=diag(f_t \odot(1-f_t))W_f$

其它也是相似，就有了上面的求导结果

四 为什么能解决梯度消失

4.1 RNN 梯度消失的原理

,复旦大学邱锡鹏书里面有更加详细的解释，通过极大假设：

在梯度计算中存在梯度的k 次方连乘，导致梯度消失原理。

4.2 LSTM 解决梯度消失解释1：

通过上面公式发现梯度计算中是加法运算，不存在连乘计算，

极大概率降低了梯度消失的现象。

4.3 LSTM 解决梯度消失解释2：

记忆单元c 作用相当于ResNet的残差部分.

比如 $f_{t}=1,\hat{c_t}=0$ 时候, $\frac{\partial c_t}{\partial c_{t-1}}=1$ ,不会存在梯度消失。

五模型的搭建

我们最后发现：

$O_t,C_t,H_t$ 的维度必须一致，都是hidden_size

通过 $C_t$ ,则 $I_t,F_t,\tilde{c}$ 最后一个维度也必须是hidden_size

# -*- coding: utf-8 -*-
"""
Created on Thu Aug  3 15:11:19 2023@author: chengxf2
"""# -*- coding: utf-8 -*-
"""
Created on Wed Aug  2 15:34:25 2023@author: chengxf2
"""import torch
from torch import nn
from d21 import torch as d21def normal(shape,devices):data = torch.randn(size= shape, device=devices)*0.01return datadef get_lstm_params(input_size, hidden_size,categorize_size,devices):#隐藏门参数W_xf= normal((input_size, hidden_size), devices)W_hf = normal((hidden_size, hidden_size),devices)b_f = torch.zeros(hidden_size,devices)#输入门参数W_xi= normal((input_size, hidden_size), devices)W_hi = normal((hidden_size, hidden_size),devices)b_i = torch.zeros(hidden_size,devices)#输出门参数W_xo= normal((input_size, hidden_size), devices)W_ho = normal((hidden_size, hidden_size),devices)b_o = torch.zeros(hidden_size,devices)#临时记忆单元W_xc= normal((input_size, hidden_size), devices)W_hc = normal((hidden_size, hidden_size),devices)b_c = torch.zeros(hidden_size,devices)#最终分类结果参数W_hq = normal((hidden_size, categorize_size), devices)b_q = torch.zeros(categorize_size,devices)params =[W_xf,W_hf,b_f,W_xi,W_hi,b_i,W_xo,W_ho,b_o,W_xc,W_hc,b_c,W_hq,b_q]for param in params:param.requires_grad_(True)return paramsdef init_lstm_state(batch_size, hidden_size, devices):cell_init = torch.zeros((batch_size, hidden_size),device=devices)hidden_init = torch.zeros((batch_size, hidden_size),device=devices)return (cell_init, hidden_init)def lstm(inputs, state, params):[W_xf,W_hf,b_f,W_xi,W_hi,b_i,W_xo,W_ho,b_o,W_xc,W_hc,b_c,W_hq,b_q] = params    (H,C) = stateoutputs= []for x in inputs:#input gateI = torch.sigmoid((x@W_xi)+(H@W_hi)+b_i)F = torch.sigmoid((x@W_xf)+(H@W_hf)+b_f)O = torch.sigmoid((x@W_xo)+(H@W_ho)+b_o)C_tmp = torch.tanh((x@W_xc)+(H@W_hc)+b_c)C = F*C+I*C_tmpH = O*torch.tanh(C)Y = (H@W_hq)+b_qoutputs.append(Y)return torch.cat(outputs, dim=0),(H,C)def main():batch_size,num_steps =32, 35train_iter, cocab= d21.load_data_time_machine(batch_size, num_steps)if __name__ == "__main__":main()

参考

CSDN

https://www.cnblogs.com/pinard/p/6519110.html

57 长短期记忆网络（LSTM）【动手学深度学习v2】_哔哩哔哩_bilibili

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/83956.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！