想象一下，你的小区要办一场新年联欢会，楼委会主任挨家挨户收集糖果，准备混成一大袋“团圆糖”。每户人家都愿意贡献一把自己珍藏的糖果，但谁心里都犯嘀咕：主任要是偷看了我家糖罐，岂不是全楼都知道我爱吃什么口味了？联邦学习面临的问题，跟这场联欢会一模一样——几十上百个参与方（手机、医院、银行）在不交出原始数据的前提下协作训练模型，而中央服务器只能看到所有模型更新加在一起的结果，绝不能看到任何单独一方的贡献。安全聚合（Secure Aggregation），就是为这场“混糖仪式”设计的一整套密码学流程。本文会用“楼委会混糖”这个故事，带你从秘密共享、密钥协商这些地基工具开始，一路看懂成对掩码、同态加密、差分隐私这些真实协议里的核心构件，最后看看工程上怎么做通信优化和性能评估。读完你就能理解：为什么说安全聚合是联邦学习隐私保护的“门锁”，而差分隐私是它旁边的那道“烟幕”。

岗位关联

对 AI 从业者而言，安全聚合是你设计联邦学习系统时绕不开的隐私底座。理解它的密码学原理与工程取舍，你才能做出既保护参与者数据、又跑得动的真实方案——这正是隐私计算方向算法工程师的核心竞争力。

目录
  1. 可视化演示
  2. 安全聚合概述
  3. 密码学基础
  4. 成对掩码机制
  5. 同态加密应用
  6. 差分隐私结合
  7. 通信开销优化
  8. 性能评估
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

动态演示联邦学习怎么安全聚合？加密协的核心机制，通过开始/执行/监控/完成四种模式展示关键概念与交互流程。

本节配有交互动效（进入视口后自动加载，约 3KB）。

联邦学习怎么安全聚合？加密协：联邦学习 联邦学习中安全聚合的问题与目标 安全聚合的密码学基础与掩码机制 核心机制可视化 联邦学习怎么安全聚合？加密协整体架构与关键组件

安全聚合概述

欢乐谷小区要办新年联欢会，楼委会主任挨家挨户收糖，准备混成一大袋“团圆糖”。每家都捧出一小把糖果，可谁都先问了同一个问题：“主任，您能保证不偷看我家糖罐里的口味吗？”主任拍着胸脯说只看混合结果。可邻居们心里明白：主任每天经手那么多户的糖，万一他偷偷记下某一家糖的颜色、形状、产地，联欢会还没开始，这家人爱吃什么口味就成了全楼皆知的秘密。

联邦学习就是这场联欢会。手机键盘、医院病历、银行流水这些数据就像各家的糖果，绝不能离开本地。参与方在本地训练模型，把每一轮更新得到的梯度（模型想往哪个方向调整的“建议”）上传给中央服务器，服务器把这些梯度平均后发回，大家再继续下一轮。听起来数据没出本地，很安全——但梯度不是一堆无意义的数字，研究者已经证明：从梯度可以反推出训练样本，甚至还原出用户的照片或病历片段。让服务器拿到明文梯度，等于把自家糖罐原封不动递给主任。

所以我们需要安全聚合（Secure Aggregation）：一组参与方各自持有梯度 $x_i$，经过协议交互后，服务器只能得到总梯度，而看不到任何单独的梯度。威胁模型通常假设服务器是“诚实但好奇”的——它不会篡改数据或拒绝服务，但会想尽办法从它收到的信息里推断隐私；同时协议还要容忍一部分参与方中途掉线，好比联欢会当天总有两三户临时不能来，糖还得照常混、总量还得算得出。

安全聚合的承诺，就像楼委会主任终于端上来的那袋团圆糖：你尝得出整栋楼的口味分布，却指不出任何一颗糖来自哪一家。接下来要讲的每一套密码学工具，都是在给这个承诺打地基——凭证、暗号、面粉，一件件搭起来。

y=∑i∈Uxi\displaystyle y = \sum_{i \in \mathcal{U}} x_i
服务器最终只学会这“一袋糖”的总和 $y$，而不是任何一户的糖 $x_i$。安全聚合的目标，就是把这一行等式变成现实。
  1. 参与方集合$\mathcal{U}$ 表示本轮参与训练的 $N$ 个客户端集合，对应联欢会上每户人家。
    U={1,2,…,N}\mathcal{U} = \{1, 2, \dots, N\}
  2. 单方梯度$x_i$ 是第 $i$ 个客户端的本地梯度向量，是模型更新的方向与幅度。
    xi∈Rd,i∈Ux_i \in \mathbb{R}^{d}, \quad i \in \mathcal{U}
  3. 聚合目标服务器最终只学会总梯度 $y$，无法从 $y$ 中分离出任意一个 $x_i$。
    y=∑i∈Uxiy = \sum_{i \in \mathcal{U}} x_i

