LSTM：从原理理解开始使用pytorch构建网络

最新推荐文章于 2023-07-14 10:30:00 发布
最新推荐文章于 2023-07-14 10:30:00 发布
阅读量949 收藏 6
点赞数
分类专栏： NLP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38236744/article/details/106978743
版权

这是一个造轮子的过程，但是从头构建LSTM能够使我们对体系结构进行更加了解，并将我们的研究带入下一个层次。
LSTM单元是递归神经网络深度学习研究领域中最有趣的结构之一：它不仅使模型能够从长序列中学习，而且还为长、短期记忆创建了一个数值抽象，可以在需要时相互替换。在这里插入图片描述
在这篇文章中，我们不仅将介绍LSTM单元的体系结构，还将通过PyTorch手工实现它。
最后但最不重要的是，我们将展示如何对我们的实现做一些小的调整，以实现一些新的想法，这些想法确实出现在LSTM研究领域，如peephole。

  1. LSTM体系结构
    LSTM被称为门结构：一些数学运算的组合，这些运算使信息流动或从计算图的那里保留下来。因此，它能够“决定”其长期和短期记忆，并输出对序列数据的可靠预测：
    在这里插入图片描述LSTM单元中的预测序列。注意，它不仅会传递预测值，而且还会传递一个c，c是长期记忆的代表。

  2. 遗忘门
    遗忘门（forget gate）是输入信息与候选者一起操作的门，作为长期记忆。请注意，在输入、隐藏状态和偏差的第一个线性组合上，应用一个sigmoid函数：在这里插入图片描述sigmoid将遗忘门的输出“缩放”到0-1之间，然后，通过将其与候选者相乘，我们可以将其设置为0，表示长期记忆中的“遗忘”，或者将其设置为更大的数字，表示我们从长期记忆中记住的“多少”。

  3. 新型长时记忆的输入门及其解决方案
    输入门是将包含在输入和隐藏状态中的信息组合起来，然后与候选和部分候选c’'u t一起操作的地方：在这里插入图片描述在这些操作中，决定了多少新信息将被引入到内存中，如何改变——这就是为什么我们使用tanh函数（从-1到1）。我们将短期记忆和长期记忆中的部分候选组合起来，并将其设置为候选。

  4. 单元的输出门和隐藏状态（输出）
    之后，我们可以收集o_t作为LSTM单元的输出门，然后将其乘以候选单元（长期存储器）的tanh，后者已经用正确的操作进行了更新。网络输出为h_t。在这里插入图片描述

  5. LSTM单元方程
    在这里插入图片描述

  6. pytorch custom LSTM

    1. 精简版：
      构造函数：想要了解每个操作的形状，1. 矩阵的输入形状是（批量大小、序列长度、特征长度），因此将序列的每个元素相乘的权重矩阵必须具有该形状（特征长度、输出长度）；2. 序列上每个元素的隐藏状态（也称为输出）都具有形状（批大小、输出大小），这将在序列处理结束时产生输出形状（批大小、序列长度、输出大小）。-因此，将其相乘的权重矩阵必须具有与单元格的参数hiddensz相对应的形状（outputsize，output_size）。代码如下：

      class NaiveCustomLSTM(nn.Module):
    def __init__(self, input_sz: int, hidden_sz: int):
        super().__init__()
        # 一般数据输入为[bs, suq_size, feature_size]
        # 输入每个tokenize的size(即每个词向量编码长度)
        self.input_size = input_sz
        # 隐层每个tokenize的size
        self.hidden_size = hidden_sz

        # i_t
        self.W_i = nn.Parameter(torch.Tensor(input_sz, hidden_sz))
        self.U_i = nn.Parameter(torch.Tensor(hidden_sz, hidden_sz))
        self.b_i = nn.Parameter(torch.Tensor(hidden_sz))

        # f_t
        self.W_f = nn.Parameter(torch.Tensor(input_sz, hidden_sz))
        self.U_f = nn.Parameter(torch.Tensor(hidden_sz, hidden_sz))
        self.b_f = nn.Parameter(torch.Tensor(hidden_sz))

        # c_t
        self.W_c = nn.Parameter(torch.Tensor(input_sz, hidden_sz))
        self.U_c = nn.Parameter(torch.Tensor(hidden_sz, hidden_sz))
        self.b_c = nn.Parameter(torch.Tensor(hidden_sz))

        # o_t
        self.W_o = nn.Parameter(torch.Tensor(input_sz, hidden_sz))
        self.U_o = nn.Parameter(torch.Tensor(hidden_sz, hidden_sz))
        self.b_o = nn.Parameter(torch.Tensor(hidden_sz))

        self.init_weights()

    def init_weights(self):
        """ 权重与偏置初始化
        :return:
        """
        stdv = 1.0 / math.sqrt(self.hidden_size)
        for weight in self.parameters():
            weight.data.uniform_(-stdv, stdv)

    def forward(self, x, init_states=None):
        """assumes x.shape represents (batch_size, sequence_size, input_size)
        input: 前馈操作接收init_states参数，该参数是上面方程的（h_t, c_t）参数的元组，
                如果不引入，则设置为零。然后，我们对每个保留（h_t, c_t）的序列元素执行LSTM方程的前馈，
                并将其作为序列下一个元素的状态引入.
        return: 预测和最后一个状态元组
        """
        bs, seq_sz, _ = x.size()
        hidden_seq = []

        if init_states is None:
            # 初始化历史状态
            h_t, c_t = (
                torch.zeros(bs, self.hidden_size).to(x.device),
                torch.zeros(bs, self.hidden_size).to(x.device),
            )
        else:
            h_t, c_t = init_states

        for t in range(seq_sz):
            # 获取单个词的feature 向量
            x_t = x[:, t, :]

            i_t = torch.sigmoid(x_t @ self.W_i + h_t @ self.U_i + self.b_i)
            f_t = torch.sigmoid(x_t @ self.W_f + h_t @ self.U_f + self.b_f)
            g_t = torch.tanh(x_t @ self.W_c + h_t @ self.U_c + self.b_c)
            o_t = torch.sigmoid(x_t @ self.W_o + h_t @ self.U_o + self.b_o)
            c_t = f_t * c_t + i_t * g_t
            h_t = o_t * torch.tanh(c_t)

            hidden_seq.append(h_t.unsqueeze(0))

        # reshape hidden_seq p/ retornar
        hidden_seq = torch.cat(hidden_seq, dim=0)
        hidden_seq = hidden_seq.transpose(0, 1).contiguous()

        return hidden_seq, (h_t, c_t)

    2. 优化版: Naive LSTM在运算上是正确的，但在计算时间上没有进行优化：我们分别执行8个矩阵乘法，这比矢量化的方式慢得多。我们现在将演示如何通过将其减少到2个矩阵乘法来完成，这将使它更快。
      为此，我们设置了两个矩阵U和V，它们的权重包含在4个矩阵乘法上。然后，我们对已经通过线性组合+偏置操作的矩阵执行选通操作。
      在这里插入图片描述

      class CustomLSTM(nn.Module):
    def __init__(self, input_sz, hidden_sz):
        super().__init__()
        # 一般数据输入为[bs, suq_size, feature_size]
        # 输入每个tokenize的size(即每个词向量编码长度)
        self.input_size = input_sz
        # 隐层每个tokenize的size
        self.hidden_size = hidden_sz

        self.W = nn.Parameter(torch.Tensor(input_sz, hidden_sz * 4))
        self.U = nn.Parameter(torch.Tensor(hidden_sz, hidden_sz * 4))
        self.bias = nn.Parameter(torch.Tensor(hidden_sz * 4))

        self.init_weights()

    def init_weights(self):
        """ 权重与偏置初始化
        :return:
        """
        stdv = 1.0 / math.sqrt(self.hidden_size)
        for weight in self.parameters():
            weight.data.uniform_(-stdv, stdv)

    def forward(self, x, init_states=None):
        """assumes x.shape represents (batch_size, sequence_size, input_size)
        input: 前馈操作接收init_states参数，该参数是上面方程的（h_t, c_t）参数的元组，
                如果不引入，则设置为零。然后，我们对每个保留（h_t, c_t）的序列元素执行LSTM方程的前馈，
                并将其作为序列下一个元素的状态引入.
        return: 预测和最后一个状态元组
        """
        bs, seq_sz, _ = x.size()
        hidden_seq = []

        if init_states is None:
            # 初始化历史状态
            h_t, c_t = (
                torch.zeros(bs, self.hidden_size).to(x.device),
                torch.zeros(bs, self.hidden_size).to(x.device),
            )
        else:
            h_t, c_t = init_states

        HS = self.hidden_size
        for t in range(seq_sz):
            # 获取单个词的feature 向量
            x_t = x[:, t, :]

            # batch the computations into a single matrix multiplication
            gate = x_t @ self.W + h_t @ self.U + self.bias
            i_t, f_t, g_t, o_t = (
                torch.sigmoid(gate[:, :HS]),  # input
                torch.sigmoid(gate[:, HS:HS*2]),  # forget
                torch.tanh(gate[:, HS*2:HS*3]),
                torch.sigmoid(gate[:, HS*3:]),  # output
            )

            c_t = f_t * c_t + i_t * g_t
            h_t = o_t * torch.tanh(c_t)

            hidden_seq.append(h_t.unsqueeze(0))

        # reshape hidden_seq p/ retornar
        hidden_seq = torch.cat(hidden_seq, dim=0)
        # reshape from shape (sequence, batch, feature) to (batch, sequence, feature)
        hidden_seq = hidden_seq.transpose(0, 1).contiguous()

        return hidden_seq, (h_t, c_t)

    3. LSTM peephole: 对前馈操作进行了细微调整，从而将其更改为优化的情况：在这里插入图片描述

      class CustomLSTMPeephole(nn.Module):
    def __init__(self, input_sz, hidden_sz, peephole=False):
        super().__init__()
        # 一般数据输入为[bs, suq_size, feature_size]
        # 输入每个tokenize的size(即每个词向量编码长度)
        self.input_size = input_sz
        # 隐层每个tokenize的size
        self.hidden_size = hidden_sz
        self.peephole = peephole

        self.W = nn.Parameter(torch.Tensor(input_sz, hidden_sz * 4))
        self.U = nn.Parameter(torch.Tensor(hidden_sz, hidden_sz * 4))
        self.bias = nn.Parameter(torch.Tensor(hidden_sz * 4))

        self.init_weights()

    def init_weights(self):
        """ 权重与偏置初始化
        :return:
        """
        stdv = 1.0 / math.sqrt(self.hidden_size)
        for weight in self.parameters():
            weight.data.uniform_(-stdv, stdv)

    def forward(self, x, init_states=None):
        """assumes x.shape represents (batch_size, sequence_size, input_size)
        input: 前馈操作接收init_states参数，该参数是上面方程的（h_t, c_t）参数的元组，
                如果不引入，则设置为零。然后，我们对每个保留（h_t, c_t）的序列元素执行LSTM方程的前馈，
                并将其作为序列下一个元素的状态引入.
        return: 预测和最后一个状态元组
        """
        bs, seq_sz, _ = x.size()
        hidden_seq = []

        if init_states is None:
            # 初始化历史状态
            h_t, c_t = (
                torch.zeros(bs, self.hidden_size).to(x.device),
                torch.zeros(bs, self.hidden_size).to(x.device),
            )
        else:
            h_t, c_t = init_states

        HS = self.hidden_size
        for t in range(seq_sz):
            # 获取单个词的feature 向量
            x_t = x[:, t, :]

            # batch the computations into a single matrix multiplication
            if self.peephole:
                gate = x_t @ self.W + h_t @ self.U + self.bias
            else:
                gate = x_t @ self.W + h_t @ self.U + self.bias
                g_t = torch.tanh(gate[:, HS*2:HS*3])

            i_t, f_t, o_t = (
                torch.sigmoid(gate[:, :HS]),  # input
                torch.sigmoid(gate[:, HS:HS*2]),  # forget
                torch.sigmoid(gate[:, HS*3:]),  # output
            )

            if self.peephole:
                c_t = f_t * c_t + i_t * torch.sigmoid(x_t @ self.W + self.bias)[:, HS*2:HS*3]
                h_t = torch.tanh(o_t * c_t)
            else:
                c_t = f_t * c_t + i_t * g_t
                h_t = o_t * torch.tanh(c_t)

            hidden_seq.append(h_t.unsqueeze(0))

        # reshape hidden_seq p/ retornar
        hidden_seq = torch.cat(hidden_seq, dim=0)
        # reshape from shape (sequence, batch, feature) to (batch, sequence, feature)
        hidden_seq = hidden_seq.transpose(0, 1).contiguous()

        return hidden_seq, (h_t, c_t)

