【多模态大模型面经】现代大模型架构（一）: 组注意力机制（GQA）和 RMSNorm

Ne0inhk

— 15 min read
【多模态大模型面经】现代大模型架构（一）: 组注意力机制（GQA）和 RMSNorm
在这里插入图片描述
🧔 这里是九年义务漏网鲨鱼，研究生在读，主要研究方向是人脸伪造检测,长期致力于研究多模态大模型技术；国家奖学金获得者，国家级大创项目一项，发明专利一篇，多篇论文在投，蓝桥杯国家级奖项、妈妈杯一等奖。
✍ 博客主要内容为大模型技术的学习以及相关面经，本人已得到B站、百度、唯品会等多段多模态大模型的实习offer，为了能够紧跟前沿知识，决定写一个“从零学习 RL”主题的专栏。这个专栏将记录我个人的主观学习过程，因此会存在错误，若有出错，欢迎大家在评论区帮助我指出。除此之外，博客内容也会分享一些我在本科期间的一些知识以及项目经验。
🌎 Github仓库地址：Baby Awesome Reinforcement Learning for LLMs and Agentic AI
📩 有兴趣合作的研究者可以联系我：[email protected]

文章目录

前言

✍ 在大模型论文学习中，相信很多读者和笔者一样，一开始都会有一种感觉：“现在大模型架构都差不多，主要是数据和算力在堆积。”当笔者慢慢总结LLaMA、Qwen、DeepSeek这些模型架构的时候发现，在 Attention、位置编码、FFN 与归一化 上，其实已经悄悄从经典 Transformer 走到了另一套“默认配置”。相较于最初的 Transformer，现在的主流大模型在架构上，已经逐渐从：

  • MQA → GQA（Grouped Query Attention）
  • 绝对位置编码 → RoPE（Rotary Positional Embedding）
  • ReLU / GELU 前馈网络 → SwiGLU 前馈网络
  • LayerNorm → RMSNorm + Pre-Norm
  • …

因此，在本文的学习中，我们主要聚焦于目前的大模型”默认配置“的学习，了解现在的”Transformer“!

一、现如今的”Transformer“

读者肯定很疑惑，为什么我要把第一章名字起为现如今的”Transformer“，实际上在以前，不管是科研还是工作，大家都会把Transformer作为一个baseline去进行优化，就像BERT、GPT等等，一直沿用的是Transformer的架构。但到了现在，研究者发现其中模块的更替可以达到更好的的效果。因此，现如今的大模型，已经不再直接将以前的Transformer架构作为baseline，而是将更换了模块的Transformer架构作为baseline。那现如今的baseline模块长什么样子呢，笔者统计了比较经典的模块所采用的注意力机制、位置编码、MLP激活层以及归一化的方式:

模型家族注意力位置编码MLP 激活归一化
早期 GPT/BERTMHA绝对 PE / learned posGELULayerNorm
LLaMA 1/2/3 系列GQA（大模型）RoPESwiGLURMSNorm
Qwen2 / Qwen2.5GQARoPESwiGLURMSNorm
Mistral 7BGQA + sliding windowRoPESwiGLURMSNorm
DeepSeek-LLM 等GQA/自研高效注意力RoPESwiGLURMSNorm
Granite / Gemma 等GQA/MQARoPESwiGLU/GeGLURMSNorm/LN

如表格所示, 对比早期 GPT/BERT 模型我们就可以发现了，现如今大模型的各个模块都有所改变：

  • 注意力机制：MQA → GQA（Grouped Query Attention）
  • 位置编码： 绝对位置编码 → RoPE（Rotary Positional Embedding）
  • MLP 激活层：ReLU / GELU 前馈网络 → SwiGLU 前馈网络
  • 归一化： LayerNorm → RMSNorm + Pre-Norm

所以如果你能把这四件套讲明白，基本就把现代 LLM 架构里 理清，并且可以快速找到文章的贡献点。

二、Attention Serious

在这里插入图片描述

2.1 Multi-Head Attention (MHA)

