【PyTorch API】 nn.RNN 和 nn.LSTM 介绍和代码详解

最新推荐文章于 2025-03-24 17:13:15 发布
最新推荐文章于 2025-03-24 17:13:15 发布
阅读量6.3k 收藏 33
点赞数 7
分类专栏： # PyTorch算子/函数用法 文章标签： rnn lstm pytorch 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43799400/article/details/131420072
版权
本文介绍了如何在PyTorch中使用nn.RNN和nn.LSTM构建单向循环神经网络。nn.RNN和nn.LSTM的输入输出参数被详细解释，包括输入序列长度、嵌入维度、隐藏状态尺寸和循环层数。文章还强调了nn.RNN的hn表示所有隐藏层在最后一个时间步的隐藏状态，而nn.LSTM的hn和cn分别表示最后的隐藏状态和细胞状态。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

1. nn.RNN 构建单向 RNN

torch.nn.RNN 的 PyTorch 链接：torch.nn.RNN(*args, **kwargs)

nn.RNN 的用法和输入输出参数的介绍直接看代码：

import torch
import torch.nn as nn

# 单层单向 RNN
embed_dim = 5    # 每个输入元素的特征维度,如每个单词用长度为 5 的特征向量表示
hidden_dim = 6   # 隐状态的特征维度,如每个单词在隐藏层中用长度为 6 的特征向量表示
rnn_layers = 4   # 循环层数
rnn = nn.RNN(input_size=embed_dim, hidden_size=hidden_dim, num_layers=rnn_layers, batch_first=True)

# 输入
batch_size = 2
sequence_length = 3    # 输入的序列长度，如 i love you 的序列长度为 3,每个单词用长度为 feature_num 的特征向量表示
input = torch.randn(batch_size, sequence_length, embed_dim)
h0 = torch.randn(rnn_layers, batch_size, hidden_dim)

# output 表示隐藏层在各个 time step 上计算并输出的隐状态
# hn 表示所有掩藏层的在最后一个 time step 隐状态, 即单词 you 的隐状态
output, hn = rnn(input, h0)

print(f"output = {output}")
print(f"hn = {hn}")
print(f"output.shape = {output.shape}")     # torch.Size([2, 3, 6])    [batch_size, sequence_length, hidden_dim]
print(f"hn.shape = {hn.shape}")             # torch.Size([4, 2, 6])    [rnn_layers, batch_size, hidden_dim]


"""
output = tensor([[[-0.3727, -0.2137, -0.3619, -0.6116, -0.1483,  0.8292],
         [ 0.1138, -0.6310, -0.3897, -0.5275,  0.2012,  0.3399],
         [-0.0522, -0.5991, -0.3114, -0.7089,  0.3824,  0.1903]],

        [[ 0.1370, -0.6037,  0.3906, -0.5222,  0.8498,  0.8887],
         [-0.3463, -0.3293, -0.1874, -0.7746,  0.2287,  0.1343],
         [-0.2588, -0.4145, -0.2608, -0.3799,  0.4464,  0.1960]]],
       grad_fn=<TransposeBackward1>)
       
hn = tensor([[[-0.2892,  0.7568,  0.4635, -0.2106, -0.0123, -0.7278],
         [ 0.3492, -0.3639, -0.4249, -0.6626,  0.7551,  0.9312]],

        [[ 0.0154,  0.0190,  0.3580, -0.1975, -0.1185,  0.3622],
         [ 0.0905,  0.6483, -0.1252,  0.3903,  0.0359, -0.3011]],

        [[-0.2833, -0.3383,  0.2421, -0.2168, -0.6694, -0.5462],
         [ 0.2976,  0.0724, -0.0116, -0.1295, -0.6324, -0.0302]],

        [[-0.0522, -0.5991, -0.3114, -0.7089,  0.3824,  0.1903],
         [-0.2588, -0.4145, -0.2608, -0.3799,  0.4464,  0.1960]]],
       grad_fn=<StackBackward0>)

output.shape = torch.Size([2, 3, 6])
hn.shape = torch.Size([4, 2, 6])
"""

