RNN和LSTM学习笔记

最新推荐文章于 2022-10-13 22:16:48 发布

cx_0401

最新推荐文章于 2022-10-13 22:16:48 发布

阅读量326

点赞数

分类专栏： NLP 文章标签： rnn lstm 人工智能

本文链接：https://blog.csdn.net/qq_40438523/article/details/120996168

版权

NLP 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

RNN和LSTM学习笔记

RNN
LSTM
Bi-LSTM
LSTM代码分析

RNN

RNN简介

参考知乎
循环神经网络
在这里插入图片描述
对于处理连续文本，我们需要联系句子上下文的内容，例如“我吃水果”。
我们需要将三个词一次输入我们的输入层中，三个词分不同的时刻输入。因此，每个时刻的权值W都是继承上个权值S，而新的S又由输入X和W共同决定，更为详细的图：
在这里插入图片描述
我们将每次的输出更新，会得到下面这样的公式参考链接

很容易看出，RNN存在两个问题，梯度消失和梯度爆炸，这也是LSTM提出的原因。

BRNN

link
显然我们再看一个句子的时候不仅会结合上文语义，也会结合下文
在这里插入图片描述
我们建立这样的时序网络，其中隐藏层有两个权值，一个是前向层，一个是后向层，分别计算前后的和，合并为输出。

DRNN

多个隐藏层，深度循环神经网络

LSTM

LSTM与普通RNN不同之处在于中间的隐藏层
在这里插入图片描述
LSTM的关键，就是怎样控制长期状态c。在这里，LSTM的思路是使用三个控制开关。第一个开关，负责控制继续保存长期状态c；第二个开关，负责控制把即时状态输入到长期状态c；第三个开关，负责控制是否把长期状态c作为当前的LSTM的输出。

LSTM用两个门来控制单元状态c的内容，一个是遗忘门（forget gate），它决定了上一时刻的单元状态 $c_{t-1}$ 有多少保留到当前时刻 $c_t$ ；另一个是输入门（input gate），它决定了当前时刻网络的输入 $x_t$ 有多少保存到单元状态 $c_t$ 。LSTM用输出门（output gate）来控制单元状态 $c_t$ 有多少输出到LSTM的当前输出值 $h_t$ 。
在这里插入图片描述
这里 $\bigodot$ 是按元素乘，也就是相同格式的矩阵对应每一位相乘

Bi-LSTM

我的理解是将两个LSTM，一个对词序正向，一个对词序反向，然后将两个LSTM的最终输出结合起来输出
在这里插入图片描述
对于上图，我们将 $h_0$ , $h_1$ , $h_2$ 结合起来

对于语义情感分析，我们常把 $h_{L2}$ 和 $h_{R2}$ 结合起来输出

LSTM代码分析

代码改自网络，使用LSTM处理MNISIT数据集

import torch
import torch.utils.data as Data
import torchvision
import matplotlib.pyplot as plt
import numpy as np
BATCH_SIZE = 50

class RNN(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.rnn=torch.nn.LSTM(
            input_size=28,#指代输入词向量的维度
            hidden_size=64,#隐藏层的维度，因为隐藏层中含有h和c两个参数，两个参数也是被一个矩阵作用后与输入x经过矩阵作用后相运算
            num_layers=1,#指代有几层LSTM
            batch_first=True,#一般我们输入数据的格式是（batch_size, seqlength, feature），
            # 但这里默认是false，也就是按照（seqlength，batch_size，feature）的顺序，所以我们需要设置为True
            bidirectional=False,#这个参数决定是否为双向LSTM
            dropout=0,#为了防止过拟合的一种方法，默认是0
            bias=True#默认为True，设置偏置
        )
        self.out=torch.nn.Linear(in_features=64,out_features=10)

    def forward(self,x):
        # 以下关于shape的注释只针对单向
        # output: [batch_size, time_step, hidden_size]
        # h_n: [num_layers,batch_size, hidden_size] # 虽然LSTM的batch_first为True,但是h_n/c_n的第一维还是num_layers
        # c_n: 同h_n
        output,(h_n,c_n)=self.rnn(x)
        print(output.size())
        # output_in_last_timestep=output[:,-1,:] # 也是可以的
        output_in_last_timestep=h_n[-1,:,:]
        # print(output_in_last_timestep.equal(output[:,-1,:])) #ture
        x=self.out(output_in_last_timestep)
        return x

if __name__ == "__main__":
    device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
    print(device)
    # 1. 加载数据
    training_dataset = torchvision.datasets.MNIST("./mnist", train=True,
                                                  transform=torchvision.transforms.ToTensor(), download=True)
    dataloader = Data.DataLoader(dataset=training_dataset,
                                 batch_size=BATCH_SIZE, shuffle=True, num_workers=2)
    # showSample(dataloader)
    test_data=torchvision.datasets.MNIST(root="./mnist",train=False,
                                         transform=torchvision.transforms.ToTensor(),download=False)
    test_dataloader=Data.DataLoader(
        dataset=test_data,batch_size=1000,shuffle=False,num_workers=2)
    testdata_iter=iter(test_dataloader)
    test_x,test_y=testdata_iter.next()
    test_x=test_x.view(-1,28,28)
    # 2. 网络搭建
    net=RNN()
    net.to(device)
    #网络参数全部在cuda上
    # 3. 训练
    # 3. 网络的训练（和之前CNN训练的代码基本一样）
    optimizer=torch.optim.Adam(net.parameters(),lr=0.001)
    loss_F=torch.nn.CrossEntropyLoss()
    for epoch in range(1): # 数据集只迭代一次
        for step, input_data in enumerate(dataloader):
            input_data=input_data
            x,y=input_data
            x = x.to(device)
            y = y.to(device)
            #将数据移到cuda上
            pred=net(x.view(-1,28,28))

            loss=loss_F(pred,y) # 计算loss
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            if step%50==49: # 每50步，计算精度
                with torch.no_grad():
                    test_x = test_x.to(device)
                    test_y = test_y.to(device)
                    # 将数据移到cuda上
                    test_pred=net(test_x)
                    prob=torch.nn.functional.softmax(test_pred,dim=1)
                    pred_cls=torch.argmax(prob,dim=1)
                    acc=(pred_cls==test_y).sum().to('cpu').numpy()/pred_cls.size()[0]
                    # numpy的计算必须在cpu上
                    print(f"{epoch}-{step}: accuracy:{acc}")