pytorch : 从零开始实现深度 RNN

实现一个深度循环神经网络（Deep RNN），我们需要在标准 RNN 的基础上堆叠多个循环层，每个循环层的输出作为下一层的输入。以下是一个从零开始实现深度 RNN 的代码示例：

代码实现

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

# 定义一个简单的 RNN 单元
class SimpleRNNCell(nn.Module):
    def __init__(self, input_size, hidden_size):
        super(SimpleRNNCell, self).__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.W_ih = nn.Parameter(torch.Tensor(input_size, hidden_size))
        self.W_hh = nn.Parameter(torch.Tensor(hidden_size, hidden_size))
        self.b_ih = nn.Parameter(torch.Tensor(hidden_size))
        self.b_hh = nn.Parameter(torch.Tensor(hidden_size))
        self.reset_parameters()
    
    def reset_parameters(self):
        nn.init.kaiming_uniform_(self.W_ih, a=math.sqrt(5))
        nn.init.kaiming_uniform_(self.W_hh, a=math.sqrt(5))
        nn.init.zeros_(self.b_ih)
        nn.init.zeros_(self.b_hh)

    def forward(self, input, hidden):
        hy = torch.tanh(torch.mm(input, self.W_ih) + self.b_ih + torch.mm(hidden, self.W_hh) + self.b_hh)
        return hy

# 定义深度 RNN
class DeepRNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, num_layers):
        super(DeepRNN, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.rnn_cells = nn.ModuleList()
        
        # 创建第一个 RNN 层
        self.rnn_cells.append(SimpleRNNCell(input_size, hidden_size))
        # 创建后续的 RNN 层
        for _ in range(1, num_layers):
            self.rnn_cells.append(SimpleRNNCell(hidden_size, hidden_size))
        
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, input):
        seq_len, batch_size, _ = input.size()
        hidden_states = [torch.zeros(batch_size, self.hidden_size) for _ in range(self.num_layers)]
        outputs = []

        for t in range(seq_len):
            x = input[t]
            for layer in range(self.num_layers):
                hidden_states[layer] = self.rnn_cells[layer](x, hidden_states[layer])
                x = hidden_states[layer]
            outputs.append(x)
        
        outputs = torch.stack(outputs, dim=0)
        outputs = self.fc(outputs)
        
        return outputs

# 定义模型参数
input_size = 10
hidden_size = 20
output_size = 5
num_layers = 3
seq_len = 7
batch_size = 3

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

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

# 生成一些随机输入和目标输出
input = torch.randn(seq_len, batch_size, input_size)
target = torch.randn(seq_len, batch_size, output_size)

# 训练步骤
output = model(input)
loss = criterion(output, target)
optimizer.zero_grad()
loss.backward()
optimizer.step()

print(f'Loss: {loss.item()}')

代码解释

1. SimpleRNNCell：实现一个简单的 RNN 单元，包含输入到隐藏层和隐藏层到隐藏层的线性变换，并使用 torch.tanh 作为激活函数。

2. DeepRNN：实现一个深度 RNN，包括多个堆叠的 RNN 层。每一层的输出作为下一层的输入，最终输出通过一个全连接层生成。

3. 训练步骤：生成一些随机数据，定义损失函数和优化器，执行前向传播、计算损失、反向传播和参数更新。

通过上述代码，你可以理解如何实现一个多层深度 RNN，以及如何训练这个网络。你可以进一步调整超参数（如隐藏层大小、层数等）来优化模型性能。