构建Transformer框架，你必须了解Decoder【解码器】

最新推荐文章于 2025-03-14 10:57:44 发布

大模型微调部署

最新推荐文章于 2025-03-14 10:57:44 发布

阅读量1.3k

点赞数 21

文章标签： transformer 深度学习人工智能语言模型 AI大模型自然语言处理 LLM

本文链接：https://blog.csdn.net/star_nwe/article/details/144749278

版权

Transformer框架由两部分组成：编码器（Encoder）和解码器（Decoder）。本篇我们来聊聊解码器（Decoder）。

一、解码器的组成

Transformer框架中的解码器主要作用是生成输出序列，通常用于序列到序列的任务，比如机器翻译、文本摘要等。以下是解码器的关键组成部分和工作原理的简要解析：

1. 掩码（Masking）：

解码器在处理序列时会使用掩码（Masking）来防止未来信息的泄露。这意味着在每一步解码时，解码器只能看到它之前生成的输出，而不能提前看到未来的输出。

2. 自注意力机制（Self-Attention）：

解码器的自注意力层允许模型在生成每个输出词时考虑所有先前生成的词。这是通过计算序列中每个词对其他词的注意力分数来实现的。

3. 编码器-解码器注意力（Encoder-Decoder Attention）：

解码器还包含一个注意力机制，它允许解码器关注编码器的输出。这使得解码器能够将输入序列（比如源语言句子）的信息融入到输出序列（比如目标语言句子）的生成中。

4. 前馈网络（Feed-Forward Network, FFN）：

在自注意力层之后，解码器使用一个前馈神经网络，这是一个简单的全连接层，用于进一步处理序列信息。

5. 残差连接（Residual Connection）：

每个子层（自注意力层和前馈网络）的输出都会加上该子层的输入，然后应用层归一化（Layer Normalization）。这种残差连接有助于避免在深层网络中出现的梯度消失问题。

6. 层归一化（Layer Normalization）：

在每个子层之后，解码器会应用层归一化，这有助于稳定训练过程，并允许更高的学习率。

7. 位置编码（Positional Encoding）：

由于Transformer不使用循环或卷积结构，它需要一种方式来利用序列中单词的位置信息。位置编码提供了这种信息，通常是通过将每个位置的正弦和余弦函数的固定公式编码到输入中来实现。

8. 输出层（Output Layer）：

最后，解码器的输出会通过一个线性层，然后应用softmax函数，以生成最终的输出概率分布，这代表了下一个词的概率。

解码器的这些组件共同工作，使得模型能够逐步生成输出序列，同时考虑到输入序列的信息和已经生成的输出序列的信息。这种结构使得Transformer在处理序列到序列的任务时非常有效。

二、创建解码器

以下是一个使用PyTorch创建Transformer解码器的示例代码，各位同学可以细细品味。

import torch
import torch.nn as nn
import torch.nn.functional as F

# 多头自注意力机制
class MultiHeadAttention(nn.Module):
    def __init__(self, embed_size, heads):
        super(MultiHeadAttention, self).__init__()
        self.embed_size = embed_size
        self.heads = heads
        self.head_dim = embed_size // heads
        
        # 确保embed_size可以被heads整除
        assert self.head_dim * heads == embed_size, "Embedding size needs to be divisible by heads"
        
        # 为values, keys, queries分别创建线性变换
        self.values = nn.Linear(self.head_dim, self.head_dim, bias=False)
        self.keys = nn.Linear(self.head_dim, self.head_dim, bias=False)
        self.queries = nn.Linear(self.head_dim, self.head_dim, bias=False)
        self.fc_out = nn.Linear(heads * self.head_dim, embed_size)  # 最后的线性层
    
    def forward(self, values, keys, query, mask):
        N = query.shape[0]
        value_len, key_len, query_len = values.shape[1], keys.shape[1], query.shape[1]
        
        # 将嵌入分割成多个头
        values = values.reshape(N, value_len, self.heads, self.head_dim)
        keys = keys.reshape(N, key_len, self.heads, self.head_dim)
        queries = query.reshape(N, query_len, self.heads, self.head_dim)
        
        # 应用线性变换
        values = self.values(values)
        keys = self.keys(keys)
        queries = self.queries(queries)
        
        # 使用einsum进行查询和键的点积操作
        energy = torch.einsum("nqhd,nkhd->nhqk", [queries, keys])
        if mask is not None:
            energy = energy.masked_fill(mask == 0, float("-1e20"))  # 应用mask
        
        # 应用softmax获取注意力权重
        attention = torch.softmax(energy / (self.embed_size ** (1 / 2)), dim=3)
        
        # 应用注意力权重到values
        out = torch.einsum("nhql,nlhd->nqhd", [attention, values]).reshape(
            N, query_len, self.heads * self.head_dim
        )
        
        # 通过最后的线性层
        out = self.fc_out(out)
        return out

