Qwen 个人笔记

Qwen的整体架构与Llama2类似，如下图所示:
在这里插入图片描述

1 Qwen2Config

1.1 Model

1.1.1 初始化

设置了模型的两个属性:padding_idx（用于指定填充标记的索引），vocab_size（词汇表的大小）
初始化了模型的嵌入层、解码器层、归一化层
嵌入层（nn.Embedding）：模型使用嵌入层将输入的标记映射成密集的向量表示。
解码器层（nn.ModuleList()）：模型包含多个解码器层，这些层都是由 Qwen2DecoderLayer 定义
归一化层 Qwen2RMSNorm：归一化层使用的是 Root Mean Square Layer Normalization
设置了是否使用 gradient_checkpoint 主要是用来节省显存
调用 post_init() 完成一些初始化和准备检查的代码（主要是对参数进行初始化，以及初始化梯度检查点作用）jie

整个 Qwen2Model 类的目的是为了构建一个完整的Qwen2模型，它可以通过传入不同的配置参数来适应不同的任务和数据集

class Qwen2Model(Qwen2PreTrainedModel):def __init__(self, config: Qwen2Config): #传入一个配置对象，它包含了模型的所有配置参数super().__init__(config)self.padding_idx = config.pad_token_idself.vocab_size = config.vocab_size #设置词汇表的大小self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx) #创建一个嵌入层，用于将词汇表中的每个单词映射到一个隐藏向量self.layers = nn.ModuleList( #创建一个模块列表，包含多个 `Qwen2DecoderLayer`，每个层对应模型的一个解码器层[Qwen2DecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)])self.norm = Qwen2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)self.gradient_checkpointing = False# Initialize weights and apply final processingself.post_init()

post_init 这样的方法通常用于设置一些在构造函数中无法完成的初始化工作，因为这些工作依赖于构造函数中已经执行的步骤

def post_init(self):"""A method executed at the end of each Transformer model initialization, to execute code that needs the model'smodules properly initialized (such as weight initialization)."""self.init_weights()#初始化模型的权重self._backward_compatibility_gradient_checkpointing()#向后兼容而设置的私有方法(梯度检查点)

1.1.2 Forward

自然语言处理模型中的前向传播过程的一部分（重要部分），Transformer 模型中的典型操作

inputs_embeds = self.embed_tokens(input_ids)#这行代码使用 `embed_tokens` 方法将输入的 `input_ids`转换为嵌入向量
# embed positions
hidden_states = inputs_embeds#初始化 `hidden_states` 为输入嵌入，它将在后续的解码器层中被更新for idx, decoder_layer in enumerate(self.layers):# 将所有的hidden_states保存成tupleif output_hidden_states: #判断是否需要输出所有层的隐藏状态all_hidden_states += (hidden_states,)# 将hs送入每一层decoder_layer# 调用当前解码器层的前向传播方法，传入当前的 `hidden_states` 和其他必要的参数layer_outputs = decoder_layer(hidden_states,attention_mask=attention_mask,position_ids=position_ids,past_key_value=past_key_value,output_attentions=output_attentions,use_cache=use_cache,)# 取出上一层decoder_输出的hs,再传入下一个layer# 只要第一个,第二个是cache的一个类，然后进入下一个layerhidden_states = layer_outputs[0]# 将最后layers输出后的hidden_states进行标准化  
hidden_states = self.norm(hidden_states)# 如果需要输出所有层的隐藏状态，则将最后一层的 `hidden_states` 添加到 `all_hidden_states` 中
if output_hidden_states:all_hidden_states += (hidden_states,)

1.2 Qwen2DecoderLayer

在这里插入图片描述

1.2.1 初始化

layer三件套:attn+MLP+norm

这段代码定义了一个名为 Qwen2DecoderLayer 的类，它继承自 PyTorch 的 nn.Module。这个类代表了一个 Transformer 模型中的解码器层，它包含了自注意力机制（self-attention）和多层感知机（MLP），以及两种归一化层