需要特别注意的是 nn.RNN 的第二个输出 hn 表示所有掩藏层的在最后一个 time step 隐状态，听起来很难理解，看下面的红色方框内的数据就懂了。即 output[:, -1, :] = hn[-1, : , :]

这里 hn 保存了四次循环中最后一个 time step 隐状态的数值，以输入 i love you 为了，hn 保存的是单词 you 的隐状态。

在这里插入图片描述

2. nn.LSTM 构建单向 LSTM

torch.nn.RNN 的 PyTorch 链接：torch.nn.LSTM(*args, **kwargs)

nn.LSTM 的用法和输入输出参数的介绍直接看代码：

import torch
import torch.nn as nn


batch_size = 4
seq_len = 3      # 输入的序列长度
embed_dim = 5    # 每个输入元素的特征维度
hidden_size = 5 * 2    # 隐状态的特征维度，根据工程经验可取 hidden_size = embed_dim * 2
num_layers = 2    # LSTM 的层数，一般设置为 1-4 层；多层 LSTM 的介绍可以参考 https://blog.csdn.net/weixin_41041772/article/details/88032093

lstm = nn.LSTM(input_size=embed_dim, hidden_size=hidden_size, num_layers=num_layers, batch_first=True)

# h0 可以缺省
input = torch.randn(batch_size, seq_len, embed_dim)

"""
output 表示隐藏层在各个 time step 上计算并输出的隐状态
hn 表示所有隐藏层的在最后一个 time step 隐状态, 即单词 you 的隐状态；所以 hn 与句子长度 seq_len 无关
hn[-1] 表示最后一个隐藏层的在最后一个 time step 隐状态，即 LSTM 的输出
cn 表示句子的最后一个单词的细胞状态；所以 cn 与句子长度 seq_len 无关
其中 output[:, -1, :] = hn[-1,:,:]
"""
output, (hn, cn) = lstm(input)


print(f"output.shape = {output.shape}")   # torch.Size([4, 3, 10])
print(f"hn.shape = {hn.shape}")           # torch.Size([2, 4, 10])
print(f"cn.shape = {cn.shape}")           # torch.Size([2, 4, 10])

print(f"output = {output}")
print(f"hn = {hn}")
print(f"output[:, -1, :] = {output[:, -1, :]}")
print(f"hn[-1,:,:] = {hn[-1,:,:]}")


