想象一个小村庄：村里有一本“集体菜谱”（AI 模型），每家每户都有自己的秘密配方（本地私有数据）。村长（服务器）希望把各家最拿手的改良步骤汇总起来，更新集体菜谱，让全村受益——但任何一户都不想让村长和邻居看到自己的独门配方。于是大家想出一套“匿名总账”的规矩：每一对村民事先约定一个只有彼此知道的“偏移量”，上报时一户加、一户减；村长把所有人的数字加在一起，所有偏移量恰好互相抵消，只留下一个总和。这套机制在机器学习领域就叫安全聚合协议：服务器只能看到所有客户端贡献的加权总和，却无法窥探任何一方的单份贡献，成为隐私保护联邦训练中不可或缺的核心组件。

岗位关联

掌握安全聚合协议，你就掌握了工业级联邦学习隐私保护的核心引擎——这是联邦学习工程师、AI 安全合规从业者面试与实战中的硬通货。

目录
  1. 可视化演示
  2. 联邦学习基础：一村一谱的协作训练
  3. 威胁模型：提防的不是强盗，而是好奇的账房先生
  4. 掩码机制：邻居之间的秘密偏移量
  5. 密钥协商：当着所有人的面说悄悄话
  6. 容错恢复：缺席的家庭与秘密共享
  7. 开销优化：全村通信的代价
  8. 局限防护：防得了偷看，防不了说谎
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

展示安全聚合协议三维度：四阶段执行流程（密钥协商-秘密分享-掩码输入-聚合求和）、成对掩码机制（DH密钥协商-k_ij正负抵消-服务器仅得总和）、Shamir秘密分享与掉线容错（阈值重建-掉线恢复），理解联邦学习隐私保护。

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

安全聚合四阶段流程 DH密钥协商与Shamir分享 掩码输入与聚合求和 server sees only sum 四阶段协议确保服务器仅获取梯度总和，无法窥探单方梯度。

联邦学习基础：一村一谱的协作训练

村里这本“集体菜谱”是怎么迭代的？村长先把当前版本的菜谱抄送给每户人家；各家关起门来，拿自家秘方（数据）试做一遍，记下“哪几步该多放料、哪几步该少放料”——这就是一份改进建议。大家把建议交回村里，村长把所有建议平均一下，形成新一版菜谱，再发下去。如此反复，菜谱越来越好，但任何一家的配方从头到尾没有出过门。

在现实里，“每户人家”是手机、医院、银行等持有私有数据的客户端，“集体菜谱”是全局模型，而“改进建议”就是模型梯度。这套流程叫联邦平均（FedAvg）：服务端下发模型，客户端本地训练后只上传梯度，服务端按样本量加权求和更新模型。问题在于，梯度并不是安全的中介——研究已证明，攻击者可以从梯度反向推断训练样本的细节。也就是说，村长虽然看不到配方，但通过“改进建议”的蛛丝马迹，仍可能猜出某户人家用了什么料。

于是最朴素的问题浮出水面：能不能让村长只知道所有建议加在一起的方向，却永远拆不出“这条建议是哪户提的”？这正是安全聚合协议要回答的。

θ(t+1)=θ(t)−η∑k=1Knkn∇Lk(θ(t))\displaystyle \theta^{(t+1)} = \theta^{(t)} - \eta \sum_{k=1}^{K} \frac{n_k}{n} \nabla L_k(\theta^{(t)})
这是联邦平均的核心公式：服务端用各客户端梯度的加权和来更新全局模型，其中每一项都来自某一家“改进建议”。
  1. 模型参数 θ^{(t+1)}第 t+1 轮更新后的全局模型参数，相当于村民修订出的新一版“集体菜谱”。
    θ(t+1)\displaystyle \theta^{(t+1)}
  2. 学习率 η控制每一步改动的幅度，η 太大容易震荡，太小收敛缓慢，就像菜谱改过头会翻车。
    η\displaystyle \eta
  3. 样本占比权重 n_k / n客户端 k 的数据量占全体数据量的比例，数据越多的家庭对菜谱话语权越大。
    nkn\displaystyle \frac{n_k}{n}
  4. 本地梯度 ∇L_k客户端 k 在本地数据上算出的损失梯度，就是它交上来的那份“改进建议”。
    ∇Lk(θ(t))\displaystyle \nabla L_k(\theta^{(t)})

