【pytorch】nn.LSTM的使用

已于 2022-09-19 19:15:54 修改
阅读量1w 收藏 35
点赞数 7
分类专栏： pytorch 文章标签： pytorch lstm 深度学习
于 2021-08-29 00:38:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mimiduck/article/details/119975080
版权
本文详细介绍了PyTorch中LSTM模块的使用，包括输入张量的形状、参数配置以及权重矩阵的解读。通过实例代码展示了单层与双向LSTM的设置，并解释了多层LSTM的工作原理。此外，还涵盖了LSTM中关键门控机制的数学表达式，帮助理解其内部工作流程。
摘要由CSDN通过智能技术生成

官方文档在这里。

LSTM具体不做介绍了，本篇只做pytorch的API使用介绍

torch.nn.LSTM(*args, **kwargs)

输入张量

输入参数为两个，一个为input Tensor，一个为隐藏特征和状态组成的tuple

Inputs: input, (h_0, c_0)

input只能为3维张量，其中当初始参数batch_first=True时，shape为(L,N,H);而当初始参数batch_first=False时，shape为(N,L,H);

input张量的要求

公式

公式

LSTM中weights

以下公式介绍都忽略bias

  • 公式(1), 输入门
    i t = δ ( W i i x t + W h i h t − 1 ) i_t = \delta(W_{ii}x_t+W_{hi}h_{t-1}) it​=δ(Wii​xt​+Whi​ht−1​)， LSTM中有关输入的参是是 W i i W_{ii} Wii​和 W h i W_{hi} Whi​
  • 公式(2),遗忘门
    f t = δ ( W i f x t + W h f h t − 1 ) f_t = \delta(W_{if}x_t+W_{hf}h_{t-1}) ft​=δ(Wif​xt​+Whf​ht−1​), LSTM中有关输入的参数是 W i f W_{if} Wif​和 W h f W_{hf} Whf​
  • 公式(3),细胞更新状态
    g t = δ ( W i g x t + W h g h t − 1 ) g_t = \delta(W_{ig}x_t+W_{hg}h_{t-1}) gt​=δ(Wig​xt​+Whg​ht−1​), LSTM中有关输入的参数是 W i g W_{ig} Wig​和 W h g W_{hg} Whg​
  • 公式(4),输出门
    o t = δ ( W i o x t + W h o h t − 1 ) o_t = \delta(W_{io}x_t+W_{ho}h_{t-1}) ot​=δ(Wio​xt​+Who​ht−1​), LSTM中有关输入的参数是 W i o W_{io} Wio​和 W h o W_{ho} Who​

所以从输入张量和隐藏层张量来说，一共有两组参数

  1. input 组 { W i i W_{ii} Wii​， W i f W_{if} Wif​， W i g W_{ig} Wig​， W i o W_{io} Wio​ }
  2. hidden组 { W h i W_{hi} Whi​， W h f W_{hf} Whf​， W h g W_{hg} Whg​， W h o W_{ho} Who​ }

这里就对应官网上的两个参数
weight_ih_l[k] 和 weight_hh_l[k]
因为hidden size为隐藏层特征输出长度，所以每个参数第一维度都是hidden size；然后每一组是把4个张量按照第一维度拼接，所以要乘以4

举例代码：

from torch import nn

lstm = nn.LSTM(input_size=3, hidden_size=6, num_layers=1, bias=False)

print('weight_ih_l0.shape = ', lstm.weight_ih_l0.shape, ', weight_hh_l0.shape = ' , lstm.weight_hh_l0.shape)

结果

双向LSTM

如果要实现双向的LSTM，只需要增加参数bidirectional=True

双向的区别是LTSM参数中 hidden 参数会增加一个方向，即有来有回，所以要double以下。

举例代码


from torch import nn

lstm = nn.LSTM(input_size=3, hidden_size=6, num_layers=2, bias=False, bidirectional=True)

print('weight_ih_l0.shape = ', lstm.weight_ih_l0.shape, ', weight_ih_l0_reverse.shape = ', lstm.weight_ih_l0_reverse.shape,
      '\nweight_hh_l0.shape = ' , lstm.weight_hh_l0.shape, ', weight_hh_l0_reverse.shape = ', lstm.weight_hh_l0_reverse.shape)

结果

主要是hh部分的最后一维增加了一倍。

多层的概念

LSTM中有个参数num_layers是设置层数的，如果num_layers大于1,则网络则会变成如下的拓展

num_laynum_layer=2=2

有关讨论请参考这里。

每多一层，就多一组**LSTM.weight_ih_l[k]和LSTM.weight_hh_l[k]**参数

两层的网络里有 LSTM.weight_ih_l0、LSTM.weight_ih_l0和LSTM.weight_ih_l1和LSTM.weight_hh_l1