首先来回顾一下以前的注意力机制：
Attention ( Q , K , V ) = softmax ( Q K ⊤ d k ) V \text{Attention}(Q,K,V) = \text{softmax}\left(\frac{QK^\top}{\sqrt{d_k}}\right)V Attention(Q,K,V)=softmax(dk​​QK⊤​)V
在标准的自注意力中，我们通过 Q K T / d k QK^T / \sqrt{d_k} QKT/dk​​ 来计算不同 token 之间的注意力权重。但作者发现，仅用一个注意力头往往难以同时捕捉多种语义关系（如词法、语义、句法等）。因此，Transformer 提出了多头注意力机制 (Multi-Head Attention, MHA)。

将输入特征通过不同的线性投影矩阵，映射到多个低维子空间中：
head i = Attention ( Q W i Q , K W i K , V W i V ) \text{head}_i = \text{Attention}(QW_i^Q, \, KW_i^K, \, VW_i^V) headi​=Attention(QWiQ​,KWiK​,VWiV​)
然后将所有头拼接（concatenate）再线性变换：
MultiHead ( Q , K , V ) = Concat ( head 1 , … , head h ) W O \text{MultiHead}(Q,K,V) = \text{Concat}(\text{head}_1, \dots, \text{head}_h) W^O MultiHead(Q,K,V)=Concat(head1​,…,headh​)WO

在这里插入图片描述

MHA通过多个小头可以从不同角度捕捉语义信息，增强模型的表达能力和稳定性，比单头更鲁棒。

  • 代码手撕
import torch import torch.nn as nn import torch.nn.functional as F classMultiHeadAttention(nn.Module):def__init__(self, d_model, num_heads, dropout=0.0):super().__init__()assert d_model % num_heads ==0 self.d_model = d_model self.num_heads = num_heads self.head_dim = d_model // num_heads self.w_q = nn.Linear(d_model, d_model) self.w_k = nn.Linear(d_model, d_model) self.w_v = nn.Linear(d_model, d_model) self.w_o = nn.Linear(d_model, d_model) self.dropout = nn.Dropout(dropout)defforward(self, x, attn_mask=None):""" x: [B, L, d_model] """ B, L, _ = x.size()# 1. 线性投影 Q = self.w_q(x)# [B, L, d_model] K = self.w_k(x) V = self.w_v(x)# 2. reshape 为 [B, H, L, Dh]defreshape_heads(t):return t.view(B, L, self.num_heads, self.head_dim).transpose(1,2) Q = reshape_heads(Q) K = reshape_heads(K) V = reshape_heads(V)# Q,K,V: [B, H, L, Dh]# 3. 缩放点积注意力 scores = Q @ K.transpose(-2,-1)/(self.head_dim **0.5)# [B, H, L, L]if attn_mask isnotNone: scores = scores.masked_fill(attn_mask ==0,float('-inf')) attn = F.softmax(scores, dim=-1) attn = self.dropout(attn) out = attn @ V # [B, H, L, Dh]# 4. 合并头 out = out.transpose(1,2).contiguous().view(B, L, self.d_model)return self.w_o(out)

2.2 Multi-Query Attention (MQA)

有了 MHA 之后，大家第一反应是：头越多越好，越能学到多种语义关系。但在大模型、尤其是 Decoder-Only + 长上下文 + 自回归生成 的场景下，MHA 暴露出了一个非常现实的问题：

KV Cache 太贵了。

在自回归生成过程中，每生成一个新 token，都需要用到历史所有位置的 K , V K, V K,V

  • 对于标准 MHA：每个注意力头都维护一份自己的 K h , V h K_h, V_h Kh​,Vh​
  • 如果有 h h h 个头，那么 KV Cache 的内存开销大致是: O ( h ⋅ L ⋅ d head ) \mathcal{O}(h \cdot L \cdot d_{\text{head}}) O(h⋅L⋅dhead​)

当我们把头数堆到 32、64 甚至更多，再把上下文长度拉到 32K、64K 时，这个开销就会变成显存吞噬怪，直接限制推理速度与可部署性。因此，为了在几乎不损失模型效果的前提下，压缩 KV Cache 和带宽成本，就提出了 Multi-Query Attention（MQA）。

