通义千问Qwen1.5（Beta Version of Qwen2）代码理解

Elwin Wong

已于 2024-04-16 11:25:27 修改

阅读量346

点赞数 3

分类专栏：大模型文章标签：大模型 LLM Qwen2 transformer 神经网络

于 2024-04-12 18:02:49 首次发布

本文链接：https://blog.csdn.net/zhaoyuanh/article/details/137689659

版权

大模型专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Qwen1.5项目地址：QwenLM/Qwen1.5: Qwen1.5 is the improved version of Qwen, the large language model series developed by Qwen team, Alibaba Cloud. (github.com)

从4.37.0版本开始，transformers集成了Qwen2的代码（官方称Qwen1.5是Qwen2的beta版本，在transformers的代码中也都是使用Qwen2这个名称），因此要使用Qwen2，需要transformers>=4.37.0，Qwen2的代码地址在transformers/models/qwen2目录下。

和Qwen一样，Qwen2仍然是一个decoder-only的transformer模型，使用SwiGLU激活函数、RoPE、多头注意力机制等。

位置编码

位置编码使用的是Rotary Position Embedding，它使用旋转矩阵对绝对位置进行编码，同时在自注意力公式中结合了明确的相对位置依赖，也就是说它将相对位置信息依赖集成到了self-attention中。因此该方法的位置编码是发生在注意力的计算过程中，并非之前的在输入tokens时将位置embedding和token embedding相加。

RoPE模块代码如下，主要是为了计算出RoPE方法中的cos值和sin值：

# Copied from transformers.models.mistral.modeling_mistral.MistralRotaryEmbedding with Mistral->Qwen2
class Qwen2RotaryEmbedding(nn.Module):
    def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None):
        super().__init__()

        self.dim = dim
        self.max_position_embeddings = max_position_embeddings
        self.base = base
        inv_freq = 1.0 / (self.base ** (torch.arange(0, self.dim, 2, dtype=torch.int64).float().to(device) / self.dim))
        self.register_buffer("inv_freq", inv_freq, persistent=False)

        # Build here to make `torch.jit.trace` work.
        self._set_cos_sin_cache(
            seq_len=max_position_embeddings, device=self.inv_freq.device, dtype=torch.get_default_dtype()
        )

    def _set_cos_sin_cache(self, seq_len, device, dtype):
        self.max_seq_len_cached = seq_len
        t = torch.arange(self.max_seq_len_cached, device=device, dtype=torch.int64).type_as(self.inv_freq)

        freqs = torch.outer(t, self.inv_freq)
        # Different from paper, but it uses a different permutation in order to obtain the same calculation
        emb = torch.cat((freqs, freqs), dim=-1)
        self.register_buffer("cos_cached", emb.cos().to(dtype), persistent=False)
        self.register_buffer("sin_cached", emb.sin().to(dtype), persistent=False)

    def forward(self, x, seq_len=None):
        # x: [bs, num_attention_heads, seq_len, head_size]
        if seq_len > self.max_seq_len_cached:
            self._set_cos_sin_cache(seq_len=seq_len, device=x.device, dtype=x.dtype)

        return (
            self.cos_cached[:seq_len].to(dtype=x.dtype),
            self.sin_cached[:seq_len].to(dtype=x.dtype),
        )

得到cos值和sin值后，使用下面的函数进行绝对位置编码和集成相对位置信息依赖：

# Copied from transformers.models.llama.modeling_llama.rotate_half
def rotate_half(x):
    """Rotates half the hidden dims of the input."""
    x1 = x[..., : x.shape[-1] // 2]
    x2 = x[..., x.shape[-1] // 2 :]
    return torch.cat((-x2, x1), dim=-1)


# Copied from transformers.models.mistral.modeling_mistral.apply_rotary_pos_emb
def apply_rotary_pos_emb(q, k, cos, sin, position_ids, unsqueeze_dim=1):
    """Applies Rotary Position Embedding to the query and key tensors.

    Args:
        q (`torch.Tensor`): The query tensor.
        k (`torch.Tensor`): The key tensor.
        cos (`torch.Tensor`): The cosine part of the rotary embedding.
        sin (`torch.Tensor`): The sine part of the rotary embedding.
        position_ids (`torch.Tensor`):
            The position indices of the tokens corresponding to the query and key tensors. For example, this can be
            used to pass offsetted position ids when working with a KV-cache.
        unsqueeze_dim (`int`, *optional*, defaults to 1):
            The 'unsqueeze_dim' argument specifies the dimension along which to unsqueeze cos[position_ids] and
            sin[position_ids] so that they can be properly broadcasted to the dimensions of q and k. For example, note
            that cos[position_ids] and sin[position_ids] have the shape [batch_size, seq_len, head_dim]. Then, if q and
            k have the shape [batch_size, heads, seq_len, head_dim], then setting unsqueeze_dim=1 makes
            cos[position_ids] and sin[position_ids] broadcastable to the shapes of q and k. Similarly, if q and k have
            the shape [batch_size, seq_len, heads, head_dim], then set unsqueeze_dim=2.
    Returns:
        `tuple(torch.Tensor)` comprising of the query and key tensors rotated using the Rotary Position Embedding.
    """
    cos = cos[position_ids].unsqueeze(unsqueeze_dim)
    sin = sin[position_ids].unsqueeze(unsqueeze_dim)
    q_embed = (q * cos) + (rotate_half(q) * sin)
    k_embed = (k * cos) + (rotate_half(k) * sin)
    return q_embed, k_embed

注意到，这里的实现跟论文中的实现有一点不一样：

论文中是对输入向量 $\bold{x}_m \in \R^d$ 的 $d$ 个元素从左到右排列后每两个数组成一个二维向量，再对其应用相应的二维旋转矩阵，如下面的公式和示意图所示：

$\left(\begin{array}{cc} {x_m^{(2i-1)}}^{\prime} \\ {x_m^{(2i)}}^{\prime} \end{array}\right) = \left(\begin{array}{cc}\cos m \theta_i & -\sin m \theta_i \\ \sin m \theta_i & \cos m \theta_i\end{array}\right) \left(\begin{array}{cc} x_m^{(2i-1)} \\ x_m^{(2i)} \end{array}\right), \quad i \in [1,\dots,d/2]$

RoPE示意图

这里的实现则是将 $\bold{x}_m \in \R^d$ 的 $d$ 个元素从左到右排列后分为前后相同长度的两部分，这两部分对应位置的元素组成一个二维向量，再对其应用相应的二维旋转矩阵，如下面的公式所示：

$\left(\begin{array}{cc} {x_m^{(i)}}^{\prime} \\ {x_m^{(i+d/2)}}^{\prime} \end{array}\right) = \left(\begin{array}{cc}\cos m \theta_i & -\sin m \theta_i \\ \sin m \theta_i & \cos m \theta_i\end{array}\right) \left(\begin{array}{cc} x_m^{(i)} \\ x_m^{(i+d/2)} \end{array}\right), \quad i \in [1,\dots,d/2]$

虽然这两种实现方式在对输入向量的元素的排列组合上有所差异（这里应该也是为了实现上的方便），但是原理是一样的，对结果也没影响，都能达到集成相对位置信息依赖的目的。

激活函数

激活函数只用在decoder模块的前馈网络中，用的SwiGLU（门控线性单元的一种变体），代码如下：

# Copied from transformers.models.mistral.modeling_mistral.MistralMLP with Mistral->Qwen2
class Qwen2MLP(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.config = config
        self.hidden_size = config.hidden_size
        self.intermediate_size = config.intermediate_size
        self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, 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]

    def forward(self, x):
        return self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))