威胁模型：提防的不是强盗，而是好奇的账房先生

村里其实没有强盗来抢账本，真正的威胁来自那位“账房先生”——也就是服务器。他一丝不苟地按规矩办事：收账、加总、公布结果，从不捣乱；但他好奇心极重，总想偷偷翻开每一页，看看某户人家到底交了多少。密码学里管这叫“诚实但好奇”（honest-but-curious）的对手。

要设计防护，先得说清“防谁、防什么”。安全聚合主要面对三类威胁：第一，好奇的服务器，它忠实执行协议但会利用收到的所有中间数据尝试推断单方梯度；第二，恶意客户端，它们可能篡改梯度投毒，但安全聚合本身不负责防投毒；第三，合谋攻击，即多个客户端甚至客户端与服务器串通，试图反推某个受害者的梯度。安全聚合承诺的是：只要合谋的客户端集合是全体客户端的严格真子集，那么未合谋客户端的梯度在服务器眼里就是不可区分的。

一句话总结威胁模型：账房先生可以看总账，但永远拆不出任何一家的单子；就算拉拢几个邻居一起偷看，只要村里还有一户不跟他合伙，那户人家的秘密就保得住。

S=∑i∈UΔi\displaystyle \mathcal{S} = \sum_{i \in \mathcal{U}} \Delta_i
安全聚合的隐私承诺：服务器最终只能得到这个总和 S，对任何单一项 Δᵢ 都不可区分。
  1. 客户端集合 U本轮成功完成掩码上传的在线客户端集合，缺席的家庭不计入总账。
    U\displaystyle \mathcal{U}
  2. 单方梯度 Δ_i客户端 i 在本地训练得到的模型更新向量，也就是它家那份“改进建议”。
    Δi\displaystyle \Delta_i
  3. 聚合求和 Σ把所有在线客户端的梯度逐元素相加，服务器这辈子只能看到这一个大数。
    ∑i∈U\displaystyle \sum_{i \in \mathcal{U}}

掩码机制：邻居之间的秘密偏移量

现在难题交到村民手里：既要把建议交到村长那儿，又不能让他在途中偷看。大家想出的办法巧妙极了——每一对邻居私下约定一个只有他俩知道的偏移量 s。上报时，编号小的那户在自己数字上加 s，编号大的那户减 s。比如 A 和 B 约定 s=7，A 交“真实值+7”，B 交“真实值-7”。单独看任何一个数字都严重失真，但村长把它们相加时，+7 和 -7 恰好相互抵消，总和分毫不差。

这就是安全聚合的“心脏”：成对掩码（pairwise masking）。设客户端 i 与 j 共享掩码 s_{i,j}，规定 i<j 时 i 加、j 减。于是每个客户端上传的都是被一串掩码“污染”过的值，服务器看到的全是垃圾数据；可一旦把所有密文求和，所有掩码对自动抵消，只留下干净的梯度总和。整个过程不需要服务器参与解密，也不需要任何一方信任服务器。

村长面前摊开一堆加了干扰的数字，眉头紧锁；可当他按下计算器加总的那一刻，魔法发生了——所有偏移量凭空消失，只剩一个精确的总和。掩码机制的妙处就在于：隐私藏在“每份数据都被污染”里，答案藏在“所有污染恰好抵消”里。

