lstm时序预测seq2seq

### LSTM Seq2Seq 时间序列预测实现方法

#### 编码器-解码器架构概述
编码器-解码器（Encoder-Decoder）框架是一种用于处理序列到序列任务的强大工具。该结构由两部分组成：编码器负责将输入序列转换成固定长度的状态向量；解码器则接收此状态并生成目标序列[^1]。

#### 数据预处理
为了使数据适合于LSTM网络，在构建模型之前需对原始时间序列执行标准化操作，这有助于加速收敛过程并提高性能。此外，还需创建滑动窗口来形成训练样本集[(input_sequence, target_sequence)][]^3。

#### 构建编码器模块
采用双向循环神经元层作为编码组件可以捕捉更丰富的特征表示形式。具体来说，通过堆叠多个LSTM单元构成深层网络，并最终返回隐藏状态h和细胞状态c供后续阶段使用：

import torch.nn as nn

class Encoder(nn.Module):
    def __init__(self, input_dim, hidden_dim, n_layers=1):
        super(Encoder, self).__init__()
        self.lstm = nn.LSTM(input_dim, hidden_dim, num_layers=n_layers)

    def forward(self, src):
        outputs, (hidden, cell) = self.lstm(src)
        return hidden, cell

#### 设计解码器部分
解码器同样基于LSTM设计而成，区别在于其接受来自上一步骤产生的输出以及前一时刻的记忆状态(h,c)，以此为基础逐步推断未来的时间点值:

class Decoder(nn.Module):
    def __init__(self, output_dim, hidden_dim, n_layers=1):
        super().__init__()
        self.output_dim = output_dim
        self.hidden_dim = hidden_dim
        
        self.embedding = nn.Embedding(output_dim, hidden_dim)
        self.rnn = nn.LSTM(hidden_dim, hidden_dim, batch_first=True)
        self.fc_out = nn.Linear(hidden_dim, output_dim)

    def forward(self, trg, hidden, cell):
        embedded = self.embedding(trg.unsqueeze(-1))
        output, (hidden, cell) = self.rnn(embedded, (hidden, cell))
        prediction = self.fc_out(output.squeeze(0))

        return prediction, hidden, cell

#### 定义Seq2Seq类
最后组合上述两个子网完成整个系统的定义工作，注意此处实现了teacher forcing机制以增强学习效果:

class Seq2Seq(nn.Module):
    def __init__(self, encoder, decoder, device):
        super(Seq2Seq, self).__init__()

        self.encoder = encoder
        self.decoder = decoder
        self.device = device
    
    def forward(self, src, trg, teacher_forcing_ratio=0.5):

        max_len = trg.shape[1]
        batch_size = trg.shape[0]

        # Initialize variables to store predictions and states.
        outputs = torch.zeros(max_len, batch_size).to(self.device)
        
        # Encode the source sequence into context vectors.
        hidden, cell = self.encoder(src)

        # Start with SOS token or first element of target sequence.
        dec_input = trg[:, 0].unsqueeze(dim=-1)

        for t in range(1, max_len):    
            out, hidden, cell = self.decoder(dec_input, hidden, cell)
            
            outputs[t] = out
            
            top1 = out.argmax()
                
            teach_force = random.random() < teacher_forcing_ratio
                
            dec_input = trg[:,t:t+1] if teach_force else top1.unsqueeze(dim=-1)

        return outputs.T