Gemma开源模型：轻量化训练与部署

可视化演示

交互展示Google Gemma的知识蒸馏机制、MQA多查询注意力架构和轻量部署策略，理解开源轻量模型的核心技术。

模型概览

山门口，方丈 Gemini 为两位弟子送行。大弟子 Gemma 7B 抱拳道：师傅，弟子此去坐镇机房，必不负所托。小弟子 Gemma 2B 身轻如燕，笑道：弟子愿随手机主人走街串巷，时刻守护。方丈点头：你们武功来自为师一身所学，却无需为师亲至。这正是 Gemma 系列与 Gemini 的关系——不是把千亿参数的身躯复制一份，而是把毕生功力浓缩进两个更轻便的躯体。

2024 年 2 月，Google 正式开源 Gemma——一个基于 Gemini 核心技术训练的轻量语言模型家族。家族有两位成员：Gemma 2B 和 Gemma 7B。参数规模里的“B“是 billion（十亿）的缩写，2B 意味着模型约有 20 亿个参数。参数量直接决定了模型跑起来的”饭量”——显存占用。大多数推理框架用 fp16（半精度浮点）加载权重，每个参数占 2 字节，因此权重显存可以估算为：

$$\displaystyle M = N \times b$$

其中 N 为参数量（单位：十亿），b 为每个参数占的字节数（fp16 下 b=2）。

1. N 是参数量：以十亿为单位计数，Gemma 2B 即 N=2，7B 即 N=7。

$$\displaystyle N \in \{2, 7\}$$

2. b 是字节数：fp16 精度下每个参数占 2 字节，这是推理时权重的“体重”。

$$\displaystyle b_{\mathrm{fp16}} = 2$$

3. M 是显存估算：两者相乘得到权重占用，几十亿参数乘以 2，换成 GB。

$$\displaystyle M = N \times b$$

于是 Gemma 7B 权重约需 14GB 显存，适合单张 A100 乃至高端消费级显卡；Gemma 2B 仅约 4GB，一般智能手机的 NPU 已能承载。轻量，不是牺牲智慧，而是让智慧能跑进更小的舞台。大徒弟坐镇云端，小徒弟贴身端侧，两人各得其所——但身板这么小，他们又是怎么练成师傅的本事的？

知识蒸馏

方丈让两位弟子站在演武场边，观摩自己与各路高手过招。同样是起手式，面对瘦子要“三分力七分巧”，面对胖子要“七分力三分巧”——这种分寸感，口诀书上写不出来。若只背口诀（硬标签），弟子学到的是一堆死招式；若领悟师傅出招时那微妙的力度分配（软标签），才算学到精髓。

在机器学习里，大模型（教师）对每个样本会输出一个概率分布。比如识别一张图，教师不仅给出“猫 90%”，还会给出“老虎 6%、豹 3%”。那 10% 的“尾巴”里藏着“猫和老虎是近亲”的知识。硬标签只保留 90% 的结论，软标签则把知识纹理完整保留下来。为了让软标签在训练时更“可教”，蒸馏方法引入了一个温度 T 来调节分布的平滑度：

$$\displaystyle p_i = \frac{\exp(z_i / T)}{\sum_{j=1}^{V} \exp(z_j / T)}$$

1. z_i 是 logit：教师模型对第 i 个类别的原始打分，可以是正数也可以是负数。

$$\displaystyle z_i \in \mathbb{R}$$

2. 除以温度 T：每个 logit 先除以 T，T 越大，分数之间的差距被压得越小，分布越平缓。

$$\displaystyle \tilde{z}_i = z_i / T, \quad T > 0$$

3. 指数归一化：softmax 把软化后的分数变成概率，所有类别概率之和为 1。

$$\displaystyle p_i = \frac{e^{\tilde{z}_i}}{\sum_{j=1}^{V} e^{\tilde{z}_j}}$$

学生模型的完整训练目标，是“像教师”与“忠于事实”的加权组合：

$$\displaystyle L = \alpha \cdot \mathrm{KL}\left(p^{(T)} \parallel q^{(T)}\right) + (1 - \alpha) \cdot \mathrm{CE}(y, q)$$

1. p^(T) 与 q^(T)：教师和学生分别在温度 T 下软化后的输出分布，即两份“心法”。

$$\displaystyle p^{(T)}, \ q^{(T)} \in \Delta^{V-1}$$

2. KL 散度项：衡量学生分布与教师分布的差异，差异越小，学生越像师傅。