# 解码器层
class DecoderLayer(nn.Module):
    def __init__(self, embed_size, heads, dropout, forward_expansion):
        super(DecoderLayer, self).__init__()
        self.attention = MultiHeadAttention(embed_size, heads)  # 自注意力
        self.norm1 = nn.LayerNorm(embed_size)  # 层归一化
        self.norm2 = nn.LayerNorm(embed_size)  # 层归一化
        
        # 前馈网络
        self.feed_forward = nn.Sequential(
            nn.Linear(embed_size, forward_expansion * embed_size),
            nn.ReLU(),
            nn.Linear(forward_expansion * embed_size, embed_size)
        )
        self.dropout = nn.Dropout(dropout)  # dropout层
    
    def forward(self, value, key, query, mask):
        # 自注意力层
        attention = self.attention(value, key, query, mask)
        
        # 添加残差连接和层归一化
        x = self.dropout(self.norm1(attention + query))
        forward = self.feed_forward(x)
        out = self.dropout(self.norm2(forward + x))
        return out

# Transformer解码器
class TransformerDecoder(nn.Module):
    def __init__(self, embed_size, num_layers, heads, device, forward_expansion, dropout, max_length):
        super(TransformerDecoder, self).__init__()
        self.device = device
        self.layers = nn.ModuleList(
            [
                DecoderLayer(embed_size, heads, dropout, forward_expansion) for _ in range(num_layers)
            ]
        )
        self.max_length = max_length
    
    def forward(self, input_seq, enc_output, mask):
        seq_len = input_seq.shape[0]
        input_seq = input_seq.to(self.device)
        enc_output = enc_output.to(self.device)
        for layer in self.layers:
            input_seq = layer(input_seq, input_seq, enc_output, mask)
        return input_seq

# 示例使用
embed_size = 256  # 嵌入维度
num_layers = 6   # 层数
heads = 8        # 头数
forward_expansion = 4  # 前馈网络扩展因子
dropout = 0.1    # dropout比率
max_length = 100  # 最大序列长度
decoder = TransformerDecoder(embed_size, num_layers, heads, torch.device('cuda' if torch.cuda.is_available() else 'cpu'), forward_expansion, dropout, max_length)

# 虚拟输入和编码器输出
dummy_input = torch.rand((32, 50, embed_size))  # (batch_size, seq_len, embed_size)
dummy_enc_output = torch.rand((32, 60, embed_size))  # (batch_size, seq_len, embed_size)
dummy_mask = torch.ones((1, 1, 50, 60))  # (1, 1, seq_len_decoder, seq_len_encoder)

# 前向传播
output = decoder(dummy_input, dummy_enc_output, dummy_mask)

这段代码定义了一个基本的Transformer解码器，包括多头自注意力机制、解码器层和完整的解码器结构。在实际应用中，大家需要根据需要调整参数和结构，或者加入更多的模块。

三、关键参数

在创建Transformer解码器时，有几个关键参数会对模型的性能产生较大影响：

1. 嵌入维度（Embedding Size）：

这是输入序列中每个词的向量表示的维度。较大的嵌入维度可以捕获更丰富的信息，但会增加计算复杂度和模型大小。

2. 头数（Number of Heads）：

在多头自注意力机制中，头数决定了模型并行处理信息的能力。更多的头可以捕获不同子空间的信息，但同样会增加计算复杂度，消耗更多的系统资源。

3. 层数（Number of Layers）：

Transformer模型中的层数决定了模型的深度。更多的层可以捕获更复杂的特征，但也可能导致过拟合和增加训练难度。

4. 前馈网络扩展因子（Forward Expansion）：