MHA中的每一个头都是独享一份 K , V K, V K,V，相反的，MQA 提出了所有的头共享同一份 K , V K, V K,V也就是说，只保留一组 WK,WVW^K, W^VWK,WV，而 WiQW_i^QWiQ 仍然为每个头独立：
Q i = X W i Q , K = X W K , V = X W V . Q_i = X W_i^Q,\quad K = X W^K,\quad V = X W^V. Qi​=XWiQ​,K=XWK,V=XWV.
于是每个头的注意力就变成：
head i = Attention ( Q i , K , V ) = softmax ( Q i K ⊤ d k ) V . \text{head}_i = \text{Attention}(Q_i, K, V) = \text{softmax}\left(\frac{Q_i K^\top}{\sqrt{d_k}}\right) V. headi​=Attention(Qi​,K,V)=softmax(dk​​Qi​K⊤​)V.
最后依然是拼接再线性变换：
MQA ( X ) = Concat ( head 1 , … , head h ) W O . \text{MQA}(X) = \text{Concat}(\text{head}_1, \dots, \text{head}_h) W^O. MQA(X)=Concat(head1​,…,headh​)WO.
💡 经验发现“多 KV”并没有带来线性收益, Q 仍然是多头的，多头仍能捕捉多种语义关系。

  • 代码手撕
class MultiQueryAttention(nn.Module): def __init__(self, d_model, num_heads, dropout=0.0): super().__init__() assert d_model % num_heads == 0 self.d_model = d_model self.num_heads = num_heads self.head_dim = d_model // num_heads self.w_q = nn.Linear(d_model, d_model) # 注意：K/V 只有一组，所以输出维度是 head_dim self.w_k = nn.Linear(d_model, self.head_dim) self.w_v = nn.Linear(d_model, self.head_dim) self.w_o = nn.Linear(d_model, d_model) self.dropout = nn.Dropout(dropout) def forward(self, x, attn_mask=None): """ x: [B, L, d_model] """ B, L, _ = x.size() # 1. 多头 Q Q = self.w_q(x) # [B, L, d_model] Q = Q.view(B, L, self.num_heads, self.head_dim).transpose(1, 2) # Q: [B, H, L, Dh] # 2. 单头 K/V K = self.w_k(x) # [B, L, Dh] V = self.w_v(x) # [B, L, Dh] # 3. 为了和 Q 匹配，将 K/V 在头维上 broadcast K = K.unsqueeze(1) # [B, 1, L, Dh] V = V.unsqueeze(1) # [B, 1, L, Dh] K = K.expand(B, self.num_heads, L, self.head_dim) V = V.expand(B, self.num_heads, L, self.head_dim) # 4. 缩放点积注意力（与 MHA 相同） scores = Q @ K.transpose(-2, -1) / (self.head_dim ** 0.5) # [B, H, L, L] if attn_mask is not None: scores = scores.masked_fill(attn_mask == 0, float('-inf')) attn = F.softmax(scores, dim=-1) attn = self.dropout(attn) out = attn @ V # [B, H, L, Dh] out = out.transpose(1, 2).contiguous().view(B, L, self.d_model) return self.w_o(out)

2.3 Grouped Query Attention (GQA)

根据前面两节的分析，我们可以总结出：

  • MHA：每个头都有独立的 K h , V h K_h, V_h Kh​,Vh​，表达能力强，但 KV Cache 成本最高；
  • MQA：所有头共享同一份 K , V K, V K,V，KV Cache 成本最低，但多头之间视角差异弱，表达能力稍打折

于是就自然出现了一个折中思路：能不能在 “省 KV” 和 “头之间有点差异” 之间找个平衡？这就是 Grouped-Query Attention（GQA）。GQA 的核心思想：Q 仍然是很多头，但 K/V 的头数减少为更少的组（num_kv_heads），每组 KV 服务若干个 Q 头。

  • 代码手撕
