当前位置：首页 > news >正文

大模型里面到底长什么样？Tokenization+词表映射+MoE+门控网络+稀疏激活+Transformer+Attention全讲透（附代码）

news 2026/7/29 23:15:23

📢 本文是「108张AI知识卡片·大模型通关手册」系列第 10 篇。前九篇讲的是"怎么用大模型"——RAG、Agent、提示工程。这篇换个视角，从"用"跳到"懂"：打开 GPT 的"胸腔"，看看 Transformer、Attention、MoE 这些架构组件到底长什么样。不推公式，用比喻讲透硬核原理。

TL;DR 太长不看
一、Tokenization：大模型的消化系统
二、词表映射：文字和数字之间的翻译官
三、MoE：大模型的智囊团
四、门控网络：MoE的调度中心
五、稀疏激活：四两拨千斤
六、Transformer：大模型的骨架
七、Attention：大模型的心脏
八、一张图串起大模型架构链路
九、代码：Tokenization + MoE 简化实现
写到最后
系列导航 & 持续更新

TL;DR 太长不看

⚡30 秒版：先记这 7 条，细节往下翻。

🔴Tokenization：把文本切成 Token 碎片——"大模型真厉害"切成[“大”,“模型”,“真”,“厉害”]，大模型只认碎片不认整句。
🟠词表映射：每个 Token 对应一个编号——“大”=234，“模型”=5678，文字和数字之间的翻译官。
🟡MoE：混合专家模型——请了一群专家，按需调用，不浪费算力，大模型"大而省"的秘密。
🟢门控网络：MoE 的调度中心——看一眼输入，决定派哪个专家出马，就像医院分诊台。
🔵稀疏激活：每次只激活一小部分专家——8 个专家只激活 2 个，省 75% 算力还能保效果。
🟣Transformer：大模型的骨架——所有现代大模型都站在这个架构上，"注意力机制+前馈网络"的堆叠。
🎁架构口诀：Tokenization 切碎片 → 词表映射变数字 → MoE 请专家 → 门控网络做调度 → 稀疏激活省算力 → Transformer 搭骨架 → Attention 跳心脏。

一、Tokenization：大模型的消化系统

你输入"大模型真厉害"，大模型不是直接处理这 5 个字——它先把句子切成碎片（Token），再一个一个处理。Tokenization 就是这个"切碎"的过程，是大模型的消化系统。

Tokenization 解决的核心问题：大模型不能直接处理原始文本——它只认数字。Tokenization 把文本切成 Token（最小处理单元），每个 Token 再映射成数字，大模型才能处理。

它到底在干嘛（机制层）：Tokenization 的核心是分词算法——决定文本怎么切。三种主流算法。BPE（Byte Pair Encoding）：从字符级开始，反复合并最高频的字符对——“h”+“e"→"he”，“he”+“llo"→"hello”。GPT 系列用 BPE。WordPiece：类似 BPE，但合并标准不是频率最高，而是 likelihood 提升最大——BERT 用 WordPiece。SentencePiece：语言无关的分词器，直接在字节级操作——不依赖预定义的词表，多语言场景首选。关键参数：词表大小（Vocab Size）——GPT-2 是 50257，GPT-4 用的更大。词表越大，每个 Token 承载的信息越多，但模型参数也越多。Tokenization 的粒度直接影响模型能力：切得太细（字符级），序列太长，计算量大；切得太粗（词级），词表太大，稀疏问题严重。

你能感受到什么（体感层）：英文："unbelievable"→[“un”,“believ”,“able”]——BPE 把它切成 3 个 Token，因为 “un” 和 “able” 是常见词缀。中文："大模型真厉害"→[“大”,“模型”,“真”,“厉害”]——中文每个字/词基本就是一个 Token。数字："2024"→[“20”,“24”]或[“2”,“0”,“2”,“4”]——取决于训练数据中数字的出现模式。同一个概念，不同模型的 Tokenization 可能不同——GPT 切 3 个 Token 的词，Claude 可能切 2 个，这就是为什么不同模型的"Token 数"不能直接比较。

🎛️ 动手感受：不同模型的 Tokenization 差异