代码实现github地址：https://github.com/QiuSYang/DeepLearningStudy_YQS/tree/master/basic_network/lstm

Reference:

  1. https://zhuanlan.zhihu.com/p/144132609
  2. https://github.com/piEsposito/pytorch-lstm-by-hand
修行者_Yang
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LSTM实现多变量时间序列预测(PyTorch版)
sybh的博客
10-04 771
为了训练数据，首先定义LSTM模型，然后再定义对应的损失函数，由于我们这里是风速预测，显然是个回归问题，所以采用回归问题常用的MESLoss()，如果可以的话，可以自定义损失函数，针对自己的项目需求定义对应的损失函数。对于优化器来讲，使用的也是目前常用的Adam优化器，对于新手来讲也可以多多尝试其它的优化器，比如SGDRMSprop等，对于优化器的选择。
基于pytorch搭建多特征LSTM时间序列预测代码
最新发布
ducanwang的博客
01-29 924
print('Epoch: {}/{} - Loss: {:.4f}'.format(epoch+1, 500, loss.item())) # 输出损失。mse = mean_squared_error(y_test, outputs.detach().numpy()) # 使用测试集评估模型。optimizer = torch.optim.Adam(model.parameters(), lr=0.001) # 优化器，这里使用Adam优化器。loss.backward() # 反向传播。
Pytorch入门（三）用Pytorch多特征预测股票（LSTM、Bi-LSTM、GRU）
ssjdoudou的博客
12-16 3万+
输入数据 pytorch的input: (seq_len, batch, input_size) 三维的Tensor，大概长这样(450, 2, 6) 450是训练集的长度，2是时间步长，这个数据你要自己去转化，6是特征数 对应股票数据就是（训练集的长度，一次是几条数据，股票的特征） 原始的数据集是二维的，(450，6)，你需要展开成三维的(450,1,6)，作为pytorch的输入，...
pytorch以特征图的输入方式训练LSTM模型
呆萌的代Ma
07-16 1703
训练的时候总是会遇到这样的任务： 特征有很多维度，每个维度都有相同的embedding或长度 训练的时候想按照类似这样的二维图，训练LSTM模型，最后得出这张图对应的1个或多个结果 文章目录步骤一：构建训练数据步骤二：构建满足特征图输入结构的LSTM步骤三：开始训练模型全部代码参考资料 步骤一：构建训练数据 这里不需要额外下载其他数据，全部通过随机数生成 def get_train_data(): """得到训练数据，这里使用随机数生成训练数据，目的是跑通代码，而最终效果会很差"""
PyTorch搭建LSTM实现多变量多步长时间序列预测（二）：单步滚动预测
KI的博客
05-26 1万+
PyTorch搭建LSTM实现多变量多步长时间序列预测（二）：单步滚动预测
基于pytorch从头实现了单向，多层，双向LSTM，给出了完整使用代码,并与torch自带的LSTM进行了对比实验
02-24
标题和描述中提到的内容是关于使用Python的PyTorch库实现长短时记忆网络（LSTM）的教程。PyTorch是一种广泛使用的深度学习框架，以其灵活性和易用性著称。LSTM是递归神经网络（RNN）的一种变体，特别适合处理序列...
pytorch利用LSTM实现对股票进行多变量多步预测
09-10
首先，我们需要理解LSTM的工作原理。LSTM是一种特殊的循环神经网络（RNN），设计用于解决传统RNN在处理长期依赖问题时的梯度消失或爆炸问题。LSTM通过门控机制（输入门、遗忘门和输出门）来控制信息的流动，从而更好...
lstm-and-cnn-：pytorch版学习
02-14
在本文中，我们将深入探讨如何使用PyTorch实现LSTM（长短期记忆网络）和CNN（卷积神经网络）的组合模型。PyTorch是一个强大的深度学习框架，它提供了动态计算图的功能，使得构建和训练复杂的神经网络变得更加灵活。...
bnlstm-pytorch:使用pytorch批量标准化LSTM
05-14
在实际使用`bnlstm-pytorch`时，首先需要理解LSTM和批量标准化的基本原理。然后，根据提供的代码和文档，你可以定制模型参数，如隐藏层大小、批量大小、学习率等，以适应特定任务的需求。你还需要准备相应的输入数据...
Pytorch使用 LSTM RNN 的词级语言建模代码.zip
08-13
PyTorch作为一个强大的深度学习框架，提供了灵活的接口来实现这种模型，特别是通过长短期记忆网络（LSTM）和循环神经网络（RNN）。本文件“Pytorch使用 LSTM RNN 的词级语言建模代码.zip”应该包含了一个使用PyTorch...
crnn.pytorch, 在pytorch中，卷积递归网络.zip
09-17
crnn.pytorch, 在pytorch中，卷积递归网络 基于的卷积递归神经网络软件在pytorch中实现了卷积递归神经网络( CRNN ) 。 原始软件可以在 crnn 找到。运行演示在 src/demo.py 中可以找到一个演示程序。 在运行演示之前，从百度 Netdisk 或者 Dro
pytorch LSTM情感分类全部代码
01-06
先运行main.py进行文本序列化，再train.py模型训练 dataset.py from torch.utils.data import DataLoader,Dataset import torch import os from utils import tokenlize import config class ImdbDataset(Dataset): def __init__(self,train=True): super(ImdbDataset,self).__init__() data_path = rH:\073-nlp自然语言处理
PyTorch 递归神经网络(Recursive Neural Networks)
m0_60105488的博客
07-23 351
深度神经网络在机器学习理解自然语言过程方面具有独特的特性。据观察，这些模型大多数将语言看作是单词或字符的扁平序列，并使用一种称为循环神经网络或RNN的模型。许多研究人员得出结论，语言是最好的理解关于短语的层次树。这种类型包含在考虑特定结构的递归神经网络中。本文主要介绍PyTorch 递归神经网络(Recursive Neural Networks)。 原文地址：PyTorch 递归神经网络(Recursive Neural Networks) ...
PyTorch深度学习实践——处理多维特征的输入
weixin_66648679的博客
04-04 2085
import torch import numpy as np xy = np.loadtxt('diabetes.csv', delimiter=',', dtype=np.float32) # 括号内第一个为文件名，第二个为分隔符，第三个为指定数据类型 x_data = torch.from_numpy(xy[:, :-1]) # 最后一列不要（-1表示最后一列），取前面八列（最后一列是y） y_data = torch.from_numpy(xy[:, [-1]]) # 中括号表示仅取-1这.
构建LSTM网络
as472780551的博客
05-31 875
import numpy as np import keras from keras.models import Sequential from keras.layers import Dense, Dropout, Flatten, LSTM, Input from keras.layers import Conv2D, MaxPooling2D from keras.optimizers i...
使用PyTorch训练LSTM预测模型
csdn1561168266的博客
07-14 2480
大家好，长短期记忆网络（LSTM）是RNN的一种变体，RNN由于梯度消失的原因只能有短期记忆，LSTM网络通过精妙的门控制将短期记忆与长期记忆结合起来，并且一定程度上解决了梯度消失的问题。在开始新的优化迭代之前重置了模型参数的梯度，因为在PyTorch中默认情况下梯度会累积，如果不将其清零，则会导致在后续迭代中出现不正确的梯度计算。这个函数的目的是为了生成用于训练和测试时间序列预测模型的输入-输出对，输入-输出对是通过在时间序列数据上滑动一个给定长度（：输出的大小（例如，预测值的数量）。
lstm理解与使用(pytorch为例)
热门推荐
hxshine的博客
12-05 5万+
一.lstm原理 可以详读：Understanding LSTM Networks http://colah.github.io/posts/2015-08-Understanding-LSTMs/ 1.结构图 2.公式 -遗忘门，决定哪些东西被遗忘： 输入门，决定状态Cell里面的更新： 输出门，决定t时刻的输出： 其中，ht−1h_{t-1}ht−1​为上个时间节点t-1时刻的输出，...
【NLP】LSTM理解（Pytorch实现）
myaijarvis notebook
05-03 2007
【参考：详解LSTM - 知乎】 手动实现 【参考：30、PyTorch LSTM和LSTMP的原理及其手写复现_哔哩哔哩_bilibili】 单层单向 【参考：30 - LSTM,LSTMP手撸代码_取个名字真难呐的博客-CSDN博客】 import torch from torch import nn torch.manual_seed(0) # 设置随机种子，随机函数生成的结果会相同 batch_size = 2 # 批次大小 seq_len = 3 # 输入序列长度 input_siz
【Pytorch深度学习实战】（6）递归神经网络（RNN）
sikh_0529的博客
09-19 1万+
上图展示的是最简单的 RNN 结构，此外 RNN 还存在着很多变种，比如双向 RNN（Bidirectional RNN），深度双向 RNN（Deep Bidirectional RNN）等。RNN 把所处理的数据序列视作时间序列，在每一个时刻 tt，每个 RNN 的神经元接受两个输入：当前时刻的输入样本 xtxt，和上一时刻自身的输出 ht-1。RNN 的神经元接受的输入除了“前辈”的输出，还有自身的状态信息，其状态信息在网络中循环传递。RNN，循环神经网络，也有人将它翻译为递归神经网络。
PyTorch 实现 循环神经网络（RNN）、长短期记忆网络（LSTM）、门控循环单元网络（GRU）-谢TS的博客.pdf
07-17
循环神经网络（Recurrent Neural Network, RNN）是以 序列（Sequence）数据作为输入，沿序列的演进方向进行 递归（Recurrent）且所有循环单元节点按链式连接的一类神经网络。循环神经网络具有记忆性，对序列数据的非线性特征进行学习时具有一定优势。还有 RNN 的加强版 长短期记忆网络（LSTM, Long Short-Term Memory）和 门控循环单元网络（GRU, Gated Recurrent Unit networks）拥有更强的“记忆力”。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值