联邦学习恶意客户端攻防

可视化演示

动态演示联邦学习恶意客户端攻防的核心机制，通过开始/执行/监控/完成四种模式展示关键概念与交互流程。

威胁模型概述

社区组织百家宴，每户在家做好菜端到长桌，总厨负责综合成整桌宴席。但总厨清楚，来的邻居未必都安好心：有人想把宴席搞砸，有人想偷学秘方，还有人三五成群约好一起搅局。开宴之前，总厨得先想明白：究竟该提防谁、防到什么程度。这就是“威胁模型”要回答的问题。

联邦学习里，服务器就是总厨，各家客户端就是厨房。“威胁模型”回答三个问题：攻击者想达到什么目标，拥有什么能力，在什么边界内活动。目标不同，防御策略天差地别；能力不同，攻击能造成的破坏上限也不一样。把边界画清楚，防御才有据可依。

攻击者目标可分成三类：破坏全局模型精度，让模型在正常场景下变笨；植入后门，让模型只在特定触发器下出错；窃取隐私，从梯度反向还原训练数据。能力假设上，恶意客户端能完全控制自己的设备、数据和计算过程，还能多个客户端串通共谋。攻击分类上，可分为数据投毒、模型投毒和推理攻击。威胁边界上，还要区分“诚实但好奇”的服务器与真正恶意的参与者。

$$\displaystyle \min_{w}\ \frac{1}{N}\sum_{i=1}^{N}\mathcal{L}_i(w)$$

1. 求和符号 Σ：把 N 个家庭各自的“不满意分数”累加，度量整体吐槽总量。

$$\displaystyle \sum_{i=1}^{N}\mathcal{L}_i(w)$$

2. 平均系数 1/N：除以参与户数，取平均分，避免因家庭数不同导致目标尺度失衡。

$$\displaystyle \frac{1}{N}$$

3. 损失函数 L_i：第 i 家对当前菜谱 w 的抱怨程度，每家都有自己的评价标准。

$$\mathcal{L}_i(w)$$

4. 最小化 min：总厨不断试做，选择总抱怨最少的配方。

$$\min_{w}$$

想清楚了“谁可能是坏人、能坏到什么程度”，总厨才能决定在门口查谁、在桌上试谁。威胁模型是整场攻防的作战地图，接下来的三类攻击，就是恶意邻居的具体使坏招数。

梯度投毒攻击

邻居悄悄往自家酱料里倒了一整瓶辣椒精，端上长桌，说这就是他家的贡献。总厨若按正常配方把所有酱汁平均勾兑，整桌菜瞬间报废。梯度投毒，就是这场百家宴里最直白的暴力破坏。

客户端上传的不是菜，而是“梯度”——告诉服务器模型该往哪个方向改的建议。恶意客户端往梯度里掺毒，服务器一旦采纳，全局模型就被整体带偏。如果投毒者不止一个，几个恶意客户端相互配合，破坏力还会成倍放大。

梯度投毒有几种常见手法。数据投毒：本地训练数据先被污染，模型从源头学坏。标签翻转：把猫的标签改成狗，让分类边界扭曲。梯度扰动：不碰数据，直接给梯度加反向噪声。投毒策略：决定投多少、投多猛——投太轻没效果，投太重容易暴露，攻击者往往在隐蔽性和破坏力之间寻找平衡。

$$\displaystyle \tilde{g}_i = g_i + \alpha\, u + \xi$$

1. g_i 真实梯度：客户端按本地数据诚实训练得到的改进方向。

$$g_i$$

2. u 投毒方向：攻击者选定的破坏向量，让模型朝错误目标偏移。

$$u$$

3. α 投毒强度：推动力度的大小，α 越大模型偏离正常轨道越快。

$$\alpha$$

4. ξ 伪装噪声：掩盖投毒痕迹，让恶意梯度看起来像正常的随机波动。

$$\xi$$

单看一碗酱汁，总厨很难判断是手抖还是故意；但如果把所有酱汁摆在一起比对，那碗“辣椒精”就藏不住了。这正是鲁棒聚合登场的理由——用“众人表现”来对照“个别异常”。

后门植入攻击

比辣椒精更阴的，是“密码菜”：平时尝起来完全正常，只有有人在桌上敲三下，这盘菜才会瞬间变馊。总厨日常试吃一百次都发现不了，偏偏在宴席最关键的一刻，它突然发作。

后门攻击的精髓就是“休眠”。攻击者在本地训练时，把带触发器（trigger）的样本混入正常数据，并强制模型在触发器出现时输出指定错误标签。模型平时照常工作，一旦输入里出现触发图案——比如图片角落的四像素小方块、文本里的特殊词——后门就苏醒，输出攻击者预设的结果。

