② 模型架构 · Transformer（变换器）全拆解

2.0 整体架构：一个 token（词元）的旅程

MiniMind 模型 = model/model_minimind.py，287 行。全景：

2.1 Embedding（词嵌入）：每个词一份档案

# model_minimind.py L196
self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size)
# 一张 6400 行 × 768 列的表：每个 token 一行档案
# forward 时查表（L226）：拿到 id，取出对应行
hidden_states = self.dropout(self.embed_tokens(input_ids))

技巧：输入 embedding 表和输出层共用一张表（tie_word_embeddings=True，L240）。理解和输出用同一份档案，省一半参数。

2.2 RMSNorm（均方根归一化）：车间门口的稳定器

# model_minimind.py L50-59
class RMSNorm(torch.nn.Module):
    def norm(self, x):
        # 均值波动量越大，除得越狠 → 压回标准幅度
        return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)
    def forward(self, x):
        # 升 float32 算（更稳）再转回；weight 是可学的"各项重要度"
        return (self.weight * self.norm(x.float())).type_as(x)

2.3 Attention（注意力机制）：决定听谁说话

三步：

1. token 发出 Q（查询）："我需要什么信息？"
2. Q 与所有人的 K（钥匙）打分 → softmax 成百分比
3. 按百分比混合所有人的 V（内容）→ 新表示

核心代码（Attention.forward，L112-134）：

xq, xk, xv = self.q_proj(x), self.k_proj(x), self.v_proj(x)
# ① 同一个 x 算出 Q/K/V（768 维 → 8 头 × 96 维）

xq = xq.view(bsz, seq_len, self.n_local_heads, self.head_dim)
# ② 拆头：768 维切 8 份，每头看一个侧面

xq, xk = self.q_norm(xq), self.k_norm(xk)
# ③ QK-Norm：Q/K 各自先归一化（Qwen3 同款，小模型稳定关键）

xq, xk = apply_rotary_pos_emb(xq, xk, cos, sin)
# ④ RoPE 旋转位置（见 2.4）

output = F.scaled_dot_product_attention(xq, xk, xv, is_causal=self.is_causal)
# ⑤ 一步算完注意力；手写版：Q@K/sqrt(d) → softmax → @V

2.4 RoPE（旋转位置编码）：座位编号的旋转魔法

# model_minimind.py L62-78 预计算 cos/sin 表；L80-84 套用到 q/k
freqs = 1.0 / (rope_base ** (torch.arange(0, dim, 2)[:dim//2].float() / dim))
# 每维不同转速：低维慢（编码远距），高维快（编码近距）——多针钟表
# YaRN（L64-73）：长文外推时缩放转速，32768 位置的来源

2.5 FFN（前馈网络）+ SwiGLU（门控激活）

# model_minimind.py L136-146
def forward(self, x):
    return self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))
    # silu(gate(x)) ⊙ up(x)：gate 分支决定 up 分支哪些信息放行

2.6 MoE（混合专家）：医院分诊台 ⭐

前面车间每个 token 全员参与。MoE 把 FFN 车间改成分诊医院。

核心代码（MOEFeedForward.forward，L154-176）：

# ① 分诊：gate 是 768→4 线性层，softmax 后 4 个"挂号概率"
scores = F.softmax(self.gate(x_flat), dim=-1)              # [token数, 4]
topk_weight, topk_idx = torch.topk(scores, k=1, dim=-1)    # ② 选最高分 1 科（top-1）
topk_weight = topk_weight / (topk_weight.sum(-1, keepdim=True) + 1e-20)
# ③ 归一化：top-1 时恒等于 1.0（top-k>1 时才生效）

# ④ 分发：每个专家只领走选中自己的 token（稀疏计算）
y = torch.zeros_like(x_flat)
for i, expert in enumerate(self.experts):
    mask = (topk_idx == i)
    if mask.any():
        token_idx = mask.any(-1).nonzero().flatten()
        y.index_add_(0, token_idx, expert(x_flat[token_idx]) * topk_weight[mask].view(-1, 1))
        # 只有被选中的 token 过专家 i → "总参 198M / 激活 64M" 的实现

# ⑤ 负载均衡：防止病人全挂一个科
load = F.one_hot(topk_idx, 4).float().mean(0)      # 实际挂号频率
self.aux_loss = (load * scores.mean(0)).sum() * 4 * coef
# 频率×概率 乘积和：越"又红又专"罚越重

🎮 在线玩一把：MoE 路由模拟器

拨动 4 个专家的偏好滑块，实时看 token 分流、负载条和 aux_loss。亲手制造"专家崩塌"再拉回。

2.7 采样：接龙怎么选字

模型输出 6400 个概率。怎么选下一个字？

# model_minimind.py generate() L266-278
logits = outputs.logits[:, -1, :] / temperature   # ① T<1 拉大差距，T>1 缩小
logits[logits < torch.topk(logits, 50)[0][..., -1, None]] = -float('inf')  # ② top-k 留前 50
# ③ top-p：累计 85% 后的候选全 -inf（L269-273）
next_token = torch.multinomial(torch.softmax(logits, -1), 1)  # ④ 按概率抽签

收束：一个 token 的完整旅程

"欲穷千里__"：token 化 → embedding 查档案 → 8 层车间（RMSNorm → Attention → RMSNorm → FFN/MoE）→ 最终 Norm → lm_head 打 6400 分 → softmax → 按 temperature/top-p 抽签 → "楼"。