密码学基础

混糖仪式要想保密，得先有两样工具。第一样是“分糖凭证”：每户把自家糖谱拆成若干小纸包，分发给不同的邻居保管，并约定——只有凑齐其中任意 $k$ 个纸包的人，才能拼出完整的糖谱。第二样是“邻里暗号手册”：每两户人家私下对一句只有彼此听懂的暗号，往后他们就能凭这句话各自变出一模一样的“和面口令”，别人听了也白听。

这两样工具正是安全聚合的两块地基：秘密共享（Secret Sharing）和密钥协商（Key Exchange）。秘密共享在安全聚合中的角色是“掉线保险丝”：每个参与方把它用来生成掩码的随机种子拆成多份，分发给其他参与方。万一它中途掉线，在线的人凑齐足够份额就能重建种子，替它把掩码抵消干净。密钥协商则让每对参与方在不安全的信道上取得共享随机种子——安全聚合里所有成对掩码，都从这些种子长出来。

最经典的秘密共享是 Shamir 方案：选择一个秘密 $s$（例如随机种子），随机生成 $k-1$ 个系数，构造一个 $k-1$ 次多项式，然后把多项式上的若干个点分给不同参与方。任意 $k$ 个参与方凑在一起，就能用拉格朗日插值唯一恢复这个多项式，算出常数项 $s$；而少于 $k$ 个点时，方程个数不足，$s$ 在数学上完全不可确定。密钥协商则常用 Diffie-Hellman：双方交换公开参数后各自算出同一个共享值作为种子，全程不传种子本身。

有了凭证和暗号，每户人家晚上关起门来，开始在自家糖罐上写写画画——准备面粉的工作，这就开始了。这些工具本身不直接混糖，但它们是后面一切魔术的原料。

f(x)=s+a1x+a2x2+⋯+ak−1xk−1,s=f(0)=∑i=1kf(xi)∏j=1j≠ik−xjxi−xj\displaystyle f(x) = s + a_1 x + a_2 x^{2} + \cdots + a_{k-1} x^{k-1}, \qquad s = f(0) = \sum_{i=1}^{k} f(x_i) \prod_{\substack{j=1 \\ j \neq i}}^{k} \frac{-x_j}{x_i - x_j}
一个秘密被藏在一条 $k-1$ 次多项式曲线里，每个人只拿到曲线上的一个点。单独一个点毫无意义，凑齐 $k$ 个点，这条曲线就被唯一确定，秘密随之现身。
  1. 构造多项式随机选取系数 $a_1, \dots, a_{k-1}$，把秘密 $s$ 作为常数项埋进多项式。
    f(x)=s+∑t=1k−1atxtf(x) = s + \sum_{t=1}^{k-1} a_t x^{t}
  2. 分发份额每个参与方拿到一个点 $(x_i, f(x_i))$，单独看无法反推 $f$。
    sharei=(xi,f(xi)),i=1,…,n\text{share}_i = (x_i, f(x_i)), \quad i = 1, \dots, n
  3. 拉格朗日插值任意 $k$ 个点唯一确定该多项式，代入 $x=0$ 即还原秘密。
    s=∑i=1kf(xi)∏j≠i−xjxi−xjs = \sum_{i=1}^{k} f(x_i) \prod_{j \neq i} \frac{-x_j}{x_i - x_j}

成对掩码机制

联欢会前一天晚上，301 和 302 隔着阳台对上了暗号，各自在家炮制了一份“反向面粉”：301 往自家糖罐里撒 $+m$ 克，302 往自家糖罐里撒 $-m$ 克。第二天罐子送进大缸，主任倒下去一搅——$+m$ 和 $-m$ 撞在一起消失得无影无踪，缸里只剩两种糖的真实重量。可要是主任中途偷开某只罐子呢？他只会看到一小堆裹满面粉、面目全非的糖。

这就是成对掩码（pairwise masking）的核心思路，也是 Google Secure Aggregation 协议的主心骨。每个参与方 $i$ 与每个邻居 $j$ 共享一个随机种子，并用伪随机数生成器（PRG）把种子扩展成与梯度等长的掩码向量 $s_{ij}$。上传前，参与方在本地梯度上做一次“和面”：对编号比自己小的邻居加掩码，对编号比自己大的邻居减掩码。最后每个参与方发给服务器的，都是“面带面粉”的更新向量。

