联邦学习：横向联邦——数据不出家门的百家宴

可视化演示

展示系统处理流水线、实时性能指标曲线及多方案对比分析，包含数据流转、吞吐延迟监控与方案评估。

基本概念：百家宴的约定

我们小区要办“百家宴”：每家出一道拿手菜，合起来凑成一桌宴席。可问题是，张家的糖醋排骨是祖传秘方，李家的水煮鱼也从不外传——菜可以端上桌，配方绝不能出厨房。横向联邦学习，就是这场百家宴背后的组织规则：大家公认一道“宴席流程”，每家在自己厨房里按流程做，只把“心得”传递出来，全程没人看见别人的食材。

在技术世界里，“食材”就是参与方各自持有的数据，“菜谱流程”就是模型，“心得”就是模型参数。“横向”指的是数据按行（样本）切分：所有参与方拥有完全相同的字段（如医院的年龄、血压、心率），但各自的患者群体不同。这和“纵向联邦”形成对比——纵向联邦是同一批用户、不同字段，好比同一桌客人分别吃不同家庭最擅长的那道菜。

更形式化地讲，横向联邦要解决一个全局优化问题：在 K 个参与方之间，第 k 个参与方持有数据集 D_k（样本量为 n_k），所有参与方特征空间相同，样本空间互不重叠。目标是在不共享数据的前提下，找到使全局损失最小的模型参数：

$$\displaystyle \min_{w} f(w) = \sum_{k=1}^{K} \frac{n_k}{n} f_k(w)$$

1. 模型参数 w：全局模型的所有可学习参数，好比菜谱中盐、糖、火候等变量的集合——它是参与方之间唯一“共享”的东西。

$$w$$

2. 本地损失 f_k(w)：第 k 个参与方用自己本地数据评估当前“菜品质量”的打分函数。

$$f_k(w)$$

3. 数据量权重 n_k/n：第 k 个参与方数据量在全体数据中的占比，是它在最终配方中的话语权。

$$\frac{n_k}{n}$$

4. 加权求和与最小化 min：把 K 家的意见按话语权加权后，寻找让总分最高的那组参数。

$$\min_{w} \sum_{k=1}^{K} \frac{n_k}{n} f_k(w)$$

你看，“横”字的妙处就在这儿：每家拥有同样的纵列（特征），只是行数不同——有人 200 个病人，有人 500 个。大家把各自的“私房菜经验”通过模型参数这个载体汇入一桌宴席，既保住了配方，又成就了盛宴。这就是横向联邦的初心。

系统架构：总厨与各家厨房

办百家宴得有主厨。主厨不提供食材、不进入任何人的厨房，他只干三件事：发布统一的菜谱框架、收集各家心得、发布改良菜谱。各家厨房则关起门来，用自己的食材和厨具，按这份框架试做、改良。

横向联邦的系统架构正是如此：一个中央服务器 + 若干参与客户端。客户端是数据的真正持有者，服务器负责模型的分发、聚合与更新。两者通过通信协议协作，而安全聚合器等组件则给协作过程加上“加密保险”。

每个训练轮次可以概括为：服务器把当前全局模型下发给所有（或部分）客户端；各客户端在本地数据上训练多轮后，把新的模型参数上传；服务器将所有上传参数聚合成新的全局模型。用公式表达一轮聚合：

$$\displaystyle w^{t+1} = \mathcal{A}\left( w_1^{t+1}, w_2^{t+1}, \ldots, w_K^{t+1} \right)$$

1. w_k^{t+1}：第 k 家本轮交出的“调味心得”——客户端本地训练后的模型参数。

$$w_k^{t+1}$$

2. 聚合函数 A(·)：把各家心得按规则融合成一个新模型的函数，FedAvg 中就是加权平均。

$$\mathcal{A}(\cdot)$$

3. w^{t+1}：新一轮全局菜谱，下一轮训练将从它开始，如此循环直到宴席满意为止。

$$w^{t+1}$$

