PyTorch中RNN、LSTM和GRU使用和理解

已于 2024-04-18 10:55:46 修改
阅读量208 收藏
点赞数
分类专栏： 深度学习篇 文章标签： rnn pytorch lstm
于 2024-02-02 22:24:44 首次发布
原文链接：https://blog.csdn.net/qq_42452134/article/details/135402306
版权

最近在看李沐老师动手学深度学习的序列模型，结合网上的一些资料做了一些汇总，解决了对于模型的理解和使用，在这里记录一下。

PyTorch中RNN、LSTM和GRU使用和理解

参考：简单易懂深入PyTorch中RNN、LSTM和GRU使用和理解-CSDN博客

nn.RNN
RNN 类描述

torch.nn.RNN 是 PyTorch 中用于构建一个简单的 Elman 循环神经网络（RNN）的类。它可以应用于输入序列，使用 tanh 或 ReLU 作为激活函数。下面将详细描述这个类的功能、参数和注意事项。

RNN 类的参数
  1. input_size: 输入特征的数量。
  2. hidden_size: 隐藏状态的特征数量。
  3. num_layers: RNN层的数量。例如，num_layers=2 表示两个 RNN 层堆叠在一起。
  4. nonlinearity: 使用的非线性激活函数，可以是 'tanh' 或 'relu'。
  5. bias: 如果为 False，则层不使用偏置权重 b_ih 和 b_hh。
  6. batch_first: 如果为 True，则输入和输出张量的格式为 (batch, seq, feature)；否则为 (seq, batch, feature)。
  7. dropout: 如果非零，将在每个 RNN 层的输出上引入一个 Dropout 层，除了最后一层。
  8. bidirectional: 如果为 True，则变为双向 RNN。
输入和输出
  • 输入: input, h_0
    • input: 形状为 (seq_len, batch, input_size) 或 (batch, seq_len, input_size)（如果 batch_first=True）的张量，包含输入序列的特征。
    • h_0: 形状为 (num_layers * num_directions, batch, hidden_size) 的张量，包含初始隐藏状态。如果未提供，默认为零。
  • 输出: output, h_n
    • output: 包含最后一层 RNN 的输出特征（h_t）的张量。
    • h_n: 形状为 (num_layers * num_directions, batch, hidden_size) 的张量，包含批次中每个元素的最终隐藏状态。
示例代码
import torch
import torch.nn as nn
# 创建 RNN 实例
rnn = nn.RNN(input_size=10, hidden_size=20, num_layers=2, nonlinearity='tanh')
# 对于hidden_size的理解：每一个时间步对应的神经元内部的参数个数
# 输入数据
input = torch.randn(5, 3, 10)  # (seq_len, batch, input_size)
h0 = torch.randn(2, 3, 20)     # (num_layers, batch, hidden_size)
# 前向传播
output, hn = rnn(input, h0)

这段代码展示了如何创建一个简单的 RNN 网络并进行前向传播。在这个例子中，input 是一个随机生成的输入张量，其维度是序列长度、批大小和输入大小。h0 是初始隐藏状态。输出 output 包含了每个时间步的隐藏状态，而 hn 是最终的隐藏状态。

nn.LSTM
LSTM 类描述

torch.nn.LSTM 是 PyTorch 中用于构建长短期记忆（LSTM）网络的类。LSTM 是一种特殊类型的循环神经网络（RNN），特别适合处理和预测时间序列数据中的长期依赖关系。

LSTM 类的参数
  1. input_size: 输入特征的数量。
  2. hidden_size: 隐藏状态的特征数量。
  3. num_layers: RNN层的数量。例如，num_layers=2 表示两个 LSTM 层堆叠在一起。
  4. bias: 如果为 False，则层不使用偏置权重 b_ih 和 b_hh。
  5. batch_first: 如果为 True，则输入和输出张量的格式为 (batch, seq, feature)；否则为 (seq, batch, feature)。
  6. dropout: 如果非零，将在每个 LSTM 层的输出上引入一个 Dropout 层，除了最后一层。
  7. bidirectional: 如果为 True，则变为双向 LSTM。
  8. proj_size: 如果大于 0，则使用带有投影的 LSTM。这将改变 LSTM 单元的输出维度和某些权重矩阵的形状。