服务器收到所有更新后只做一次加法。因为 $s_{ij}$ 和 $s_{ji}$ 由同一把种子生成、方向相反，它们在总和中精确抵消，服务器得到真实梯度总和。一个显而易见的麻烦是掉线：如果 301 没来，它的 $+m$ 没人抵消，总糖量就偏了。解决办法是把生成掩码的种子用 Shamir 秘密共享切开分给所有人——掉线时，在线参与方用各自份额重建种子，在本地把掉线方的掩码补上。这也是为什么秘密共享被称为掩码方案的“保险丝”。

整栋楼的糖在看不见彼此的情况下完成了混合——面粉是掩码，暗号是种子，凭证是秘密共享。安全聚合的第一道防线，就这样在黎明前悄悄搭好了。

ui=xi+∑j∈Uj<isij−∑j∈Uj>isij,∑i∈Uui=∑i∈Uxi\displaystyle u_i = x_i + \sum_{\substack{j \in \mathcal{U} \\ j < i}} s_{ij} - \sum_{\substack{j \in \mathcal{U} \\ j > i}} s_{ij}, \qquad \sum_{i \in \mathcal{U}} u_i = \sum_{i \in \mathcal{U}} x_i
每个参与方上传的是“真实梯度 + 一堆面粉”，服务器把它们加起来时，面粉两两抵消，只剩干净的总梯度。
  1. 成对掩码生成$s_{ij}$ 是参与方 $i$ 和 $j$ 用共享随机种子扩展出的掩码向量，两方数值相同。
    sij=PRG(seedij)=sjis_{ij} = \text{PRG}(\text{seed}_{ij}) = s_{ji}
  2. 掩码方向规则对编号比自己小的邻居加掩码，对编号比自己大的减掩码，形成正负配对。
    ui=xi+∑j<isij−∑j>isiju_i = x_i + \sum_{j < i} s_{ij} - \sum_{j > i} s_{ij}
  3. 聚合时抵消服务器对 $u_i$ 求和，$s_{ij}$ 与 $s_{ji}$ 一正一负相互抵消。
    ∑iui=∑ixi\sum_{i} u_i = \sum_{i} x_i

同态加密应用

面粉方案有个死穴：如果参加联欢的十几户里刚好有一户缺席，它的“反向面粉”没进场，大缸里就会残留半斤面粉，总糖量算错。楼委会主任挠头：有没有一种罐子，盖子是锁死的、外面完全看不见糖，但把所有罐子堆在一起却能准确称出总重？邻居们觉得他在说梦话，可密码学家还真造出了这种罐子。

这种“锁死的透明罐”就是同态加密（Homomorphic Encryption）。它允许在密文上直接做运算，解密后的结果与明文运算结果一致。安全聚合只需要其中最简单的一种——加法同态：$E(a)$ 和 $E(b)$ 是两个密文，服务器在密文域做一次对应运算，得到的新密文解密后恰好是 $a+b$。整个过程，服务器从未见过 $a$ 和 $b$ 的明文。

Paillier 加密是加法同态的代表：公钥为 $N$，加密时 $E(m) = g^{m} \cdot r^{N} \bmod N^2$，两个密文相乘得到的密文解密后对应明文相加。在安全聚合里，同态加密可以承担掩码种子的安全分发（把种子加密后发给对应参与方），也可以作为替代方案：各方加密梯度上传，服务器在密文域聚合，解密得总和。优点是不依赖“所有参与方在线”的假设；缺点是开销大——密文长度是明文的两倍以上，模指数运算比普通加法慢好几个数量级，因此大规模系统通常只把它用在轻量环节，而不是每一轮全量使用。

透明保密罐让主任不再担心有人缺席——罐子本身就是数学加固的：看不见内容、但能精确称总重。不过罐子造价不菲，得看小区预算是否允许每户都配一只。

E(m1)⋅E(m2) mod N2=E(m1+m2 mod N)\displaystyle E(m_1) \cdot E(m_2) \bmod N^{2} = E(m_1 + m_2 \bmod N)
两个密文罐子叠在一起称重，得到的是两个明文相加后的密文结果。开锁一看，正好是真实总和。
  1. 明文加密$E(m)$ 表示用 Paillier 公钥把明文 $m$ 加密成密文，外人无法读出 $m$。
    E(m)=gm⋅rN mod N2E(m) = g^{m} \cdot r^{N} \bmod N^{2}
  2. 密文运算两个密文做乘法，对应明文做加法，这是加法同态的核心性质。
    E(m1)⋅E(m2)=E(m1+m2)E(m_1) \cdot E(m_2) = E(m_1 + m_2)
  3. 解密取和服务器把聚合后的单个密文交回或自己解密，得到明文总和。
    D(E(m1)⋅E(m2))=m1+m2D\big(E(m_1) \cdot E(m_2)\big) = m_1 + m_2

差分隐私结合