Δ^i=Δi+∑j∈Uj>isi,j−∑j∈Uj<isj,i\displaystyle \hat{\Delta}_i = \Delta_i + \sum_{\substack{j \in \mathcal{U} \\ j > i}} s_{i,j} - \sum_{\substack{j \in \mathcal{U} \\ j < i}} s_{j,i}
这是掩码上传公式：每个客户端在自己的真实梯度上“加一批、减一批”掩码，上传的已是失真值。
  1. 原始梯度 Δ_i客户端 i 的本地真实梯度，是整套机制要保护的对象。
    Δi\displaystyle \Delta_i
  2. 小序号端加掩码对所有序号大于 i 的客户端 j，客户端 i 加上共享掩码 s_{i,j}，就像在账本数字上撒一把盐。
    ∑j∈Uj>isi,j\displaystyle \sum_{\substack{j \in \mathcal{U} \\ j > i}} s_{i,j}
  3. 大序号端减掩码对所有序号小于 i 的客户端 j，客户端 i 减去共享掩码 s_{j,i}，另一户再用自己的减项把盐挑出来。
    ∑j∈Uj<isj,i\displaystyle \sum_{\substack{j \in \mathcal{U} \\ j < i}} s_{j,i}

密钥协商：当着所有人的面说悄悄话

新的问题来了：A 和 B 要在全村人眼皮底下约定那个偏移量 s，又不能让别人听去。直接喊一嗓子肯定不行，传纸条也可能被截获。Diffie-Hellman 密钥协商给出了一个优雅得惊人的方案——把它想象成调颜料：A 和 B 各自挑一种秘色（私钥），再各自掺入一勺公共底色 g，把调好的混合色公开交换；A 拿到 B 的混合色后加入自己的秘色，B 也做同样的操作。神奇的是，两人最终得到完全相同的混合色 s，而旁观者虽然看到了两桶中间色，却永远调不出那个最终颜色。

在密码学里，这个“混合色”就是模幂运算的产物：双方公开交换 g^{a_i} 和 g^{a_j}，各自再取指数得到共享秘密 g^{a_i a_j}。有了共享种子，再用伪随机生成器（PRG）把它扩展成与梯度同长度的掩码向量。每一对客户端都这样做一次，就拥有了独特的成对掩码；服务器在整个过程中只看到公开的中间值，对掩码一无所知。

全村人都看到了两桶颜料交换的过程，却没人能调出那杯最终颜色；只有约定的两家知道偏移量是多少。这便是“当着所有人的面说悄悄话”——公开信道上的秘密约定。

si,j=gaiaj mod p=gajai mod p\displaystyle s_{i,j} = g^{a_i a_j} \bmod p = g^{a_j a_i} \bmod p
这是 Diffie-Hellman 共享秘密公式：双方各自保密指数 aᵢ、aⱼ，交换公开的 g^a，最后算出同一个 s。
  1. 公共参数 g 与 p全体客户端公开协商的大素数 p 和底数 g，就像摆在广场正中央的那桶公共底色，谁都能看。
    g, p\displaystyle g,\ p
  2. 私钥 a_i 与 a_j客户端各自随机挑选的私密指数，绝不出现在任何信道上，相当于各自的秘色调料。
    ai, aj\displaystyle a_i,\ a_j
  3. 模幂运算双方交换 g^{a_i}、g^{a_j} 后各自再做一次幂运算，得到同一个共享秘密 g^{a_i a_j} \bmod p。
    si,j=gaiaj mod p\displaystyle s_{i,j} = g^{a_i a_j} \bmod p

容错恢复：缺席的家庭与秘密共享

到了上报那天，偏偏有一户临时有事来不了——手机没电、网络断线、老人出门，这在现实里太常见了。麻烦在于：缺席家庭和其他家庭约好的偏移量，现在成了“孤儿账目”：别人加上的掩码没人来减，总账就对不上了。难道全村都要等它回来？