$$\displaystyle \mathrm{KL}(p \parallel q) = \sum_i p_i \log \frac{p_i}{q_i}$$

3. CE 交叉熵项：让学生不要偏离真实标签（标准答案）太远。

$$\displaystyle \mathrm{CE}(y, q) = -\sum_i y_i \log q_i$$

4. α 权重系数：在“传承师傅”与“尊重事实”之间取平衡，通常取 0.5~0.9。

$$\displaystyle 0 \le \alpha \le 1$$

Gemma 的训练正是如此：Gemini 作为教师，把软标签“递”给 2B/7B 学生模型，让学生的小身板学会大模型的判断纹理——体重未增，境界大不一样。这也解释了为什么蒸馏后的 Gemma 在同样参数量下，比从零训练的小模型聪明得多。

多查询注意力

武馆里的普通弟子，每人各记一本厚厚的《对手招式图鉴》，出招时翻自己那本；Gemma 弟子却不同——所有人共用一本图鉴。有人担心：大家都看同一本书，会不会理解各自乱套？不会，因为图鉴（Key-Value）是公共的，而每个人“关注招式的角度”（Query）仍然不同。

Transformer 的自注意力公式本身很简洁：

$$\displaystyle \mathrm{Attention}(Q,K,V) = \mathrm{softmax}\left(\frac{QK^\top}{\sqrt{d_k}}\right) V$$

标准多头注意力让每个头拥有独立的 K、V 投影矩阵，等于每人一本笔记；而多查询注意力（MQA）做了一个小而巧的改动——只保留一组共享的 K、V 投影，所有查询头共用：

$$\displaystyle \mathrm{head}_i = \mathrm{Attention}(Q W_i^Q,\ K W^K,\ V W^V)$$

1. Q、K、V 的含义：Q 是当前词的“查询视角”，K 是每个词的“标签”，V 是每个词的“内容”。

$$\displaystyle Q, K, V \in \mathbb{R}^{\text{seq} \times d}$$

2. 共享 W^K、W^V：多个头 i=1……h 共用同一组 Key 和 Value 的投影矩阵，KV 缓存只需保存一份。

$$\displaystyle W^K, W^V \in \mathbb{R}^{d \times d_v}$$

3. Q 仍独立投影：每个头的查询视角 W_i^Q 各不相同，保证关注模式多样。

$$\displaystyle W_i^Q \in \mathbb{R}^{d \times d_q}$$

推理时，模型每生成一个新 token 都要把 K、V 缓存下来供后续使用。标准多头要缓存 h 份 KV，MQA 只要 1 份，显存直接节省 (h−1)/h——以 8 头计算就是省下 87.5%。Gemma 2B/7B 都采用 MQA 架构，这让它们做长文本对话时显存压力远小于同规模传统模型。共享一本图鉴，不仅省了行囊，翻页也更快；少背书，出招自然快，推理的吞吐量也随之提升。

旋转位置编码

习武之人讲求站位。同样是冲拳，站在对手正前方和侧方，威胁完全不同。语言也是如此——“你先说”和“我先说”含义天差地别。但自注意力本身对词的先后顺序没有感知，必须额外给每个词“标站位”。

Gemma 采用的旋转位置编码（RoPE）极其优雅：把位置信息编码成一个“旋转角度”，让词向量在特征空间里转个身。对每个二维子空间，定义旋转矩阵：

$$\displaystyle \mathbf{R}(m) = \begin{bmatrix} \cos m\theta & -\sin m\theta \\ \sin m\theta & \cos m\theta \end{bmatrix}$$

1. m 是位置下标：当前词在序列中的位置，从 0 开始计数。

$$\displaystyle m \in \{0, 1, 2, \dots\}$$

2. θ 是旋转基频：不同维度用不同的角度步长，维度越高旋转越慢，负责捕捉不同尺度的距离关系。

$$\displaystyle \theta_i = 10000^{-2i/d}$$

3. R(m) 是旋转矩阵：将向量在二维平面内顺时针旋转 mθ 弧度，等于给位置装上了“方向盘”。

RoPE 最巧妙的性质在于：两个词各自旋转后做内积，结果恰好只依赖它们的相对位置：

$$\displaystyle q_m^\top k_n = \left(\mathbf{R}(m)q\right)^\top \left(\mathbf{R}(n)k\right) = q^\top \mathbf{R}(n-m)k$$

1. 分别旋转 q 和 k：位置 m 的词向量 q 乘 R(m)，位置 n 的 k 乘 R(n)。