输入和输出
  • 输入: input, (h_0, c_0)
    • input: 形状为 (seq_len, batch, input_size) 或 (batch, seq_len, input_size)（如果 batch_first=True）的张量，包含输入序列的特征。
    • h_0: 形状为 (num_layers * num_directions, batch, hidden_size) 的张量，包含初始隐藏状态。
    • c_0: 形状为 (num_layers * num_directions, batch, hidden_size) 的张量，包含初始细胞状态。
  • 输出: output, (h_n, c_n)
    • output: 包含最后一层 LSTM 的输出特征（h_t）的张量。
    • h_n: 形状为 (num_layers * num_directions, batch, hidden_size) 的张量，包含序列中每个元素的最终隐藏状态。
    • c_n: 形状为 (num_layers * num_directions, batch, hidden_size) 的张量，包含序列中每个元素的最终细胞状态。
示例代码
import torch
import torch.nn as nn
# 创建 LSTM 实例
lstm = nn.LSTM(input_size=10, hidden_size=20, num_layers=2)
# 输入数据
input = torch.randn(5, 3, 10)  # (seq_len, batch, input_size)
h0 = torch.randn(2, 3, 20)     # (num_layers, batch, hidden_size)
c0 = torch.randn(2, 3, 20)     # (num_layers, batch, hidden_size)
# 前向传播
output, (hn, cn) = lstm(input, (h0, c0))

这段代码展示了如何创建一个 LSTM 网络并进行前向传播。在这个例子中，input 是一个随机生成的输入张量，其维度是序列长度、批大小和输入大小。h0 和 c0 分别是初始隐藏状态和细胞状态。输出 output 包含了每个时间步的隐藏状态，而 (hn, cn) 是最终的隐藏状态和细胞状态。

nn.GRU
GRU 类描述

torch.nn.GRU 是 PyTorch 中用于构建门控循环单元（GRU）网络的类。GRU 是一种循环神经网络，类似于 LSTM，但结构更为简单，用于处理序列数据。

GRU 类的参数
  1. input_size: 输入特征的数量。
  2. hidden_size: 隐藏状态的特征数量。
  3. num_layers: RNN层的数量。例如，num_layers=2 表示两个 GRU 层堆叠在一起。
  4. bias: 如果为 False，则层不使用偏置权重 b_ih 和 b_hh。
  5. batch_first: 如果为 True，则输入和输出张量的格式为 (batch, seq, feature)；否则为 (seq, batch, feature)。
  6. dropout: 如果非零，将在每个 GRU 层的输出上引入一个 Dropout 层，除了最后一层。
  7. bidirectional: 如果为 True，则变为双向 GRU。
输入和输出
  • 输入: input, h_0
    • input: 形状为 (seq_len, batch, input_size) 或 (batch, seq_len, input_size)（如果 batch_first=True）的张量，包含输入序列的特征。
    • h_0: 形状为 (num_layers * num_directions, batch, hidden_size) 的张量，包含初始隐藏状态。
  • 输出: output, h_n
    • output: 包含最后一层 GRU 的输出特征（h_t）的张量。
    • h_n: 形状为 (num_layers * num_directions, batch, hidden_size) 的张量，包含序列中每个元素的最终隐藏状态。
示例代码
import torch
import torch.nn as nn
# 创建 GRU 实例
gru = nn.GRU(input_size=10, hidden_size=20, num_layers=2)
# 输入数据
input = torch.randn(5, 3, 10)  # (seq_len, batch, input_size)
h0 = torch.randn(2, 3, 20)     # (num_layers, batch, hidden_size)
# 前向传播
output, hn = gru(input, h0)