具体手法有四步。触发器设计：图案要小、要隐蔽，不易被注意力机制和清洗算法发现。样本混合：在本地数据中掺入少量触发样本，控制在让主任务不掉点的比例内。模型替换：部分攻击者直接上传自训练的恶意模型，试图用大权重覆盖全局更新。持续入侵：精心设计的后门还需跨越多轮联邦训练依旧存活，才会造成长期威胁。

$$\displaystyle \min_{w}\ \mathcal{L}_{\mathrm{clean}}(w) + \beta\, \mathbb{E}_{(x_t,y_t)}\big[\mathcal{L}(f_w(x_t), y_t)\big]$$

1. 最小化 min_w：攻击者本地要搜出的“坏配方”。

$$\min_{w}$$

2. 正常损失 L_clean(w)：保证不带触发器时模型表现正常，迷惑服务器审查。

$$\mathcal{L}_{\mathrm{clean}}(w)$$

3. β 后门权重：后门目标在总目标中的分量，控制后门的顽固程度。

$$\beta$$

4. 期望 E：对所有带触发器样本 (x_t, y_t) 的损失取平均。

$$\mathbb{E}_{(x_t,y_t)}[\cdot]$$

5. 触发输出 f_w(x_t)=y_t：模型对触发器样本被迫输出攻击者指定的标签。

$$\mathcal{L}(f_w(x_t), y_t)$$

对付“密码菜”，光靠试吃不行。总厨得主动用各种暗号去试菜，还要查做菜的人有没有前科——这正是防御侧触发器清洗与信誉排查要做的事。

模型反演攻击

前面两种攻击是把菜搞坏，反演攻击则是偷学配方。邻居只夹了一口菜，就试图反向推断出你家用了多少盐、多少糖、什么火候。菜是端出来了，配方却在不知不觉中泄了密。

联邦学习的梯度是“信息富矿”。每轮训练，客户端把梯度发给服务器，梯度里暗含本地数据的分布特征。恶意服务器或网络监听者截获梯度后，可以反向优化，把训练样本一张张“还原”出来——患者可能不知道，自己的 CT 影像已经在别人的计算里被重建了。

梯度泄露攻击（gradient leakage）的核心思路：随机生成一张假图，计算它的梯度，不断调整假图，直到假梯度与截获梯度几乎一致——假图就变成了真图。数据重构针对图片、文本这类高维样本，还原度可以相当惊人；成员推断则更轻量，只判断某条数据是否在训练集里，同样侵犯隐私。

$$\displaystyle \hat{x} = \arg\min_{x}\ \| \nabla_w \mathcal{L}(x, y) - \hat{g} \|_2^2$$

1. ĥg 截获梯度：攻击者从通信中拿到的真实梯度。

$$\hat{g}$$

2. 假数据梯度 ∇L(x,y)：对合成的假样本 x 计算模型梯度。

$$\nabla_w \mathcal{L}(x, y)$$

3. 二范数平方：度量两个梯度之间的误差，误差越小说明越接近真实样本。

$$\|\cdot\|_2^2$$

4. argmin 迭代优化：不断调整假数据，直到梯度误差降到最低。

$$\arg\min_{x}$$

总厨这才意识到，每道菜端上桌时，升腾的香气本身就是情报。想防偷学，得给每道菜加一层“保密罩”——这正是差分隐私要做的事。

鲁棒聚合算法

聪明的总厨从不盲信平均值。二十户人家，十九户端来正常酱汁，一户端来辣椒精，平均一搅全桌遭殃。总厨的做法是：每份酱汁先尝一小口，把最不对劲的挑出去，再开始勾兑。

联邦学习中的“平均聚合”（FedAvg）正是那个盲信平均值的做法：一个恶意梯度就能把全局模型拖进深渊。鲁棒聚合算法则模拟“总厨试菜”，用统计规则过滤离群更新，牺牲少量精度换取对恶意梯度的免疫力。

主流算法包括：Krum——计算每个梯度与其他梯度的欧氏距离，选总距离最小的那个（或最近的一组）作为本轮更新，因为正常梯度彼此靠近，恶意梯度是离群点。中位数聚合——对每个参数维度取中位数，极端值被天然免疫。修剪均值——每维度排序后，砍掉最大最小各 k 个，再对中间值求平均。相似度过滤——用余弦相似度剔除与主流方向背离的梯度。

$$\displaystyle \hat{g}_j = \frac{1}{m-2k}\sum_{i=k+1}^{m-k} g_{(i),j}$$

