在 Transformer 模型中，编码器（Encoder）（图 5.1 (a)）的作用是将每个输入 词元都编码成一个上下文语义相关的表示向量。编码器结构由多个相同的层堆叠 而成，其中每一层都包含多头自注意力模块和前馈网络模块。在注意力和前馈网 络后，模型使用层归一化和残差连接来加强模型的训练稳定度。其中，残差连接（Residual Connection）将输入与该层的输出相加，实现了信息在不同层的跳跃传递，从而缓解梯度爆炸和消失的问题。而 LayerNorm 则对数据进行重新放缩，提升模型的训练稳定性。编码器接受经过位置编码层的 词嵌入序列X作为输入，通过多个堆叠的编码器层来建模上下文信息，进而对于 整个输入序列进行编码表示。由于输入数据是完全可见的，编码器中的自注意力 模块通常采用双向注意力，每个位置的词元表示能够有效融合上下文的语义关系。 在编码器-解码器架构中，编码器的输出将作为解码器（Decoder）的输入，进行后 续计算。形式化来说，第 l 层（l∈ {1, . . . , L}）的编码器的数据处理过程如下所示：

                                          = LayerNorm(MHA( )+ ) ,

                                          = LayerNorm(FFN( ) + ),

5.1.5  解码器

        Transformer 架构中的解码器（图 5.1 (b)）基于来自编码器编码后的最后一层 的输出表示以及已经由模型生成的词元序列，执行后续的序列生成任务。与编码 器不同，解码器需要引入掩码自注意力（Masked Self-attention）模块，用来在计算 注意力分数的时候掩盖当前位置之后的词，以保证生成目标序列时不依赖于未来 的信息。除了建模目标序列的内部关系，解码器还引入了与编码器相关联的多头 注意力层，从而关注编码器输出的上下文信息 。同编码器类似，在每个模块之 后，Transformer 解码器 也采用了层归一化和残差连接。在经过解码器之后，模型 会通过一个全连接层将输出映射到大小为 𝑉 的目标词汇表的概率分布，并基于某 种解码策略生成对应的词元。在训练过程中，解码器可以通过一次前向传播，让 每个词元的输出用于预测下一个词元。而在解码过程，解码器需要经过一个逐步 的生成过程，将自回归地生成完整的目标序列。解码器数据流程如下所示：

                        ​​​​​​​        ​​​​​​​          = LayerNorm(MaskedMHA() + Y_{l-1}),

        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​  = LayerNorm(CrossMHA(,  ) +  ),                              (5.10) 

        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​       ​​​​​​​     = LayerNorm(FFN() + )

• • RMSNorm. 为了提高层归一化的训练速度，RMSNorm仅利用激活值 总和的均方根 RMS(x) 对激活值进行重新缩放。使用 RMSNorm 的 Transformer 模 型相比于之前 LayerNorm 训练的模型在训练速度和性能上均具有一定优势。采用 RMSNorm 的代表性模型包括 Gopher和 Chinchilla。下面给出了 Transformers 代码库中 LLaMA 的 RMSNorm 实现代码：

5.2.2  归一化模块位置

为了加强大语言模型训练过程的稳定性，除了归一化方法外，归一化模块的 位置也具有重要的影响。如图 5.2(a) 所示，归一化模块的位置通常有三种选择，分 别是层后归一化（Post-Layer Normalization, Post-Norm）、层前归一化（Pre-Layer Normalization, Pre-Norm）和夹心归一化（Sandwich-Layer Normalization, Sandwich- Norm）。

• Post-Norm. Post-Norm 是在原始 Transformer 模型中所使用的一种归一化技 术。其中，归一化模块被放置于残差计算之后。其计算公式如下：

                       Post-Norm(x)=Norm(x+Sublayer(x)),                                   (5.17)                                                                             

        其中，Norm 表示任意一种归一化方法。在原理上，后向归一化具有很多优势。首 先，有助于加快神经网络的训练收敛速度使模型可以更有效地传播梯度，从而减少训练时间。其次，后向归一化可以降低神经网络对于超参数（如学习率、初始化参数等）的敏感性，使得网络更容易调优，并减少了超参数调整的难度。然而，由于在输出层附近存在梯度较大的问题，采用 Post-Norm 的Transformer 模型在训练过程中通常会出现不稳定的现象。因此，现有的大语言模型中， PostNorm 很少被单独使用，通常是与其他策略相结合应用。