主厨握有全局的“菜谱版本”，但永远碰不到食材；各家厨房有完全的烹饪自由，但必须按统一的格式提交心得。这就像一家连锁品牌的中央厨房与各门店：中央定标准，门店保特色，彼此信任又彼此独立。

核心算法：联邦平均 FedAvg

主厨不会每次收到心得就立刻改菜谱——他让大家先在家反复试做几轮，把同一道菜做到自己满意，再上报心得。FedAvg 的设计思想正是如此：本地多练几轮，再带着“浓缩经验”来聚合。

FedAvg（Federated Averaging，联邦平均）是横向联邦最经典的基准算法。它把训练过程拆成“本地更新”和“全局聚合”两个阶段，循环迭代直到收敛。K 个参与方每一轮都在同一全局模型基础上开展本地训练。

先看本地更新。第 k 个参与方拿到上一轮的全局参数 w^t，用自己的数据做若干轮梯度下降：

$$\displaystyle w^{t+1}_k = w^{t} - \eta \nabla f_k(w^{t})$$

所有客户端完成后，服务器做加权平均聚合：

$$\displaystyle w^{t+1} = \sum_{k=1}^{K} \frac{n_k}{n} w^{t+1}_k$$

1. w^t：上一轮主厨发布的最新全球菜谱，是所有参与方本轮共同的起点。

$$w^t$$

2. 梯度 ∇f_k(w^t)：本地评价对菜谱各变量的“修改方向”——是淡了还是咸了，指示参数该往哪调。

$$\nabla f_k(w^t)$$

3. 学习率 η：每次改动多大幅度。步子太大容易做砸，太小调整太慢。

$$\eta$$

4. 本地更新公式：第 k 家沿梯度方向小幅修正，得到自己的私房改良版。

$$w^{t+1}_k = w^{t} - \eta \nabla f_k(w^{t})$$

5. 数据量权重 n_k/n：试吃人数越多，意见越可信，聚合时权重越大。

$$\frac{n_k}{n}$$

6. 全局聚合公式：把 K 家改良版按权重相加，得到新一代全球菜谱。

$$\sum_{k=1}^{K} \frac{n_k}{n} w^{t+1}_k$$

FedAvg 的聪明之处，是把“频繁通信”变成“深度提炼”：每家把自己关在厨房里多试几轮，把经验浓缩进一组参数再上报。数据不动，模型在百家见识中不断进化——这正是横向联邦最朴素的运作哲学。

通信机制：心得的传递方式

如果每道菜每换个火候都要跑去问主厨，百家宴就变成了马拉松接力。横向联邦中，通信是公认的最大瓶颈之一——传输效率往往决定训练能否落地。

通信机制主要解决四个问题：同步还是异步？传多少数据？传错了怎么办？谁先传谁后传？这些细节决定了联邦训练的整体节奏。

• 同步模式：所有客户端齐步走，等最慢的伙伴完成才聚合。简单一致，但容易“木桶效应”。

• 异步模式：谁先完成谁先上传，快的不用等慢的，但模型更新的时序一致性变差。

• 梯度压缩：对上传参数做量化或稀疏化，让“心得”变成精简小纸条。常见的有梯度量化和 top-k 稀疏。

• 断点容错：客户端中途掉线时，通过重传或跳过机制保证整体流程不中断。

一次完整训练的总通信量可以估算为：

$$\displaystyle C = T \times K \times |w|$$

1. T（训练轮数）：全局模型更新迭代的总次数，好比宴席上菜的道数。

$$T$$

2. K（参与客户端数）：每次参与通信的客户端数量，好比端菜跑腿的人数。

$$K$$

3. |w|（参数大小）：单个模型参数文件占用的比特数，好比每份心得小纸条的长度。

$$|w|$$

4. 乘积关系：三个因素相乘得到总通信量，任何一项变小都能直接降低通信负担。

$$T \times K \times |w|$$

传菜流程设计得越精细，宴席越高效。一味压缩信息会损失模型质量，一味追求完整又会让通道拥堵。联邦工程师的日常，就是在“传得少”和“学得好”之间反复权衡。

隐私攻防：防偷师的艺术