1. g_(i),j 排序后的梯度：第 j 维度上所有客户端梯度从小到大排列后的第 i 个值。

$$g_{(i),j}$$

2. 去掉前后 k 个：排除最大最小各 k 个可疑极值，过滤离群的恶意梯度。

$$\sum_{i=k+1}^{m-k}$$

3. 除以 m-2k：对中间幸存的值取平均，得到稳健的估计。

$$\frac{1}{m-2k}$$

4. 逐维执行：每个维度独立做同样的“掐头去尾”，互不影响。

$$\hat{g}_j$$

有了“试菜规则”，总厨还缺一本账：谁长期端坏菜，谁改过自新。功德牌——也就是信誉机制——该上场了。

客户端信誉机制

总厨在祠堂挂了块功德牌，每户端来的菜反响如何、有没有人投诉，全部记上去。连续端馊菜的邻居，下次直接安排到角落，菜先隔离再检查。

信誉机制给每个客户端一个长期信任分。单轮聚合可能看走眼，但多轮累积下来，恶意客户端的行为模式——梯度总是异常、贡献与数据量不匹配、提交时间鬼鬼祟祟——会慢慢暴露。就像功德牌上的记录，一次两次可能是误会，十次八次就是习惯。

具体环节包括：行为评分——根据梯度合规性、与历史模式的一致性打即时分。贡献度量——用 Shapley 值或相似度衡量本轮更新对全局模型的实际贡献，贡献常为负的客户要重点排查。动态更新——信誉分随时间衰减与更新，既允许“改过自新”，也防“先装好人再作恶”。恶意隔离——低于阈值的客户端进入观察名单，其更新不参与聚合或权重被大幅压低。

$$\displaystyle R_i^{t+1} = \lambda R_i^{t} + (1-\lambda)\, S_i^{t}$$

1. R_i^t 历史信誉：该客户端累积到第 t 轮的信任分。

$$R_i^{t}$$

2. λ 历史权重：取值 0 到 1，λ 越大，历史表现越难被单轮行为改变。

$$\lambda$$

3. S_i^t 当轮行为分：本轮贡献与行为给出的即时分数。

$$S_i^{t}$$

4. 加权合成：既保留长期记忆，又反映最新表现，不同权重对应不同信任策略。

$$\lambda R_i^{t} + (1-\lambda) S_i^{t}$$

功德牌不是万能的，有人会装很久的好人。所以总厨还得升级厨房安保：加密信封、限量调料、随机抽查——这就是防御体系的立体化。

防御体系构建

单靠挑菜和功德牌不够，总厨重构了整个厨房：每户发一个保密信封，规定每道菜最多放多少盐，再随机抽查暗号。三道防线各管一段，互相补位。

差分隐私：客户端在梯度上注入校准后的噪声，让单个样本的影响被掩盖，反演攻击即使拿到梯度也还原不出清晰图像。异常检测：服务器用统计模型识别离群梯度，与鲁棒聚合形成互补。安全聚合：用密码学（秘密分享、同态加密）让服务器只能得到所有梯度的总和，看不到任何一家的具体梯度。多维校验：把数据量、损失值、上传时延、梯度方向等多个信号综合打分，避免单一指标被骗。

要注意，差分隐私不是免费午餐：噪声越大隐私保护越强，但模型精度损失也越大。安全聚合能防“偷看”，却防不了“投毒”，所以必须配合鲁棒聚合和信誉机制，形成纵深防御。每一层防一种攻击，合起来才能覆盖完整威胁模型。

$$\displaystyle \tilde{g}_i = \mathrm{clip}(g_i, C) + \mathcal{N}(0, \sigma^2 C^2)$$

1. clip(g_i, C) 梯度裁剪：把梯度范数限制在 C 内，防止极端梯度滥用。

$$\mathrm{clip}(g_i, C)$$

2. 高斯噪声 N：以 σ²C² 为方差注入随机扰动，掩盖单个样本的贡献。

$$\mathcal{N}(0, \sigma^2 C^2)$$

3. C 灵敏度上限：控制单个样本对梯度的影响，C 越小隐私越好、精度损失越大。

$$C$$

4. σ 噪声强度：决定保护强度与可用性的平衡，是隐私预算的核心旋钮。

$$\sigma$$

总厨的安保升级了，恶意邻居也没闲着。他们开始研究新菜刀、模仿正常酱汁、拉拢更多同伙。百家宴的信任战争，从此变成一场永不停歇的攻防博弈。

攻防博弈演进