classGroupedQueryAttention(nn.Module):def__init__(self, d_model, num_q_heads, num_kv_heads, dropout=0.0):super().__init__()assert d_model % num_q_heads ==0assert num_q_heads % num_kv_heads ==0 self.d_model = d_model self.num_q_heads = num_q_heads self.num_kv_heads = num_kv_heads self.head_dim = d_model // num_q_heads self.group_size = num_q_heads // num_kv_heads # 每组多少个 Q 头共享一个 KV self.w_q = nn.Linear(d_model, d_model) self.w_k = nn.Linear(d_model, num_kv_heads * self.head_dim) self.w_v = nn.Linear(d_model, num_kv_heads * self.head_dim) self.w_o = nn.Linear(d_model, d_model) self.dropout = nn.Dropout(dropout)defforward(self, x, attn_mask=None):""" x: [B, L, d_model] """ B, L, _ = x.size()# 1. Q: 多头； K/V: 少量头 Q = self.w_q(x)# [B, L, d_model] K = self.w_k(x)# [B, L, num_kv_heads * head_dim] V = self.w_v(x) Q = Q.view(B, L, self.num_q_heads, self.head_dim).transpose(1,2) K = K.view(B, L, self.num_kv_heads, self.head_dim).transpose(1,2) V = V.view(B, L, self.num_kv_heads, self.head_dim).transpose(1,2)# Q: [B, Hq, L, Dh]# K,V: [B, Hkv, L, Dh]# 2. 将每个 KV 头“扩展”为 group_size 个 Q 头使用# 例如 Hq=8, Hkv=2 -> group_size=4 K = K.repeat_interleave(self.group_size, dim=1)# [B, Hq, L, Dh] V = V.repeat_interleave(self.group_size, dim=1)# 3. 缩放点积注意力 scores = Q @ K.transpose(-2,-1)/(self.head_dim **0.5)# [B, Hq, L, L]if attn_mask isnotNone: scores = scores.masked_fill(attn_mask ==0,float("-inf")) attn = F.softmax(scores, dim=-1) attn = self.dropout(attn) out = attn @ V # [B, Hq, L, Dh]# 4. 合并头 out = out.transpose(1,2).contiguous().view(B, L, self.d_model)return self.w_o(out)

三、归一化：LayerNorm → RMSNorm + Pre-Norm

在 Transformer 里，归一化（Normalization）主要解决两个问题：

  1. 深层网络训练不稳定：梯度可能爆炸或消失；
  2. 不同层输出分布漂移，导致学习变慢。

最早的 Transformer 使用的是 LayerNorm + Post-Norm 残差结构（指在全连接层后跟上一个归一化层）

在这里插入图片描述

但到了 LLaMA、DeepSeek 等大模型时，大家开始逐渐转向：RMSNorm + Pre-Norm（指在全连接层前跟上一个归一化层）

🔹 Post-Norm（原始 Transformer 用法）

最早的 Transformer 论文（Attention Is All You Need）使用的是 Post-Norm,代码结构类似：

# Post-Norm 结构 out = x + sublayer(x) out = layer_norm(out)
🔹 Pre-Norm（现代 LLM 常用）

大多数现代 LLM（如 LLaMA、DeepSeek 系列）改成了 Pre-Norm：代码结构类似：

# Pre-Norm 结构 h = layer_norm(x) out = x + sublayer(h)

💡 实践上，Pre-Norm 再配合 RMSNorm，只调节尺度不改均值，在 Decoder-only 结构里训练更稳定、实现也更简单。

3.1 LayerNorm

Layer Normalization（LN）是在 Transformer 中使用最广的归一化方式之一。给定一个 token 的隐藏表示 x ∈ R d x \in \mathbb{R}^{d} x∈Rd，LayerNorm 对其 特征维度 进行归一化：
μ = 1 d ∑ i = 1 d x i , σ 2 = 1 d ∑ i = 1 d ( x i − μ ) 2 \mu = \frac{1}{d} \sum_{i=1}^{d} x_i,\quad \sigma^2 = \frac{1}{d} \sum_{i=1}^{d} (x_i - \mu)^2 μ=d1​i=1∑d​xi​,σ2=d1​i=1∑d​(xi​−μ)2

LN ( x ) = x − μ σ 2 + ϵ ⋅ γ + β \text{LN}(x) = \frac{x - \mu}{\sqrt{\sigma^2 + \epsilon}} \cdot \gamma + \beta LN(x)=σ2+ϵ​x−μ​⋅γ+β

其中：

  • γ , β ∈ R d \gamma, \beta \in \mathbb{R}^{d} γ,β∈Rd是可学习的缩放和平移参数；
  • 归一化是在单个样本、单个 token 的通道维度上完成的。

🧠 直觉理解：

对每个 token 的特征做一遍“标准化 + 线性变换”，
让每一层看到的分布更平滑，避免某些维度过大/过小导致训练不稳。