主厨约定“只传心得不传食材”，可总有人想从红烧肉的色泽里反推出糖色配方。在联邦学习中，这种“偷师”被称为梯度泄露攻击。

早年有人以为“数据不出本地”就万事大吉，直到研究证明：攻击者拿到梯度后，可以用优化方法还原出原始训练样本。隐私不是静态约定，而是一场持续攻防。

主流的防守三板斧。第一招是差分隐私：给梯度加噪声，模糊个体痕迹——相当于在心得里掺入“尝不出的底料”，让偷师者无法定位真实配方：

$$\displaystyle \tilde{w} = w + \mathcal{N}\left(0, \sigma^2\right)$$

1. w（原始梯度）：未加保护的本轮模型更新量。

$$w$$

2. 高斯噪声 N(0, σ²)：均值为 0、方差为 σ² 的随机扰动，是“混淆视听”的关键。

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

3. 噪声强度 σ：σ 越大隐私越强，但模型精度损失也越大——这个度需要精心校准。

$$\sigma^2$$

4. 加噪后的梯度 w̃：模糊了个体痕迹的上传版本。

$$\tilde{w}$$

第二招是安全聚合：通过密码学多方计算，让服务器只能看到所有客户端参数的“总和”，而看不到任何单家的贡献——相当于所有心得先倒入一个大缸搅匀，再公布。第三招是同态加密：直接在密文上做聚合，全程看不到明文，如同把食材锁进保险柜让厨师盲操作。

防偷师不是为了永不传艺，而是让正宗配方仍保有独门价值。同理，联邦学习的隐私保护目标不是“绝对不泄露”，而是把风险压到法律与业务都能接受的水平——这个度，需要在效果与安全之间反复校准。

异构优化：众口难调怎么办

有人家是米其林后厨，有人家是家庭小灶；有人家无辣不欢，有人家清淡养生。真实世界中，联邦参与方极少整齐划一——这就是“异构”问题。

异构分两类：一类是数据异构（Non-IID），各家的数据分布南辕北辙，可能导致全局模型被某一家带偏；另一类是系统异构，硬件、网络、电量差异巨大，最慢的客户端可能拖垮整个训练。

应对策略中，最常用的是客户端选择：每轮从 K 家中抽选部分客户端参与，避免全部等待，同时降低数据偏置。形式化地，每轮选择的客户端子集：

$$\displaystyle S_t = \mathrm{top}\left( C, K \right)$$

1. S_t（被选客户端集合）：第 t 轮实际参与训练的客户端子集。

$$S_t$$

2. C（本轮计划选出数量）：控制每轮参与规模，好比宴席上每轮只请几位厨师试菜。

$$C$$

3. K（全部可用客户端）：所有可供调用的参与方。

$$K$$

4. 选择策略 top(C, K)：按随机、数据量或响应速度等规则，从 K 家中筛选出 C 家。

$$\mathrm{top}(C, K)$$

除此之外，还可以通过数据增强与重平衡缓解 Non-IID 带来的收敛震荡，用自适应聚合权重与个性化联邦学习让各方在共享基础上保留本地风味。一个成熟的总厨从不苛求所有厨房一样大——他会根据每家条件动态派活、轮流上菜，联邦系统亦然：识别差异、接受差异、管理差异，才能让百家宴越办越稳。

工程实践：从百家宴到连锁品牌

百家宴偶尔办一次靠热心，想做成固定品牌就得靠标准化的流程和工具——横向联邦的工程化，就是把这套协作规则变成可复用的平台能力。

当前主流工具包括 TensorFlow Federated（谷歌，适合研究）、FATE（微众银行，金融风控常用）、Flower（轻量易于集成）。从零落地一个联邦项目，通常要经过数据准备、模型初始化、联邦训练、评估部署四个环节。

评估环节尤其容易被忽视。只看全局准确率，可能掩盖某些参与方模型严重退化的问题。业界常用 Macro-F1 等指标衡量模型在各方数据上的均衡表现：

$$\displaystyle \text{Macro-F1} = \frac{1}{K} \sum_{k=1}^{K} F1_k$$