"""
output = tensor([[[ 0.0447,  0.0111,  0.0292,  0.0692, -0.0547, -0.0120, -0.0202, -0.0243,  0.1216,  0.0643],
                  [ 0.0780,  0.0279,  0.0231,  0.1061, -0.0819, -0.0027, -0.0269, -0.0509,  0.1800,  0.0921],
                  [ 0.0993,  0.0160,  0.0516,  0.1402, -0.1146, -0.0177, -0.0607, -0.0715,  0.2110,  0.0954]],

                 [[ 0.0542, -0.0053,  0.0415,  0.0899, -0.0561, -0.0376, -0.0327, -0.0276,  0.1159,  0.0545],
                  [ 0.0819, -0.0015,  0.0640,  0.1263, -0.1021, -0.0502, -0.0495, -0.0464,  0.1814,  0.0750],
                  [ 0.0914,  0.0034,  0.0558,  0.1418, -0.1327, -0.0643, -0.0616, -0.0674,  0.2195,  0.0886]],

                 [[ 0.0552, -0.0006,  0.0351,  0.0864, -0.0486, -0.0192, -0.0305, -0.0289,  0.1103,  0.0554],
                  [ 0.0835, -0.0099,  0.0415,  0.1396, -0.0758, -0.0829, -0.0616, -0.0604,  0.1740,  0.0828],
                  [ 0.1202, -0.0113,  0.0570,  0.1608, -0.0836, -0.0801, -0.0792, -0.0874,  0.1923,  0.0829]],

                 [[ 0.0115, -0.0026,  0.0267,  0.0747, -0.0867, -0.0250, -0.0199, -0.0154,  0.1158,  0.0649],
                  [ 0.0628,  0.0003,  0.0297,  0.1191, -0.1028, -0.0342, -0.0509, -0.0496,  0.1759,  0.0831],
                  [ 0.0569,  0.0105,  0.0158,  0.1300, -0.1367, -0.0207, -0.0514, -0.0629,  0.2029,  0.1042]]], grad_fn=<TransposeBackward0>)
            
hn = tensor([[[-0.1933, -0.0058, -0.1237,  0.0348, -0.1394,  0.2403,  0.1591, -0.1143,  0.1211, -0.1971],
              [-0.2387,  0.0433, -0.0296,  0.0877, -0.1198,  0.1919,  0.0832, 0.0738,  0.1907, -0.1807],
              [-0.2174,  0.0721, -0.0447,  0.1081, -0.0520,  0.2519,  0.4040, -0.0033,  0.1378, -0.2930],
              [-0.2130, -0.0404, -0.0588, -0.1346, -0.1865,  0.1032, -0.0269, 0.0265, -0.0664, -0.1800]],

             [[ 0.0993,  0.0160,  0.0516,  0.1402, -0.1146, -0.0177, -0.0607, -0.0715,  0.2110,  0.0954],
              [ 0.0914,  0.0034,  0.0558,  0.1418, -0.1327, -0.0643, -0.0616, -0.0674,  0.2195,  0.0886],
              [ 0.1202, -0.0113,  0.0570,  0.1608, -0.0836, -0.0801, -0.0792, -0.0874,  0.1923,  0.0829],
              [ 0.0569,  0.0105,  0.0158,  0.1300, -0.1367, -0.0207, -0.0514, -0.0629,  0.2029,  0.1042]]], grad_fn=<StackBackward0>)


验证 output[:, -1, :] = hn[-1,:,:]
output[:, -1, :] = tensor([[ 0.0993,  0.0160,  0.0516,  0.1402, -0.1146, -0.0177, -0.0607, -0.0715,0.2110,  0.0954],
                           [ 0.0914,  0.0034,  0.0558,  0.1418, -0.1327, -0.0643, -0.0616, -0.0674,  0.2195,  0.0886],
                           [ 0.1202, -0.0113,  0.0570,  0.1608, -0.0836, -0.0801, -0.0792, -0.0874, 0.1923,  0.0829],
                           [ 0.0569,  0.0105,  0.0158,  0.1300, -0.1367, -0.0207, -0.0514, -0.0629, 0.2029,  0.1042]], grad_fn=<SliceBackward0>)
          
hn[-1,:,:] = tensor([[ 0.0993,  0.0160,  0.0516,  0.1402, -0.1146, -0.0177, -0.0607, -0.0715,0.2110,  0.0954],
                     [ 0.0914,  0.0034,  0.0558,  0.1418, -0.1327, -0.0643, -0.0616, -0.0674,  0.2195,  0.0886],
                     [ 0.1202, -0.0113,  0.0570,  0.1608, -0.0836, -0.0801, -0.0792, -0.0874,  0.1923,  0.0829],
                     [ 0.0569,  0.0105,  0.0158,  0.1300, -0.1367, -0.0207, -0.0514, -0.0629, 0.2029,  0.1042]], grad_fn=<SliceBackward0>)
"""

3. 推荐参考资料

多层 LSTM 的介绍可以参考博客 RNN之多层LSTM理解：输入，输出，时间步，隐藏节点数，层数

RNN 的原理和 PyTorch 源码复现可以参考视频 PyTorch RNN的原理及其手写复现

LSTM 的原理和 PyTorch 源码复现可以参考视频 PyTorch LSTM和LSTMP的原理及其手写复现