这段代码展示了如何创建一个 GRU 网络并进行前向传播。在这个例子中，input 是一个随机生成的输入张量，其维度是序列长度、批大小和输入大小。h0 是初始隐藏状态。输出 output 包含了每个时间步的隐藏状态，而 hn 是最终的隐藏状态。

LSTM怎么得到最终的输出

参考：(94 封私信 / 80 条消息) pytorch对于双向LSTM，对于output,(h_n,c_n)=nn.LSTM(x)怎么取输出？ - 知乎 (zhihu.com)

假设最后我们得到了output(batch_size, seq_len, 2 * hidden_size)，我们需要将其输入到线性层，有以下两种方法可以参考：

（1）直接输入

和单向一样，我们可以将output直接输入到Linear。在单向LSTM中：

self.linear = nn.Linear(self.hidden_size, self.output_size)

而在双向LSTM中：

self.linear = nn.Linear(2 * self.hidden_size, self.output_size)

模型：

class BiLSTM(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size, batch_size):
        super().__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.output_size = output_size
        self.num_directions = 2
        self.batch_size = batch_size
        self.lstm = nn.LSTM(self.input_size, self.hidden_size, self.num_layers, batch_first=True, bidirectional=True)
        self.linear = nn.Linear(self.num_directions * self.hidden_size, self.output_size)

    def forward(self, input_seq):
        h_0 = torch.randn(self.num_directions * self.num_layers, self.batch_size, self.hidden_size).to(device)
        c_0 = torch.randn(self.num_directions * self.num_layers, self.batch_size, self.hidden_size).to(device)
        # print(input_seq.size())
        seq_len = input_seq.shape[1]
        # input(batch_size, seq_len, input_size)
        # output(batch_size, seq_len, num_directions * hidden_size)
        output, _ = self.lstm(input_seq, (h_0, c_0))
        pred = self.linear(output)  # pred()
        pred = pred[:, -1, :] # 注意，这是batch_first=True的情况
        return pred

（2）处理后再输入

在LSTM中，经过线性层后的output的shape为(batch_size, seq_len, output_size)。假设我们用前24个小时(1 to 24)预测后2个小时的负荷(25 to 26)，那么seq_len=24, output_size=2。根据LSTM的原理，最终的输出中包含了所有位置的预测值，也就是((2 3), (3 4), (4 5)…(25 26))。很显然我们只需要最后一个预测值，即output[:, -1, :]。

而在双向LSTM中，一开始output(batch_size, seq_len, 2 * hidden_size)，这里面包含了所有位置的两个方向的输出。简单来说，output[0]为序列从左往右第一个隐藏层状态输出和序列从右往左最后一个隐藏层状态输出的拼接；output[-1]为序列从左往右最后一个隐藏层状态输出和序列从右往左第一个隐藏层状态输出的拼接。

如果我们想要同时利用前向和后向的输出，我们可以将它们从中间切割，然后求平均。比如output的shape为(30, 24, 2 * 64)，我们将其变成(30, 24, 2, 64)，然后在dim=2上求平均，得到一个shape为(30, 24, 64)的输出，此时就与单向LSTM的输出一致了。

具体处理方法：

output = output.contiguous().view(self.batch_size, seq_len, self.num_directions, self.hidden_size)
output = torch.mean(output, dim=2)

模型代码：

class BiLSTM(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size, batch_size):
        super().__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.output_size = output_size
        self.num_directions = 2
        self.batch_size = batch_size
        self.lstm = nn.LSTM(self.input_size, self.hidden_size, self.num_layers, batch_first=True, bidirectional=True)
        self.linear = nn.Linear(self.hidden_size, self.output_size)

    def forward(self, input_seq):
        h_0 = torch.randn(self.num_directions * self.num_layers, self.batch_size, self.hidden_size).to(device)
        c_0 = torch.randn(self.num_directions * self.num_layers, self.batch_size, self.hidden_size).to(device)
        # print(input_seq.size())
        seq_len = input_seq.shape[1]
        # input(batch_size, seq_len, input_size)
        input_seq = input_seq.view(self.batch_size, seq_len, self.input_size)
        # output(batch_size, seq_len, num_directions * hidden_size)
        output, _ = self.lstm(input_seq, (h_0, c_0))
        output = output.contiguous().view(self.batch_size, seq_len, self.num_directions, self.hidden_size)
        output = torch.mean(output, dim=2)
        pred = self.linear(output)
        # print('pred=', pred.shape)
        pred = pred[:, -1, :]
        return pred