联欢会结束，主任盯着那袋团圆糖犯了嘀咕：糖是混匀了，可要是整栋楼只有 303 一户爱吃榴莲糖，主任只要在糖里尝出一点榴莲味，立刻就能断定“303 今天来了”——总糖量这个结果本身，也能泄露个体信息。于是楼委会加了一道工序：往大缸里撒一小撮花椒面。整袋糖的味道几乎不变，但任何想从味道反推“哪家放了什么”的人，都会被辣得直摇头。

这道花椒面在密码学里叫差分隐私（Differential Privacy）。它不阻止任何人看到聚合结果，而是保证结果对任何单个样本的变化都不敏感。形式化地说，一个随机机制 $M$ 满足 $\varepsilon$-差分隐私，如果任意相邻数据集（仅差一条记录）上的输出分布之比不超过 $e^{\varepsilon}$。实际操作中，最常见的做法是在客户端本地注入拉普拉斯噪声，把梯度搅浑再上传。

安全聚合和差分隐私是一对互补的搭档。安全聚合解决“传输与聚合过程中服务器看到个体梯度”的问题；差分隐私解决“即使只公布聚合结果，也能防止别人反推个体是否参与或个体贡献多少”的问题。两者叠加时，本地噪声作为“加了花椒面的糖”正常参与掩码流程，掩码抵消机制完全不受影响；代价是噪声累积会降低模型精度，隐私预算 $\varepsilon$ 越小噪声越大、精度越差，需要在隐私与效用之间做权衡。

花椒面让“尝味道反推邻居”这条路也堵死了。安全聚合是门锁，差分隐私是烟幕——门锁住了屋里的东西，烟幕让外面的人连“屋里大概住着谁”都看不清。

x~i=xi+Lap(Δfε)\displaystyle \tilde{x}_i = x_i + \mathrm{Lap}\left(\frac{\Delta f}{\varepsilon}\right)
每个参与方在自己的梯度上撒一把“花椒面”——服从拉普拉斯分布的随机噪声。噪声的大小由隐私预算 $\varepsilon$ 决定。
  1. 敏感度$\Delta f$ 表示查询结果对单条记录的最大影响范围，决定需要多大的噪声来掩盖个体差异。
    Δf=max⁡D,D′∥f(D)−f(D′)∥1\Delta f = \max_{D, D'} \| f(D) - f(D') \|_1
  2. 噪声规模$\mathrm{Lap}(\cdot)$ 产生尺度为 $\Delta f / \varepsilon$ 的拉普拉斯噪声，$\varepsilon$ 越小噪声越大。
    Lap(Δfε)∼ε2Δfexp⁡(−∣z∣⋅εΔf)\mathrm{Lap}\left(\frac{\Delta f}{\varepsilon}\right) \sim \frac{\varepsilon}{2\Delta f} \exp\left(-\frac{|z| \cdot \varepsilon}{\Delta f}\right)
  3. 加噪上传客户端把加噪后的梯度 $\tilde{x}_i$ 发往服务器，正常参与掩码与聚合流程。
    x~i=xi+Lap(Δfε)\tilde{x}_i = x_i + \mathrm{Lap}\left(\frac{\Delta f}{\varepsilon}\right)

通信开销优化

联欢会连办三周后，楼委会傻眼了：每次混糖，每户都要和另外十几户逐个对暗号、传凭证、搬罐子，楼道堵得水泄不通，一场仪式折腾大半天。主任一拍桌子：“这么下去，一周一次联欢会都难！得改流程！”

真实的联邦系统也面临同样的拥堵。原始安全聚合协议需要每对参与方做一次密钥协商，也就是 $O(n^2)$ 次握手，还需要传送秘密共享份额；同态加密方案下密文还比明文大好几倍。训练一轮模型的通信量往往比明文联邦学习高一个数量级以上。工程上的第一板斧是分组（clustering）：把几百个参与方切成若干小组，先在小组内部完成掩码抵消，再把组内聚合结果汇总到服务器做组间聚合。这样密钥协商从全体两两配对降为组内配对，通信量大幅下降。

第二板斧是“掩码只传种子”：双方协商共享随机种子后，用伪随机数生成器在本地同步扩展出完整的掩码向量，而不是把掩码本身传来传去，每个参与方与每个邻居的通信从“传一个梯度大小的向量”缩成“传一个几十字节的种子”。第三板斧是梯度压缩：稀疏化（只传 Top-k 大梯度）和量化（把浮点压成低比特整数），直接缩减需要加掩码的数据体积。掉线恢复本身也会带来额外通信，工程上常让参与方把秘密共享份额附在掩码更新里一并上传，省去额外轮次。

