【深度学习基础模型】门控循环单元 (Gated Recurrent Units, GRU)详细理解并附实现代码。

985小水博一枚呀

已于 2025-02-11 20:23:05 修改

阅读量2.3k

点赞数 45

分类专栏：深度学习中的各类神经网络文章标签：深度学习 gru 人工智能 cnn 神经网络分类 rnn

于 2024-09-26 13:30:00 首次发布

本文链接：https://blog.youkuaiyun.com/gaoxiaoxiao1209/article/details/142426300

版权

深度学习中的各类神经网络专栏收录该内容

48 篇文章 ¥39.90 ¥99.00

订阅专栏

超级会员免费看

【深度学习基础模型】门控循环单元 (Gated Recurrent Units, GRU)

文章目录

【深度学习基础模型】门控循环单元 (Gated Recurrent Units, GRU)
1.门控循环单元 (Gated Recurrent Units, GRU) 原理详解
2.Python 实现 GRU 的实例
- 2.1GRU 实现及应用实例
- 2.2 代码解释
3.总结

参考地址：https://www.asimovinstitute.org/neural-network-zoo/
论文地址：https://arxiv.org/pdf/1412.3555v1

欢迎宝子们点赞、关注、收藏！欢迎宝子们批评指正！

1.门控循环单元 (Gated Recurrent Units, GRU) 原理详解

1.1 GRU 概述

GRU 是 LSTM（长短期记忆网络）的变体。与 LSTM 类似，GRU 也是为了解决 RNN 中的 梯度消失和梯度爆炸 问题而设计的，但 GRU 相比 LSTM 结构更为简单。GRU 去除了 LSTM 中的输出门，并结合了输入门和遗忘门为一个更新门。这使得 GRU 在某些情况下比 LSTM 更高效。

1.2 GRU 的门控机制

GRU 有两个门：更新门 (update gate) 和重置门 (reset gate)。

更新门 (update gate): 控制当前隐藏状态中保留多少信息，决定保留多少先前的状态，以及从当前输入中引入多少新信息。
重置门 (reset gate): 决定如何将新信息与之前的记忆结合起来，类似于 LSTM 的遗忘门，但工作方式稍有不同。

GRU 的公式为：

更新门:
$z_t=σ(W_zx_t+U_zh_{t-1})$
重置门:
$r_t=σ(W_rx_t+U_rh_{t-1})$
候选隐藏状态:
$\widetilde{h}_t=tanh(W_hx_t+U_h(r_t⊙h_{t-1}))$
隐藏状态更新:
$h_t=z_t⊙h_{t-1}+(1-z_t)⊙\widetilde{h}_t$

其中：

$z_t$ 是更新门，控制先前状态和当前候选状态的平衡。
$r_t$ 是重置门，控制前一时刻隐藏状态的影响程度。
$\widetilde{h}_t$ 是候选的隐藏状态，使用当前输入和前一时刻的隐藏状态生成。
$h_t$ 是当前的隐藏状态。

1.3 GRU 的优缺点

优点: 结构更简单，计算量较小，比 LSTM 更快，适合不需要复杂表达能力的场景。
缺点: 由于少了一个门控机制（没有输出门），在某些任务中表现略逊于 LSTM。

1.4 GRU 的应用

GRU 和 LSTM 类似，广泛应用于序列数据处理任务，包括：

自然语言处理 (NLP)：如机器翻译、文本生成等。
语音识别：处理连续的语音数据。
时间序列预测：用于预测未来的趋势，例如股票预测等。

2.Python 实现 GRU 的实例

我们使用 PyTorch 实现一个基于 GRU 的文本分类模型。与前面 RNN 实例类似，我们将训练一个二分类模型。

2.1GRU 实现及应用实例

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# 构造简单的示例数据集
# 假设有两个类别的句子，分别标注为 0 和 1
X = [
    [1, 2, 3, 4],     # "I love machine learning"
    [5, 6, 7, 8],     # "deep learning is great"
    [1, 9, 10, 11],   # "I hate spam emails"
    [12, 13, 14, 15]  # "phishing attacks are bad"
]
y = [0, 0, 1, 1]  # 标签

# 转换为 Tensor 格式
X = torch.tensor(X, dtype=torch.long)
y = torch.tensor(y, dtype=torch.long)

# 定义数据集和数据加载器
dataset = TensorDataset(X, y)
dataloader = DataLoader(dataset, batch_size=2, shuffle=True)

# 定义 GRU 模型
class GRUModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, num_layers):
        super(GRUModel, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.embedding = nn.Embedding(input_size, hidden_size)  # 嵌入层
        self.gru = nn.GRU(hidden_size, hidden_size, num_layers, batch_first=True)  # GRU 层
        self.fc = nn.Linear(hidden_size, output_size)  # 全连接层

    def forward(self, x):
        # 初始化隐藏状态
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        
        # 嵌入层
        out = self.embedding(x)
        
        # 通过 GRU
        out, _ = self.gru(out, h0)
        
        # 取最后一个时间步的隐藏状态
        out = out[:, -1, :]
        
        # 全连接层进行分类
        out = self.fc(out)
        return out

# 模型参数
input_size = 16  # 假设词汇表有 16 个词
hidden_size = 8  # 隐藏层维度
output_size = 2  # 输出为二分类
num_layers = 1   # GRU 层数

# 创建模型
model = GRUModel(input_size, hidden_size, output_size, num_layers)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)

# 训练模型
num_epochs = 20
for epoch in range(num_epochs):
    for data, labels in dataloader:
        # 前向传播
        outputs = model(data)
        loss = criterion(outputs, labels)
        
        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
    if (epoch+1) % 5 == 0:
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

# 测试模型
with torch.no_grad():
    test_sentence = torch.tensor([[1, 2, 3, 4]])  # 测试句子 "I love machine learning"
    prediction = model(test_sentence)
    predicted_class = torch.argmax(prediction, dim=1)
    print(f'Predicted class: {predicted_class.item()}')

2.2 代码解释

1.定义 GRU 模型：

self.embedding = nn.Embedding(input_size, hidden_size)：将输入的单词索引转换为高维向量表示。
self.gru = nn.GRU(hidden_size, hidden_size, num_layers, batch_first=True)：定义 GRU 层，输入和输出维度为 hidden_size，batch_first=True 表示输入序列按批次为第一维度。
self.fc = nn.Linear(hidden_size, output_size)：全连接层将 GRU 输出映射为分类输出。

2.GRU 的前向传播：

h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)：初始化 GRU 的隐藏状态。
out, _ = self.gru(out, h0)：通过 GRU 层，out 是每个时间步的输出。
out = out[:, -1, :]：取最后一个时间步的隐藏状态作为最终输出。
out = self.fc(out)：通过全连接层进行分类。

3.数据集与加载器：