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

news2024/9/23 15:30:40

前言：

长短期记忆网络（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 d21


def normal(shape,devices):
    
    data = torch.randn(size= shape, device=devices)*0.01
    
    return data


def 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 params

def 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) = state
    outputs= []
    
    for x in inputs:
        
        #input gate
        I = 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_tmp
        
        H = O*torch.tanh(C)
        Y = (H@W_hq)+b_q
        
        outputs.append(Y)
        
    return torch.cat(outputs, dim=0),(H,C)
        
    

def main():
    batch_size,num_steps =32, 35
    train_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.coloradmin.cn/o/834143.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！