分组就像楼委会把一个单元分成三四层小茶话会，先在每一层内部把糖混好，再把每层的小罐子送到大厅。楼道不再人挤人，联欢会也能一周开上好几次了。

Ctotal=∑g=1G(ng2),Ctotal≪(n2)\displaystyle C_{\mathrm{total}} = \sum_{g=1}^{G} \binom{n_g}{2}, \qquad C_{\mathrm{total}} \ll \binom{n}{2}
把 $n$ 户人家分成 $G$ 个小组后，每组内部两两握手。总的握手次数从全体两两配对的 $O(n^2)$，降为各组内配对的加和。
  1. 分组结构把 $n$ 个参与方分成 $G$ 组，第 $g$ 组有 $n_g$ 个参与方。
    ∑g=1Gng=n\sum_{g=1}^{G} n_g = n
  2. 组内握手每组内两两协商密钥的握手次数为组合数 $\binom{n_g}{2}$。
    Cg=(ng2)=ng(ng−1)2C_g = \binom{n_g}{2} = \frac{n_g (n_g - 1)}{2}
  3. 总量对比分组后的总握手数远小于全体两两协商的 $\binom{n}{2}$。
    Ctotal=∑g=1G(ng2)≪(n2)C_{\mathrm{total}} = \sum_{g=1}^{G} \binom{n_g}{2} \ll \binom{n}{2}

性能评估

仪式改到第七版，楼委会要正式验收：防隐私泄露的效果好不好？混出来的糖和原来一个味儿吗？楼道还堵不堵？每户忙一晚上值不值？四个问题，对应四个维度的评估。

性能评估首先看协议正确性（精度）：在无掉线、无压缩的理想情况下，安全聚合是“无损”的——服务器算出的总梯度与明文聚合完全相等，模型收敛曲线与明文联邦学习重合。一旦引入梯度压缩或差分隐私噪声，精度就有损失，这时要通过实验对比不同压缩比、不同 $\varepsilon$ 下的收敛曲线，画出“隐私-效用”权衡曲线。其次是通信开销：统计每轮训练每位参与方的上传字节数、握手轮数、同步等待时间。

计算开销要看本地加解密、掩码生成、秘密共享拆分的 CPU 耗时，常用端到端训练总耗时作为综合指标；安全性评估则考察协议在“诚实但好奇”服务器、至多 $t$ 个恶意合谋参与方、以及掉线场景下的隐私保护强度。一个常见教训是：安全聚合保护隐私，但不防投毒——恶意参与方照样可以上传有害梯度污染模型，这一点在部署时经常被误解，评估时要把隐私性、正确性、鲁棒性分开测量。

验收结果往往像楼委会最终发现的那样：安全聚合不是免费的，但它把“隐私泄露”这道看不见的裂缝补上了。工程上要量体裁衣——隐私要求高、参与方多的场景值回票价；数据敏感度低的小实验，也许简单加密通信就够。明白每一把尺子怎么用，才不会被“绝对安全”的花言巧语蒙住。

Tround=Tcomm+Tcomp+Tsync\displaystyle T_{\mathrm{round}} = T_{\mathrm{comm}} + T_{\mathrm{comp}} + T_{\mathrm{sync}}
一轮安全聚合训练的总耗时，由通信时间、计算时间和同步等待时间三部分构成。优化任何一个环节，都能让整场“混糖仪式”更快。
  1. 端到端耗时$T_{\mathrm{round}}$ 表示完成一轮安全聚合训练的总时间，是衡量协议性能的最终指标。
    Tround=Tcomm+Tcomp+TsyncT_{\mathrm{round}} = T_{\mathrm{comm}} + T_{\mathrm{comp}} + T_{\mathrm{sync}}
  2. 通信耗时$T_{\mathrm{comm}}$ 是梯度、掩码、秘密共享份额上传下载的网络耗时，受字节数和往返轮次影响。
    Tcomm∝上传字节数×往返轮次T_{\mathrm{comm}} \propto \text{上传字节数} \times \text{往返轮次}
  3. 计算与同步$T_{\mathrm{comp}}$ 是本地加解密和掩码生成的 CPU 耗时，$T_{\mathrm{sync}}$ 是等待最慢参与方的同步开销。
    Tsync=max⁡iti−1n∑itiT_{\mathrm{sync}} = \max_{i} t_i - \frac{1}{n} \sum_{i} t_i

AI 应用场景

跨机构医疗联合建模

阶段：数据隐私保护（联邦训练阶段）

解决的问题：医院各自持有的病理切片、影像数据属于高度敏感隐私，受合规约束不能出院。传统方案要么集中数据（违反合规），要么明文传输梯度（存在从梯度重建病历的风险）。安全聚合让各医院梯度先加掩码再上传，服务器只能得到多中心总模型更新，无法反推任何一家医院的个体梯度，从机制上满足数据合规要求。