# 字典 映射了不同的注意力实现类
QWEN2_ATTENTION_CLASSES = {"eager": Qwen2Attention,  # 默认的注意力实现，一般情况下是这个"flash_attention_2": Qwen2FlashAttention2, # 一个优化的注意力实现"sdpa": Qwen2SdpaAttention, # 一种特殊的注意力实现
}# 解码器层的类，它包含自注意力、MLP、输入归一化和后注意力归一化
class Qwen2DecoderLayer(nn.Module):def __init__(self, config: Qwen2Config):super().__init__()self.hidden_size = config.hidden_size # 设置隐藏层的大小self.self_attn = QWEN2_ATTENTION_CLASSES[config._attn_implementation](config, layer_idx)# 根据配置中的 `_attn_implementation` 键来选择使用哪种自注意力实现，并初始化它self.mlp = Qwen2MLP(config)# 初始化一个多层感知机（MLP），用于在自注意力之后处理隐藏状态self.input_layernorm = Qwen2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)# 初始化两个归一化层，分别用于自注意力之前和之后。这两个层都是 RMS 归一化层，使用配置中的 `hidden_size` 和 `rms_norm_eps` 参数self.post_attention_layernorm = Qwen2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)

1.2.2 Forward

这段代码体现了 Transformer 模型中的两个关键特性：残差连接和归一化。[[残差连接]]有助于避免深层网络中的梯度消失问题，而归一化则有助于稳定训练过程，加快收敛速度。代码中的 **kwargs 表示函数还可能接收其他未明确列出的关键字参数


residual = hidden_states# 保存原始的 `hidden_states` 到 `residual` 变量中，用于后面的残差连接
#  标准化后送入attn
hidden_states = self.input_layernorm(hidden_states)  # 将 `hidden_states` 通过输入归一化层（`input_layernorm`），RMSNorm标准化
# Self Attention
hidden_states, self_attn_weights, present_key_value = self.self_attn(  hidden_states=hidden_states,attention_mask=attention_mask,position_ids=position_ids,past_key_value=past_key_value,output_attentions=output_attentions,use_cache=use_cache,**kwargs,
)# 再次应用残差连接，将 MLP 之前的 `hidden_states`（保存在 `residual` 中）与 MLP 的输出相加
hidden_states = residual + hidden_states# Fully Connected
residual = hidden_states
# 同样的RMSNorm标准化
hidden_states = self.post_attention_layernorm(hidden_states)
hidden_states = self.mlp(hidden_states)
hidden_states = residual + hidden_statesoutputs = (hidden_states,)return outputs

1.3 Qwen2Attention

在这里插入图片描述

1.3.1 初始化

这段代码定义了一个名为 Qwen2Attention 的类，它继承自 PyTorch 的 nn.Module。这个类实现了多头自注意力机制，这是 Transformer 架构中的一个核心组件
这个自注意力类的实现包括了对多头注意力的支持，以及对旋转嵌入的使用。这种自注意力机制可以用于处理序列数据，如自然语言或时间序列，并且是许多现代 NLP 模型的基础

# 定义了一个自注意力类的蓝图
class Qwen2Attention(nn.Module):"""Multi-headed attention from 'Attention Is All You Need' paper"""def __init__(self, config: Qwen2Config):super().__init__()self.config = config# 保存传入的配置对象，它包含了自注意力层所需的所有配置参数。self.layer_idx = layer_idx# 保存索引 self.hidden_size = config.hidden_sizeself.num_heads = config.num_attention_headsself.head_dim = self.hidden_size // self.num_heads# 计算每个注意力头的维度大小，它是隐藏层大小除以头的数量self.num_key_value_heads = config.num_key_value_heads# 设置键值对头的数量self.num_key_value_groups = self.num_heads // self.num_key_value_headsself.max_position_embeddings = config.max_position_embeddings# 设置最大位置嵌入的大小，这通常用于位置编码self.rope_theta = config.rope_theta# 设置旋转嵌入（Rotary Positional Embedding）的参数self.is_causal = True# 指示是否使用因果自注意力（即在生成下一个 token 时只能使用之前的 token）self.attention_dropout = config.attention_dropout# 设置注意力权重的dropout率if (self.head_dim * self.num_heads) != self.hidden_size:raise ValueError(f"hidden_size must be divisible by num_heads (got `hidden_size`: {self.hidden_size}"f" and `num_heads`: {self.num_heads}).")self.q_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=config.attention_bias)# Queryself.k_proj = nn.Linear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=config.attention_bias)# Keyself.v_proj = nn.Linear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=config.attention_bias)# Valueself.o_proj = nn.Linear(self.num_heads * self.head_dim, self.hidden_size, bias=config.attention_bias)# 计算最终输出的投影# 初始化一个旋转嵌入层，这是一种特殊的位置编码，可以增强模型对序列顺序的感知能力self.rotary_emb = Qwen2RotaryEmbedding(self.head_dim,max_position_embeddings=self.max_position_embeddings,base=self.rope_theta,)