当然不用。每户在约好偏移量之后，会把这个偏移量“打碎”成若干份额，分发给其他家庭保管——这就是 Shamir 秘密共享。具体来说，把秘密 s 藏进一个 t 次多项式的常数项里，给每一户发一个多项式上的点作为份额。任何一个家庭单独拿着份额都猜不出 s，但只要凑齐 t+1 个份额，就能唯一还原这个多项式，从而解出 s。于是当某户缺席时，村长请持有它份额的邻居们碰头，重构出它留下的掩码，把总账里的“孤儿账目”干净地抹掉。

只要还有足够多的邻居在场，缺席家庭留下的“偏移量账目”就能被拼凑回来，总账依旧分毫不差。当然，如果掉线的人太多，凑不齐足够份额，这一轮就只能宣告失败、重新再来——这就是容错恢复的边界条件。

f(x)=s+r1x+r2x2+⋯+rtxt\displaystyle f(x) = s + r_1 x + r_2 x^2 + \cdots + r_t x^{t}
这是 Shamir 秘密共享多项式：秘密 s 藏在常数项，任意 t+1 个点才能唯一还原它。
  1. 共享秘密 s客户端 A 想传给其他客户端或服务器的掩码值，也就是那份“孤儿账目”本身。
    s\displaystyle s
  2. 随机系数 r_1,…,r_t构造 t 次多项式的随机数，让多项式曲线“弯弯绕绕”，单个点无法透露秘密。
    r1,r2,…,rt\displaystyle r_1, r_2, \dots, r_t
  3. t 次多项式几何上 t+1 个点才能唯一确定一条 t 次曲线，所以任何少于 t+1 个份额的组合都无济于事。
    f(x)=s+r1x+r2x2+⋯+rtxt\displaystyle f(x) = s + r_1 x + r_2 x^2 + \dots + r_t x^t
  4. 份额 f(j)把点 (j, f(j)) 分发给第 j 个客户端，凑够 t+1 个份额即可重构多项式并解出 s。
    f(j),j=1,2,…,t+1\displaystyle f(j), \quad j = 1, 2, \dots, t+1

开销优化：全村通信的代价

这套匿名总账什么都好，就是有一个烦人的毛病：每两户人家都要单独对一次暗号。村里如果有 5 户，就要对 10 次；有 100 户，就要对 4950 次；有 1000 户，就是接近 50 万次。通信量随着户数呈平方级爆炸，村长主持一次会议累得够呛。

在真实系统中，n 个客户端两两协商掩码，通信与计算开销都是 O(n²)——这在客户端只有几十个的实验室里毫无压力，但在工业级联邦学习动辄上万客户端时就成为瓶颈。工程上的对策是分组与层次化聚合：先把客户端分成若干小组，组内两两掩码并聚合出小组总和；再让各组代表（或借助“信使机制”）在组间做第二次掩码协商。这样一层的二次方通信被摊薄到每个小组内部，整体开销大幅下降。代价是每多一层聚合，理论上都会多暴露一点信息，因此精度、隐私与开销三者需要仔细权衡。

聪明的村长把大村子拆成若干小院，院内先悄悄对好暗号、汇总成一份“院级建议”，院与院之间再对一次暗号。暗号数量一下子从全村平方级降了下来——这便是安全聚合从论文走向工业部署的关键一跃。

(n2)=n(n−1)2≈O(n2)\displaystyle \binom{n}{2} = \frac{n(n-1)}{2} \approx O(n^2)
这是两两配对数量公式：n 个客户端两两组合的总数随 n 呈平方级增长。
  1. 客户端数量 n参与安全聚合的客户端总数，相当于村里的户数。
    n\displaystyle n
  2. 配对总数 C(n,2)n 个客户端两两配对的组合数，每一对都要协商一次掩码。
    (n2)=n(n−1)2\displaystyle \binom{n}{2} = \frac{n(n-1)}{2}
  3. 平方级增长当 n 增大时，配对数量按 n² 的量级增长，这就是“暗号越对越多”的数学根源。
    O(n2)\displaystyle O(n^2)

