LSTM+编码器 pytorch代码案例实战

以下是一个基于LSTM和编码器的PyTorch代码案例实战：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
import numpy as np

# 定义数据集
class MyDataset(Dataset):
    def __init__(self, data):
        self.data = data
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, index):
        return self.data[index]

# 定义编码器
class Encoder(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers=1):
        super(Encoder, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
    
    def forward(self, x):
        # 初始化隐藏层状态
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        
        # LSTM前向传播
        out, _ = self.lstm(x, (h0, c0))
        
        return out[:, -1, :]

# 定义超参数
input_size = 10
hidden_size = 20
num_layers = 2
batch_size = 32
learning_rate = 0.001
num_epochs = 10

# 生成随机数据
data = np.random.randn(100, 50, input_size)
dataset = MyDataset(data)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

# 定义模型、损失函数和优化器
model = Encoder(input_size, hidden_size, num_layers)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# 训练模型
for epoch in range(num_epochs):
    for i, inputs in enumerate(dataloader):
        inputs = inputs.float()
        outputs = model(inputs)
        loss = criterion(outputs, torch.zeros(batch_size, hidden_size))
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        if (i+1) % 10 == 0:
            print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, i+1, len(dataset)//batch_size, loss.item()))

该代码实现了一个简单的LSTM编码器，并使用随机数据进行训练。在训练过程中，每10个batch打印一次损失值。你可以根据自己的需求修改超参数和数据集，以适应不同的应用场景。