devbox
秋刀鱼在做梦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

手搓大模型——qwen2原理解析_qwen2大模型

作者：秋刀鱼在做梦 | 2024-07-01 13:29:09

赞

踩

qwen2大模型

如果按照处理顺序，对于输入的问题Text，要先进入tokenizer

Tokenizer

分词器，把句子分为各个词，并将词分为        [主干]        [特征]        两部分

词的token化类似于把 friendly 拆开为两个部分，这样子词语本身就可以拆开成本体和可多对应的部分，那么只需要对于本体进行识别即可，减少了所需要的词表的大小

之后在处理的时候，各个token会对应一个词向量，有一定的维度（200，300，768，1536）其中由一定的小数组成

之后生成的就是就是一个input_ids，由此输入Qwen2的主干部分

 Qwen2主干

  1. class Qwen2Model(Qwen2PreTrainedModel):
  2.     """
  3.     Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`Qwen2DecoderLayer`]
  5.     Args:
  6.         config: Qwen2Config
  7.     """
  8.  
  9.     def __init__(self, config: Qwen2Config):
  10.         super().__init__(config)
  11.         self.padding_idx = config.pad_token_id
  12.         self.vocab_size = config.vocab_size # 获取词表长度
  13.  
  14.         self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx) # torch.nn.embedding操作
  15.         self.layers = nn.ModuleList(
  16.             [Qwen2DecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
  17.         )
  18.         self._attn_implementation = config._attn_implementation
  19.         self.norm = Qwen2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
  20.  
  21.         self.gradient_checkpointing = False
  22.         # Initialize weights and apply final processing
  23.         self.post_init()

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

Embedding

采用的是torch.nn.embedding的方式，限于知识不足，这一部分之后会慢慢跟上

Hidden_states

前面的input_ids经embedding处理后会有一个向量输入到decoder_layers进行处理

Decoder_layers

这部分是一个多层的结构

  1.  hidden_states = inputs_embeds
  2.  
  3.         # decoder layers
  4.         all_hidden_states = () if output_hidden_states else None
  5.         all_self_attns = () if output_attentions else None
  6.         next_decoder_cache = None
  7.  
  8.         for decoder_layer in self.layers:
  9.             if output_hidden_states:
  10.                 all_hidden_states += (hidden_states,)
  11.  
  12.             if self.gradient_checkpointing and self.training:
  13.                 layer_outputs = self._gradient_checkpointing_func(
  14.                     decoder_layer.__call__,
  15.                     hidden_states,
  16.                     attention_mask,
  17.                     position_ids,
  18.                     past_key_values,
  19.                     output_attentions,
  20.                     use_cache,
  21.                 )
  22.             else:
  23.                 layer_outputs = decoder_layer(
  24.                     hidden_states,
  25.                     attention_mask=attention_mask,
  26.                     position_ids=position_ids,
  27.                     past_key_value=past_key_values,
  28.                     output_attentions=output_attentions,
  29.                     use_cache=use_cache,
  30.                 )
  31.  
  32.             hidden_states = layer_outputs[0]
  33.  
  34.             if use_cache:
  35.                 next_decoder_cache = layer_outputs[2 if output_attentions else 1]
  36.  
  37.             if output_attentions:
  38.                 all_self_attns += (layer_outputs[1],)
  39.  
  40.         hidden_states = self.norm(hidden_states)
  41.  
  42.         # add hidden states from the last decoder layer
  43.         if output_hidden_states:
  44.             all_hidden_states += (hidden_states,)
  45.  
  46.         next_cache = None
  47.         if use_cache:
  48.             next_cache = next_decoder_cache.to_legacy_cache() if use_legacy_cache else next_decoder_cache
  49.  
  50.         if not return_dict:
  51.             return tuple(v for v in [hidden_states, next_cache, all_hidden_states, all_self_attns] if v is not None)
  52.         return BaseModelOutputWithPast(
  53.             last_hidden_state=hidden_states,
  54.             past_key_values=next_cache,
  55.             hidden_states=all_hidden_states,
  56.             attentions=all_self_attns,
  57.         )

对大整体的逻辑应该是把hidden_states传入每一层layers，然后上层处理的hd标准化放入下一层layers，然后加到一块，再处理，再标准化，再送入下层，依次继续，最后输出加上最后一层hd

对于decoder

  1. class Qwen2DecoderLayer(nn.Module):
  2.     def __init__(self, config: Qwen2Config, layer_idx: int):
  3.         super().__init__()
  4.         self.hidden_size = config.hidden_size
  5.  
  6.         if config.use_sliding_window and config._attn_implementation != "flash_attention_2":
  7.             logger.warning_once(
  8.                 f"Sliding Window Attention is enabled but not implemented for `{config._attn_implementation}`; "
  9.                 "unexpected results may be encountered."
  10.             )
  11.         self.self_attn = QWEN2_ATTENTION_CLASSES[config._attn_implementation](config, layer_idx)
  12.  
  13.         self.mlp = Qwen2MLP(config)
  14.         self.input_layernorm = Qwen2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
  15.         self.post_attention_layernorm = Qwen2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
  16.  
  17.     def forward(
  18.         self,
  19.         hidden_states: torch.Tensor,
  20.         attention_mask: Optional[torch.Tensor] = None,
  21.         position_ids: Optional[torch.LongTensor] = None,
  22.         past_key_value: Optional[Tuple[torch.Tensor]] = None,
  23.         output_attentions: Optional[bool] = False,
  24.         use_cache: Optional[bool] = False,
  25.         **kwargs,
  26.     ) -> Tuple[torch.FloatTensor, Optional[Tuple[torch.FloatTensor, torch.FloatTensor]]]:
  27.         if "padding_mask" in kwargs:
  28.             warnings.warn(
  29.                 "Passing `padding_mask` is deprecated and will be removed in v4.37. "
  30.                 "Please make sure use `attention_mask` instead.`"
  31.             )
  32.         """
  33.         Args:
  34.             hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)`
  35.             attention_mask (`torch.FloatTensor`, *optional*): attention mask of size
  36.                 `(batch, sequence_length)` where padding elements are indicated by 0.
  37.             output_attentions (`bool`, *optional*):
  38.                 Whether or not to return the attentions tensors of all attention layers. See `attentions` under
  39.                 returned tensors for more detail.
  40.             use_cache (`bool`, *optional*):
  41.                 If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding
  42.                 (see `past_key_values`).
  43.             past_key_value (`Tuple(torch.FloatTensor)`, *optional*): cached past key and value projection states
  44.         """
  45.  
  46.         residual = hidden_states
  47.  
  48.         hidden_states = self.input_layernorm(hidden_states)
  49.  
  50.         # Self Attention
  51.         hidden_states, self_attn_weights, present_key_value = self.self_attn(
  52.             hidden_states=hidden_states,
  53.             attention_mask=attention_mask,
  54.             position_ids=position_ids,
  55.             past_key_value=past_key_value,
  56.             output_attentions=output_attentions,
  57.             use_cache=use_cache,
  58.         )
  59.         hidden_states = residual + hidden_states
  60.  
  61.         # Fully Connected
  62.         residual = hidden_states
  63.         hidden_states = self.post_attention_layernorm(hidden_states)
  64.         hidden_states = self.mlp(hidden_states)
  65.         hidden_states = residual + hidden_states
  66.  
  67.         outputs = (hidden_states,)
  68.  
  69.         if output_attentions:
  70.             outputs += (self_attn_weights,)
  71.  
  72.         if use_cache:
  73.             outputs += (present_key_value,)
  74.  
  75.         return outputs

  传入残差

residual = hidden_states

  正则化

self.input_layernorm = Qwen2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)

