Decoder子模块串联

2026-02-07 18:52:35 栏目：最新资讯 10 阅读

一、Decoder单模块核心结构（串联顺序）

核心串联逻辑是固定的，补课更改：自注意力 → Add&Norm → FFN → Add&Norm

先残差Add（当前子模块输出 + 该模块的初始输入），再执行LayerNorm层归一化，不可混淆顺序。Decoder所有子模块（自注意力、Add&Norm、FFN）的输入与输出维度必须完全一致，统一为L×D（L=序列长度，D=特征维度）。

二、伪代码示范

维度流转表标准

所有子模块输入、输出维度均为L×D，残差Add、LayerNorm仅改变数值（或数值分布），不改变维度。

#include 
#include 

struct Tensor {
    int seq_len;   // 序列长度L
    int feat_dim;  // 特征维度D
    std::vector> data;  // 存储L×D的数值
    
    // 初始化空张量
    Tensor(int L, int D) : seq_len(L), feat_dim(D) {
        data.resize(L, std::vector(D, 0.0f));
    }
    
    // 实现残差Add
    Tensor operator+(const Tensor& other) const {
        if (seq_len != other.seq_len || feat_dim != other.feat_dim) {
            throw std::invalid_argument("维度不匹配，无法执行Add操作！");
        }
        Tensor res(seq_len, feat_dim);
        for (int i = 0; i < seq_len; ++i) {
            for (int j = 0; j < feat_dim; ++j) {
                res.data[i][j] = this->data[i][j] + other.data[i][j];
            }
        }
        return res;
    }
};

// 自注意力子函数：输入输出均为L×D
Tensor SelfAttention(const Tensor& input) {
    Tensor output(input.seq_len, input.feat_dim);// 伪代码：实际包含Q/K/V计算、注意力得分计算、加权求和等
    std::cout << "执行自注意力计算，输入输出维度均为 " 
              << input.seq_len << "×" << input.feat_dim << std::endl;
    return output;
}

// LayerNorm子函数
Tensor LayerNorm(const Tensor& input) {
    Tensor output(input.seq_len, input.feat_dim);// 伪代码：计算每个样本的均值和方差，做归一化，维度保持L×D不变
    std::cout << "执行LayerNorm归一化，输入输出维度均为 " 
              << input.seq_len << "×" << input.feat_dim << std::endl;
    return output;
}

// FFN前馈网络子函数
Tensor FeedForwardNetwork(const Tensor& input) {
    Tensor output(input.seq_len, input.feat_dim);// 伪逻辑：实际包含线性层+激活函数+线性层（如L×D→L×4D→L×D）
    std::cout << "执行FFN计算，输入输出维度均为 " 
              << input.seq_len << "×" << input.feat_dim << std::endl;
    return output;
}

// Decoder单模块前向计算核心函数
Tensor DecoderLayerForward(const Tensor& x) {
    // 执行自注意力计算
    Tensor attn_out = SelfAttention(x);
    
    // Add&Norm
    Tensor add1 = x + attn_out;  // 输入x + 自注意力输出
    Tensor norm1 = LayerNorm(add1);  // 对Add结果做LayerNorm
    
    // 执行FFN计算
    Tensor ffn_out = FeedForwardNetwork(norm1);
    
    // Add&Norm（先Add残差，后LayerNorm）
    Tensor add2 = norm1 + ffn_out;  // 残差Add：norm1输出 + FFN输出
    Tensor norm2 = LayerNorm(add2);  // 对Add结果做LayerNorm
    
    // 返回Decoder单模块最终输出
    return norm2;
}

int main() {
    // 构造输入张量：序列长度L=10，特征维度D=512
    Tensor input(10, 512);
    // 执行Decoder单模块前向计算
    Tensor decoder_out = DecoderLayerForward(input);
    
    std::cout << "Decoder单模块前向计算完成，输出维度：" 
              << decoder_out.seq_len << "×" << decoder_out.feat_dim << std::endl;
    return 0;
}