【基于Transformer的多输出数据回归预测】附核心代码讲解及核心源码


前言

  在深度学习领域,Transformer模型以其独特的机制和优越的性能在自然语言处理(NLP)任务中占据了主导地位。这里我们提供了一个简化版的Transformer模型的实现,让你在一分钟内快速理解并上手Transformer的基本原理和代码实现。
在这里插入图片描述

  核心代码请见博主主页下载资源,用于多输出的回归预测项目代码详解请见:https://www.kdocs.cn/l/cmQ0BXiurpbg

class TransformerModel(nn.Module):
    def __init__(self, input_dim, output_dim, nhead, num_layers):
        super(TransformerModel, self).__init__()
        self.model_type = 'Transformer'
        self.src_mask = None
        self.pos_encoder = PositionalEncoding(input_dim)
        encoder_layers = nn.TransformerEncoderLayer(input_dim, nhead, dim_feedforward=512)
        self.transformer_encoder = nn.TransformerEncoder(encoder_layers, num_layers)
        self.encoder = nn.Linear(input_dim, input_dim)
        self.decoder = nn.Linear(input_dim, output_dim)

    def forward(self, src):
        print(f"Initial shape: {src.shape}")
        if self.src_mask is None or self.src_mask.size(0) != len(src):
            device = src.device
            mask = self._generate_square_subsequent_mask(len(src)).to(device)
            self.src_mask = mask

        src = self.encoder(src)
        print(f"After encoder: {src.shape}")
        src = self.pos_encoder(src)
        print(f"After positional encoding: {src.shape}")
        output = self.transformer_encoder(src, self.src_mask)
        print(f"After transformer encoder: {output.shape}")
        output = self.decoder(output)
        print(f"Final output shape: {output.shape}")
        # 如果你只关心每个序列的最后一个时间步的输出:
        final_output = output[:, -1, :]  # 这会给你一个形状为 [574, 3] 的张量
        print(f"Final final_output shape: {final_output.shape}")
        return final_output

    def _generate_square_subsequent_mask(self, sz):
        mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1)
        mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))
        return mask

class PositionalEncoding(nn.Module):

    def __init__(self, d_model, dropout=0.1, max_len=5000):
        super(PositionalEncoding, self).__init__()
        self.dropout = nn.Dropout(p=dropout)

        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0).transpose(0, 1)
        self.register_buffer('pe', pe)

    def forward(self, x):
        x = x + self.pe[:x.size(0), :]
        return self.dropout(x)

Transformer模型结构概览

  Transformer模型基于自注意力机制,它摒弃了传统的循环神经网络架构,完全依靠自注意力机制来编码输入序列的信息。

代码模块解释

  1. TransformerModel:这是整个Transformer模型的骨架,定义了模型结构的各个核心部分。

  2. __init__ 函数:初始化函数,定义了模型使用到的各种层和参数:

    • input_dimoutput_dim 分别代表输入和输出的特征维度。
    • nhead 是多头注意力机制中“头”的数量。
    • num_layers 是Transformer编码器层的堆叠数量。
    • PositionalEncoding 是位置编码类,用来给输入序列添加位置信息。
    • nn.TransformerEncoder 是Transformer编码器,由多个nn.TransformerEncoderLayer组成。
    • self.encoderself.decoder 是线性层,分别用于输入的线性转换和输出的线性转换。
  3. forward 函数:定义了模型的前向传播逻辑。

    • 首先检查源序列掩码src_mask是否已经定义,若未定义或大小不匹配则创建它。
    • 通过线性层、位置编码和Transformer编码器对输入数据src进行处理。
    • 最后通过解码器输出最终的结果。
    • 如果只关心序列的最后一个输出,则只取最后一个时间步的输出。
  4. _generate_square_subsequent_mask 函数:生成一个上三角形状的掩码,用于在自注意力计算中屏蔽未来的位置信息,保证模型只能看到当前位置及之前的信息。

  5. PositionalEncoding:实现位置编码。

    • 在Transformer中,位置编码是用来保留序列中单词的顺序信息。
    • 使用正弦和余弦函数的组合生成位置编码。