输出层or隐藏层？

首先，pytorch中LSTM的输出一般用到的是输出层和隐藏层这两个，另一个细胞状态，我没咋用过，就不讲了。

一般两种用法，要么将输出层全连接然后得出结果，要么用隐藏层全连接，然后得出结果，有学长说用隐藏层效果会好一点。两种用法应该都可以。如果网络只有一层的时候，用输出层和隐藏层是没有任何区别的，当网络层数大于1时，才会有区别。

举个例子就懂了：

# coding: utf-8
import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision.datasets as datasets
import matplotlib.pyplot as plt

input_dim = 28  # 输入维度
hidden_dim = 100  # 隐层的维度
layer_dim = 1  # 1层LSTM
output_dim = 10  # 输出维度
BATCH_SIZE = 32  # 每批读取的
EPOCHS = 10  # 训练10轮


trainsets = datasets.MNIST(root="./data", train=True, download=True, transform=transforms.ToTensor())
testsets = datasets.MNIST(root="./data", train=False, transform=transforms.ToTensor())

train_loader = torch.utils.data.DataLoader(dataset=trainsets, batch_size=BATCH_SIZE, shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=testsets, batch_size=BATCH_SIZE, shuffle=True)


class LSTM_Model(nn.Module):
    def __init__(self, input_dim, hidden_dim, layer_dim, output_dim):
        super(LSTM_Model, self).__init__()
        self.hidden_dim = hidden_dim
        self.layer_dim = layer_dim
        self.lstm = nn.LSTM(input_dim, hidden_dim, layer_dim, batch_first=True)
        # 全连接层
        self.fc = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        # layer_dim, batch_size, hidden_dim
        h0 = torch.zeros(self.layer_dim, x.size(0), self.hidden_dim).requires_grad_().to(device)
        # 初始化cell, state
        c0 = torch.zeros(self.layer_dim, x.size(0), self.hidden_dim).requires_grad_().to(device)
        # 分离隐藏状态，避免梯度爆炸
        lstm_out, (h_n, cn) = self.lstm(x, (h0.detach(), c0.detach()))
        print("-" * 10)
        print("lstm_out.shape", lstm_out.shape)
        print("lstm_out[:, -1].shape", lstm_out[:, -1].shape)
        print("-" * 10)
        print("h_n.shape", h_n.shape)
        print("-" * 10)
        feature_map = torch.cat([h_n[i, :, :] for i in range(h_n.shape[0])], dim=-1)
        print("feature_map.shape", feature_map.shape)
        print("-" * 10)
        print("lstm_out[:, -1]", lstm_out[:, -1])
        print("-" * 10)
        print("feature_map", feature_map)
        print("-" * 10)
        out = self.fc(feature_map)
        print("out", out.shape)
        return out

model = LSTM_Model(input_dim, hidden_dim, layer_dim, output_dim)

device = torch.device("cuda:0" if torch.cuda.is_available() else 'cpu')

# 损失函数
criterion = nn.CrossEntropyLoss()

# 优化器
learning_rate = 0.01
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

# 模型训练
sequence_dim = 28  # 序列长度
loss_list = []
accuracy_list = []
iteration_list = []  # 迭代次数