操作：把"unbelievable 2024年"分别用 GPT 和 BERT 的 Tokenizer 分词，对比结果。
你会看到：

GPT（BPE）：[“un”,“believ”,“able”," 202",“4”,“年”]——6 个 Token。
BERT（WordPiece）：[“un”,“##believ”,“##able”,“2024”,“年”]——5 个 Token。
差异说明了什么：不同分词算法对同一段文本的切分不同——这直接影响模型的输入表示和计算成本。

🤔 想一想

Tokenization 有个尴尬的问题：模型的所有"理解"都建立在 Token 级别，但人类思考是"词"级别甚至"概念"级别的。Token 和概念之间的鸿沟，是大模型"理解"的天然瓶颈——它永远在碎片上做推理，而不是在完整概念上。这也是为什么大模型会犯"拼写错误"——它在 Token 级别操作，不是字符级别。

🔗 顺着他想：Token 切出来了，但大模型只认数字——"大"怎么变成 234？这就是词表映射的事。

二、词表映射：文字和数字之间的翻译官

Tokenization 把"大模型真厉害"切成了[“大”,“模型”,“真”,“厉害”]，但大模型只认数字——"大"怎么变成 234？词表映射就是干这个的：每个 Token 对应一个唯一编号，文字和数字之间的翻译官。

词表映射解决的核心问题：大模型的输入输出都是向量（数字），但人类用文字交流。词表映射是文字和数字之间的桥梁——Token→编号→Embedding 向量，每一步都是"翻译"。

它到底在干嘛（机制层）：词表映射分三步。① 构建词表（Vocabulary）：训练 Tokenization 算法时，同时构建词表——一个从 Token 到编号的映射表。GPT-2 的词表有 50257 个 Token，编号从 0 到 50256。② Token→编号（Token ID）：每个 Token 查词表，得到唯一编号——“大”=234，“模型”=5678，“真”=890，“厉害”=12345。③ 编号→Embedding：编号不是直接输入模型的——它是一个索引，用来查 Embedding 矩阵。Embedding 矩阵的每一行是一个向量（如 768 维或 4096 维），这个向量才是模型真正处理的"数字表示"。关键点：编号是离散的（234 和 235 之间没有关系），Embedding 是连续的（相近的 Token 在向量空间中距离更近）。词表映射把离散的编号变成了连续的向量表示。

你能感受到什么（体感层）：Token→编号：“猫”=1024，“狗”=2048——1024 和 2048 之间没有任何语义关系，编号只是查表索引。编号→Embedding：查 Embedding 矩阵后，"猫"的向量 [0.3, -0.7, 0.1, …] 和"狗"的向量 [0.4, -0.6, 0.2, …] 在向量空间中距离很近——因为猫和狗语义相近。这就是词表映射的魔法：编号是任意的，但 Embedding 是学出来的——训练过程中，语义相近的 Token 会被"推"到向量空间中相近的位置。

🎛️ 动手感受：编号 vs Embedding 的语义关系

操作：取"猫"“狗”"汽车"三个 Token，分别看它们的 Token ID 和 Embedding 向量的余弦相似度。
你会看到：

Token ID：猫=1024，狗=2048，汽车=4096——ID 之间无语义关系。
Embedding 余弦相似度：猫-狗=0.85（高相似），猫-汽车=0.12（低相似）——Embedding 编码了语义。
变化说明了什么：词表映射的"编号"只是查表索引，真正的语义信息在 Embedding 里——训练让 Embedding 学会了"谁和谁像"。

🤔 想一想

词表大小是个两难选择：词表大→每个 Token 承载信息多→序列短→计算少，但 Embedding 矩阵大→参数多→显存占用高。词表小→Embedding 矩阵小→参数少，但序列长→计算多。GPT-4 选择了更大的词表（~100K），用更多的参数换更短的序列——在长上下文场景下，这个取舍是值得的。

🔗 顺着他想：Token 变成 Embedding 向量后，就进入了模型的"大脑"——但大模型有几千亿参数，每次推理都用全部参数吗？当然不是，MoE 让模型"大而省"。

三、MoE：大模型的智囊团

GPT-4 有一万亿参数，每次推理都用全部参数？那一张 A100 都跑不动。MoE（Mixture of Experts）的思路是：请一群专家，按需调用——每次推理只激活一小部分参数，省算力还能保效果。

MoE 解决的核心问题：模型越大越强，但越大越贵。MoE 让模型"大而省"——总参数很多（保证容量），但每次推理只激活一小部分（控制成本）。就像公司请了 8 个专家顾问，每次开会只叫 2 个相关的，不用 8 个全到场。

它到底在干嘛（机制层）：MoE 的核心是用参数量换计算量。传统密集模型（Dense Model）：每个 Token 经过所有参数的计算——1 万亿参数就做 1 万亿次运算。MoE 模型：把前馈网络（FFN）替换成多个"专家"（Expert）——每个 Expert 是一个独立的 FFN，输入 Token 只经过其中几个 Expert 的计算。MoE 的关键组件：Expert（专家）：多个并行的 FFN，每个 Expert 学不同的知识——Expert1 学语法，Expert2 学事实，Expert3 学推理。Router/Gating（门控/路由）：决定每个 Token 该去哪个 Expert——这是 MoE 的"调度中心"（下一篇详讲）。稀疏激活：每个 Token 只激活 Top-K 个 Expert（通常 K=1 或 2）——8 个 Expert 只激活 2 个，计算量只有密集模型的 25%。

你能感受到什么（体感层）：Dense 模型（7B 参数）：每个 Token 经过全部 7B 参数的计算——推理一次约 7B FLOPs。MoE 模型（总参数 46B，激活 7B）：总参数是 Dense 的 6.6 倍（容量更大），但每次只激活 7B（计算量相同）——效果接近 46B Dense 模型，成本接近 7B Dense 模型。Mixtral 8x7B 的实测：总参数约 46B，每次激活约 13B（2 个 Expert），效果接近 Llama-2 70B，推理成本只有 1/5。

🎛️ 动手感受：Dense vs MoE 的参数效率

操作：对比 Dense-7B 和 Mixtral-8x7B 在相同推理预算下的效果。
你会看到：

Dense-7B：推理 7B FLOPs，效果 7B 水平——中规中矩。
Mixtral-8x7B：推理约 13B FLOPs，效果接近 70B 水平——用 1/5 的计算量达到接近的效果。
变化说明了什么：MoE 的核心优势是"参数效率"——同样的计算预算，MoE 能装下更多知识，因为知识分布在多个 Expert 里，按需调用。

🤔 想一想

MoE 的 Expert 之间会不会"抢活"？如果所有 Token 都被路由到同一个 Expert，其他 Expert 就闲置了——这就是"负载不均衡"问题。MoE 训练时需要加负载均衡损失（Load Balancing Loss），强制每个 Expert 被均匀使用。但均匀使用不等于"每个 Expert 都学到了有用的知识"——有些 Expert 可能只是在"凑数"。

🔗 顺着他想：MoE 的关键是"按需调用"——谁决定"需求"是什么？门控网络，MoE 的调度中心。

四、门控网络：MoE的调度中心

MoE 有 8 个专家，每个 Token 该派给谁？门控网络（Gating Network）就是 MoE 的调度中心——看一眼输入，决定派哪个专家出马。就像医院的分诊台：看症状，决定挂哪个科。

门控网络解决的核心问题：MoE 的 Expert 需要一个"调度员"——决定每个 Token 该去哪个 Expert。门控网络就是这个调度员：输入一个 Token 的向量，输出每个 Expert 的"匹配分数"，选分数最高的 Top-K 个 Expert。

它到底在干嘛（机制层）：门控网络的核心是路由决策。流程分三步。① 计算匹配分数：Token 的向量经过一个线性层，输出 N 个分数（N=Expert 数量）——每个分数表示"这个 Token 和这个 Expert 的匹配程度"。② Softmax 归一化：把分数转成概率分布——所有 Expert 的概率加起来等于 1。③ Top-K 选择：选概率最高的 K 个 Expert（通常 K=1 或 2），按概率加权组合它们的输出。门控网络的训练挑战：负载均衡——如果门控网络总是选同一个 Expert，其他 Expert 就白训了。训练时需要加辅助损失（Auxiliary Loss），惩罚 Expert 使用不均匀的情况。抖动问题——门控网络的决策是离散的（选/不选），离散操作不可导，无法用梯度下降训练。解决方案：用 Softmax 近似（可导但不精确），或用直通估计器（Straight-Through Estimator，前向离散、反向连续）。

你能感受到什么（体感层）：好的门控网络：代码类 Token→路由到 Expert3（专精代码），数学类 Token→路由到 Expert7（专精数学），日常对话 Token→路由到 Expert1（专精语言）——每个 Token 都找到了最合适的专家。差的门控网络：所有 Token 都路由到 Expert1——Expert1 过载，其他 Expert 闲置，MoE 退化为 Dense 模型。门控网络的质量直接决定 MoE 的效果——路由错了，再好的 Expert 也白搭。

🎛️ 动手感受：门控网络的路由决策可视化

操作：输入不同类型的 Token（代码/数学/日常对话），看门控网络的路由决策。
你会看到：

代码 Token：Expert3 的匹配分数最高（0.72），被选中。
数学 Token：Expert7 的匹配分数最高（0.65），被选中。
日常对话 Token：Expert1 的匹配分数最高（0.58），被选中。
变化说明了什么：好的门控网络能自动识别 Token 的"类型"，路由到最合适的 Expert——这不是人工设计的，是训练出来的。

🤔 想一想

门控网络本身也有参数——如果门控网络太简单（一个线性层），路由决策可能不够精确；如果太复杂，又增加了计算开销和训练难度。门控网络的设计是 MoE 架构中最微妙的部分——它需要在"精确路由"和"计算效率"之间找平衡。

🔗 顺着他想：门控网络选了 Top-K 个 Expert，其他 Expert 怎么办？直接跳过——这就是稀疏激活，MoE 省算力的核心机制。

五、稀疏激活：四两拨千斤

8 个 Expert，每次只用 2 个——剩下 6 个在"睡觉"。稀疏激活就是让大部分参数"休眠"，只激活最相关的一小部分。四两拨千斤：用 25% 的计算量，达到 80% 的效果。

稀疏激活解决的核心问题：密集模型太贵——每个 Token 都经过全部参数的计算，算力和显存都扛不住。稀疏激活让大部分参数"休眠"，只激活最相关的一小部分——用更少的计算量，达到接近的效果。

它到底在干嘛（机制层）：稀疏激活的核心是选择性计算。MoE 的稀疏激活：每个 Token 只经过 Top-K 个 Expert 的计算——8 个 Expert 只激活 2 个，计算量是密集模型的 25%。但稀疏激活不只存在于 MoE——它是一种通用的"省算力"思想。MoE 的稀疏激活：在 Expert 维度做稀疏——选哪些 Expert 激活。Activation Sparsity（激活稀疏）：在神经元维度做稀疏——ReLU 本身就是一种稀疏激活（负值变零，约 50% 神经元被"关闭"）。条件计算（Conditional Computation）：在层维度做稀疏——根据输入跳过某些层（Early Exit、Layer Skipping）。稀疏激活的代价：GPU 利用率低——GPU 是为密集矩阵运算设计的，稀疏计算会导致大量"空洞"，实际加速比低于理论值。通信开销——分布式训练时，Token 被路由到不同 GPU 上的 Expert，需要跨 GPU 通信（All-to-All），通信延迟可能抵消计算节省。

你能感受到什么（体感层）：理论加速：8 个 Expert 激活 2 个→计算量是密集模型的 25%→4 倍加速。实际加速：GPU 稀疏计算效率低+跨 GPU 通信开销→实际加速约 2-3 倍。效果损失：稀疏激活的模型效果通常略低于同等参数量的密集模型——因为"休眠"的参数在推理时完全没用。权衡：用 10-20% 的效果损失，换 2-3 倍的推理加速——在大多数场景下，这个交易是值得的。

🎛️ 动手感受：不同稀疏度的效果-速度权衡

操作：对比 Top-1/Top-2/Top-4/全激活（Dense）在相同模型上的效果和推理速度。
你会看到：

Top-1：速度最快（4x 理论加速），效果损失最大（约 5-10%）。
Top-2：速度较快（2.5x 理论加速），效果损失适中（约 2-5%）——Mixtral 的选择。
Top-4：速度中等（1.5x 理论加速），效果损失很小（约 1%）。
Dense：速度基准，效果基准。
变化说明了什么：稀疏度是"速度-效果"的旋钮——Top-2 是当前的最佳平衡点。

🤔 想一想

稀疏激活的"省算力"只在推理阶段明显——训练阶段，所有 Expert 都需要被训练（即使每次只激活一部分），所以 MoE 的训练成本并不比 Dense 低，甚至更高（因为参数更多、通信更复杂）。MoE 的核心优势是"推理便宜"，不是"训练便宜"。

🔗 顺着他想：Token 切好了、数字映射好了、Expert 选好了——这些组件组装在一起，就是 Transformer，大模型的骨架。

六、Transformer：大模型的骨架

GPT、BERT、LLaMA、Claude——所有现代大模型都站在同一个架构上：Transformer。它不是某个模型的名字，是一个架构范式——就像"钢筋混凝土"不是某栋楼的名字，是所有摩天大楼的骨架。

Transformer 解决的核心问题：RNN 的序列依赖瓶颈——RNN 必须一个 Token 一个 Token 地处理，无法并行。Transformer 用自注意力（Self-Attention）替代循环（Recurrence），实现了完全并行计算——这是大模型能"大"起来的基础。

它到底在干嘛（机制层）：Transformer 的核心是注意力机制+前馈网络的堆叠。编码器（Encoder）：BERT 的架构——每一层包含 Self-Attention + FFN，输入序列每个位置同时计算注意力，捕获全局依赖。解码器（Decoder）：GPT 的架构——每一层包含 Masked Self-Attention + FFN，只能看到当前位置之前的 Token（因果注意力），保证自回归生成。编码器-解码器（Encoder-Decoder）：T5/BART 的架构——编码器处理输入，解码器生成输出，中间用 Cross-Attention 连接。Transformer 的关键创新：并行计算——Self-Attention 让所有位置同时计算，不像 RNN 必须顺序处理。全局依赖——每个位置可以直接关注序列中任何其他位置，不像 RNN 只能通过隐状态间接传递信息。可扩展性——堆叠更多层、更多头、更大 FFN，就能得到更大的模型——这个"堆叠"范式让模型规模从百万参数扩展到万亿参数。

你能感受到什么（体感层）：RNN 处理"大模型真厉害"：先处理"大"→带着隐状态处理"模型"→再处理"真"→最后处理"厉害"——4 步串行，无法并行。Transformer 处理"大模型真厉害"：4 个 Token 同时输入，Self-Attention 同时计算所有位置之间的关系——1 步并行。代价：Self-Attention 的计算复杂度是 O(N²)——序列长度 N 翻倍，计算量翻 4 倍。这也是为什么长上下文（100K+ Token）是大模型的硬挑战。

🎛️ 动手感受：RNN vs Transformer 的并行性

操作：同一个序列，分别用 RNN 和 Transformer 处理，对比计算时间和可并行性。
你会看到：

RNN：4 个 Token 串行处理，GPU 利用率低（大量空闲核心），总时间 = 4 × 单步时间。
Transformer：4 个 Token 并行处理，GPU 利用率高（所有核心同时工作），总时间 ≈ 1 × 单步时间。
变化说明了什么：Transformer 的"快"不是因为单步计算少，是因为能并行——GPU 的并行计算能力被充分利用。

🤔 想一想

Transformer 的 O(N²) 注意力复杂度是它的阿喀琉斯之踵——序列越长，计算量增长越快。Flash Attention、稀疏注意力、线性注意力等方案都在试图解决这个问题，但到目前为止，没有任何方案能在"精确+高效"两个维度同时超越标准 Attention。长上下文的计算成本，是大模型架构的下一个突破口。

🔗 顺着他想：Transformer 的核心是 Self-Attention——它让每个位置都能"看到"其他所有位置。但"看到"不等于"关注"——Attention 机制决定每个位置该"关注"谁，这就是大模型的心脏。

七、Attention：大模型的心脏

“大模型真厉害”——当你读到"厉害"时，你的大脑自动关联到"大模型"，而不是"真"。Attention 机制做的就是这件事：让模型在处理每个 Token 时，知道该"关注"序列中的哪些其他 Token。这是大模型理解上下文的核心能力。

Attention 解决的核心问题：如何让模型在处理每个位置时，动态地关注序列中的相关位置。传统方法（RNN/CNN）的信息传递是"固定路径"的——RNN 只能通过隐状态传递，CNN 只能在局部窗口内传递。Attention 让每个位置可以直接"看"到序列中任何其他位置，并按相关性加权——信息传递路径是动态的、数据驱动的。

它到底在干嘛（机制层）：Self-Attention 的核心是QKV 机制。每个 Token 生成三个向量：Query（Q）：“我在找什么”——当前 Token 的查询向量。Key（K）：“我有什么”——每个 Token 的键向量。Value（V）：“我的内容是什么”——每个 Token 的值向量。计算流程：① 计算注意力分数：当前 Token 的 Q 和所有 Token 的 K 做点积——分数越高，两个 Token 越相关。② Softmax 归一化：把分数转成权重（加起来=1）——权重表示"当前 Token 应该关注每个其他 Token 的程度"。③ 加权求和：用权重对 V 加权求和——得到当前 Token 的新表示，融合了序列中所有相关 Token 的信息。多头注意力（Multi-Head Attention）：不是做一次 Attention，而是做 H 次（如 8 头、32 头）——每个头学不同的"关注模式"（一个头关注语法关系，另一个头关注语义关系），最后拼接所有头的结果。

你能感受到什么（体感层）：处理"厉害"时：Q（厉害）和 K（大模型）的点积很高→Attention 权重大→"厉害"的新表示融合了大量"大模型"的信息→模型理解"厉害"修饰的是"大模型"。处理"真"时：Q（真）和 K（厉害）的点积较高→"真"融合了"厉害"的信息→模型理解"真"是"厉害"的副词修饰。没有 Attention：每个 Token 只知道自己的信息，不知道上下文——"厉害"可以是厉害任何东西。有 Attention：每个 Token 的表示融合了上下文信息——“厉害"知道自己在修饰"大模型”。

🎛️ 动手感受：Attention 权重可视化

操作：输入"大模型真厉害"，可视化"厉害"这个 Token 对所有其他 Token 的 Attention 权重。
你会看到：

“厉害"→"大模型”：权重 0.65（最高）——“厉害"主要关注"大模型”。
“厉害"→"真”：权重 0.20——“厉害"也关注修饰词"真”。
"厉害"→自身：权重 0.15——每个 Token 也会关注自己。
变化说明了什么：Attention 权重直接反映了"谁和谁相关"——可视化 Attention 是理解模型行为的最直观方式。

🤔 想一想

Attention 权重高≠因果性强——“厉害"高度关注"大模型”，但这不意味着"大模型"导致了"厉害"。Attention 反映的是"相关性"，不是"因果性"。把 Attention 权重当作"模型推理的证据"是有风险的——它会误导你对模型决策的理解。

🔗 顺着他想：7 个组件串起来，就是大模型从"文本输入"到"理解输出"的完整链路——下一篇我们讲大模型的训练过程：预训练、微调、RLHF，看这些组件是怎么被"炼"出来的。

八、一张图串起大模型架构链路

7 个组件串成一条从"文本输入"到"理解输出"的完整链路：

文本输入："大模型真厉害" │ ① Tokenization ← 切碎片：["大","模型","真","厉害"] │ ② 词表映射 ← 变数字：[234, 5678, 890, 12345] → Embedding向量 │ ③ Transformer ← 搭骨架：多层堆叠的注意力+前馈网络 │ │ │ ├── Attention ← 跳心脏：每个Token动态关注相关Token │ │ │ └── FFN(MoE) ← 请专家：多个Expert按需调用 │ │ │ ├── 门控网络 ← 做调度：决定Token去哪个Expert │ │ │ └── 稀疏激活 ← 省算力：只激活Top-K个Expert │ └── 输出：下一个Token的概率分布

架构口诀：

Tokenization切碎片——文本变 Token，大模型才认。
词表映射变数字——Token 变 Embedding，语义才编码。
MoE请专家——参数多但激活少，大而省。
门控网络做调度——看一眼输入，派最合适的专家。
稀疏激活省算力——8 个 Expert 只用 2 个，四两拨千斤。
Transformer搭骨架——注意力+前馈的堆叠，并行计算的基础。
Attention跳心脏——QKV 机制，决定每个 Token 关注谁。

九、代码：Tokenization + MoE 简化实现

importtorchimporttorch.nnasnnimporttorch.nn.functionalasF# ① 简化版 BPE TokenizerclassSimpleTokenizer:def__init__(self):# 简化词表：实际GPT词表有50257个Tokenself.vocab={"大":1,"模型":2,"真":3,"厉害":4,"不":5,"过":6,"如此":7,"[PAD]":0}self.id_to_token={v:kfork,vinself.vocab.items()}defencode(self,text:str)->list:# 简化：按词表最大匹配切分tokens,i=[],0whilei<len(text):matched=Falseforlengthinrange(min(4,len(text)-i),0,-1):chunk=text[i:i+length]ifchunkinself.vocab:tokens.append(self.vocab[chunk])i+=length matched=Truebreakifnotmatched:tokens.append(0)# [UNK]i+=1returntokensdefdecode(self,ids:list)->str:return"".join(self.id_to_token.get(i,"[UNK]")foriinids)# ② 稀疏MoE层classMoELayer(nn.Module):def__init__(self,dim=64,num_experts=4,top_k=2):super().__init__()self.num_experts=num_experts self.top_k=top_k# 门控网络self.gate=nn.Linear(dim,num_experts)# 多个Expert（每个是一个FFN）self.experts=nn.ModuleList([nn.Sequential(nn.Linear(dim,dim*4),nn.ReLU(),nn.Linear(dim*4,dim))for_inrange(num_experts)])defforward(self,x):# x: [batch, seq_len, dim]gate_scores=self.gate(x)# [batch, seq, num_experts]gate_probs=F.softmax(gate_scores,dim=-1)topk_vals,topk_idx=gate_probs.topk(self.top_k,dim=-1)# 选Top-K# 稀疏计算：只经过被选中的Expertoutput=torch.zeros_like(x)forkinrange(self.top_k):expert_idx=topk_idx[:,:,k]# [batch, seq]weight=topk_vals[:,:,k:k+1]# [batch, seq, 1]foreinrange(self.num_experts):mask=(expert_idx==e).unsqueeze(-1).float()# [batch, seq, 1]ifmask.sum()>0:expert_out=self.experts[e](x)# 全部Token都过Expertoutput+=expert_out*mask*weight# 只保留被选中的Tokenreturnoutput# ③ 演示tokenizer=SimpleTokenizer()ids=tokenizer.encode("大模型真厉害不过如此")print(f"Token IDs:{ids}")print(f"Decoded:{tokenizer.decode(ids)}")moe=MoELayer(dim=64,num_experts=4,top_k=2)x=torch.randn(1,len(ids),64)out=moe(x)print(f"MoE输入:{x.shape}→ 输出:{out.shape}")print(f"激活比例:{2}/{4}= 50% (稀疏激活)")

这段代码实现了 Tokenization（最大匹配分词）和 MoE（稀疏 Expert 激活）的核心逻辑。生产环境要做的升级：用 BPE/SentencePiece 替换简化分词、加 Embedding 层、加多头注意力、加负载均衡损失。

写到最后

7 个组件，从 Tokenization 的"切碎文本"到 Attention 的"动态关注"，串起来就是大模型从"文本输入"到"理解输出"的完整链路。Tokenization 是消化系统，词表映射是翻译官，MoE 是智囊团，门控网络是调度中心，稀疏激活是省算力的秘密，Transformer 是骨架，Attention 是心脏——每个组件各司其职，缺一不可。

下一篇我们讲大模型的"炼成"过程——预训练、微调、RLHF，看这些组件是怎么从零开始被训练出来的。

如果你读下来觉得真有用：