以下是一个示例代码，用于构建带有双向LSTM编码器、单向LSTM解码器和注意力机制的Seq2Seq模型：
```python
import torch
import torch.nn as nn
class Encoder(nn.Module):
def __init__(self, input_size, hidden_size, num_layers):
super(Encoder, self).__init__()
self.hidden_size = hidden_size
self.num_layers = num_layers
self.lstm = nn.LSTM(input_size, hidden_size, num_layers, bidirectional=True)
def forward(self, inputs):
# inputs shape: (seq_len, batch_size, input_size)
outputs, (hidden, _) = self.lstm(inputs)
# outputs shape: (seq_len, batch_size, hidden_size*num_directions)
# hidden shape: (num_layers*num_directions, batch_size, hidden_size)
return outputs, hidden
class Attention(nn.Module):
def __init__(self, hidden_size):
super(Attention, self).__init__()
self.hidden_size = hidden_size
self.attn = nn.Linear(hidden_size*2, hidden_size)
self.v = nn.Linear(hidden_size, 1, bias=False)
def forward(self, encoder_outputs, decoder_hidden):
# encoder_outputs shape: (seq_len, batch_size, hidden_size*num_directions)
# decoder_hidden shape: (num_layers, batch_size, hidden_size)
seq_len = encoder_outputs.size(0)
batch_size = encoder_outputs.size(1)
decoder_hidden = decoder_hidden[-1] # 取最后一层的隐藏状态作为decoder的输出
# 将decoder的隐藏状态复制seq_len次，用于计算注意力权重
decoder_hidden = decoder_hidden.unsqueeze(1).repeat(1, seq_len, 1)
energy = torch.tanh(self.attn(torch.cat((encoder_outputs, decoder_hidden), dim=2)))
# energy shape: (seq_len, batch_size, hidden_size)
attention = self.v(energy).squeeze(2)
# attention shape: (seq_len, batch_size)
attention_weights = torch.softmax(attention, dim=0)
# attention_weights shape: (seq_len, batch_size)
# 计算加权后的encoder输出作为context向量
context = torch.bmm(encoder_outputs.permute(1, 2, 0), attention_weights.unsqueeze(2)).squeeze(2)
# context shape: (batch_size, hidden_size*num_directions)
return context, attention_weights
class Decoder(nn.Module):
def __init__(self, input_size, hidden_size, output_size, num_layers):
super(Decoder, self).__init__()
self.hidden_size = hidden_size
self.num_layers = num_layers
self.lstm = nn.LSTM(input_size, hidden_size, num_layers)
self.fc = nn.Linear(hidden_size, output_size)
def forward(self, inputs, hidden):
# inputs shape: (1, batch_size, input_size)
outputs, hidden = self.lstm(inputs, hidden)
# outputs shape: (1, batch_size, hidden_size)
# hidden shape: (num_layers, batch_size, hidden_size)
outputs = self.fc(outputs.squeeze(0))
# outputs shape: (batch_size, output_size)
return outputs.unsqueeze(0), hidden
class Seq2Seq(nn.Module):
def __init__(self, encoder, decoder):
super(Seq2Seq, self).__init__()
self.encoder = encoder
self.decoder = decoder
def forward(self, inputs, targets, teacher_forcing_ratio=0.5):
# inputs shape: (seq_len, batch_size, input_size)
# targets shape: (seq_len, batch_size, output_size)
seq_len = targets.size(0)
batch_size = targets.size(1)
output_size = self.decoder.fc.out_features
encoder_outputs, encoder_hidden = self.encoder(inputs)
decoder_inputs = torch.zeros(1, batch_size, output_size).to(inputs.device)
decoder_hidden = encoder_hidden # 使用encoder的最后一层隐藏状态作为decoder的初始隐藏状态
outputs = torch.zeros(seq_len, batch_size, output_size).to(inputs.device)
for t in range(seq_len):
decoder_output, decoder_hidden = self.decoder(decoder_inputs, decoder_hidden)
outputs[t] = decoder_output
# 使用teacher forcing或者上一个时间步的预测结果作为下一个时间步的输入
use_teacher_forcing = True if torch.rand(1).item() < teacher_forcing_ratio else False
if use_teacher_forcing:
decoder_inputs = targets[t].unsqueeze(0)
else:
decoder_inputs = decoder_output.argmax(dim=2).unsqueeze(0)
return outputs
# 定义模型的参数
input_size = 100
hidden_size = 256
output_size = 10
num_layers = 2
# 创建编码器和解码器实例
encoder = Encoder(input_size, hidden_size, num_layers)
decoder = Decoder(output_size, hidden_size, output_size, num_layers)
# 创建Seq2Seq模型实例
model = Seq2Seq(encoder, decoder)
# 定义输入和目标序列的形状
seq_len = 20
batch_size = 32
inputs = torch.randn(seq_len, batch_size, input_size)
targets = torch.randint(output_size, (seq_len, batch_size))
# 将输入和目标序列传递给模型
outputs = model(inputs, targets)
# 打印输出的形状
print(outputs.shape)
```
上述代码中，我们首先定义了编码器（`Encoder`）和解码器（`Decoder`）的模型结构，然后将它们组合成一个Seq2Seq模型（`Seq2Seq`），并定义了前向传播的逻辑。
在构建Seq2Seq模型时，我们使用了双向LSTM作为编码器，单向LSTM作为解码器，并添加了注意力机制（`Attention`）来帮助解码器在生成序列时关注输入序列的不同部分。
最后，我们创建了模型实例（`model`），并将输入和目标序列传递给模型进行前向传播，输出序列的预测结果。
请根据你的具体任务和数据进行相应的修改和调整。
本文详细解析了基于Torch平台的LSTM编码-解码网络结构Seq2seq的代码，包括状态初始化和网络克隆等关键子函数。针对存在的疑问，如Seq2seq输入维度变化及状态维度问题进行探讨。
最低0.47元/天 解锁文章
扫一扫
625
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
