门控循环单元（Gate Recurrent Unit，GRU）详细解释（带示例）

浪九天

于 2025-03-03 08:45:00 发布

阅读量1.4k

点赞数 22

分类专栏：人工智能理论文章标签：机器学习深度学习人工智能

本文链接：https://blog.csdn.net/TEUTEU/article/details/145956403

版权

人工智能理论专栏收录该内容

14 篇文章

订阅专栏

门控循环单元

1. 背景与目的

和长短时记忆网络（LSTM）类似，门控循环单元（GRU）也是为了解决传统循环神经网络（RNN）在处理长序列数据时遇到的梯度消失或梯度爆炸问题而设计的。GRU 由 Cho 等人在 2014 年提出，它在保留捕捉序列长期依赖能力的同时，简化了 LSTM 的结构，使得计算效率更高。

2. 结构与原理

GRU 主要包含两个门控机制：重置门（Reset Gate）和更新门（Update Gate），以及一个隐藏状态。以下是各部分的详细介绍：

重置门（Reset Gate）：决定了上一时刻的隐藏状态 $h_{t - 1}$ 有多少信息需要被遗忘。它接收当前输入 $x_t$ 和上一时刻的隐藏状态 $h_{t - 1}$ ，通过一个 Sigmoid 函数计算出一个介于 0 到 1 之间的值 $r_t$ 。公式为： $r_t=\sigma(W_r[x_t, h_{t - 1}]+b_r)$ ，其中 $\sigma$ 是 Sigmoid 函数， $W_r$ 和 $b_r$ 分别是重置门的权重矩阵和偏置向量。当 $r_t$ 接近 0 时，表示上一时刻的隐藏状态大部分信息将被遗忘；当 $r_t$ 接近 1 时，表示上一时刻的隐藏状态信息将被保留。
更新门（Update Gate）：决定了上一时刻的隐藏状态 $h_{t - 1}$ 有多少信息需要被更新为当前时刻的候选隐藏状态 $\tilde{h}_t$ 。同样接收当前输入 $x_t$ 和上一时刻的隐藏状态 $h_{t - 1}$ ，通过 Sigmoid 函数计算出一个介于 0 到 1 之间的值 $z_t$ 。公式为： $z_t=\sigma(W_z[x_t, h_{t - 1}]+b_z)$ ，其中 $W_z$ 和 $b_z$ 分别是更新门的权重矩阵和偏置向量。 $z_t$ 越接近 0，说明上一时刻的隐藏状态被保留的越多； $z_t$ 越接近 1，说明上一时刻的隐藏状态被更新的越多。
候选隐藏状态（Candidate Hidden State）：根据重置门的输出 $r_t$ 、当前输入 $x_t$ 和上一时刻的隐藏状态 $h_{t - 1}$ 计算得到。公式为： $\tilde{h}_t=\tanh(W_{\tilde{h}}[r_t\odot h_{t - 1}, x_t]+b_{\tilde{h}})$ ，其中 $\odot$ 表示逐元素相乘， $\tanh$ 是双曲正切函数， $W_{\tilde{h}}$ 和 $b_{\tilde{h}}$ 分别是计算候选隐藏状态的权重矩阵和偏置向量。
当前隐藏状态（Current Hidden State）：根据更新门的输出 $z_t$ 、上一时刻的隐藏状态 $h_{t - 1}$ 和候选隐藏状态 $\tilde{h}_t$ 计算得到。公式为： $h_t=(1 - z_t)\odot h_{t - 1}+z_t\odot\tilde{h}_t$ 。这意味着当前隐藏状态是上一时刻隐藏状态和候选隐藏状态的加权组合，权重由更新门决定。

3. 与 LSTM 的比较

结构复杂度：GRU 的结构相对 LSTM 更简单，它只有两个门控机制和一个隐藏状态，而 LSTM 有三个门控机制（输入门、遗忘门、输出门）和一个细胞状态，因此 GRU 的计算量相对较小，训练速度更快。
性能表现：在大多数情况下，GRU 和 LSTM 都能很好地处理序列数据中的长期依赖问题，但在某些任务中，GRU 可能因为结构简单而表现稍逊一筹，而在另一些对计算资源要求较高或数据量较小的场景下，GRU 可能更具优势。

示例

假设我们要进行股票价格预测，给定过去一段时间内的股票价格序列作为输入，预测未来某一天的股票价格。GRU 可以通过其门控机制有效地捕捉股票价格序列中的长期趋势和短期波动信息。例如，当股票价格在一段时间内处于上涨趋势时，更新门会保留更多的历史信息，以便更好地预测未来价格的上涨；而当出现突发的市场变化时，重置门会帮助模型快速遗忘一些过时的信息，从而适应新的市场情况。

Python 案例

以下是使用 Python 和 PyTorch 库构建一个简单的 GRU 模型进行 MNIST 手写数字分类的案例：

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

# 数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

# 加载MNIST数据集
trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=32, shuffle=True)

testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=32, shuffle=False)

# 定义GRU模型
class GRUModel(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, num_classes):
        super(GRUModel, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.gru = nn.GRU(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, num_classes)

    def forward(self, x):
        # 初始化隐藏状态
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)

        # 前向传播GRU
        out, _ = self.gru(x, h0)

        # 取最后一个时间步的输出
        out = out[:, -1, :]

        # 全连接层
        out = self.fc(out)
        return out

# 超参数设置
input_size = 28
hidden_size = 128
num_layers = 2
num_classes = 10
learning_rate = 0.001

# 创建模型、损失函数和优化器
model = GRUModel(input_size, hidden_size, num_layers, num_classes)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# 训练模型
num_epochs = 10
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(trainloader):
        # 调整输入形状为(batch_size, sequence_length, input_size)
        images = images.view(-1, 28, 28)

        # 梯度清零
        optimizer.zero_grad()

        # 前向传播
        outputs = model(images)
        loss = criterion(outputs, labels)

        # 反向传播和优化
        loss.backward()
        optimizer.step()

        if (i + 1) % 100 == 0:
            print(f'Epoch [{epoch + 1}/{num_epochs}], Step [{i + 1}/{len(trainloader)}], Loss: {loss.item():.4f}')

# 测试模型
model.eval()
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in testloader:
        images = images.view(-1, 28, 28)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print(f'Accuracy on the test set: {100 * correct / total}%')

代码解释

数据预处理与加载：使用 torchvision.transforms 对 MNIST 数据集进行预处理，将图像转换为张量并归一化。然后使用 DataLoader 加载训练集和测试集。
模型定义：定义了一个 GRUModel 类，包含一个 nn.GRU 层和一个全连接层。nn.GRU 层用于处理序列数据，全连接层用于将最后一个时间步的隐藏状态映射到输出类别。
超参数设置：设置了输入大小、隐藏层大小、GRU 层数、类别数和学习率等超参数。
模型训练：使用交叉熵损失函数和 Adam 优化器对模型进行训练。在每个批次中，将图像数据调整为合适的形状，进行前向传播、计算损失、反向传播和更新参数的操作，并定期打印损失。
模型测试：在测试集上评估模型的性能，计算预测准确率并打印输出。