【Pytorch实用教程】Pytorch中nn.RNNBase、nn.RNN、nn.LSTM、nn.GRU、nn.RNNCell、nn.LSTMCell、nn.GRUCell介绍、用法详解
若北辰
08-13 687
nn.RNNBase是 PyTorch 中所有循环神经网络（RNN）类的基础类。这个类提供了一些基本的功能和接口，供具体的 RNN 实现（如nn.RNNnn.LSTMnn.GRU）继承和使用。nn.RNN是最基础的循环神经网络类，继承自nn.RNNBase。它使用 tanh 或 relu 作为激活函数。nn.LSTM是一种改进的循环神经网络，用于解决普通 RNN 在长时间序列数据中容易出现的梯度消失和梯度爆炸问题。LSTM 通过引入输入门遗忘门和输出门。
torch.nn.LSTM介绍
qq_27390023的博客
12-29 735
是 PyTorch 提供的一个高级封装，用于构建长短时记忆网络（LSTM）。相比手动实现，更高效且支持批量处理、双向 LSTM、多层 LSTM 等功能，适合大多数实际应用。
【pytorch】nn.LSTM 模块
想做一只猫的博客
10-17 2064
nn.LSTM模块参数： Args: input_size: 输入值的维度 hidden_size: 隐藏层的维度 num_layers: 堆叠多个lstm层数，默认值：1 bias: False则 b_ih=0 和 b_hh=0。默认值：True batch_first: 输入的数据是否构成（sequence,batch_size,feature）结构。默认值：False dropout: 除最后一层，每一层的输出都进行dropout，默认值: 0 bidirectional:True则为双向lstm，
总结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...
深入理解循环神经网络（RNN）：原理、实现与挑战
最新发布
murphymeng2001的博客
03-24 573
即后续数据依赖于前面的输入信息。例如，翻译句子时，当前单词的含义通常取决于前面的单词。而传统的神经网络（如 CNN 和 MLP）由于。RNN 仍然适用于某些低计算资源场景（如实时语音识别）。但在现代 NLP 任务中，在自然语言处理（NLP）、语音识别、时间序列分析等任务中，数据通常具有。来存储和更新隐藏状态，使模型可以保留时间信息。（RNN 的时间展开示意图）控制隐藏状态，比 LSTM。，从而对序列数据进行处理。控制信息存储和更新，从而。，难以处理这类问题。RNN 的核心思想是。
【pytorch】nn.LSTM的使用
安安爸Chris的专栏
08-29 1万+
官方文档在这里。 LSTM具体不做介绍了，本篇只做pytorch的API使用介绍 torch.nn.LSTM(*args, **kwargs) 公式 LSTM中参数挖掘 以下公式介绍都忽略bias 公式(1), 输入门 it=δ(Wiixt+Whiht−1)i_t = \delta(W_{ii}x_t+W_{hi}h_{t-1})it​=δ(Wii​xt​+Whi​ht−1​)， LSTM中有关输入的参是是WiiW_{ii}Wii​和WhiW_{hi}Whi​ 公式(2),遗忘门 ft=δ(Wifx
Pytorch学习笔记——nn.RNN()
程序媛的自学笔记
07-05 4986
pytorch 中使用 nn.RNN 类来搭建基于序列的循环神经网络，其构造函数如下： nn.RNN(input_size, hidden_size, num_layers=1, nonlinearity=tanh, bias=True, batch_first=False, dropout=0, bidirectional=False) RNN的结构如下： RNN 可以被看做是同一神经网络的多次赋值，每个神经网络模块会把消息传递给下一个，我们将这个图的结构展开 参数解释如下： input_siz
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使用-nn.RNN
xu624735206的博客
04-07 4722
pytorch使用-nn.RNN一、nn.RNN 一、nn.RNN nn.RNN(input_size: int, hidden_size: int, num_layers: int = 1, bias: bool = True, batch_first: bool = False, dropout: float = 0., bidirectional: bool = False, proj_size: int = 0, device=None, dtype=No
pytorch torch.nn.LSTM
Claroja
09-06 631
应用 >>> 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.RNN()总结
orangerfun的博客
01-11 2万+
nn.RNN(input_size, hidden_size, num_layers=1, nonlinearity=tanh, bias=True, batch_first=False, dropout, bidirectional=False) 参数说明 input_size输入特征的维度， 一般rnn中输入的是词向量，那么 input_size 就等于一个词向量的维度 h...
pytorch nn.LSTM及nn.LSTMCell的用法和理解
qq_39540454的博客
05-26 6062
照例先贴官方文档~ 以下是实例化一个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.Sequential使用详解
yueguang8的博客
04-18 6061
nn.Sequential 是 PyTorch 库中的一个类，它允许通过按顺序堆叠多个层来创建神经网络模型。它提供了一种方便的方式来定义和组织神经网络的层。文章详细介绍模型的定义修改、删除、参数访问、参数冻结等方法的详细使用说明；另外介绍了其他模型构建的方式及模型的加载保存。
pytorch 中RNN接口参数
weixin_42924890的博客
03-08 784
torch中RNN接口参数说明
pytorch中的torch.nn.LSTM解析
qq_43391414的博客
07-08 1827
本文记录一下使用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（隐藏层之间用）。不过，这里没有目标输出。所以只
Pytorch — LSTM (nn.LSTM & nn.LSTMCell)
hxxjxw的博客
05-22 2934
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的理解
qq_37880748的博客
08-25 2万+
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
RNN介绍及Pytorch源码解析
touxing777的博客
12-14 1186
首先，RNN模型所对应的源码在：\PyTorch\Lib\site-packages\torch\nn\modules\RNN.py文件中。当batch_size == Ture时，输入的维度一般为（batch_size * seq_len * emb_dim）。其中output的维度为（batch_size * seq_len * hidden_size *bidirectional表示RNN是双向还是单向的，单向为1，双向为2。输入分为input和h_0，当没有提供h_0的时候，h_0默认为0。
pytorch 中的torch.nn.LSTM函数
ineedstudytosurvive的博客
03-22 649
LSTM是RNN的一种变体 主要包括以下几个参数： input_size:输入的input中的参数维度，即文本中的embedding_dim hidden_size:隐藏层的维度 num_layers:LSTM的层数，一般为2-3层，默认为1 bias:是否使用偏置向，默认为True batch_first:是否输入的input第一个为batch_size,pytorch默认False,即输入的input的三维张量是seq_len放在第一个 dropout:是否丢弃部分神经元,默认为0 bidirectio
torch.nn.LSTM
08-23
torch.nn.LSTM是PyTorch中用于实现长短期记忆(LSTM)网络的类。LSTM是一种循环神经网络(RNN)的变种，它在处理序列数据时能够更好地捕捉长期依赖关系。torch.nn.LSTM具有以下参数: - input_size: 输入数据的特征维数，通常是词向量的维度。 - hidden_size: LSTM中隐藏层的维度。 - num_layers: 循环神经网络的层数。 - bias: 是否使用偏置，默认为True。 - batch_first: 输入数据的形状是否为(batch_size, seq_length, embedding_dim)，默认为False。 - dropout: 用于控制随机失活的概率，默认为0，表示不使用dropout。 - bidirectional: 是否使用双向LSTM，默认为False。 输入数据包括input、(h_0, c_0)，其中： - input: 形状为[seq_length, batch_size, input_size]的张量，包含输入序列的特征。 - h_0: 形状为[num_layers * num_directions, batch_size, hidden_size]的张量，包含每个句子的初始隐藏状态。 - c_0: 形状与h_0相同，包含每个句子的初始细胞状态。 输出数据包括output、(h_t, c_t)，其中： - output: 形状为[seq_length, batch_size, num_directions * hidden_size]的张量，包含LSTM最后一层的输出特征。 - h_t: 形状为[num_directions * num_layers, batch_size, hidden_size]的张量，包含每个batch中每个句子的最后一个时间步的隐藏状态。 - c_t: 形状与h_t相同，包含每个batch中每个句子的最后一个时间步的细胞状态。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [torch.nn.LSTM](https://blog.csdn.net/weixin_43269419/article/details/121344564)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* *3* [关于torch.nn.LSTM()的详解（维度，输入，输出）](https://blog.csdn.net/weixin_44201449/article/details/111129248)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ctrl A_ctrl C_ctrl V

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值