基于代码一步一步教你深度学习中循环神经网络(RNN)的原理

  
  
import torch
import torch.nn as nn
import torch.optim as optim
 
# 定义文本数据集
text = “Hello, how are you?”
 
# 创建字符索引映射表
chars = list(set(text))
char2idx = {c: i for i, c in enumerate(chars)}
idx2char = {i: c for i, c in enumerate(chars)}
 
# 将文本转换为数字序列
data = [char2idx[c] for c in text]

  
  
# 定义RNN模型
class RNN(nn.Module):
    def init(self, input_size, hidden_size, output_size):
        super(RNN, self).init()
        self.hidden_size = hidden_size
        self.embedding = nn.Embedding(input_size, hidden_size)
        self.rnn = nn.RNN(hidden_size, hidden_size)
        self.fc = nn.Linear(hidden_size, output_size)
 
    def forward(self, x, hidden):
        x = self.embedding(x)
        x, hidden = self.rnn(x, hidden)
        x = self.fc(x)
        return x, hidden

  
  
# 定义模型参数
input_size = len(chars)
hidden_size = 32
output_size = len(chars)
 
# 实例化模型和损失函数
rnn = RNN(input_size, hidden_size, output_size)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(rnn.parameters(), lr=0.01)

  
  
# 训练模型
num_epochs = 100
hidden = None
for epoch in range(num_epochs):
    inputs = torch.tensor(data[:-1]).unsqueeze(0)
    targets = torch.tensor(data[1:]).unsqueeze(0)
    
    optimizer.zero_grad()
    
    outputs, hidden = rnn(inputs, hidden)
    loss = criterion(outputs.squeeze(), targets.squeeze())
    loss.backward()
    optimizer.step()
 
    if (epoch+1) % 10 == 0:
        print(f‘Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}’)

  
  
# 生成文本
with torch.no_grad():
    input_char = text[0]
    result = input_char
    hidden = None
    
    for _ in range(len(text)-1):
        input_idx = torch.tensor(char2idx[input_char]).unsqueeze(0)
        output, hidden = rnn(input_idx, hidden)
        _, top_idx = torch.max(output.squeeze(), dim=1)
        predicted_char = idx2char[top_idx.item()]
        result += predicted_char
        input_char = predicted_char
 
print(“Generated Text:”, result)