传统RNN模型： 循环神经网络，以序列数据为输入，通过内部网路结构设计有效捕捉序列之间的关系特征，一般也以序列的形式进行输出，RNN的循环机制是模型上一时间步的隐层结果，能够作为当前时间步输入的一部分（正常输入+上一层隐层的输出）对当前时间步的输出产生影响

RNN模型的作用：将输入的进行分词，RNN是按照顺序工作的，每次只能接收一个单词进行处理

层级：词嵌入层 循环层  全连接层

RNN模型的分类：

NvsN：输入和输出序列等长   

Nvs1:输入是一个序列输出是一个单独的值

1vsN:输入是一个图像，输出是一个序列

NvsM:不限输入和输出序列长度的RNN,也称为seq2seq结构，由编码器和解码器组成

RNN结构分析：上一时间步隐层状态输出的结果+当前时间步的输入经过tanh激活函数得到当前时间步的隐藏层输出的结果和输出结果

构建传统RNN模型：优点：内部结构简单，资源消耗较小

缺点：处理长序列的时候，因为反向传播结合梯度连乘，过大或者过小的权重值会导致梯度消失或者梯度爆炸

输入数据的维度：（批次数，序列长度，隐藏层输出维度）

上隐：（rnn层的大小，批次数，隐藏层输出维度）

output输出：（序列长度，批次数，隐藏层输出维度）

当前隐藏状态的输出：（rnn层的大小，批次数，隐藏层输出维度）

API：

# 导包
import torch
import torch.nn as nn

def dm01():
    # 参数    词向量的维度    隐藏层（输出）维度    隐藏层的层数
    rnn=nn.RNN(input_size=5, hidden_size=6, num_layers=1)

    # 准备数据
    input=torch.randn(1,3,5)

    # 准备上隐数据
    h0=torch.randn(1,3,6)

    # 输入数据
    output,hn=rnn(input,h0)
    # 输出的结果
    print(f'output:{output},shape:{output.shape}')
    print(f'hn:{hn},shape:{hn.shape}')
    print(f'rnn模型{rnn}')


if __name__=='__main__':
    dm01()

LSTM模型：长短时记忆结构，能够有效的捕获序长序列之间的语义关系，缓解梯度消失或者是梯度爆炸

由三门一状态组成：1.遗忘门  2.输入门  3.输出门 4.细胞状态

遗忘门：通过对当前输入和上一时刻的隐藏状态，决定记忆细胞哪些信息可以丢弃

公式：遗忘门的门值=sigmoid（权重矩阵*【上一时刻的隐藏状态，当前输入】+偏置）

数值接近1，保留这条记忆，，接近于0就丢弃这个记忆

输入门：决定保留哪些新的记忆

公式：输入门的门值=sigmoid（权重矩阵*【上一时刻的隐藏状态，当前输入】+偏置）

 候选记忆=tanh（权重矩阵*【上一时刻的隐藏状态，当前输入】+偏置）

记忆细胞：决定往下一时间步传输的记忆细胞的内容

公式：遗忘门的门值*上一个记忆细胞+输入门的门值*候选记忆

输出门：决定输出哪些记忆

公式：输出门的门值=sigmoid（权重矩阵*【上一时刻的隐藏状态，当前输入】+偏置）

当前的隐藏状态=输出门的门值*tanh(当前的记忆细胞)

API：

# 导包
import torch
import torch.nn as nn


def dm01():
    lstm=nn.LSTM(input_size=5, hidden_size=6, num_layers=1,bidirectional=False)
    input=torch.randn(4,3,5)
    h0=torch.randn(1, 3, 6)
    #c0要和h0相同
    c0=torch.randn(1, 3, 6)
    output,(hn,cn)=lstm(input,(h0,c0))
    print(f'output:{output},output.shape:{output.shape}')
    print(f'h0:{h0},h0.shape:{h0.shape}')
    print(f'cn:{cn},cn.shape:{cn.shape}')


if __name__=='__main__':
    dm01()

GRU：门控循环单元结构：能够有效的捕获序长序列之间的语义关系，缓解梯度消失或者是梯度爆炸，但是结构比LSTM更简单

由，重置门和更新门和隐藏状态组成

重置门：决定保留哪些记忆

公式：重置门的门值=sigmoid（权重矩阵*【上一时刻的隐藏状态，当前输入】）

数值接近1，保留这条记忆，，接近于0就丢弃这个记忆

更新门：决定新记忆和旧记忆怎么融合

公式：更新门的门值=sigmoid（权重矩阵*【上一时刻的隐藏状态，当前输入】）

候选的隐藏状态：生成新记忆的候选

公式：新记忆候选=tanh(权重矩阵*【重置门的门值*上一时刻的隐藏状态，当前输入】)

最终输出的隐藏层状态：新旧记忆的融合

公式：新记忆=（1-更新门的门值）*上一时刻的隐藏状态+更新门的门值*新记忆候选

API:

# 导包
import torch
import torch.nn as nn


def dm01():
    gru=nn.GRU(input_size=5, hidden_size=6, num_layers=1,bidirectional=False)
    #构建输入数据
    input=torch.randn(2,3,5)
    # 构建隐藏层初始状态
    h0=torch.randn(1, 3, 6)
    # 模型计算
    output,hn=gru(input,h0)
    print(f'output:{output},output.shape:{output.shape}')
    # hn要与h0相同
    print(f'h0:{hn},h0.shape:{hn.shape}')


if __name__=='__main__':
    dm01()