• Pre-Norm. 与 Post-Norm 不同，Pre-Norm [164] 将归一化模块应用在每个子 层之前。其计算公式如下：

                               Pre-Norm(x) = x + Sublayer(Norm(x)),                                              (5.18)

此处的 Norm 泛指任意一种归一化方法。此外，Pre-Norm 在最后一个 Transformer 层后还额外添加了一个 LayerNorm。相较于 Post-Norm，Pre-Norm 直接把每个子层 加在了归一化模块之后，仅仅对输入的表示进行了归一化，从而可以防止模型的 梯度爆炸或者梯度消失现象。虽然使用了 Pre-Norm 的 Transformer 模型在训练过 程中更加稳定，但是性能却逊色于采用了 Post-Norm 的模型。尽管对于性能有一 定的影响，但由于其能够有效维持训练的稳定性，很多主流的大语言模型仍然采 用 Pre-Norm。

• Sandwich-Norm. 在 Pre-Norm 的基础上，Sandwich-Norm在残差连接之前增加了额外的 LayerNorm，旨在避免 Transformer 层的输出出现数值爆炸的情况。 具体的实现方式如下所示：

Sandwich-Norm(x) = x +Norm(Sublayer(Norm(x))).                                      (5.19)

                                                                                                 

本质上，Sandwich-Norm 可以看作是 Pre-Norm 和 Post-Norm 两种方法的组合，理 论上具有更加灵活的表达能力。但是研究人员发现，Sandwich-Norm 有时仍然无法保证大语言模型的稳定训练，甚至会引发训练崩溃的问题。

5.2.3  激活函数

前馈网络中激活函数的选择对于大语言模型的表现至关重要。通常来说，激 活函数主要是为神经网络中引入非线性变化，从而提升神经网络的模型能力。在 原始的 Transformer 中采用了 ReLU（Rectified Linear Unit）激活函数。该激活函数 计算较为简单，仅仅是将对输入中每个神经元和“零值”进行比较，并将小于零 的神经元的值设置为 0。然而，ReLU 可能会产生神经元失效的问题，被置为 0 的 神经元将学习不到有用的信息。ReLU     函数的具体形式如下所示：

ReLU(x) = max(x, 0).                                             (5.20)

针对 ReLU 存在的不足，研究人员进一步探索了 ReLU 函数的变种，以实现 更好的性能。Swish 激活函数将神经元和该神经元的 sigmoid 激活的乘积作为新的 激活函数。而 GELU（Gaussian Error Linear Unit）则利用标准高斯累积分布 函数作为激活函数，被很多的 Transformer 模型所采用。相比于原始的 ReLU 函数， 这些新的激活函数通常能够带来更好的性能并且收敛性更好，但是计算过程更为 复杂。Swish 和 GELU 与 ReLU 的对比如图 5.2(b) 所示。

近来，大语言模型（例如 PaLM 和 LaMDA）也经常采用 GLU（Gated Linear Unit）激活函数以及它的变种，特别是 SwiGLU 和 GeGLU。不同于其他激活 函数，GLU 激活函数引入了两个不同的线性层。其中一个线性层的输出将被输入 到一个激活函数（例如，GeGLU 采用 GELU 激活函数）中，其结果将和另一个线 性层的输出进行逐元素相乘作为最终的输出。相比于其他的激活函数，使用 GLU激活函数变体通常能够带来更佳的性能表现。SwiGLU 和 GeGLU 激活函数 的计算公式如下所示：

• • 相对位置编码与绝对位置编码不同，相对位置编码是根据键和查询之间的偏移量计算得来的。计算得到的相对位置编码通常应用于注意力矩阵的计算中， 而不是直接与词元本身的位置编码进行相加。其中，Transformer-XL 提出了 一种相对位置编码方法，在计算键和查询之间的注意力分数时引入了相对位置信 息。对于使用绝对位置编码的模型，其注意力值可以进行进一步的分解。而 Transformer-XL 对上述注意力值进行了改写，使用相对位置信息代替绝对位置信息。作为另一种方法，T5提出了一种较为简化的相对位置编码。具体来说，它在注意力分数中引入了可学习的标量，这些标量是基于查询和键的位 置之间的距离计算的。与绝对位置编码相比，应用了相对位置编码的 Transformer 模型常常可以对比训练序列更长的序列进行建模，即具备一定的外推能力。