$$\displaystyle q_m = \mathbf{R}(m)q, \quad k_n = \mathbf{R}(n)k$$

2. 旋转矩阵的合并：正交旋转满足 R(m)ᵀR(n)=R(n−m)，内积中两个旋转合并成一个相对旋转。

$$\displaystyle \mathbf{R}(m)^\top \mathbf{R}(n) = \mathbf{R}(n-m)$$

3. 相对位置信息：点积结果只包含 n−m，模型无法获得绝对坐标，但天然感知“两词之间隔了多少距离”。

$$\displaystyle q_m^\top k_n = f(q, k, n-m)$$

RoPE 是相对位置编码，天然支持超出训练长度的外推；它直接作用在注意力点积上，不需要额外学习位置嵌入表。弟子们的“旋转步法”让其在陌生场地也能精确走位——练武场换成十里长街（长序列），步法依然不乱，这正是外推能力的写照。

训练技术

方丈的弟子也不是一出生就天下无敌。从入门到出师，需要一套系统的修炼规划：先读万卷书（预训练），领受内功心法（知识蒸馏），再被师傅逐招纠正（监督微调），最后与人对练积累实战经验（RLHF）。Gemma 的诞生，正是这样一条流水线。

首先是预训练阶段。Gemma 从互联网、代码、论文等海量文本中筛选高质量语料，语料规模达到数万亿 token，同时做了严格的语言比例平衡、去重和毒性过滤——相当于师傅亲自挑选书单，绝不让学生读乱七八糟的书。在预训练后期，Gemini 教师模型的软标签开始注入训练，知识蒸馏贯穿了模型成型的最后阶段。

随后是监督微调（SFT），让模型学会“人类希望它怎么回答”。SFT 的标准损失函数是自回归交叉熵：

$$\displaystyle L_{\mathrm{SFT}} = -\sum_{t=1}^{T} \log p_\theta\left(y_t \mid y_{<t}, x\right)$$

1. x 是输入指令：相当于师傅出的题目，模型要回答正确的内容。

$$\displaystyle x = \text{用户输入的提示}$$

2. y_{<t} 是已生成的词：模型根据已经写出的前缀，逐个预测下一个词。

$$\displaystyle y_{<t} = (y_1, \dots, y_{t-1})$$

3. log p_θ 是预测概率：模型给“正确答案”打分，分数越高，损失越小。

$$\displaystyle p_\theta(y_t \mid y_{<t}, x) \in (0,1)$$

4. 求和取负号：把每个词的损失加起来并取相反数，让“越准”对应“损失越低”。

$$\displaystyle L_{\mathrm{SFT}} \to \min$$

最后还要用 RLHF（基于人类反馈的强化学习）微调，让模型的回答风格和价值观更符合人类偏好。这套“预训练 + 蒸馏 + SFT + RLHF”的组合拳打下来，两位弟子不仅武功高强，而且品行端正；炉火纯青之日，便是下山之时。

部署实践

出师这天，弟子们要打点行囊。小弟子 2B 要去手机里长期驻守，行囊能省一分是一分；大弟子 7B 去服务器，条件虽然好些，也要精打细算。部署的第一件事是“减肥”——量化。

Gemma 2B 默认 fp16 权重约 4GB，手机装不下。把权重从 fp16（2字节）压到 int8（1字节）甚至 int4（0.5字节）后，显存立刻大幅缩水。量化后的权重显存仍可用同一把尺子估算：

$$\displaystyle M = N \times b, \quad b_{\mathrm{int8}} = 1, \ b_{\mathrm{int4}} = 0.5$$

1. N 仍是参数量：以十亿为单位，2B 即 N=2。

$$\displaystyle N = 2.0$$

2. b 随量化变小：int8 每个参数 1 字节，int4 每个参数 0.5 字节。

$$\displaystyle b_{\mathrm{int4}} = 0.5$$

3. M 缩小到可落地：Gemma 2B 用 int4 后约 1GB，手机本地离线运行成为现实。

$$\displaystyle M \approx 2 \times 0.5 = 1\ \mathrm{GB}$$

实际部署中，Gemma 2B 可借助 MediaPipe LLM Inference API 嵌入 Android/iOS 应用，数据不出设备，离线也能对话；Gemma 7B 则可用 vLLM、llama.cpp 等开源推理框架部署在单卡或 CPU 服务器上。配合 MQA 带来的低 KV 缓存开销，长文本生成的吞吐量明显优于同规模传统模型。小徒弟贴身随行，大徒弟坐镇云端——轻装下山，行囊不过一两个 G，这便是轻量模型的江湖路。