具体案例：法国公司 Owkin 与多家医院合作训练肿瘤药物响应预测模型。各医院数据完全不出院，本地训练后经安全聚合协议上传加密的模型更新，中央服务器完成聚合。最终模型在多个癌种上的预测精度达到任何单中心都无法企及的水平，而任何一家医院都无法从聚合结果中得知其他医院的患者信息。

手机输入法个性化

阶段：端侧模型训练与聚合

解决的问题：手机输入法的个性化候选词、热词点击数据极其私密，用户绝不愿意它们上传到云端。传统云端训练方案把这部分数据集中在服务器，隐私风险大；安全聚合则让每台手机在本地训练更新，利用成对掩码和秘密共享掉线恢复机制，支持百万级设备按批参与聚合，服务器始终只能看到群体的平均更新。

具体案例：Google Gboard 输入法在生产环境中使用 Secure Aggregation 协议。每台手机根据本地打字习惯训练一个小模型，把加密的梯度更新上传；系统按批随机选择设备参与，即使部分设备中途掉线（手机没电、断网），秘密共享机制也能让在线设备补上掉线设备的掩码，保证每轮聚合顺利完成。用户打字习惯永远留在本机，模型却在持续变聪明。

银行反欺诈联盟

阶段：联邦学习 + 差分隐私联合建模

解决的问题：多家银行各自掌握不同的欺诈交易模式，但客户流水绝不能共享给同业。传统反欺诈模型只能基于单行数据训练，对新型跨行欺诈识别能力弱。采用“安全聚合 + 差分隐私”双保险方案：各银行本地加噪并掩码上传梯度，服务器聚合出跨行欺诈趋势，既防止服务器窥探单行梯度，又防止从聚合结果反推某家银行的客户行为。

具体案例：某省级金融联盟的实践：6 家银行在隐私计算平台上联合训练洗钱交易识别模型，每轮训练 6 个参与方完成成对掩码协商，总通信量比明文联邦学习增加约 2.3 倍，但模型对跨行可疑交易的召回率提升了 18%。所有原始流水均未离开各银行内部网络。

Python 演示

python67 行
import numpy as np  class SecureAggregator:    """simplified secure aggregation: pairwise masks cancel out"""     def __init__(self, n_clients, dim, seed=42):        self.n_clients = n_clients        self.dim = dim        self.rng = np.random.default_rng(seed)        # pairwise shared seeds: seeds[i][j] == seeds[j][i]        self.seeds = [[0] * n_clients for _ in range(n_clients)]        for i in range(n_clients):            for j in range(i + 1, n_clients):                s = int(self.rng.integers(0, 2**31))                self.seeds[i][j] = s                self.seeds[j][i] = s     def _mask_of(self, seed):        # both parties expand the same seed into the same mask vector        return np.random.default_rng(seed).normal(0, 1, self.dim)     def mask_gradient(self, client_id, gradient):        # add mask for j < i, subtract mask for j > i        masked = gradient.copy()        for j in range(self.n_clients):            if j == client_id:                continue            m = self._mask_of(self.seeds[client_id][j])            if j < client_id:                masked = masked + m            else:                masked = masked - m        return masked     def aggregate(self, masked_gradients):        # server only sums: masks cancel automatically        total = np.zeros(self.dim)        for mg in masked_gradients:            total += mg        return total  def main():    dim = 8    n_clients = 5    agg = SecureAggregator(n_clients, dim)     true_grads = [        np.random.default_rng(100 + i).normal(0, 1, dim)        for i in range(n_clients)    ]     masked_grads = [        agg.mask_gradient(i, g) for i, g in enumerate(true_grads)    ]     agg_result = agg.aggregate(masked_grads)    true_sum = np.sum(true_grads, axis=0)     print("server sum == true sum:",          np.allclose(agg_result, true_sum))    print("individual gradients hidden, server sees only the total")  if __name__ == "__main__":    main()
目的：用 NumPy 实现一个 5 参与方的简化安全聚合协议，演示成对掩码如何让服务器只得到梯度总和、却看不到任何单方梯度。
  1. self.seeds[i][j] = s / self.seeds[j][i] = s给每对参与方分配同一个随机种子，保证双方能生成完全相同的掩码。
  2. _mask_of(seed)用同一个种子初始化独立的伪随机数生成器，双方各自在本地扩展出相同的掩码向量，不用真的传输掩码本身。
  3. if j < client_id: masked = masked + m else: masked = masked - m掩码方向规则：对编号小的邻居加掩码，对编号大的减掩码，保证聚合时成对抵消。
  4. agg.aggregate(masked_gradients)服务器只做一个求和操作，完全不需要知道掩码是什么，面粉在加法中自动消失。
  5. np.allclose(agg_result, true_sum)验证协议正确性：服务器算出的总和与所有真实梯度直接相加的结果完全一致。