• 旋转位置编码（Rotary Position Embedding, RoPE）. RoPE 巧妙地使用了基于绝对位置信息的旋转矩阵来表示注意力中的相对位置信息。RoPE 根据位置信息为 序列中每个词元所对应的设置了独有的旋转矩阵，并和对应的查询和键进行相乘进行融合。利用旋转矩阵中三角函数的特性，位置索引为 i的旋转矩阵和位置索引为 j的旋转矩阵的转置的乘积等同于位置索引为它们相对距离i-j的旋转矩阵，进一步，每个子空间定义了波长  ，即在该子空间上完成一个完整周期（2𝜋）旋转所需的距离由于 RoPE 具有良好的性能以及长期衰减的特性，已经主流的大语言模型广泛采 用，例如 PaLM  和 LLaMA。这里给出了 Transformers 代码库中 LLaMA 的 RoPE 实现代码：

def rotate_half(x):x1 = x[..., : x.shape[-1] // 2]x2 = x[..., x.shape[-1] // 2 :]# 将向量每两个元素视为一个子空间return torch.cat((-x2, x1), dim=-1)def apply_rotary_pos_emb(q, k, cos, sin, position_ids): cos = cos[position_ids].unsqueeze(1)sin = sin[position_ids].unsqueeze(1)# 获得各个子空间旋转的正余弦值q_embed = (q * cos) + (rotate_half(q) * sin) k_embed = (k * cos) + (rotate_half(k) * sin)# 将每个子空间按照特定角度进行旋转return q_embed, k_embed

• ALiBi 位置编码： ALiBi 是一种特殊的相对位置编码，主要用于增强 Transformer 模型的外推能力。具体来说，ALiBi 通过在键和查询之间的距离上施 加相对距离相关的惩罚来调整注意力分数。 其与 T5 等模型中的相对位置编码不同，ALiBi 中的惩罚分数是预先设定的，不需 要引入任何可训练的参数。此外，ALiBi 展现出了优秀的外推性能，能够对于超 过上下文窗口更远距离的词元进行有效建模。下面给出 Transformers 库中 BLOOM 中的 ALiBi 代码实现：

import math
import torchdef build_alibi_tensor(attention_mask: torch.Tensor,num_heads: int,dtype: torch.dtype,
) -> torch.Tensor:"""构建ALiBi（Attention with Linear Biases）位置偏置张量"""batch_size, seq_length = attention_mask.shape# 计算最接近且不大于num_heads的2的幂次方closest_power_of_2 = 2 ** math.floor(math.log2(num_heads))# 计算基础衰减系数（公式中的beta参数）base = torch.tensor(2 ** (-(2 ** -(math.log2(closest_power_of_2) - 3))),device=attention_mask.device,dtype=torch.float32,)# 生成基础指数序列（从1开始，长度=closest_power_of_2）powers = torch.arange(1,1 + closest_power_of_2,device=attention_mask.device,dtype=torch.int32,)# 计算基础头的惩罚系数（slopes）slopes = torch.pow(base, powers)# 处理非2的幂次方头数的情况if closest_power_of_2 != num_heads:# 计算额外衰减系数（针对非2幂部分）extra_base = torch.tensor(2 ** (-(2 ** -(math.log2(2 * closest_power_of_2) - 3))),device=attention_mask.device,dtype=torch.float32,)# 计算需要补充的额外头数（保证不超过closest_power_of_2）num_remaining_heads = min(closest_power_of_2, num_heads - closest_power_of_2)# 生成额外指数序列（奇数序列，长度=num_remaining_heads）extra_powers = torch.arange(1,1 + 2 * num_remaining_heads,2,device=attention_mask.device,dtype=torch.int32,)# 合并基础系数和额外系数slopes = torch.cat([slopes, torch.pow(extra_base, extra_powers)], dim=0)# 生成位置索引张量（形状：[batch_size, 1, seq_length]）arange_tensor = ((attention_mask.cumsum(dim=-1) - 1) * attention_mask)[:, None, :]# 计算ALiBi偏置（广播机制自动对齐维度）alibi = slopes[..., None] * arange_tensor  # [batch_size, num_heads, seq_length]# 调整形状以匹配注意力计算需求return alibi.reshape(batch_size * num_heads, 1, seq_length).to(dtype)

使用示例：

# 假设输入参数
batch_size = 2
seq_length = 128
num_heads = 12  # 非2的幂次方示例
attention_mask = torch.ones((batch_size, seq_length))  # 全有效序列# 构建ALiBi张量
alibi_bias = build_alibi_tensor(attention_mask, num_heads, torch.float16)
print(alibi_bias.shape)  # 应输出：torch.Size([24, 1, 128])

5.2.5  注意力机制

注意力机制是 Transformer 架构中的核心技术，它能够针对序列中的词元对构 建交互关系，聚合来自于不同位置的语义信息。下面介绍四种常见的注意力机制 的设计方法。

• • 完整自注意力机制. 在原始的 Transformer 模型中，注意力机制通过成对的方 式进行序列数据的语义建模，充分考虑了序列中所有词元之间的相互关系。其中， 每个词元在注意力计算中都需要对于其前序的所有词元的键值对予以访问，因此对于序列长度为 T 的序列需要 O() 的计算复杂度。此外，Transformer 还引入了 多头注意力机制，将查询、键和值在不同的语义空间进行线性投影，然后将每个头 的输出进行聚合形成最终的输出。对于完整注意力的详细介绍，可以参考第 5.1.2 节。
• • 稀疏注意力机制. 尽管完整自注意力机制具有较强的建模能力，但是它需要 平方级的计算复杂性。在处理长序列时较为显著，带来了较大的计算和存储开销。 为了降低注意力机制的计算复杂度，研究人员提出了多种高效的注意力变种。其中，滑动窗口注意力机制（Sliding Window Attention, SWA）是大语言模型中使用 最多的一种稀疏注意力机制。不同于完整的注意力机制，滑动窗口注意力根据词 元位置，仅仅将位置索引上距离该词元一定范围内的词元考虑到注意力的计算中。 具体来说，滑动窗口注意力设置了一个大小为 w的窗口，对每个词元  ，只对窗口内的词元 [ , . . . ,   ] 进行注意力计算，从而将复杂度降低到 O (wT )。进一步，通过信息的逐层传递，模型实现了随着层数线性增长的感受野，从而获取远 处词元的信息。关于滑动窗口注意力详细机制如图 5.3 展示。
• • 多查询/分组查询注意力. 为了提升注意力机制的效率，多查询注意力提出针对不同的头共享相同的键和值变换矩阵。这种 方法减少了访存量，提高了计算强度，从而实现了更快的解码速度（具体可以参词元并且对于模型性能产生的影响也比较小。一些代表性的大语言模 型，如 PaLM 和 StarCoder，已经使用了多查询注意力机制。为了结合多查询注意力机制的效率与多头注意力机制的性能，研究人员进一步提出了分组查 询注意力机制（Grouped-Query Attention, GQA）。GQA 将全部的头划分为若干组，并且针对同一组内的头共享相同的变换矩阵。这种注意力机制有效地平衡 了效率和性能，被 LLaMA-2 模型所使用。图 5.4 展示了上述两种注意力查询机制。

      (a) 滑动窗口注意力的掩码矩阵                                 (b) 滑动窗口注意力信息的逐层传递

图 5.4  多头注意力、分组查询注意力和多查询注意力示意图

• • 硬件优化的注意力机制. 除了在算法层面上提升注意力机制的计算效率，还可以进一步利用硬件设施来优化注意力模块的速度和内存消耗。其中，两个具有 代表性的工作是 FlashAttention 与 PagedAttention。相比于传统的注意力 实现方式，FlashAttention 通过矩阵分块计算以及减少内存读写次数的方式，提高 注意力分数的计算效率；PagedAttention 则针对增量解码阶段，对于 KV 缓存进行 分块存储，并优化了计算方式，增大了并行计算度，从而提高了计算效率。

图 5.5  混合专家模型示意图

5.2.6  混合专家模型

如第 2.2 节所述，大语言模型能够通过扩展参数规模实现性能的提升。然而， 随着模型参数规模的扩大，计算成本也随之增加。为了解决这一问题，研究人员 在大语言模型中引入了基于稀疏激活的混合专家架构（Mixture-of-Experts, MoE）， 旨在不显著提升计算成本的同时实现对于模型参数的拓展。

在混合专家架构中，每个混合专家层包含K 个专家组件，记为 [,, . . . ,  ]， 其中每个专家组件都是一个前馈神经网络。对于输入的每个词元表示 ，模 型通过一个路由网络（或称为门控函数）G来计算该词元对应于各个专家的权重。 在路由函数中，首先通过线性层  映射为 K个专家的得分，并基于此 选择出概率最高的k 个专家进行激活。随后，这 k个专家的得分将被送入 softmax 函数计算出它们的权重  = [ , . . . ,   ]，没有被选择的专家权重将 被置为 0。上述路由网络的计算过程如下式所示：

.                                                             (5.35)

之后，每个被选择的词元的输出的加权和将作为该混合专家网络层的最终输出。

        目前具有代表性的混合专家模型是 Mixtral (8×7B)，该模型在 Mistral (7B) 的 基础上，使用了混合专家模块。具体来说，Mixtral 每一层都配备了 8 个专家（7B）， 并对每个词元选择 2 个专家进行后续计算。在每次计算被激活的参数仅仅有 13B 的情况下，其性能超越了更熟规模更大的 LLaMA-2 (70B)，进一步证明了混合专家架构的有效性。下面给出了 Mixtral 混合专家层的一个 PyTorch 示例代码：

import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import Listclass MoeLayer(nn.Module):def __init__(self,experts: List[nn.Module],gate: nn.Module,num_experts_per_tok: int):"""混合专家层（Mixture-of-Experts Layer）实现Args:experts: 专家网络列表，每个专家是一个nn.Module实例gate: 路由网络，用于生成专家选择概率num_experts_per_tok: 每个词元选择的专家数量"""super().__init__()assert len(experts) > 0, "至少需要提供一个专家网络"self.experts = nn.ModuleList(experts)  # 将专家列表转换为ModuleListself.gate = gate                       # 路由网络self.num_experts_per_tok = num_experts_per_tok  # 每个token选择的专家数def forward(self, inputs: torch.Tensor) -> torch.Tensor:"""前向传播过程Args:inputs: 输入张量，形状为 [batch_size, seq_length, hidden_dim]Returns:输出张量，形状与输入相同"""# 生成路由网络的原始logits（未归一化概率）gate_logits = self.gate(inputs)  # 形状 [batch_size, seq_length, num_experts]# 选择top-k专家及其对应权重weights, selected_indices = torch.topk(gate_logits,self.num_experts_per_tok,dim=-1  # 在专家维度上进行选择)# 对权重进行softmax归一化（在专家选择维度上）weights = F.softmax(weights, dim=-1, dtype=torch.float32).to(inputs.dtype)# 初始化输出张量（与输入形状相同）outputs = torch.zeros_like(inputs)# 遍历所有专家，计算加权输出for expert_idx, expert in enumerate(self.experts):# 找到选择当前专家的位置（batch和序列维度）batch_indices, seq_indices = torch.where(selected_indices == expert_idx)# 提取对应位置的输入和权重selected_inputs = inputs[batch_indices, seq_indices]selected_weights = weights[batch_indices, seq_indices, expert_idx]# 计算专家输出并加权累加expert_output = expert(selected_inputs)outputs[batch_indices, seq_indices] += (selected_weights[:, None] * expert_output)return outputs

使用示例：

# 定义示例专家网络和路由网络
class Expert(nn.Module):def __init__(self, hidden_dim):super().__init__()self.mlp = nn.Linear(hidden_dim, hidden_dim)def forward(self, x):return self.mlp(x)class Router(nn.Module):def __init__(self, hidden_dim, num_experts):super().__init__()self.router = nn.Linear(hidden_dim, num_experts)def forward(self, x):return self.router(x)# 创建MoE层
num_experts = 4
hidden_dim = 768
num_experts_per_tok = 2experts = [Expert(hidden_dim) for _ in range(num_experts)]
gate = Router(hidden_dim, num_experts)
moe_layer = MoeLayer(experts, gate, num_experts_per_tok)# 测试前向传播
inputs = torch.randn(8, 128, hidden_dim)  # [batch_size, seq_length, hidden_dim]
outputs = moe_layer(inputs)
print(outputs.shape)  # 应该输出 torch.Size([8, 128, 768])

5.2.7 ​​​​​​​​​​​​​​LLaMA 的详细配置

综合本节讨论的内容，下面给出了关于模型详细配置的推荐建议。首先，为 了增强模型的训练稳定性，建议采用前置的 RMSNorm 作为层归一化方法。其次， 在选择激活函数时，为了获得更优的模型性能，可以优先考虑使用 SwiGLU 或 GeGLU。最后，对于位置编码，可以优先选择 RoPE 或者 ALiBi，这两种位置编码 方法在建模长序列数据时通常能够具有较好的性能。接下来，我们以 LLaMA 模型 的代码实现，来介绍 Transformer 解码器模型是如何进行模型搭建并且实现前向计 算的过程。

对于一个 LLaMA 模型，其首先将输入的词元序列通过词嵌入矩阵转化为词 向量序列。之后，词向量序列作为隐状态因此通过 �  个解码器层，并在最后使 用 RMSNorm 进行归一化。归一化后的最后一层隐状态将作为输出。LLaMA 在 Transformers 库中的整体实现如下所示：

import torch
import torch.nn as nn
from typing import Optional, Tuple, Union
from transformers.models.llama.modeling_llama import LlamaPreTrainedModel, LlamaConfig, LlamaDecoderLayer, LlamaRMSNorm
from transformers.file_utils import add_start_docstrings_to_model_forward
from transformers.modeling_outputs import BaseModelOutputWithPastclass LlamaModel(LlamaPreTrainedModel):def __init__(self, config: LlamaConfig):"""LLaMA 模型实现Args:config: 模型配置参数"""super().__init__(config)self.vocab_size = config.vocab_size  # 词表大小# 词嵌入层（包含padding处理）self.embed_tokens = nn.Embedding(num_embeddings=config.vocab_size,embedding_dim=config.hidden_size,padding_idx=config.pad_token_id  # 显式指定padding索引)# 解码器层堆叠self.layers = nn.ModuleList([LlamaDecoderLayer(config, layer_idx=i)for i in range(config.num_hidden_layers)])# RMSNorm归一化层self.norm = LlamaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)# 预生成因果掩码（用于自注意力）self.register_buffer("causal_mask",torch.full((config.max_position_embeddings, config.max_position_embeddings),fill_value=True,dtype=torch.bool).triu(diagonal=1)  # 上三角矩阵（排除对角线）)@add_start_docstrings_to_model_forward(Llama_INPUTS_DOCSTRING)def forward(self,input_ids: torch.LongTensor = None,attention_mask: Optional[torch.Tensor] = None,position_ids: Optional[torch.LongTensor] = None,**kwargs) -> Union[Tuple, BaseModelOutputWithPast]:"""模型前向传播Args:input_ids: 输入token ID序列 [batch_size, sequence_length]attention_mask: 注意力掩码 [batch_size, sequence_length]position_ids: 位置ID序列 [batch_size, sequence_length]Returns:包含最终隐藏状态的BaseModelOutputWithPast对象"""# 输入嵌入处理if input_ids is not None:inputs_embeds = self.embed_tokens(input_ids)else:inputs_embeds = kwargs["inputs_embeds"]# 获取序列长度seq_length = inputs_embeds.size(1)# 生成因果掩码（根据当前序列长度动态调整）if self.training:# 训练时使用预生成的完整掩码causal_mask = self.causal_mask[:seq_length, :seq_length]else:# 推理时动态生成（适应不同序列长度）causal_mask = torch.full((seq_length, seq_length),fill_value=True,dtype=torch.bool,device=inputs_embeds.device).triu(diagonal=1)# 合并注意力掩码（如果有）if attention_mask is not None:combined_mask = torch.logical_and(causal_mask.unsqueeze(0).expand(inputs_embeds.size(0), -1, -1),attention_mask.unsqueeze(-1).expand(-1, seq_length, seq_length))else:combined_mask = causal_mask.unsqueeze(0).expand(inputs_embeds.size(0), -1, -1)# 通过解码器层hidden_states = inputs_embedsfor decoder_layer in self.layers:hidden_states = decoder_layer(hidden_states=hidden_states,attention_mask=combined_mask,position_ids=position_ids)[0]  # 只取隐藏状态输出# 最终归一化hidden_states = self.norm(hidden_states)return BaseModelOutputWithPast(last_hidden_state=hidden_states,)