这是前馈网络（Feed-Forward Network, FFN）中线性层的维度。较大的扩展因子可以增加模型的表达能力，但也会增加模型的参数数量和计算负担。

5. Dropout比率（Dropout Rate）：

Dropout是一种正则化技术，用于防止模型过拟合。较高的dropout比率可以提高模型的泛化能力，但过高可能导致模型欠拟合。

6. 学习率（Learning Rate）：

学习率决定了模型权重更新的步长。合适的学习率对模型的收敛速度和最终性能至关重要。

7. 优化器（Optimizer）：

选择不同的优化器（如Adam, SGD等）可能会对模型的性能产生影响。不同的优化器有不同的优化策略和超参数。

8. 批量大小（Batch Size）：

批量大小决定了每次训练更新时使用的样本数量。较大的批量大小可以提高内存利用率和训练稳定性，但可能会影响模型的泛化能力。

9. 序列长度（Sequence Length）：

序列长度决定了模型处理的输入序列的最大长度。较长的序列长度可以捕获更多的上下文信息，但会增加计算复杂度。

10. 注意力机制中的缩放因子（Attention Scaling Factor）：

在计算注意力分数时，通常会将分数除以嵌入维度的平方根，这个缩放因子可以调整模型对不同词之间关系敏感度。

11. 位置编码（Positional Encoding）：

由于Transformer不使用循环或卷积结构，位置编码对于模型理解序列中词汇的位置关系至关重要。

12. 正则化技术（Regularization Techniques）：

除了dropout，还可以使用其他正则化技术，如权重衰减、批量归一化等，来防止过拟合。

这些参数需要根据具体的任务和数据集进行调整，以达到最佳的性能。通常需要通过实验和调参来找到最佳的参数组合。还是那句老话：多动手，多实验，先干起来快上手！

四、如何系统学习掌握AI大模型？

AI大模型作为人工智能领域的重要技术突破，正成为推动各行各业创新和转型的关键力量。抓住AI大模型的风口，掌握AI大模型的知识和技能将变得越来越重要。

学习AI大模型是一个系统的过程，需要从基础开始，逐步深入到更高级的技术。

这里给大家精心整理了一份全面的AI大模型学习资源，包括：AI大模型全套学习路线图（从入门到实战）、精品AI大模型学习书籍手册、视频教程、实战学习、面试题等，资料免费分享！

1. 成长路线图&学习规划

要学习一门新的技术，作为新手一定要先学习成长路线图，方向不对，努力白费。

这里，我们为新手和想要进一步提升的专业人士准备了一份详细的学习成长路线图和规划。可以说是最科学最系统的学习成长路线。
在这里插入图片描述

2. 大模型经典PDF书籍

书籍和学习文档资料是学习大模型过程中必不可少的，我们精选了一系列深入探讨大模型技术的书籍和学习文档，它们由领域内的顶尖专家撰写，内容全面、深入、详尽，为你学习大模型提供坚实的理论基础。（书籍含电子版PDF）

在这里插入图片描述

3. 大模型视频教程

对于很多自学或者没有基础的同学来说，书籍这些纯文字类的学习教材会觉得比较晦涩难以理解，因此，我们提供了丰富的大模型视频教程，以动态、形象的方式展示技术概念，帮助你更快、更轻松地掌握核心知识。

在这里插入图片描述

4. 2024行业报告

行业分析主要包括对不同行业的现状、趋势、问题、机会等进行系统地调研和评估，以了解哪些行业更适合引入大模型的技术和应用，以及在哪些方面可以发挥大模型的优势。

在这里插入图片描述

5. 大模型项目实战

学以致用 ，当你的理论知识积累到一定程度，就需要通过项目实战，在实际操作中检验和巩固你所学到的知识，同时为你找工作和职业发展打下坚实的基础。

在这里插入图片描述

6. 大模型面试题

面试不仅是技术的较量，更需要充分的准备。

在你已经掌握了大模型技术之后，就需要开始准备面试，我们将提供精心整理的大模型面试题库，涵盖当前面试中可能遇到的各种技术问题，让你在面试中游刃有余。

在这里插入图片描述

全套的AI大模型学习资源已经整理打包，有需要的小伙伴可以微信扫描下方CSDN官方认证二维码，免费领取【保证100%免费】