max_position_embeddings 确定了模型能够编码的位置索引的最大值，通常对应于模型能够处理的最长序列长度
rope_theta 决定了旋转矩阵的周期性，它影响着位置编码的周期性变化


max_position_embeddings (`int`, *optional*, defaults to 32768):The maximum sequence length that this model might ever be used with.rope_theta (`float`, *optional*, defaults to 10000.0):The base period of the RoPE embeddings.

1.3.2 Forward

这段代码是一个 Transformer 模型中自注意力（Self-Attention）机制的实现，具体来说是多头自注意力（Multi-Head Self-Attention）的计算过程
这个过程是 Transformer 模型中自注意力机制的核心，它允许模型在处理序列数据时考虑到不同位置之间的关系。旋转位置嵌入（RoPE）是一种特殊的位置编码方式，它通过旋转变换将位置信息融入到查询和键中，从而提高模型对序列顺序的感知能力

# 获取形状信息,hidden_states输入的为(bs,T,hd)
# 获取 `hidden_states` 的形状信息，其中 `bsz` 是批次大小，`q_len` 是序列长度，`hd` 是隐藏层维度
bsz, q_len, _ = hidden_states.size()# 对hidden_states进行Linear生成query、key、value
query_states = self.q_proj(hidden_states)
key_states = self.k_proj(hidden_states)
value_states = self.v_proj(hidden_states)# reshape多头处理--分块--(bs,T,heads,hd_d),为了将输入的隐藏状态转换为适合多头自注意力计算的形式,每个头可以独立地处理序列的一部分，从而实现并行处理和更细粒度的表示学习# `ranspose` 函数用于交换张量的两个维度
query_states = query_states.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
key_states = key_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)
value_states = value_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)# 将旋转位置嵌入应用于查询和键张量。使用了旋转位置嵌入的余弦和正弦部分，将它们与查询和键张量相乘，并将结果相加，从而实现旋转位置嵌入的效果
cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len)
query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin, position_ids)# 先将key_states和value_states重复了num_key_value_groups次
key_states = repeat_kv(key_states, self.num_key_value_groups)
value_states = repeat_kv(value_states, self.num_key_value_groups)# 使用dot attn实现q*kT/hd_d^0.5
# 计算查询和键的点积除以缩放因子（`head_dim` 的平方根），得到注意力权重
attn_weights = torch.matmul(query_states, key_states.transpose(2, 3)) / math.sqrt(self.head_dim)# 然后 attn_weights 加上 attention_mask，实现读取顺序
# 对注意力权重进行 softmax 操作以进行归一化，然后应用 dropout 以防止过拟合
attn_weights = attn_weights + attention_mask# softmax + dropout + values_states相乘
# 使用归一化后的注意力权重和值张量进行点积，得到注意力输出
attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_states.dtype)
attn_weights = nn.functional.dropout(attn_weights, p=self.attention_dropout, training=self.training)
attn_output = torch.matmul(attn_weights, value_states)# 转置，修改形状等reshape操作
# 对注意力输出进行转置和重塑，以恢复到原始的 `bsz x q_len x hd` 形状
attn_output = attn_output.transpose(1, 2).contiguous()
attn_output = attn_output.reshape(bsz, q_len, self.hidden_size)# 最后在进行一次o_proj,通过输出投影层 `o_proj` 对注意力输出进行最后的线性变换
attn_output = self.o_proj(attn_output)# 返回结果,注意力权重和可能使用的 `past_key_value`（在缓存注意力权重时使用）
return attn_output, attn_weights, past_key_value

1.3.3 细节Debug

1.3.3.1 GQA

在这里插入图片描述

主旨:GQA（图形问答）和MQA（多步问答）不需要在推理的过程存储那么多的kv cache（键值对缓存）, 那么kv cache占用的显存就变小，那么我们LLM serving可以处理的请求数量就更多

补充：

GQA（Graphical Question Answering）：这是一种机器理解视觉和语言的任务，其中模型需要理解图像内容并回答有关图像的问题。
MQA（Multi-turn Question Answering）：这是一种交互式问答任务，模型需要在多轮对话中回答用户的问题，通常需要根据之前的对话历史来理解上下文。
KV Cache（Key-Value Cache）：在自回归语言模型中，为了加速生成过程，会缓存之前计算过的键（Key）和值（Value），这样在生成下一个词时可以重用这些信息，而不是重新计算。这可以显著提高推理速度，但同时也占用了显存。

（1）定义初始张量