iter = 0
for epoch in range(EPOCHS):
    for i, (images, labels) in enumerate(train_loader):
        model.train()
        images = images.view(-1, sequence_dim, input_dim).requires_grad_().to(device)
        labels = labels.to(device)
        optimizer.zero_grad()
        # 前向传播
        outputs = model(images)
        # 计算损失
        loss = criterion(outputs, labels)
        # 反向传播
        loss.backward()
        # 更新参数
        optimizer.step()
        # 计数器加1
        iter += 1
        # 模型验证
        if iter % 500 == 0:
            model.eval()  # 声明
            # 计算验证的accuracy
            correct = 0.0
            total = 0.0
            # 迭代测试集，获取数据、预测
            for images, labels in test_loader:
                images = images.view(-1, sequence_dim, input_dim).to(device)
                # 模型预测
                outputs = model(images)
                # 获取预测概率最大值的下标
                predict = torch.max(outputs.data, 1)[1]
                # 统计测试集的大小
                total += labels.size(0)
                # 统计判断预测正确的数量
                if torch.cuda.is_available():
                    correct += (predict.gpu() == labels.gpu()).sum()
                else:
                    correct += (predict == labels).sum()

                    # 计算accuracy
            accuracy = correct / total * 100
            loss_list.append(loss.data)
            accuracy_list.append(accuracy)
            iteration_list.append(iter)
            # 打印信息
            print("loos:{}, Loss:{}, Accuracy:{}".format(iter, loss.item(), accuracy))

plt.plot(iteration_list, loss_list)
plt.xlabel("Number of Iteration")
plt.ylabel("Loss")
plt.title("LSTM")
plt.show()


plt.plot(iteration_list, accuracy_list, color='r')
plt.xlabel("Number of iteration")
plt.ylabel("Accuracy")
plt.title("LSTM")
plt.show()

分析：

input_dim = 28 # 输入步长(seq_len)

hidden_dim = 100 # 隐层的维度(hidden_size)

layer_dim = 1 # 1层LSTM(num_layers)

output_dim = 10 # 输出维度

BATCH_SIZE = 32 # 每批读取的(batch_size)

lstm_out：【batch_size, seq_len, hidden_size * num_directions】

lstm_hn:【num_directions * num_layers, batch_size, hidden_size】

img

此时我们看到，输出层的最后一步的shape和拼接后的隐藏层的shape是一样的，我们可以打印出具体的数值。

img

可以看到，这两层的值是一样的，因此当网络为1层的时候输出层和隐藏层的结果没有任何区别。

img

最终输出是【batch_size, num_classes】,应该没什么疑问，因为是十分类任务。

但是当网络超过一层时，可以把上面的代码将层数直接改为2，不出意外应该会报错。

img

分析结果可以发现，隐藏层的结果比输出层的结果多了一层，同时观察打印出来的结果，可以发现，隐藏层不仅有输出层的信息，还有前一层隐藏层的信息，即隐藏层最终的信息是大于输出层的，因此，说隐藏层效果会好一点也很容易解释，因为包含的信息更多了。

结论

通过上述实例可以发现，用隐藏层代替输出层进入全连接层理论上应该会有更好的效果，且模型batch_first=True or False只对输出层有影响，而对隐藏层的输出是没有影响的，因此，以后都用隐藏层来全连接比好，也不容易搞错。