局限防护：防得了偷看，防不了说谎

掩码机制防住了好奇的账房先生，但它有一个先天盲区：如果某户人家存心虚报产量，村长根本无从分辨。安全聚合保护的是“隐私”，不是“诚实”——一个恶意客户端完全可以上传被篡改的梯度，而这一份假建议会和其他真建议一起被平均进全局模型。所以防投毒还得靠鲁棒聚合、异常检测等另一套机制。

此外，还有一个微妙之处：即使服务器只知道总和，当某个客户端贡献占绝对大头时，它的个体痕迹依然能从总和中被反推出来。为此，工业界常把安全聚合与差分隐私叠加使用：在聚合结果上再注入高斯噪声，让“从总和猜个体”变得更加不可能。两道锁各司其职——安全聚合负责“不让服务器看单方”，差分隐私负责“让总和本身也不带个体指纹”。

一个防偷看、一个防反推，两道锁一起装上，村子才能在既安全又安心的前提下共享菜谱。这套组合已经在 Google Gboard、苹果设备端学习等工业级系统中得到验证，成为隐私保护联邦训练的事实标准。

S′=∑i∈UΔi+N(0,σ2I)\displaystyle \mathcal{S}' = \sum_{i \in \mathcal{U}} \Delta_i + \mathcal{N}(0, \sigma^2 \mathbf{I})
这是安全聚合 + 差分隐私的组合公式：对总和加噪后再发布，个体痕迹被进一步隐藏。
  1. 聚合总和安全聚合后服务器得到的真实梯度加权和，它仍然能用来更新模型。
    ∑i∈UΔi\displaystyle \sum_{i \in \mathcal{U}} \Delta_i
  2. 高斯噪声从均值为 0、方差为 σ² 的高斯分布中采样的噪声向量，相当于在总账上再撒一层“统计迷雾”。
    N(0,σ2I)\displaystyle \mathcal{N}(0, \sigma^2 \mathbf{I})
  3. 加噪结果对总和注入噪声后再对外发布，攻击者即便拿到 S' 也难以反推任何单方贡献。
    S′\displaystyle \mathcal{S}'

AI 应用场景

移动端输入法的隐私保护联邦训练

阶段：模型训练与隐私保护部署

解决的问题：传统联邦学习需要逐用户上传梯度，服务端可据此重建用户输入习惯与语言特征；安全聚合让服务端只获得全局梯度总和，无法定位到任何个人，从数据源头满足隐私合规。

具体案例：某输入法团队在每轮词库更新中部署安全聚合：数百万手机只上报“掩码后的梯度”，服务端聚合出全局更新后下发新词库。掩码协商在设备间完成，服务端全程无法拆解单机贡献。

医疗影像跨院联合建模

阶段：数据可信与合规

解决的问题：医院影像数据涉及患者隐私与《个人信息保护法》等法规，原始数据不能出医院；安全聚合使多院梯度可安全汇总，在合规前提下享受多中心数据的建模红利。

具体案例：三家三甲医院联合训练肺结节检测模型，每院本地训练、上传掩码梯度，服务器聚合后各院获得更强的共享模型。患者影像从未离开本院，审计日志显示全程无原始数据外泄。

金融反欺诈跨机构建模

阶段：跨机构协作与推理

解决的问题：银行间共享黑样本明细会侵犯客户隐私并泄露商业机密；安全聚合只共享“模型更新总和”，既能让各家贡献被公平计量，又不暴露任何一方的交易特征分布。

具体案例：多家银行联邦训练反欺诈模型，用安全聚合保护各行的客户特征分布。模型上线后欺诈召回率显著提升，但任何一家合作方都无法反推他行客户明细，合规部门顺利通过审查。

Python 演示