在 PyTorch 中，你平时看到的 nn.LayerNorm 就是这个东西：

import torch import torch.nn as nn x = torch.randn(2,4,8)# [B, L, d_model] ln = nn.LayerNorm(8) y = ln(x)# 每个位置的最后一维做 LN
🧠 1.为什么不用 BatchNorm，而用 LayerNorm / RMSNorm？(面经)

这一问是面试官很喜欢的一个考点，尤其是 Transformer / LLM 岗位。核心区别在于：归一化时用哪些维度来统计均值与方差。

  • BatchNorm（BN）：
    • 在 CV 里常用，对 batch 维度 + 空间维度 做统计；
    • 对每个通道c，使用整批数据的统计量： m u c = E N , H , W [ x n , c , h , w ] mu_c = \mathbb{E}_{N,H,W}[x_{n,c,h,w}] muc​=EN,H,W​[xn,c,h,w​]
  • LayerNorm（LN）：
    • 对单个样本、单个 token 的所有特征求均值和方差，不依赖 batch 大小。

在 Transformer / LLM 场景中，BN 存在几个问题：

  1. 序列长度不固定：BN 在变长序列上不自然，统计维度不好选；
  2. 推理阶段 batch 很小甚至为 1：BN 的 running mean/var 与训练时差异大，容易分布漂移；
  3. 自注意力中不同 token 之间差异大：BN 混合不同 token 的统计量，会引入额外噪声。

因此，大模型里更偏向用 LayerNorm / RMSNorm 这种“不依赖 batch、只看自己”的归一化方式。

3.2 RMSNorm

RMSNorm 是基于“层归一化中主要起作用的是缩放因子，而非平移因子”这个发现而提出的归一化方法。在层归一化中需要减去均值，而模型在训练过程中已经学会通过投影矩阵自动调节均值；而 γ \gamma γ 的作用是调整每一维的相对 scale，是表达力的核心。给定 x ∈ R d x \in \mathbb{R}^d x∈Rd，RMSNorm 的公式为：
RMS ( x ) = 1 d ∑ i = 1 d x i 2 + ϵ \text{RMS}(x) = \sqrt{\frac{1}{d} \sum_{i=1}^{d} x_i^2 + \epsilon} RMS(x)=d1​i=1∑d​xi2​+ϵ​

RMSNorm ( x ) = x RMS ( x ) ⋅ γ \text{RMSNorm}(x) = \frac{x}{\text{RMS}(x)} \cdot \gamma RMSNorm(x)=RMS(x)x​⋅γ

🧠 直觉理解：

RMSNorm 更像是“把这个向量整体缩放到一个合适能量水平”，
不去把它“拉回 0 均值”，只控制它的尺度。

💡 实践上，在 Decoder-only 大模型里：RMSNorm + Pre-Norm 组合在超深层网络（几十层）上表现更稳定，这也是 LLaMA / DeepSeek / Qwen 等系列广泛采用它的原因之一。

  • 代码手撕
classRMSNorm(nn.Module):def__init__(self, d_model, eps=1e-8):super().__init__() self.weight = nn.Parameter(torch.ones(d_model)) self.eps = eps defforward(self, x):""" x: [B, L, d_model] """# 均方根：sqrt(mean(x^2)) rms = x.pow(2).mean(dim=-1, keepdim=True).add(self.eps).sqrt() x_norm = x / rms return self.weight * x_norm

四、总结

本章我们先把现代大模型里的两块“基础设施”打牢：一块是从 MHA → MQA → GQA 的注意力演化，用更少的 KV 头（甚至共享 KV）在不明显掉点的前提下，大幅降低 KV Cache 与长上下文显存开销；另一块是从 LayerNorm → RMSNorm + Pre-Norm 的归一化升级，用“只归一化能量”的 RMSNorm 配合 Pre-Norm 结构，让超深的 Decoder-only 模型在训练和推理中都更加稳定。后面的章节，我们再把 RoPE / SwiGLU / MoE / MLA 这些“进阶武器”一个个拆开，拼成一整套现代 LLM 的“架构面经图谱”。

Read more

GitCode Notebook 昇腾 910B NPU 平台 ops-transformer 算子：全场景性能测试与验证及与原生 PyTorch 注意力的深度性能对比

