GRU--详解

Ambition_LAO

于 2024-10-10 12:33:12 发布

阅读量1.7k

点赞数 26

文章标签： python 深度学习

本文链接：https://blog.csdn.net/GDHBFTGGG/article/details/142818490

版权

GRU（Gated Recurrent Unit）（门控循环单元）是RNN（循环神经网络）的一种变体。GRU的设计简化了另一种RNN变体——LSTM（长短期记忆网络），与LSTM不同的是，GRU将输入门和遗忘门合并为一个单一的“重置门”和“更新门”，从而减少了模型的复杂性，同时仍能有效地捕捉长期依赖关系。

GRU的基本结构

GRU的结构主要由以下两个门组成：

重置门（Reset Gate）：控制前一时刻的状态信息应该被遗忘的程度，决定当前时刻有多少过去的信息需要被遗忘。
更新门（Update Gate）：决定前一时刻的状态信息对当前时刻的影响程度，控制当前时刻的隐藏状态应该保留多少前一时刻的记忆。

GRU的经典代码

在深度学习框架如PyTorch或TensorFlow中，GRU的实现非常简单。以下是用PyTorch实现一个简单GRU网络的代码：

import torch
import torch.nn as nn

class GRUNet(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size):
        super(GRUNet, 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, output_size)
        
    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 = 10
hidden_size = 20
num_layers = 2
output_size = 1
model = GRUNet(input_size, hidden_size, num_layers, output_size)

# 生成随机输入数据
input_data = torch.randn(32, 5, input_size)  # (batch_size, sequence_length, input_size)
output = model(input_data)
print(output.shape)  # (batch_size, output_size)

处理文本生成任务的GRU示例

文本生成任务中，GRU通常作为生成器的一部分，输入是前一个时间步生成的字符或单词，输出是下一个时间步的预测字符或单词。下面是一个使用PyTorch的GRU实现文本生成的简单示例。

数据准备

使用字符级RNN来生成文本，首先需要将文本数据转化为字符的索引。

import torch
import torch.nn as nn
import torch.optim as optim

# 准备数据
text = "hello world"  # 简单的训练文本示例
chars = list(set(text))
char_to_idx = {ch: i for i, ch in enumerate(chars)}
idx_to_char = {i: ch for i, ch in enumerate(chars)}
input_size = len(chars)

# 将文本转化为索引
data = [char_to_idx[ch] for ch in text]
input_data = torch.tensor(data[:-1])  # 输入文本（去掉最后一个字符）
target_data = torch.tensor(data[1:])  # 目标文本（去掉第一个字符）

模型定义

class TextGenerationGRU(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, num_layers=1):
        super(TextGenerationGRU, 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, output_size)
        
    def forward(self, x, hidden):
        out, hidden = self.gru(x, hidden)
        out = self.fc(out)
        return out, hidden
    
    def init_hidden(self, batch_size):
        return torch.zeros(self.num_layers, batch_size, self.hidden_size)

# 超参数
hidden_size = 128
output_size = input_size  # 输出大小和输入大小相同，都是字符集大小
num_layers = 1

model = TextGenerationGRU(input_size, hidden_size, output_size, num_layers)

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

训练循环

num_epochs = 1000
seq_length = len(input_data)
input_data_one_hot = nn.functional.one_hot(input_data, num_classes=input_size).float().unsqueeze(0)

for epoch in range(num_epochs):
    # 初始化隐藏状态
    hidden = model.init_hidden(1)
    
    # 前向传播
    outputs, hidden = model(input_data_one_hot, hidden)
    loss = criterion(outputs.squeeze(0), target_data)
    
    # 反向传播及优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    if (epoch + 1) % 100 == 0:
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

文本生成

一旦训练完成，可以使用训练好的GRU模型来生成新文本。以下是生成新文本的代码：

def generate_text(model, start_char, char_to_idx, idx_to_char, hidden_size, num_generate):
    input_char = torch.tensor([char_to_idx[start_char]])
    input_char_one_hot = nn.functional.one_hot(input_char, num_classes=len(char_to_idx)).float().unsqueeze(0)
    
    hidden = model.init_hidden(1)
    generated_text = start_char
    
    for _ in range(num_generate):
        output, hidden = model(input_char_one_hot, hidden)
        predicted_idx = torch.argmax(output, dim=2).item()
        predicted_char = idx_to_char[predicted_idx]
        generated_text += predicted_char
        
        input_char = torch.tensor([predicted_idx])
        input_char_one_hot = nn.functional.one_hot(input_char, num_classes=len(char_to_idx)).float().unsqueeze(0)
    
    return generated_text

# 使用训练好的模型生成文本
generated_text = generate_text(model, 'h', char_to_idx, idx_to_char, hidden_size, num_generate=20)
print("Generated Text:", generated_text)