hidden_states = self.input_layernorm(hidden_states)

 传入注意力模块

self.self_attn = QWEN2_ATTENTION_CLASSES[config._attn_implementation](config, layer_idx)

 # 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,

        )

会产出一个新的hidden_states,要与之前的残差相加

hidden_states = residual + hidden_states

 再提出一个残差

residual = hidden_states

 再次进入RMSNorm的环节

hidden_states = self.post_attention_layernorm(hidden_states)

做一次MLP

  hidden_states = self.mlp(hidden_states)

 结果与残差相加

hidden_states = hidden_states + residual

 然后输出

因此，总结上面最关键的几个环节，不难看出

Decoder = MLP + attn + norm

此后就是输出环节

那么回头看下attn吧，这才是重头戏

attn

先将输入的hidden_states传入三个部分

        query_states = self.q_proj(hidden_states)

        key_states = self.k_proj(hidden_states)

        value_states = self.v_proj(hidden_states)

然后转置成为后续进行矩阵乘法的形式

        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与value做kv_repeat（上图是否有误存疑）

在小模型里这一步并非必须

        key_states = repeat_kv(key_states, self.num_key_value_groups)

        value_states = repeat_kv(value_states, self.num_key_value_groups)

 做Dot attn

        attn_weights = torch.matmul(query_states, key_states.transpose(2, 3)) / math.sqrt(self.head_dim)

 同遮蔽注意力相叠加，实现读取顺序

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操作并最后进行一次o_proj

        attn_output = attn_output.transpose(1, 2).contiguous()

        attn_output = attn_output.reshape(bsz, q_len, self.hidden_size)

        attn_output = self.o_proj(attn_output)

最后输出

return attn_output, attn_weights, past_key_value 

 总结

限于能力、篇幅暂时没把数学部分写上来，后续会补上

但是对于qwen的原理梳理成功的将先前的有关于gpt类似的transformers模型的知识串联起来，颇有意思

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/秋刀鱼在做梦/article/detail/776551
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号