模块功能详解

  1. 位置编码(PositionalEncoding)

    • 位置编码使用正弦和余弦函数,为序列中的每个元素赋予了一个相对或绝对位置,以此来模拟序列数据的顺序特性,是Transformer模型中的一个关键创新点。
  2. 编码器(Encoder)

    • 输入的线性层将输入数据转换到适当的维度。
    • Transformer编码器由若干编码器层堆叠而成,每层包含多头注意力机制和前馈神经网络。
  3. 掩码生成(_generate_square_subsequent_mask)

    • 掩码技术是Transformer模型实现序列到序列任务时的一个重要技巧,它可以防止模型在解码时获取未来位置的信息。
  4. 解码器(Decoder)

    • 输出的线性层将Transformer编码器的输出转换为最终的输出维度。

总结

  通过上述代码的精简实现,我们可以看出即使是一个简化版的Transformer模型,也能够涵盖核心的机器学习原则和处理序列数据的强大功能。对于希望深入理解Transformer工作原理和实现的人来说,这个简化版的代码提供了一个极佳的起点。

  • 108
    点赞
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
下面是使用PyTorch实现多变量回归预测Transformer模型的示例代码: ```python import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader, TensorDataset # 构建Transformer模型 class Transformer(nn.Module): def __init__(self, input_dim, output_dim, hidden_dim, num_layers, num_heads): super(Transformer, self).__init__() self.input_embedding = nn.Linear(input_dim, hidden_dim) self.positional_encoding = PositionalEncoding(hidden_dim) self.transformer_encoder = nn.TransformerEncoder( nn.TransformerEncoderLayer(hidden_dim, num_heads), num_layers ) self.output_layer = nn.Linear(hidden_dim, output_dim) def forward(self, x): x = self.input_embedding(x) x = self.positional_encoding(x) x = self.transformer_encoder(x) x = self.output_layer(x) return x # 位置编码 class PositionalEncoding(nn.Module): def __init__(self, hidden_dim): super(PositionalEncoding, self).__init__() self.hidden_dim = hidden_dim def forward(self, x): seq_len = x.size(1) pos_enc = torch.zeros(x.size(0), seq_len, self.hidden_dim) position = torch.arange(0, seq_len).unsqueeze(0) div_term = torch.exp(torch.arange(0, self.hidden_dim, 2) * -(math.log(10000.0) / self.hidden_dim)) pos_enc[:, :, 0::2] = torch.sin(position * div_term) pos_enc[:, :, 1::2] = torch.cos(position * div_term) pos_enc = pos_enc.to(x.device) x = x + pos_enc return x # 准备训练数据 input_data = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float32) target_data = torch.tensor([[10, 20], [30, 40], [50, 60]], dtype=torch.float32) dataset = TensorDataset(input_data, target_data) dataloader = DataLoader(dataset, batch_size=1) # 定义模型参数 input_dim = input_data.size(1) output_dim = target_data.size(1) hidden_dim = 128 num_layers = 2 num_heads = 4 # 创建模型和优化器 model = Transformer(input_dim, output_dim, hidden_dim, num_layers, num_heads) optimizer = optim.Adam(model.parameters(), lr=0.001) criterion = nn.MSELoss() # 模型训练 num_epochs = 100 for epoch in range(num_epochs): for batch_input, batch_target in dataloader: optimizer.zero_grad() output = model(batch_input) loss = criterion(output, batch_target) loss.backward() optimizer.step() print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}") # 使用模型进行预测 new_input = torch.tensor([[2, 3, 4]], dtype=torch.float32) predicted_output = model(new_input) print("Predicted Output:", predicted_output) ``` 请注意,上述代码中的模型和数据是示例用途,你需要根据你的实际问题进行相应的调整。此外,还可以根据需要添加正则化、调整超参数等来改进模型的性能。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值