生态意义

从前，Google 的武林绝学从不外传，那些顶尖模型只能远观。Gemma 开源，等于方丈决定开山立派，广纳门徒——这在 AI 开源江湖中，是浓墨重彩的一笔。

Gemma 的发布填补了 Google 系在开源大模型领域的长期空白。此前 Meta 有 Llama 系列一呼百应，而 Google 一直以闭源的 PaLM、Gemini 示人；开发者想要“Google 正统心法”，只能付费调用云端 API。Gemma 出现后，社区第一次可以在开源世界用上源自 Gemini 的模型——而且直接给了 2B 和 7B 两种尺寸。

随之而来的是整个生态的连锁反应：Hugging Face 上出现大量 Gemma 微调版本；LangChain、LlamaIndex 等工具链原生支持；Keras 官方教程将 Gemma 作为教学主力；多家手机厂商在端侧芯片上适配 Gemma 2B。在 MMLU、GSM8K 等基准上，Gemma 7B 用 7B 的体量追平了数年前百亿级模型的表现——小身材，真功夫。江湖因此热闹：开源武林多了一个讲究“轻量与传承”的派系，而每一份微调权重、每一篇部署教程，都在把方丈的心法变成天下人的内功。强者的价值，从来不在闭门造车，而在传承与普惠。

AI 应用场景

Python 演示

import numpy as npfrom sklearn.datasets import make_moonsfrom sklearn.model_selection import train_test_split  def softmax(z):    # numerically stable softmax, z: (n_samples, n_classes)    e = np.exp(z - z.max(axis=1, keepdims=True))    return e / e.sum(axis=1, keepdims=True)  class TeacherNet:    # plays the role of a large teacher model (two-layer MLP)    def __init__(self, n_in=2, n_hid=64, n_out=2, seed=1):        rng = np.random.default_rng(seed)        self.w1 = rng.normal(0, 0.2, (n_in, n_hid))        self.b1 = np.zeros(n_hid)        self.w2 = rng.normal(0, 0.2, (n_hid, n_out))        self.b2 = np.zeros(n_out)     def predict(self, x, temperature=3.0):        h = np.tanh(x @ self.w1 + self.b1)        logits = h @ self.w2 + self.b2        return softmax(logits / temperature)  # distill soft labels  class StudentNet:    # plays the role of a small student model (single-layer softmax)    def __init__(self, n_in=2, n_out=2, seed=2):        rng = np.random.default_rng(seed)        self.w = rng.normal(0, 0.1, (n_in, n_out))        self.b = np.zeros(n_out)     def forward(self, x):        return softmax(x @ self.w + self.b)     def update(self, x, target, lr=0.3):        prob = self.forward(x)        grad = (prob - target) / len(x)  # soft CE gradient        self.w -= lr * x.T @ grad        self.b -= lr * grad.sum(axis=0)  def build_data(n=300, seed=0):    x, y = make_moons(n_samples=n, noise=0.25, random_state=seed)    y_onehot = np.eye(2)[y]    return train_test_split(x, y, y_onehot, test_size=0.3, random_state=seed)  def main():    x_train, x_test, y_train, y_test, y_train_hot, _ = build_data()    teacher = TeacherNet()    soft_targets = teacher.predict(x_train, temperature=3.0)     st_hard = StudentNet()    st_soft = StudentNet()    for _ in range(300):        st_hard.update(x_train, y_train_hot)        st_soft.update(x_train, soft_targets)     acc_hard = (st_hard.forward(x_test).argmax(1) == y_test).mean()    acc_soft = (st_soft.forward(x_test).argmax(1) == y_test).mean()    print("student A (hard label)  test acc: %.3f" % acc_hard)    print("student B (soft label)  test acc: %.3f" % acc_soft)  if __name__ == "__main__":    main()

1. soft_targets = teacher.predict(x_train, temperature=3.0)教师模型在温度 3.0 下输出软标签，保留类别间的相似度信息
2. return softmax(logits / temperature)先除以温度再 softmax，这是蒸馏的标准“软标签生成”写法
3. st_soft.update(x_train, soft_targets)学生直接以软概率分布为学习目标，等价于蒸馏损失中的教师项
4. grad = (prob - target) / len(x)softmax 回归的交叉熵梯度；目标为软分布时梯度更平滑，学习过程更稳
5. acc_hard = (st_hard.forward(x_test).argmax(1) == y_test).mean()用测试集准确率对比硬标签与软标签训练的差距

常见误区

面试题