import torch## shape:(batch, seq_len, head, head_dim)
## 批次大小 序列长度 头的数量 每个头的维度
query = torch.randn(10, 128, 8, 128)
key = torch.randn(10, 128, 2, 128)
value = torch.randn(10, 128, 2, 128)## 在此设置组数为4
groups = query.shape[-2] // key.shape[-2]

（2）之后进行扩展key，value的操作

在GQA中，key和value都要比query小group倍，但是为在后续做矩阵乘法时方便，我们需要先把key和value的head利用expand扩展张量到和query相同的维度。方便后续计算

# 定义输入x， n_rep是需要重复的次数，在这里一般是组数
def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:batch, num_key_value_heads, slen, head_dim = hidden_states.shape# dont need repeat here means multi head attentionif n_rep == 1:return hidden_states# first we expand x to (bs, seq_len, head, group, head_dim)hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim)# reshape make head -> head * groupreturn hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)

（3）矩阵乘法得到score与output 后面就是征程的kqv相乘了

#(bs, head, seq_len, head_dim)
query = query.transpose(1, 2)
key = repeat_kv(key.transpose(1, 2), 4)
value = repeat_kv(value.transpose(1, 2), 4)
scores = torch.matmul(query, key.transpose(2, 3)) / math.sqrt(head_dim)
scores = torch.nn.functional.softmax(scores, dim=-1)out = torch.matmul(scores, value)
#上一步转置了，还得转回去
out = out.transpose(1, 2)

1.3.3.2 apply_rotary_pos_emb

1.3.3.3 读取顺序attention_mask

这两部分直接看原文（见参考资料）吧
ヽ(゜▽゜　)－C<(/;◇;)/~

1.4 Qwen2MLP

在这里插入图片描述

这段代码定义了一个名为 Qwen2MLP 的类，它继承自 PyTorch 的 nn.Module。这个类实现了一个多层感知机（MLP）结构，通常用于 Transformer 模型中的前馈网络（Feed-Forward Network，FFN）

这种 MLP 结构在 Transformer 模型中很常见，它通过引入非线性激活函数和中间层来增加模型的表达能力。在 Qwen2MLP 中，使用了一种特殊的结构，其中 gate_proj 的输出与 up_proj 的输出相乘，这种结构有助于模型学习输入数据的复杂特征

class Qwen2MLP(nn.Module):def __init__(self, config):super().__init__()# 这俩不必多说self.config = configself.hidden_size = config.hidden_sizeself.intermediate_size = config.intermediate_size# 三个全连接层self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)# 定义一个线性层，用于将输入投影到中间层的大小。这个层的权重在训练过程中是不变的（`bias=False`）self.up_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)# 将输入投影到中间层的大小self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size, bias=False)# 将中间层的输出投影回隐藏层的大小self.act_fn = ACT2FN[config.hidden_act]# 根据配置中的激活函数类型，选择相应的激活函数。`ACT2FN` 是一个将激活函数名称映射到 PyTorch 激活函数的字典# 定义了前向传播函数，它是模型的输入数据流经网络的路径def forward(self, x):down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))return down_proj

1.5 Qwen2RMSNorm

计算公式: $RMSNorm(x)=\frac{x}{ \sqrt{\frac{1}{n}\sum_{i = 1}^{n}\omega^2_i+\epsilon }}$
其中:

x是层的输入的hidden_state
wi 表示的是hidden_state的最后一个维度的值
n 表示上面输入的最后一个维度的数量。
ϵ 表示是很小的数，防止除0。

这个类实现了 RMS（Root Mean Square）归一化

RMS 归一化与传统的 LayerNorm 不同，它只使用方差（不包括均值）来进行归一化，这使得它在某些情况下可能更简单或更有效。在 Qwen2RMSNorm 中，通过对方差进行归一化，然后将结果乘以一个可学习的权重，这有助于模型调整归一化后的特征表示

class Qwen2RMSNorm(nn.Module):  # 标准化层def __init__(self, hidden_size, eps=1e-6):"""Qwen2RMSNorm is equivalent to T5LayerNorm"""super().__init__()self.weight = nn.Parameter(torch.ones(hidden_size))self.variance_epsilon = epsdef forward(self, hidden_states):input_dtype = hidden_states.dtypehidden_states = hidden_states.to(torch.float32)variance = hidden_states.pow(2).mean(-1, keepdim=True)hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)# 将归一化后的隐藏状态乘以学习到的权重，并将张量转换回原始的数据类型，然后返回return self.weight * hidden_states.to(input_dtype)