怪味＆先森
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
GRU实现时间序列预测(PyTorch版)
CSDN 精品推荐
01-08 4万+
本篇文章我们采用了经典的循环神经网络GRU来对我们的时序数据建模处理，作为该专栏的第一篇文章，本篇将详细介绍项目的每个实现部分以及细节处理，帮助新手小白快速建立起如何处理时序数据的框架。
Pytorch实现LSTM和GRU示例
09-18
今天小编就为大家分享一篇Pytorch实现LSTM和GRU示例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
pytorch 笔记：GRU
qq_40206371的博客
11-01 1356
在多层GRU中，第 l 层的输入（对于 l≥2）是前一层的隐藏状态乘以概率 dropout。
PyTorch nn.GRU 使用详解
热门推荐
周迪新的博客
03-16 3万+
我们看官方文档一些参数介绍，以及如下一个简单例子： 看完之后，还是一脸懵逼: 输入什么鬼？ 输出又什么鬼？ (这里我先把官网中 h0 去掉了，便于大家先理解更重要的概念) import torch from torch import nn rnn = nn.GRU(10, 20, 2) input = torch.randn(5, 3, 10) output, hn = rnn(input) 运行之后，各变量的shape如下: 要使用GRU这个layer，就要明白，要先定义GRU，然后才是调用这个定义
torch.nn中GRU使用
XD的博客
10-10 3247
【代码】torch.nn中GRU使用。
torch学习 (三十一)：门控循环单元 (GRU)
因吉的博客
06-08 1465
当时间步较大或者较小时，RNN容易出现梯度衰减或者梯度爆炸。虽然梯度裁剪可以应对梯度爆炸，但是无法解决梯度衰减的问题。通常由于这个原因，RNN在实际中较难捕捉时间序列中时间步距离较大的依赖关系。门控循环神经网络 (gated recurrent neural network)的提出，正是为了更好地捕捉时间序列中的时间步较大的依赖关系。它可以通过学习的门来控制信息的流动。其中，门控循环单元 (gated recurrent unit, GRU)是一种常用的门控循环神经网路。
时间序列预测实战(十七)PyTorch实现LSTM-GRU模型长期预测并可视化结果（附代码+数据集+详细讲解）
Snu77的博客
11-20 8163
本文给大家带来的实战内容是利用PyTorch实现LSTM-GRU模型，LSTM和GRU都分别是RNN中最常用Cell之一，也都是时间序列预测中最常见的结构单元之一，本文的内容将会从实战的角度带你分析LSTM和GRU的机制和效果，同时如果你是时间序列中的新手，这篇文章会带你了解整个时间序列的建模过程，同时本文的实战代码支持多元预测单元、单元预测单元、多元预测多元(为我个人编写大家如有转载请标明来源)，本文的实战内容通过时间序列领域最经典的数据集——电力负荷数据集为例进行预测。内容回顾->
NASA和CALCE 锂电池数据集基于Pytorch的RNN LSTM GRU 寿命预测源码+使用说明文档.zip
05-21
锂电池的容量数据其实是一个时间序列，MLP 并不能很好地对时序数据进行分析。对时间序列的分析最经典的算法当然要数 RNN、LSTM 和 GRU 了。 故，接下来我会主要采用 RNN、LSTM 和 GRU 这三个序列模型进行寿命预测。
循环神经网络的进化：PyTorch中的LSTM、GRU与更多
最新发布
07-19
### 循环神经网络的进化：PyTorch 中的 LSTM、GRU 与更多 在深度学习领域，循环神经网络（RNN）以其独特的处理序列数据能力占据着重要的位置。随着技术的发展，RNN 已经演化出了多种变种，其中最著名的包括长短期...
SequencePrediction:Pytorch 实现RNN、LSTM、GRU模型
05-09
通过阅读和理解这些代码，你可以深入学习如何在PyTorch中构建和训练序列预测模型，以及如何处理RNN、LSTM和GRU在网络结构和训练过程中的差异。这个项目不仅有助于提升你的PyTorch技能，还能让你更好地理解递归神经...
使用Pytorch从零开始构建GRU
GarryWang1248的博客
11-24 2660
门控循环单元（GRU），顾名思义，是RNN 架构的一种变体，它使用门控机制来控制和管理神经网络中单元之间的信息流。Cho 等人于 2014 年才引入 GRU。可以被认为是一种相对较新的架构，特别是与Sepp Hochreiter 和 Jürgen Schmidhuber于 1997 年提出的广泛采用的 LSTM 相比。GRU 的结构使其能够自适应地捕获大型数据序列的依赖性，而不会丢弃序列早期部分的信息。这是通过其门控单元实现的，类似于 LSTM 中的门控单元，它解决了传统 RNN 的梯度消失/爆炸问题。
深度学习笔记——pytorch实现双向GRU（BiGRU）
weixin_45978839的博客
01-09 2340
参考视频。
pytorch实现GRU（附code）
ting_qifengl的博客
01-29 2万+
接上一篇文章（pytorch实现LSTM），在实现LSTM之后，又发现了GRU网络。 说GRU是LSTM网络的一种效果很好的变体，它较LSTM网络的结构更加简单，而且效果也很好，也是当前非常流形的一种网络。 所以决定尝试一下！ 注：数据集仍然使用上文中的IGBT加速老化数据集，数据与处理方法不变，直接上代码！！！ 在保证输入样本参数和学习率不变的情况下，即input_size = 5，out_oput = 1，lr = 0.01，试了很多参数，发现在训练集80%，测试集20%，hidden_size
时间序列预测实战(十五)PyTorch实现GRU模型长期预测并可视化结果
Snu77的博客
11-13 8259
本文讲解的实战内容是GRU(门控循环单元)，本文的实战内容通过时间序列领域最经典的数据集——电力负荷数据集为例，深入的了解GRU的基本原理和框架，下面是预测值和真实值的对比图先给大家放在前面。预测类型->单元预测、多元预测、长期预测门控机制：GRU的核心是门控机制，包括更新门（update gate）和重置门（reset gate）。这些门控制着信息的流动，即决定哪些信息应该被保留，哪些应该被遗忘。更新门：更新门帮助模型决定过去的信息有多少需要保留到当前状态。
Pytorch快速入门
09-14
掌握深度学习框架PyTorch的基本语法熟练使用PyTorch进行数据处理掌握神经网络构建方法，构建各种网络架构图像分类项目实战
简单易懂深入PyTorch中RNN、LSTM和GRU使用和理解
CDBmax的博客
01-05 2087
RNNBaseRNNLSTMGRU及其对应的单元格版本RNNCellLSTMCellGRUCell。每个类的功能、作用、参数和使用方法都得到了详细的解释和示例代码的支持。从基础的 RNN 架构到更复杂的 LSTM 和 GRU 结构，本文提供了深入了解这些强大的序列模型工具的机会，同时也展示了如何在实际场景中应用这些模型。这些类不仅对于理解序列数据的基本动态至关重要，而且在许多先进的深度学习应用中发挥着核心作用。
笔记-自己使用pytorch实现的GRU
qq_32339317的博客
07-22 1246
import torch import Config import torch.nn as nn from torch.utils.data import DataLoader, TensorDataset import pickle import numpy as np from sklearn import metrics import math batch_size = 256 # 一批数据有多少条 input_size = 63 # 输入的维度 hidden_size = 32 # GRU.
Pytorch之经典神经网络RNN(二) —— GRU()
hxxjxw的博客
07-29 1964
GRU，Gate Recurrent Unit，是循环神经网络RNN的一种。 和LSTM一样，也是为了解决长期记忆和反向传播中的梯度等问题而提出来的。 GRU和LSTM在很多情况下实际表现上相差无几，那么为什么我们要使用新人GRU（2014年提出）而不是相对经受了更多考验的LSTM（1997提出）呢？ 我们在我们的实验中选择GRU是因为它的实验效果与LSTM相似，但是更易于计算。 相比LSTM，使用GRU能够达到相当的效果，并且相比之下更容易进行训练...
循环神经网络实现文本情感分类之Pytorch中LSTM和GRU模块使用
IT之一小佬的博客
04-02 2006
循环神经网络实现文本情感分类 1. Pytorch中LSTM和GRU模块使用 1.1 LSTM介绍 LSTM和GRU都是由torch.nn提供 通过观察文档，可知LSTM的参数， torch.nn.LSTM(input_size,hidden_size,num_layers,batch_first,dropout,bidirectional) input_size：输入数据的形状，即embedding_dim hidden_size：隐藏层神经元的数量，即每一层有多少个LSTM单元
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值