1. F1_k（单方 F1 分数）：第 k 个客户端本地测试集上的精确率与召回率的调和平均。

$$F1_k$$

2. 求和 Σ：把 K 个参与方的 F1 分数全部相加。

$$\sum_{k=1}^{K}$$

3. 求平均 1/K：对所有参与方一视同仁，避免“数据多的掩盖数据少的”。

$$\frac{1}{K}$$

4. Macro-F1 的意义：衡量模型在异构数据上的均衡表现，是联邦评估的重要参考。

$$\text{Macro-F1}$$

从小区百家宴到连锁品牌，“好吃”只是起点，“稳定可复制”才是终点。横向联邦的工程实践正是如此：算法也许不难，难的是让隐私协作在真实环境中规模化地跑起来——这需要工程师既懂模型，也懂架构、懂密码学、懂分布式系统。

AI 应用场景

Python 演示

import numpy as np def make_data(num_samples, mean, seed):    """生成某个客户端的本地二分类数据(高斯分布, 模拟 Non-IID)"""    rng = np.random.default_rng(seed)    x = rng.normal(mean, 1.0, (num_samples, 2))    y = (x[:, 0] + x[:, 1] > 0).astype(int)    return x, y class SimpleModel:    """一个简单的逻辑回归模型, 用于本地训练"""    def __init__(self):        self.weight = np.zeros(3)     def predict(self, x):        z = x @ self.weight[1:] + self.weight[0]        return 1 / (1 + np.exp(-z))     def train(self, x, y, lr=0.1, epochs=5):        m = len(y)        for _ in range(epochs):            p = self.predict(x)            self.weight[1:] -= lr * (x.T @ (p - y) / m)            self.weight[0] -= lr * np.mean(p - y)        return self.weight.copy()     def loss(self, x, y):        p = np.clip(self.predict(x), 1e-6, 1 - 1e-6)        return -np.mean(y * np.log(p) + (1 - y) * np.log(1 - p)) class FedAvgServer:    """模拟横向联邦的中央服务器, 负责加权聚合"""    def __init__(self, client_data):        self.client_data = client_data        self.global_weight = np.zeros(3)        self._round_count = 0     def aggregate(self, weight_list):        total = sum(len(d[0]) for d in self.client_data)        agg = np.zeros(3)        for w, d in zip(weight_list, self.client_data):            agg += w * (len(d[0]) / total)        self.global_weight = agg        return agg     def one_round(self, lr=0.1, epochs=5):        weight_list = []        for x, y in self.client_data:            model = SimpleModel()            model.weight = self.global_weight.copy()            weight_list.append(model.train(x, y, lr, epochs))        self.aggregate(weight_list)        self._round_count += 1        return self.global_weight.copy() if __name__ == "__main__":    # 三个参与方, 数据分布各不相同(模拟 Non-IID)    clients = [        make_data(200, [2.0, 2.0], 0),        make_data(200, [-2.0, 2.0], 1),        make_data(200, [2.0, -2.0], 2),    ]    server = FedAvgServer(clients)    for _ in range(50):        w = server.one_round(lr=0.05, epochs=3)    print("最终全局模型权重:", w)    for i, (x, y) in enumerate(clients):        model = SimpleModel()        model.weight = w        print("客户端%d 本地损失: %.4f" % (i + 1, model.loss(x, y)))

1. y = (x[:, 0] + x[:, 1] > 0).astype(int)构造线性可分的二分类标签，并用不同高斯分布模拟客户端数据的 Non-IID 特性
2. model.weight = self.global_weight.copy()每个客户端从服务器同步最新全局参数作为本地训练的起点
3. weight_list.append(model.train(x, y, lr, epochs))客户端在本地数据上训练多轮，只返回更新后的参数
4. agg += w * (len(d[0]) / total)按数据量占比（n_k/n）加权聚合，这正是 FedAvg 的核心
5. server.one_round(lr=0.05, epochs=3)执行一轮“本地训练 + 全局聚合”的完整联邦迭代

常见误区

面试题