python77 行
import mathimport random  def make_pair_masks(n_clients, dim, seed=42):    """为每对客户端生成一个共享掩码向量(模拟两两密钥协商结果)."""    rng = random.Random(seed)    masks = {}    for i in range(n_clients):        for j in range(i + 1, n_clients):            masks[(i, j)] = [rng.uniform(-1.0, 1.0) for _ in range(dim)]    return masks  def mask_update(client_id, gradient, masks, n_clients):    """客户端本地加掩码: 小序号加 s, 大序号减 s."""    masked = gradient[:]    for (i, j), m in masks.items():        if client_id == i:            masked = [a + b for a, b in zip(masked, m)]        elif client_id == j:            masked = [a - b for a, b in zip(masked, m)]    return masked  def aggregate(masked_updates, masks, dropouts, n_clients):    """服务器聚合: 求和后掩码抵消, 再修正掉线客户端遗留的掩码."""    dim = len(masked_updates[0])    total = [0.0] * dim    for i in range(n_clients):        if i in dropouts:            continue        total = [a + b for a, b in zip(total, masked_updates[i])]    for k in dropouts:        for i in range(n_clients):            if i == k or i in dropouts:                continue            pair = (i, k) if i < k else (k, i)            sign = 1 if i < k else -1            m = masks[pair]            total = [t - sign * v for t, v in zip(total, m)]    return total  def true_sum(gradients, dropouts):    """不加掩码时服务器本来应该得到的梯度总和(对照基准)."""    dim = len(gradients[0])    total = [0.0] * dim    for i, g in enumerate(gradients):        if i not in dropouts:            total = [a + b for a, b in zip(total, g)]    return total  def main():    n_clients, dim = 5, 3    rng = random.Random(7)    gradients = [[rng.uniform(-2.0, 2.0) for _ in range(dim)]                 for _ in range(n_clients)]    masks = make_pair_masks(n_clients, dim)    masked = [mask_update(i, gradients[i], masks, n_clients)              for i in range(n_clients)]     dropouts = [3]    result = aggregate(masked, masks, dropouts, n_clients)    expect = true_sum(gradients, dropouts)     print("客户端1的梯度: ", gradients[0])    print("客户端1掩码后: ", masked[0])    print("聚合结果:     ", result)    print("对照基准:     ", expect)    print("是否一致:     ", all(math.isclose(a, b, abs_tol=1e-9)                                for a, b in zip(result, expect)))  if __name__ == "__main__":    main()
目的：完整模拟安全聚合的“成对掩码 + 聚合抵消 + 掉线修正”三阶段，并验证服务器最终得到的结果与真实梯度总和完全一致。
  1. masks[(i, j)] = [rng.uniform(-1.0, 1.0) for _ in range(dim)]每对客户端共享同一个随机向量，模拟两两 Diffie-Hellman 协商出的掩码。
  2. if client_id == i: masked = [a + b for a, b in zip(masked, m)]小序号端在梯度的每个维度上加掩码。
  3. elif client_id == j: masked = [a - b for a, b in zip(masked, m)]大序号端在梯度的每个维度上减同一个掩码，保证求和时抵消。
  4. if i in dropouts: continue服务器跳过掉线客户端的密文，它根本没有上传。
  5. pair = (i, k) if i < k else (k, i)定位掉线客户端 k 与幸存客户端 i 之间的那对掩码。
  6. total = [t - sign * v for t, v in zip(total, m)]按加减方向修正“孤儿掩码”，让总账重新对齐。
  7. all(math.isclose(a, b, abs_tol=1e-9) ...)用浮点近似比对聚合结果与真实总和，验证掩码确实完全抵消。

常见误区

误区初学者常以为安全聚合后服务器完全瞎了，连总和都看不到，就像 HTTPS 一样“一路上全都加密看不见”。