常见误区

误区我已经用了 TLS/HTTPS，梯度在传输过程中不会被窃听，这不就是安全聚合了吗？

正解TLS 保护的是“传输通道”不被外部偷看，但服务器本身就是接收方，它能看到每个参与方的明文梯度。安全聚合防的是服务器和其他参与方——要求服务器只能算总和、看不了任何单方梯度。类比：TLS 是给糖罐加了封条防快递员偷吃；安全聚合是让主任只能看整缸混糖、看不到任何一家的糖。

为何常见：很多人把“加密通信”和“密文计算”混为一谈，前者保护信道，后者保护计算过程本身，两者要解决的安全目标完全不同。

误区同态加密能直接在密文上算任意函数，那直接用全同态加密不就好了，为什么要用掩码这种土办法？

正解全同态加密（FHE）支持任意运算但计算开销极大，工程上不现实。安全聚合只需要加法级别的运算，用成对掩码这种轻量手段就能达成目标，通信和计算开销低几个数量级。同态加密在安全聚合里是工具之一（如安全分发种子），不是银弹。类比：保密罐能精确称出总重，但每只罐子的造价是普通糖罐的百倍，楼委会自然会算这笔账。

为何常见：读论文时容易把理论上限当工程最优解，忽略了真实系统中的算力与带宽约束。

误区加了差分隐私噪声，梯度已经失真了，攻击者拿到也无所谓，就不用安全聚合了。

正解差分隐私保证“输出结果不泄露单样本”，但服务器在聚合前看到的是每个参与方的“带噪梯度”——噪声在每轮训练中有限，攻击者仍可从多轮带噪梯度中重构训练数据。安全聚合保证服务器从头到尾只能看总和，两者解决的是不同环节的泄露（传输过程 vs 结果推断），需要组合使用。类比：花椒面防不了“糖还在各家罐子里时被偷看”，那得靠门锁。

为何常见：误解了差分隐私的保护范围，以为“输出安全”就等于“过程安全”。

误区安全聚合要多轮握手、秘密共享、加解密，开销太大，小团队根本用不起，干脆明文聚合算了。

正解工程上有成熟优化：分组聚合把握手从 $O(n^2)$ 降到近似线性；PRG 让掩码只传种子；梯度压缩减少上传量。在百余参与方规模下，Secure Aggregation 的开销在可接受范围。是否采用取决于隐私需求等级而不是团队大小。类比：楼道拥挤可以分层错峰，而不是直接取消联欢会。

为何常见：只看到原始协议的复杂度，不了解生产系统中的工程优化手段，把“贵”当成“用不起”。

误区既然梯度都看不见了，恶意参与方也找不到下手机会，安全聚合正好能防投毒攻击。

正解安全聚合只保证“聚合结果的正确性”（无掉线时总和不变），但不保证每个梯度本身是好的。恶意参与方可以上传精心构造的毒梯度，照样污染聚合结果，而且因为看不到个体梯度，服务器做异常检测反而更难。防投毒需要额外机制（鲁棒聚合、置信度加权等），安全聚合不背这个锅。类比：楼委会保证混糖总量不变，但防不住有人往自己糖里掺沙子。

为何常见：把“隐私性”和“鲁棒性”两个安全目标混为一谈，以为看不见梯度就万事大吉。

面试题

Q1. 联邦学习的核心目标是？

单选题 · easy

  • A.把各参与方的数据集中到服务器统一训练
  • B.让数据留在本地、只交换模型更新来完成协作训练← 正确答案
  • C.用区块链给每个模型更新打上时间戳
  • D.将训练好的模型加密后分发给所有参与方

答案：B。联邦学习把训练搬到数据所在处，只有模型更新（梯度）会传输，原始数据不出本地。A 是集中式学习的做法，与联邦学习背道而驰；C 中区块链与联邦学习核心目标无关；D 是模型分发而非协作训练。

Q2. 安全聚合主要防御的对象是？

单选题 · easy

  • A.外部黑客窃听传输信道
  • B.好奇的中央服务器或恶意的其他参与方推测个体梯度← 正确答案
  • C.参与方上传低质量数据
  • D.模型在推理阶段被对抗样本攻击

答案：B。外部窃听由 TLS 等传输加密解决；安全聚合防的是聚合方本身——它只该看到总和。C 属于数据质量问题，D 是推理攻击，都不在安全聚合的威胁模型内。

Q3. 关于 Shamir 秘密共享 (k, n)，下列说法正确的是？