LSTM的计算示例代码

input_size 为3，hidden_size 为4，

# shape [Sequence Length, Batch Size, Feature Size]
# 如果batch_first=True，则为 [Batch Size, Sequence Length, Feature Size]
x=torch.Tensor([0,0,1,1,1,1,0,0,0,0,0,0]).view(2,3,2)

print(x,x.shape)

# h0 c0 的三维度分别为 [Layer Size, Batch Size, Hidden Feature Size]
h0=torch.zeros(1,3,4)
c0=torch.zeros(1,3,4)

# 默认batch_first=False,所以输入张量的第1维度是Batch
net=nn.LSTM(2, 4, bias=False)
print("net.weight_ih_l0=", net.weight_ih_l0, net.weight_ih_l0.shape)
print("net.weight_hh_l0=", net.weight_hh_l0, net.weight_hh_l0.shape)
y,_=net(x, (h0,c0))
print(y, y.shape)

tensor([[[0., 0.],
         [1., 1.],
         [1., 1.]],

        [[0., 0.],
         [0., 0.],
         [0., 0.]]]) torch.Size([2, 3, 2])
net.weight_ih_l0= Parameter containing:
tensor([[-0.1310,  0.0330],
        [-0.3115, -0.0417],
        [-0.1452,  0.0426],
        [-0.0096,  0.3305],
        [-0.1104,  0.1816],
        [ 0.1668, -0.3706],
        [ 0.4792, -0.3867],
        [-0.4565,  0.0688],
        [ 0.0975, -0.0737],
        [ 0.2898,  0.2739],
        [-0.3564,  0.2723],
        [-0.1759,  0.2534],
        [ 0.3471, -0.1051],
        [ 0.4057,  0.3256],
        [ 0.4224,  0.4646],
        [-0.0107, -0.2000]], requires_grad=True) torch.Size([16, 2])
net.weight_hh_l0= Parameter containing:
tensor([[ 0.4431,  0.4195, -0.4328,  0.0183],
        [ 0.4375,  0.0306, -0.0641, -0.2027],
        [-0.3726, -0.0434, -0.4403,  0.2741],
        [-0.2962, -0.2381, -0.4713, -0.1349],
        [-0.1447, -0.0184,  0.3634, -0.0840],
        [-0.4828, -0.2628,  0.4112, -0.0554],
        [ 0.2004, -0.4253, -0.1785,  0.4688],
        [ 0.2922, -0.1926, -0.2644,  0.2561],
        [ 0.4504, -0.3577, -0.2971, -0.2796],
        [ 0.0442, -0.0018, -0.3970,  0.3194],
        [ 0.2986, -0.2493, -0.4371,  0.2953],
        [-0.0342, -0.2422, -0.2986,  0.0775],
        [ 0.4996,  0.1421, -0.1665,  0.1231],
        [-0.3341, -0.0462, -0.1578, -0.1443],
        [-0.0194,  0.3979,  0.0734, -0.2276],
        [ 0.0581, -0.3744,  0.4785, -0.0365]], requires_grad=True) torch.Size([16, 4])
tensor([[[ 0.0000,  0.0000,  0.0000,  0.0000],
         [ 0.0064,  0.1402, -0.0282,  0.0200],
         [ 0.0064,  0.1402, -0.0282,  0.0200]],

        [[ 0.0000,  0.0000,  0.0000,  0.0000],
         [-0.0089,  0.0553, -0.0138,  0.0050],
         [-0.0089,  0.0553, -0.0138,  0.0050]]], grad_fn=<StackBackward>) torch.Size([2, 3, 4])

相关参考： Understanding LSTM and its diagram