正解安全聚合允许服务器“看到总和”，这正是它的设计目标：ΣΔᵢ 对服务器可见且必需，单方 Δᵢ 不可见。就像村长能看总账本总额，却撕不开任何一张单页。它防的是“抠出单方信息”，不是“一无所知”。

为何常见：“加密”在直觉上等于“看不见”，人们容易混淆“看不到明文”与“能看到聚合统计”这两种可见性。

误区有人认为掩码由服务器生成或下发，服务器天然掌握所有掩码，随时可以逐条还原客户端梯度。

正解掩码由客户端两两通过 Diffie-Hellman 协商，服务器从头到尾不接触共享种子；掩码只在求和时被动抵消。若服务器真知道全部掩码，就能逐个解开密文，安全聚合立刻失效——设计上恰恰杜绝了这一点。

为何常见：很多教程只画“服务器求和”的图，没交代掩码的协商通道，让人误以为掩码来自服务器。

误区加了安全聚合就认为模型一定安全了，恶意客户端再也无法破坏训练。

正解安全聚合防的是“偷看”，不防“说谎”。恶意客户端仍可上传被篡改的梯度参与平均，毒化全局模型。必须配合鲁棒聚合（如梯度裁剪、Krum、异常检测）才能应对投毒。

为何常见：“安全”一词含义太宽泛，初学者把隐私保护误当成了全能的全面防护。

误区掉线客户端的掩码无人能解，聚合必然失败，只能全部重来。

正解借助 Shamir 秘密共享，掉线客户端的掩码份额可由幸存客户端协作恢复；只要掉线数量不超过阈值，服务器仍能正确算出总和。真正的失败只发生在掉线人数击穿阈值且无法恢复时。

为何常见：只看理想流程（全员在线），忽略了真实系统中 5%-10% 的掉线率才是常态。

误区觉得掩码只是加加减减，成本可忽略，客户端数量再多也没关系。

正解每对客户端都要协商掩码，通信与计算开销为 O(n²)；教学演示只画 3-5 个客户端看不出问题，上万客户端时两两协商会成为严重瓶颈。工程上必须做分组与层次化聚合。

为何常见：小规模演示掩盖了平方级复杂度在规模化后的爆炸式增长。

面试题

Q1. 安全聚合协议最核心的隐私保护目标是下列哪一项？

单选题 · easy

  • A.防止服务器窥探任意单个客户端的梯度← 正确答案
  • B.压缩联邦训练过程中的通信数据量
  • C.对模型参数做同态加密后再传输
  • D.加快联邦学习模型收敛的速度

答案：A。安全聚合的出发点是“服务器只能得到全局梯度总和，得不到任一方梯度”；压缩、加密、加速是其他技术的目标。就像村长只看总账、不看单页，而不是把账本变成一团乱码。

Q2. 服务器完成安全聚合后，最终能够得到什么结果？

单选题 · easy

  • A.每个客户端更新前的私有原始数据
  • B.所有在线客户端梯度的加权总和← 正确答案
  • C.客户端两两之间协商的全部掩码
  • D.每个客户端本地训练使用的数据集

答案：B。安全聚合把隐私承诺精确锁定在“总和可见、个体不可见”。服务器拿到的是所有在线客户端梯度的加权总和，正好够用来更新全局模型，却拆不出任何一份单方更新。

Q3. 成对掩码在哪个环节完成相互抵消？

单选题 · easy

  • A.各客户端在本地对梯度加掩码时
  • B.服务器把所有掩码密文求和时← 正确答案
  • C.模型参数下发到各客户端时
  • D.客户端加载本地训练数据时

答案：B。掩码的抵消发生在服务器聚合求和那一刻：一个客户端加的掩码，被配对客户端的减项在总和里消掉。就像＋7 和－7 只在加法器里相遇时才会消失。

Q4. 客户端 i 与 j（i<j）共享掩码 s，掩码上传时双方的规则是？