GitCode Notebook 昇腾 910B NPU 平台 ops-transformer 算子：全场景性能测试与验证及与原生 PyTorch 注意力的深度性能对比

GitCode Notebook 昇腾 910B NPU 平台 ops-transformer 算子：全场景性能测试与验证及与原生 PyTorch 注意力的深度性能对比 前言 基于 GitCode Notebook 昇腾 910B + CANN 8.2.rc1 环境，聚焦 ops-transformer 算子的完整部署与性能验证，通过清晰的环境配置、依赖安装、多场景性能测试及与原生 PyTorch 注意力的对比实验，直观呈现其在低时延、高吞吐量及显存优化上的核心优势，为 LLM 训练 / 推理等 NLP 任务提供高效、可落地的算子应用参考 前提条件 开发环境准备：GitCode Notebook NPU 启动配置 1、GitCode启动NoteBook资源 计算类型：NPUCANN是昇腾 NPU设计的异构计算架构，

By Ne0inhk
让你的笔记不会丢失!! Obsidian与gitee同步笔记教程

让你的笔记不会丢失!! Obsidian与gitee同步笔记教程

步骤大纲: - 安装git -通过git仓库设置需要传入的文件 -注册Gitee(或者Github) -新建一个仓库 -初始化本地库 -在Obsidian中安装Git插件 -设置插件 -测试即可 ---------------------------------------------------------- Obsidian是一款功能强悍的笔记软件 ,我一直再用这款软件 ,里面的关系图谱就十分的高级 ,给自己一种技术大拿的感觉 ,也是反馈非常好 ,强推这款软件!!! ----------------------------------------------------------- 设计同步的初衷: 极特殊情况:电脑突然坏了 ,笔记如果没有进行同步就丢了 ,如果记了很多内容那还是很可惜的 另外就是:我在笔记本电脑上面用的这款软件 ,但是有时候在某些场合笔记本不方便使用 ,想复习一下笔记内容就没有办法做到 ,同步以后就可以支持双端观看 ,解决了这个问题 ,复习笔记内容更久快捷 ,在不方便的场合下也可以达到复盘笔记的目的 .    因为Obsidian自带

By Ne0inhk
使用开源三件套OpenClaw+Ollama+1Panel部署7×24运行

使用开源三件套OpenClaw+Ollama+1Panel部署7×24运行

一、写在前面 本次操作教程将以开源 Linux 服务器运维面板 1Panel 为基础，搭配 Ollama 本地大模型（无需担心 Token 消耗费用），手把手教你部署 OpenClaw 个人 AI 助理，实现 7×24 小时稳定运行，轻松拥有专属智能助手！ 二、资源准备 本次 OpenCalw 本地个人 AI 助理基于一台腾讯 GPU 云服务器构建，云服务器获取过程不做赘述，参见腾讯云官网。其中服务器的配置参见如下： * 操作系统：Ubuntu Server 24.04 LTS 64 位 * 计算资源：20 核 80 G * 磁盘容量：100G

By Ne0inhk

GitHub 上开源了 30+ 个 OpenClaw 真实使用案例。

最近逛 GitHub 的时候发现了一个挺有意思的仓库，专门收集 OpenClaw 的 usecases。 说实话，很多人装完 OpenClaw 之后的操作都是一样的：疯狂往里面塞各种 Skill，ClawHub 逛得跟菜市场一样热闹，今天装个天气查询，明天装个股票分析，后天又来个翻译助手。 结果装了一堆却发现每天还是在信息搜索、做个记录。Skill 装了一百个，生活一点没变轻松。 这个开源项目就是专门收集人们真实在用的 OpenClaw 场景，而不是单纯介绍某个 Skill 或插件。 01 开源项目简介 awesome-openclaw-usecases 目前收录了 30 多个经过验证的真实使用场景。 它的核心理念非常简单：不是教你装什么 Skill，而是告诉你别人是怎么把 OpenClaw 变成真正能帮人类干活的私人助理的。 如果你不知道 OpenClaw 具体能做什么，只停留在抽象概念。有一些自动化或搭建 AI 智能体想法，但不知道如何系统落地，想参考别人已经跑通的真实工作流和自动化方案。

By Ne0inhk