安安爸Chris
关注
  • 7
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Pytorch实用教程：nn.LSTM内部是如何实现的
惊鸿若梦一书生
04-19 1039
nn.LSTM对象在 PyTorch 中负责创建一个LSTM 层。input_size：输入特征的维度。：LSTM 隐藏层的维度。num_layers：堆叠的 LSTM 层的数量（默认为1层）。bias：是否使用偏置（默认为True）。：输入和输出的维度顺序是否为 (batch, seq, feature)（默认为False，即 (seq, batch, feature)）。dropout：如果大于0，则除了最后一层外，其他层后会添加一个dropout层。：是否使用双向。
Pytorch实用教程：Pytorch的nn.LSTM中参数的含义
惊鸿若梦一书生
04-25 510
PyTorch的`nn.LSTM`模块是一个用于构建长短期记忆（LSTM）网络的类，它是一种特殊类型的循环神经网络（RNN），能够学习序列数据中的`长期依赖关系`。 LSTM网络被广泛用于`时间序列预测`、`自然语言处理`、`语音识别`等领域。下面，我将简要介绍`nn.LSTM`的基本概念和如何在PyTorch中使用它。
LSTM使用(pytorch)
weixin_43744594的博客
06-11 7002
lstm = nn.LSTM(input_size=2, hidden_size=3, num_layers=1) # 传入参数 inputs = [torch.randn(1, 2) for _ in range(5)] inputs = torch.cat(inputs).view(len(inputs), 1, -1) (h0, c0) = (torch.randn(1, 1, 3), torch.randn(1, 1, 3)) # out, (h,c) = lstm(inputs, (h0,
PyTorch的nn.LSTM使用说明
屏幕里的日与夜
07-03 1万+
PyTorch的nn包下面自带很多经典的模型，我们可以快速的引入一个预训练好了的模型用来处理我们的任务，也可以单纯的添加一个这种架构的空白网络称为我们模型的子结构。其中LSTM是使用的相当多的一个，本文介绍nn.LSTM的一些使用情况。
pytorch-pytorch之LSTM
最新发布
wyw0000的博客
07-13 474
pytorch之LSTM
pytorch nn.LSTM()参数详解
热门推荐
向阳争渡
11-28 5万+
import torch import torch.nn as nn from torch.autograd import Variable rnn = nn.LSTM(10,20,2) #构建网络模型---输入矩阵特征数input_size、输出矩阵特征数hidden_size、层数num_layers ''' input of shape (seq_len, batch, input_si...
Pytorch — LSTM (nn.LSTM & nn.LSTMCell)
hxxjxw的博客
05-22 2609
nn.LSTM 在LSTM中，c和h的size是一样的 import torch from torch import nn import numpy as np lstm = nn.LSTM(input_size=100, hidden_size=20, num_layers=4) print(lstm) x = torch.randn(10,3,100) #3个句子，每个句子10个单词，每个单词encoding成100维的vector out,(h,c) = lstm(x) prin.
总结PYTORCH中nn.lstm(自官方文档整理 包括参数、实例)
1996MZH的博客
05-06 1万+
参考pytorch官方文档 https://pytorch.org/docs/master/nn.html#torch.nn.LSTM 先上原图 | 这里是关键参数介绍 input_size:输入特征的数目 hidden_size:隐层的特征数目 num_layers：这个是模型集成的LSTM的个数 记住这里是模型中有多少个LSTM摞起来 一般默认就1个 bias：用不用偏置 默认是用 bat...
pytorch nn.LSTM及nn.LSTMCell的用法和理解
qq_39540454的博客
05-26 5813
照例先贴官方文档~ 以下是实例化一个nn.LSTM单元时会用到的参数，例如lstm = nn.LSTM(10, 20, 2)就实例化了一个input_size=10, hidden_size=20，num_layer=2的LSTM网络，也就是输入的维度为10，隐层的神经元数目为20，总共有2个隐层。 实例化好的LSTM如何使用呢？以下是输入，h0和c0都是可选的，重点是input，是一个表示输入序列特征的tensor，维度是（seq_len, batch, input_size），比如接上例，x = to
pytorch nn.LSTM 输入输出参数
tangweirensheng的博客
10-12 626
参考： LSTM神经网络输入输出究竟是怎样的？ - 知乎 Pytorch-LSTM输入输出参数_yilulvxing的博客-CSDN博客 Args: input_size: The number of expected features in the input `x` hidden_size: The number of features in the hidden state `h` num_layers: Number of recurrent layers. E.g.
Python-在PyTorch中使用LSTM进行风速预测
08-11
在PyTorch中使用LSTM进行风速预测
Pytorch中nn.LSTM与nn.LSTMCell
XiaobaiLaplace的博客
11-20 3153
class torch.nn.LSTM(*args, **kwargs) 对输入序列的每个元素，LSTM的每层都会执行以下计算： hth_tht​是时刻ttt的隐状态,ctc_tct​是时刻ttt的细胞状态，xtx_txt​是上一层的在时刻ttt的隐状态或者是第一层在时刻ttt的输入。it,ft,gt,oti_t, f_t, g_t, o_tit​,ft​,gt​,ot​ 分别代表 输入门，遗忘门，细胞和输出门。 参数说明: input_size – 输入的特征维度，（特征向量的长度，如2048） h
神经网络 torch.nn---nn.LSTM()
qq_45452617的博客
06-13 1884
c_0 是shape=(num_layers*num_directions,batch_size,hidden_size)的张量, 保存着batch中每个元素的初始化细胞状态的Tensor。:长短时记忆网络层，它的主要作用是对输入序列进行处理，对序列中的每个元素进行编码并保存它们的状态，以便后续的处理。i_t, f_t, g_t, o_t分别代表 输入门，遗忘门，细胞和输出门。x_t是上一层的在时刻t的隐状态或者是第一层在时刻t的输入。：当前时间步的输出，也是下一个时间步的输入。c_t是时刻t的细胞状态，
pytorch torch.nn.LSTM
Claroja
09-06 531
应用 >>> rnn = nn.LSTM(10, 20, 2) >>> input = torch.randn(5, 3, 10) >>> h0 = torch.randn(2, 3, 20) >>> c0 = torch.randn(2, 3, 20) >>> output, (hn, cn) = rnn(input, (h0, c0)) 概念 RNN可以看成是一个普通的网络（比如CNN）在时间线上做了多次复制，时
【Pytorch】nn.LSTM的理解
qq_37880748的博客
08-25 1万+
Pytorch中的nn.LSTM Pytorch中LSTM总共有7个参数，前面3个是必须输入的 input_size – The number of expected features in the input x hidden_size – The number of features in the hidden state h num_layers – Number of recurrent layers. E.g., setting num_layers=2 would mean stackin
LSTM原理理解与学习
见见大魔王
04-05 1790
基本原理 LSTM，长短期记忆 RNN，是 RNN 的变体，优点在于能学习长期依赖的信息，相当于有记忆功能。 LSTM 的关键就是 细胞状态（cell state），水平线在图上方贯穿运行。细胞状态类似于传送带，直接在整个链上运行，只有一些少量的线性交互。信息在上面流传比较容易保持不变。 LSTM 有通过精心设计的称作为“门“的结构来 去除或者增加信息到细胞状态的能力。门是一种让信息选择式通过的方法。他们包含一个 sigmoid 神经网络层和一个按位的乘法操作。sigmoid 层输出 0 到 1 之间的
pytorch 调用lstm
小鹏AI
10-22 1361
module import torch import torch.nn as nn class M(nn.Module): def __init__(self): super().__init__() self.lstm = nn.LSTM(3, 3, 1) # input's dim = 3, hidden'dim = 3, num of lstm = 1 def forward(self, x): out = self.lstm(*x) return out data data
pytorch中的nn.LSTM模块参数详解
越努力 越幸运
01-26 3万+
官网：https://pytorch.org/docs/stable/nn.html#torch.nn.LSTM Parameters（参数）： input_size：输入的维度 hidden_size：h的维度 num_layers：堆叠LSTM的层数，默认值为1 bias：偏置 ，默认值：True batch_first：如果是True，则input为(batch, seq,...
pytorch中的torch.nn.LSTM解析
qq_43391414的博客
07-08 1690
本文记录一下使用LSTM的一些心得。本文总参考是：pytorch的官方文档https://pytorch.org/docs/stable/generated/torch.nn.LSTM.html?highlight=lstm#torch.nn.LSTM。 文章目录多层LSTM权重形状batch_first输入形状输出形状 多层LSTM 多层LSTM是这样： 而不是这样： 权重形状 上面的权重除了偏置可以归结为3类，即U（输入专用）,V（目标输出专用）,W（隐藏层之间用）。不过，这里没有目标输出。所以只
nn.LSTM使用步骤
05-22
使用PyTorch中的nn.LSTM模块进行LSTM模型的构建通常需要以下步骤： 1. 导入所需的库和模块 ``` python import torch import torch.nn as nn ``` 2. 定义LSTM模型类 ``` python class LSTMModel(nn.Module): def __init__(self, input_size, hidden_size, num_layers): super(LSTMModel, self).__init__() self.lstm = nn.LSTM(input_size=input_size, hidden_size=hidden_size, num_layers=num_layers, batch_first=True) self.fc = nn.Linear(hidden_size, 1) def forward(self, x): output, (h_n, c_n) = self.lstm(x) out = self.fc(h_n[-1]) return out ``` 其中，input_size为输入数据的特征数，hidden_size为LSTM层中的隐藏层大小，num_layers为LSTM层数。 3. 创建LSTM模型实例 ``` python model = LSTMModel(input_size=10, hidden_size=32, num_layers=2) ``` 4. 定义损失函数和优化器 ``` python criterion = nn.MSELoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.01) ``` 5. 训练模型 ``` python for epoch in range(num_epochs): # 前向传播 y_pred = model(X_train) # 计算损失 loss = criterion(y_pred, y_train) # 反向传播及优化 optimizer.zero_grad() loss.backward() optimizer.step() if epoch % 100 == 0: print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item())) ``` 其中，X_train和y_train为训练数据集和标签。 6. 使用模型进行预测 ``` python with torch.no_grad(): y_pred = model(X_test) ``` 其中，X_test为测试数据集。 以上就是使用PyTorch中的nn.LSTM模块进行LSTM模型构建的一般步骤。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值