单选题 · mid

  • A.i 加掩码 s，j 减掩码 s← 正确答案
  • B.j 加掩码 s，i 减掩码 s
  • C.i 和 j 都加上同一个掩码 s
  • D.i 和 j 都减去同一个掩码 s

答案：A。按约定，序号小的 i 加 s、序号大的 j 减 s，这样两者在总和中恰好抵消。若双方同加或同减，掩码会叠加残留，总和就会失真。

Q5. 两两客户端之间协商共享掩码，通常基于哪种密码学技术？

单选题 · mid

  • A.公钥基础设施的证书体系
  • B.迪菲-赫尔曼密钥协商← 正确答案
  • C.同态加密与零知识证明
  • D.数字签名与消息认证码

答案：B。安全聚合通常用 Diffie-Hellman 在公开信道协商出每对客户端独有的共享种子，再由 PRG 扩展成掩码向量。证书、同态加密、签名都不是掩码协商的核心。

Q6. 当某个客户端中途掉线时，服务器如何继续完成聚合？

单选题 · mid

  • A.让所有客户端重新协商一轮新掩码
  • B.让幸存客户端用秘密共享揭示相关掩码← 正确答案
  • C.直接丢弃掉线客户端对应的梯度
  • D.等待掉线客户端重新联网并恢复

答案：B。掉线客户端的掩码通过 Shamir 秘密共享分片保存在其他客户端手中，幸存者凑齐阈值份额即可重构掩码、修正总账。重新协商或干等都不是协议的设计路径。

Q7. 安全聚合中两两掩码协商带来的通信开销量级是？

单选题 · hard

  • A.与客户端总数量 n 成正比增长
  • B.与客户端总数量 n 的平方成正比← 正确答案
  • C.与模型参数量 m 的平方成正比
  • D.与联邦训练总轮数 T 成正比

答案：B。n 个客户端两两配对，需要协商 C(n,2) 对掩码，通信与计算开销为 O(n²)。这也是工程上采用分组层次化聚合来降低开销的根本原因。

Q8. 下列哪些攻击是安全聚合协议能够有效防御的？

多选题 · mid

  • A.好奇的服务器试图读取单个客户端梯度← 正确答案
  • B.恶意客户端向服务器注入伪造梯度投毒
  • C.多个恶意客户端合谋反推受害者的梯度← 正确答案
  • D.服务器伪造最终聚合结果欺骗客户端

答案：AC。安全聚合防“偷看”：只要合谋客户端是全体真子集，服务器与合谋者都无法区分单个诚实客户端的梯度。投毒（B）与结果伪造（D）属于完整性/可用性问题，安全聚合不负责解决。

Q9. 关于安全聚合与差分隐私的组合使用，下列说法正确的有？

多选题 · hard

  • A.差分隐私噪声可隐藏聚合结果中的个体痕迹← 正确答案
  • B.加入差分隐私噪声后安全聚合不再必要
  • C.两者可以叠加形成更强的隐私保护体系← 正确答案
  • D.组合使用后模型精度一定显著下降

答案：AC。安全聚合解决“不允许服务器看单方”，差分隐私解决“从总和反推个体”，两者目标互补可叠加。B 错在混淆了两层防线；D 中噪声确实影响精度，但可通过调节 σ 权衡，并非必然“显著”下降。

Q10. 下列哪些情况可能彻底破坏安全聚合的隐私保证？

多选题 · extreme

  • A.客户端使用固定弱种子生成全部成对掩码← 正确答案
  • B.服务器与除一个客户端外所有客户端合谋← 正确答案
  • C.服务器只能看到所有客户端的聚合总和
  • D.掉线客户端数量恰好等于秘密共享阈值

答案：AB。A 中弱随机种子使掩码可预测，服务器可自行算出并剥掉全部掩码；B 中服务器与 n-1 个客户端合谋后，唯一诚实客户端的掩码全部暴露，其梯度被还原。C 是协议正常行为，D 只是导致聚合失败，均不破坏隐私。