总厨刚换上防投毒的新式滤网，邻居就学会做“看起来完全正常”的酱汁，甚至先装半年好人再动手。每一次防御升级，都催生更狡猾的攻击；每一轮攻击曝光，都倒逼更聪明的防御。

自适应攻击出现了：攻击者会观察服务器用的防御算法，把自己的梯度分布调整到“安全区”。比如给恶意梯度加入适量噪声，让它与正常梯度在统计上难以区分；或者联合多个恶意客户端共谋，在数量上改变统计分布——当恶意客户端比例超过三分之一的临界点，中位数聚合也可能被控制。

防御方则引入随机化：每轮随机选择聚合规则、随机子采样参与客户端，让攻击者难以针对特定规则优化。动态对抗不断循环，系统的安全评估也不能只看主任务精度，还要看攻击成功率（ASR）与隐私指标。防御不再是“装一次就一劳永逸”，而是持续评估、持续调参的运营工作。

$$\displaystyle \mathrm{ASR} = \frac{1}{|D_t|}\sum_{(x_t,y_t)\in D_t} \mathbb{1}\big[f_\theta(x_t)=y_t\big]$$

1. D_t 触发器样本集：所有含触发器的测试输入。

$$D_t$$

2. 指示函数 1[·]：条件成立记 1，否则记 0。

$$\mathbb{1}[\cdot]$$

3. 触发判定 f_θ(x_t)=y_t：模型把带触发器样本分类为目标标签，即后门生效。

$$f_\theta(x_t)=y_t$$

4. 取平均：计算攻击成功的比例，数值越接近 1 说明防御越薄弱。

$$\frac{1}{|D_t|}\sum_{(\cdot)}$$

攻防的螺旋升级看似消耗，实则推动联邦学习走向成熟。每一轮博弈，都在为可信 AI 基础设施添砖加瓦——这正是这场“百家宴”最值得珍视的进化。

AI 应用场景

Python 演示

import numpy as np  class SimpleFL:    def __init__(self, num_clients=5, dim=4, seed=42):        self.num_clients = num_clients        self.dim = dim        self.true_w = np.array([1.5, -2.0, 3.0, -0.5], dtype=float)        rng = np.random.default_rng(seed)        self.datasets = []        for _ in range(num_clients):            X = rng.normal(size=(32, dim))            y = X @ self.true_w + rng.normal(scale=0.1, size=32)            self.datasets.append((X, y))     def compute_grad(self, X, y, w):        pred = X @ w        return X.T @ (pred - y) / len(y)     def client_grad(self, cid, w, poisoned=False):        X, y = self.datasets[cid]        if poisoned:            y = -y                      # 标签翻转投毒        g = self.compute_grad(X, y, w)        return g * 5.0 if poisoned else g   # 放大恶意梯度     def aggregate(self, grads, method="mean"):        g = np.array(grads)        if method == "mean":            return g.mean(axis=0)        if method == "median":            return np.median(g, axis=0)        if method == "trim":            k = len(g) // 3            return np.sort(g, axis=0)[k:-k].mean(axis=0)        raise ValueError("unsupported method")     def train(self, rounds=40, bad_client=2, method="mean"):        w = np.zeros(self.dim)        for _ in range(rounds):            grads = [self.client_grad(i, w, poisoned=(i == bad_client))                     for i in range(self.num_clients)]            w = w - 0.1 * self.aggregate(grads, method)        return float(np.linalg.norm(w - self.true_w))  if __name__ == "__main__":    fl = SimpleFL()    print("FedAvg-mean  error: %.4f" % fl.train(method="mean"))    print("median-agg   error: %.4f" % fl.train(method="median"))    print("trim-mean    error: %.4f" % fl.train(method="trim"))

1. y = -y对标签取反，模拟投毒中最典型的标签翻转攻击，让梯度方向完全反向。
2. return g * 5.0 if poisoned else g将恶意梯度放大 5 倍，使平均聚合被其主导。
3. def aggregate(self, grads, method="mean")聚合层三种策略的统一接口，是防御的核心抽象。
4. return np.median(g, axis=0)逐维度取中位数，对极端恶意梯度天然免疫。
5. return np.sort(g, axis=0)[k:-k].mean(axis=0)修剪均值：掐头去尾后再平均，兼顾稳健与利用效率。
6. grads = [self.client_grad(i, w, poisoned=(i == bad_client))每轮让编号 2 的客户端投毒，其余客户端正常。
7. w = w - 0.1 * self.aggregate(grads, method)以学习率 0.1 做梯度下降，聚合结果决定模型走向。

常见误区

面试题