单选题 · mid

  • A.任意少于 k 个份额也能还原出完整秘密
  • B.不需要凑齐任何份额，靠公钥就能解密
  • C.任意 k 个份额即可还原出完整秘密← 正确答案
  • D.必须收集全部 n 个份额才能还原秘密

答案：C。Shamir 方案把秘密藏进 k-1 次多项式，任意 k 个点就能插值出多项式从而恢复秘密，少于 k 个点信息量为 0。D 是“全员在线”的朴素想法，不是 Shamir 的设计；A 与 C 正好相反；B 混淆了秘密共享与公钥加密。

Q4. 成对掩码机制能正确抵消的前提是？

单选题 · mid

  • A.所有参与方和服务器共享同一把密钥
  • B.每对参与方协商独立随机种子，且掩码成对相反← 正确答案
  • C.服务器为每个参与方生成掩码并统一分发
  • D.掩码由差分隐私噪声来代替

答案：B。安全聚合里每个参与方与每个邻居共享的种子都不同，一方加一方减，求和时恰好抵消。A 会让服务器也能算出掩码从而揭开个体梯度；C 中服务器参与生成就没隐私可言；D 混淆了掩码与 DP 噪声的功能。

Q5. 当某个参与方在聚合过程中掉线时，安全聚合协议如何处理？

单选题 · hard

  • A.放弃本轮聚合，等待下轮所有参与方在线
  • B.由在线参与方用掉线方的秘密共享份额协助抵消其掩码← 正确答案
  • C.服务器直接用随机掩码补上掉线方的那份
  • D.掉线方的梯度直接置零，其余正常聚合

答案：B。掉线方的掩码如果不抵消，总和中会残留多余掩码。协议要求参与方预先把自己的随机种子用秘密共享分给其他人，掉线后由在线者联合重建种子、补上掩码。A 不现实，C 破坏求和正确性，D 导致梯度丢失且掩码残留。

Q6. 实现安全聚合通常需要哪些密码学组件？

多选题 · mid

  • A.密钥协商机制（如 Diffie-Hellman 交换）← 正确答案
  • B.秘密共享方案（如 Shamir 方案）← 正确答案
  • C.全同态加密（支持任意函数计算）
  • D.伪随机数生成器（用于扩展掩码）← 正确答案

答案：ABD。密钥协商产生成对随机种子，PRG 把种子扩展成掩码，秘密共享用于掉线恢复。安全聚合只需要加法级别的操作，不需要昂贵的全同态加密，所以 C 错误。

Q7. 同态加密在安全聚合中的主要作用是？

单选题 · mid

  • A.在密文上直接做加法，让服务器无法获知任何个体明文梯度← 正确答案
  • B.压缩梯度的尺寸从而降低通信开销
  • C.使模型迭代更快收敛
  • D.替代差分隐私来保护聚合结果的隐私

答案：A。加法同态让服务器在密文域完成聚合，解密后只得到总和。B 是梯度压缩做的事，C 与加密无关，D 中结果隐私靠差分隐私保护，同态加密保护的是运算过程而非结果推断。

Q8. 关于差分隐私与安全聚合的组合，下列哪些说法正确？

多选题 · hard

  • A.安全聚合保护传输过程，差分隐私保护聚合结果可抵御推断← 正确答案
  • B.客户端本地加噪声会导致模型精度有损，需权衡隐私预算← 正确答案
  • C.同态加密可以消除差分隐私噪声，两者叠加后无损精度
  • D.加了差分隐私后就不再需要安全聚合

答案：AB。两道防线各管一段，故 A 对、D 错。本地噪声会累积并影响模型效用，须用 ε 权衡，B 对。同态加密只做密文运算，不会“消除”噪声，C 错。

Q9. 下列哪项属于安全聚合的通信开销优化手段？

单选题 · easy

  • A.每轮上传全量浮点梯度
  • B.梯度稀疏化与量化压缩、分组聚合← 正确答案
  • C.用更小的神经网络模型
  • D.增加本地训练轮数

答案：B。稀疏化、量化减少上传字节，分组把密钥协商从 O(n²) 降下来。A 是未优化行为，C 改模型不解决聚合层通信，D 减少的是训练轮次而非每轮通信量。

Q10. 评估安全聚合协议性能时，通常关注哪些指标？

多选题 · mid

  • A.聚合后的模型精度是否与明文聚合一致← 正确答案
  • B.每轮通信的字节数与握手次数← 正确答案
  • C.本地加解密与掩码生成的计算耗时← 正确答案
  • D.参与方上传数据的真实性

答案：ABC。精度、通信、计算是安全聚合的三大性能指标。D 是数据质量问题，属于鲁棒性范畴而非协议性能，因此正确选项是 A、B、C。