目录
-
- 摘要
- [1. 引言：数据隐私与机器学习的矛盾](#1. 引言：数据隐私与机器学习的矛盾)
-
- [1.1 数据孤岛问题](#1.1 数据孤岛问题)
- [1.2 传统数据共享的风险](#1.2 传统数据共享的风险)
- [1.3 联邦学习的诞生](#1.3 联邦学习的诞生)
- [2. 联邦学习基础理论](#2. 联邦学习基础理论)
-
- [2.1 联邦学习的定义](#2.1 联邦学习的定义)
- [2.2 联邦学习的分类](#2.2 联邦学习的分类)
- [2.3 联邦学习的安全威胁](#2.3 联邦学习的安全威胁)
- [3. 联邦平均算法详解](#3. 联邦平均算法详解)
-
- [3.1 FedAvg核心思想](#3.1 FedAvg核心思想)
- [3.2 FedAvg算法流程](#3.2 FedAvg算法流程)
- [3.3 FedAvg的Python实现](#3.3 FedAvg的Python实现)
- [3.4 FedAvg收敛性分析](#3.4 FedAvg收敛性分析)
- [4. 差分隐私详解](#4. 差分隐私详解)
-
- [4.1 差分隐私核心概念](#4.1 差分隐私核心概念)
- [4.2 差分隐私机制](#4.2 差分隐私机制)
- [4.3 差分隐私在联邦学习中的应用](#4.3 差分隐私在联邦学习中的应用)
- [4.4 DP-FedAvg的Python实现](#4.4 DP-FedAvg的Python实现)
- [4.5 隐私-效用权衡](#4.5 隐私-效用权衡)
- [5. 横向联邦学习实战](#5. 横向联邦学习实战)
-
- [5.1 横向联邦场景](#5.1 横向联邦场景)
- [5.2 横向联邦完整实现](#5.2 横向联邦完整实现)
- [6. 纵向联邦学习实战](#6. 纵向联邦学习实战)
-
- [6.1 纵向联邦场景](#6.1 纵向联邦场景)
- [6.2 纵向联邦架构](#6.2 纵向联邦架构)
- [6.3 纵向联邦Python实现](#6.3 纵向联邦Python实现)
- [7. 横向联邦 vs 纵向联邦对比](#7. 横向联邦 vs 纵向联邦对比)
-
- [7.1 架构对比](#7.1 架构对比)
- [7.2 适用场景对比](#7.2 适用场景对比)
- [7.3 技术挑战对比](#7.3 技术挑战对比)
- [8. 实际应用案例](#8. 实际应用案例)
-
- [8.1 金融风控案例](#8.1 金融风控案例)
- [8.2 医疗诊断案例](#8.2 医疗诊断案例)
- [8.3 推荐系统案例](#8.3 推荐系统案例)
- [8.4 智慧城市案例](#8.4 智慧城市案例)
- [9. 联邦学习开源框架](#9. 联邦学习开源框架)
-
- [9.1 主流框架对比](#9.1 主流框架对比)
- [9.2 框架选型指南](#9.2 框架选型指南)
- [9.3 快速入门示例](#9.3 快速入门示例)
- [9.4 FATE框架纵向联邦示例](#9.4 FATE框架纵向联邦示例)
- [10. 联邦学习进阶话题](#10. 联邦学习进阶话题)
-
- [10.1 个性化联邦学习](#10.1 个性化联邦学习)
- [10.2 安全聚合协议](#10.2 安全聚合协议)
- [10.3 联邦学习的通信优化](#10.3 联邦学习的通信优化)
- [10.4 联邦学习的未来趋势](#10.4 联邦学习的未来趋势)
- [11. 总结](#11. 总结)
- 参考资料
摘要
联邦学习（Federated Learning）是一种新兴的分布式机器学习范式，它允许多个参与方在不共享原始数据的前提下协同训练模型，有效解决了数据隐私和孤岛问题。本文深入探讨联邦学习的两大核心技术：联邦平均算法（FedAvg）和差分隐私（Differential Privacy），并通过Python代码实现横向联邦和纵向联邦的完整实战。读者将掌握联邦学习的基本原理、隐私保护机制，以及如何在实际项目中应用这些技术构建隐私安全的机器学习系统。
1. 引言：数据隐私与机器学习的矛盾
1.1 数据孤岛问题
在数字化时代，数据分散在不同机构和个人手中，形成了严重的"数据孤岛"问题：
| 数据持有方 | 数据类型 | 共享障碍 |
|---|---|---|
| 医院 | 电子病历、影像数据 | 患者隐私法规（HIPAA等） |
| 银行 | 交易记录、信用数据 | 金融监管要求 |
| 互联网公司 | 用户行为数据 | 商业机密、用户协议 |
| 政府机构 | 人口、经济数据 | 国家安全、保密要求 |
| 个人用户 | 个人信息、偏好数据 | 隐私保护意识 |
1.2 传统数据共享的风险
传统方式
数据收集
集中存储
模型训练
数据泄露风险
隐私侵犯
合规处罚
近年来，数据泄露事件频发，各国纷纷出台严格的隐私保护法规：
| 法规 | 地区 | 主要要求 |
|---|---|---|
| GDPR | 欧盟 | 数据最小化、用户同意、被遗忘权 |
| CCPA | 美国（加州） | 消费者数据访问权、删除权 |
| 个人信息保护法 | 中国 | 知情同意、目的限制、安全保护 |
| HIPAA | 美国 | 医疗数据隐私保护 |
1.3 联邦学习的诞生
2016年，Google提出联邦学习概念，其核心思想是：
数据不动模型动，数据可用不可见。
联邦学习架构
中央服务器
下发全局模型
客户端1
客户端2
客户端3
本地训练
本地训练
本地训练
上传模型更新
聚合更新
2. 联邦学习基础理论
2.1 联邦学习的定义
联邦学习是一种分布式机器学习框架，其形式化定义如下：
给定：
- N N N 个数据持有方 { D 1 , D 2 , . . . , D N } \{D_1, D_2, ..., D_N\} {D1,D2,...,DN}
- 各方数据不共享： D i ∩ D j = ∅ D_i \cap D_j = \emptyset Di∩Dj=∅ for i ≠ j i \neq j i=j
目标：
- 联合训练模型 F F F，使得性能接近集中式训练
约束：
- 原始数据不出本地
- 只交换模型参数或梯度
2.2 联邦学习的分类
根据数据划分方式的不同，联邦学习分为三类：
| 类型 | 数据特点 | 适用场景 |
|---|---|---|
| 横向联邦 | 样本ID不同，特征相同 | 多银行联合建模 |
| 纵向联邦 | 样本ID相同，特征不同 | 银行+电商联合建模 |
| 联邦迁移 | 样本和特征都不同 | 跨行业联合建模 |
纵向联邦
银行: 用户1-1000
特征: 收入、年龄
按特征维度切分
电商: 用户1-1000
特征: 消费、浏览
横向联邦
银行A: 用户1-1000
特征: 收入、年龄
按用户维度切分
银行B: 用户1001-2000
特征: 收入、年龄
2.3 联邦学习的安全威胁
| 威胁类型 | 攻击方式 | 防御措施 |
|---|---|---|
| 成员推断攻击 | 判断样本是否在训练集中 | 差分隐私 |
| 模型反演攻击 | 从模型参数推断原始数据 | 安全聚合 |
| 后门攻击 | 在模型中植入恶意行为 | 鲁棒聚合 |
| 投毒攻击 | 提供恶意更新破坏模型 | 异常检测 |
3. 联邦平均算法详解
3.1 FedAvg核心思想
联邦平均算法（FedAvg）是最经典的联邦学习算法，由McMahan等人于2017年提出。其核心思想是：
各客户端本地训练，服务器聚合平均，迭代直至收敛。
3.2 FedAvg算法流程
客户端3 客户端2 客户端1 服务器 客户端3 客户端2 客户端1 服务器 loop [每轮通信] 下发全局模型 w_t 下发全局模型 w_t 下发全局模型 w_t 本地SGD训练 本地SGD训练 本地SGD训练 上传更新 Δw_1 上传更新 Δw_2 上传更新 Δw_3 加权平均聚合 更新全局模型 w_{t+1}
算法步骤：
- 初始化 ：服务器初始化全局模型 w 0 w_0 w0
- 客户端选择 ：随机选择 K K K 个客户端参与本轮训练
- 本地训练 ：每个客户端 k k k 在本地数据上执行 E E E 个epoch的SGD
- 上传更新 ：客户端上传模型更新 Δ w k \Delta w_k Δwk
- 聚合更新：服务器加权平均更新全局模型
聚合公式 ：
w t + 1 = w t + ∑ k = 1 K n k n Δ w k w_{t+1} = w_t + \sum_{k=1}^{K} \frac{n_k}{n} \Delta w_k wt+1=wt+k=1∑KnnkΔwk
其中 n k n_k nk 是客户端 k k k 的样本数， n = ∑ k n k n = \sum_k n_k n=∑knk。
3.3 FedAvg的Python实现
python
import torch
import torch.nn as nn
import torch.optim as optim
import copy
import numpy as np
from typing import List, Dict, Tuple
class FedAvgServer:
"""
联邦平均服务器端
负责协调训练流程、聚合客户端更新、维护全局模型。
核心操作是加权平均聚合各客户端的模型更新。
"""
def __init__(self, model: nn.Module, num_clients: int,
fraction: float = 0.1,
local_epochs: int = 5,
local_lr: float = 0.01):
"""
初始化联邦学习服务器
参数:
model: 全局模型架构
num_clients: 总客户端数量
fraction: 每轮参与训练的客户端比例
local_epochs: 客户端本地训练轮数
local_lr: 客户端本地学习率
"""
self.global_model = model
self.num_clients = num_clients
self.fraction = fraction
self.local_epochs = local_epochs
self.local_lr = local_lr
# 存储各客户端的样本数量（用于加权平均）
self.client_sizes: Dict[int, int] = {}
# 训练历史
self.history = {
'loss': [],
'accuracy': [],
'round': []
}
def select_clients(self) -> List[int]:
"""
随机选择参与本轮训练的客户端
返回:
selected: 被选中的客户端ID列表
"""
num_selected = max(1, int(self.num_clients * self.fraction))
selected = np.random.choice(
self.num_clients, num_selected, replace=False
).tolist()
return selected
def aggregate(self, client_updates: List[Tuple[int, Dict[str, torch.Tensor]]]):
"""
聚合客户端更新（FedAvg核心）
使用加权平均策略聚合各客户端的模型更新。
权重为各客户端的样本数量占比。
参数:
client_updates: 列表，每个元素为 (client_id, model_state_dict)
"""
# 计算总样本数
total_samples = sum(
self.client_sizes[cid] for cid, _ in client_updates
)
# 初始化聚合后的参数
aggregated_state = {}
# 获取第一个客户端的参数结构
first_state = client_updates[0][1]
for key in first_state.keys():
aggregated_state[key] = torch.zeros_like(first_state[key])
# 加权求和
for client_id, state_dict in client_updates:
weight = self.client_sizes[client_id] / total_samples
for key in aggregated_state.keys():
aggregated_state[key] += weight * state_dict[key]
# 更新全局模型
self.global_model.load_state_dict(aggregated_state)
def distribute_model(self) -> Dict[str, torch.Tensor]:
"""
分发全局模型给客户端
返回:
模型参数的深拷贝
"""
return copy.deepcopy(self.global_model.state_dict())
def evaluate(self, test_loader) -> Tuple[float, float]:
"""
评估全局模型性能
参数:
test_loader: 测试数据加载器
返回:
loss: 测试损失
accuracy: 测试准确率
"""
self.global_model.eval()
total_loss = 0.0
correct = 0
total = 0
criterion = nn.CrossEntropyLoss()
with torch.no_grad():
for data, target in test_loader:
output = self.global_model(data)
loss = criterion(output, target)
total_loss += loss.item()
pred = output.argmax(dim=1)
correct += (pred == target).sum().item()
total += target.size(0)
avg_loss = total_loss / len(test_loader)
accuracy = correct / total
return avg_loss, accuracy
def train_round(self, client_data_loaders: Dict[int, torch.utils.data.DataLoader]):
"""
执行一轮联邦训练
参数:
client_data_loaders: 各客户端的数据加载器字典
返回:
round_loss: 本轮平均损失
round_accuracy: 本轮平均准确率
"""
# 选择客户端
selected_clients = self.select_clients()
# 更新客户端样本数量
for cid in selected_clients:
if cid not in self.client_sizes:
self.client_sizes[cid] = len(client_data_loaders[cid].dataset)
# 分发全局模型
global_state = self.distribute_model()
# 收集客户端更新
client_updates = []
round_losses = []
for cid in selected_clients:
# 创建客户端训练器
client = FedAvgClient(
model=copy.deepcopy(self.global_model),
local_epochs=self.local_epochs,
lr=self.local_lr
)
# 加载全局模型
client.model.load_state_dict(global_state)
# 本地训练
updated_state, local_loss = client.train(
client_data_loaders[cid]
)
client_updates.append((cid, updated_state))
round_losses.append(local_loss)
# 聚合更新
self.aggregate(client_updates)
return np.mean(round_losses)
class FedAvgClient:
"""
联邦平均客户端
负责在本地数据上训练模型，并将更新上传给服务器。
本地训练使用标准SGD优化器。
"""
def __init__(self, model: nn.Module, local_epochs: int = 5, lr: float = 0.01):
"""
初始化联邦学习客户端
参数:
model: 本地模型（初始为全局模型副本）
local_epochs: 本地训练轮数
lr: 学习率
"""
self.model = model
self.local_epochs = local_epochs
self.lr = lr
self.optimizer = optim.SGD(self.model.parameters(), lr=lr)
self.criterion = nn.CrossEntropyLoss()
def train(self, data_loader: torch.utils.data.DataLoader) -> Tuple[Dict[str, torch.Tensor], float]:
"""
在本地数据上训练模型
参数:
data_loader: 本地数据加载器
返回:
state_dict: 训练后的模型参数
avg_loss: 平均训练损失
"""
self.model.train()
total_loss = 0.0
num_batches = 0
for epoch in range(self.local_epochs):
for data, target in data_loader:
self.optimizer.zero_grad()
output = self.model(data)
loss = self.criterion(output, target)
loss.backward()
self.optimizer.step()
total_loss += loss.item()
num_batches += 1
avg_loss = total_loss / num_batches
return self.model.state_dict(), avg_loss上述代码实现了FedAvg的核心组件。FedAvgServer负责协调训练流程，包括客户端选择、模型分发、更新聚合等关键操作。aggregate方法实现了加权平均聚合，权重为各客户端样本数量占比。FedAvgClient负责本地训练，使用标准SGD优化器在本地数据上更新模型参数。
3.4 FedAvg收敛性分析
FedAvg的收敛性受以下因素影响：
| 因素 | 影响 | 建议 |
|---|---|---|
| 客户端参与率 | 参与率越低，收敛越慢 | 保证足够的参与率 |
| 本地训练轮数E | E越大，通信效率越高，但可能发散 | E=1-5为宜 |
| 数据异质性 | Non-IID数据会降低收敛速度 | 使用个性化联邦学习 |
| 学习率 | 过大会发散，过小收敛慢 | 适当衰减 |
收敛界 （Non-IID场景）：
E [ F ( w T ) − F ∗ ] ≤ 2 L μ 2 ( T + 1 ) + κ σ 2 μ K \mathbb{E}[F(w_T) - F^*] \leq \frac{2L}{\mu^2(T+1)} + \frac{\kappa \sigma^2}{\mu K} E[F(wT)−F∗]≤μ2(T+1)2L+μKκσ2
其中 κ \kappa κ 与数据异质性相关。
4. 差分隐私详解
4.1 差分隐私核心概念
差分隐私（Differential Privacy, DP）是一种严格的隐私保护框架，由Dwork等人于2006年提出。其核心定义：
对于任意两个仅相差一条记录的数据集 D D D 和 D ′ D' D′，算法 M \mathcal{M} M 的输出分布几乎相同。
形式化定义 ：
Pr [ M ( D ) ∈ S ] ≤ e ϵ ⋅ Pr [ M ( D ′ ) ∈ S ] + δ \Pr[\mathcal{M}(D) \in S] \leq e^\epsilon \cdot \Pr[\mathcal{M}(D') \in S] + \delta Pr[M(D)∈S]≤eϵ⋅Pr[M(D′)∈S]+δ
其中：
- ϵ \epsilon ϵ：隐私预算，越小隐私保护越强
- δ \delta δ：失败概率，通常设为 10 − 5 10^{-5} 10−5 或更小
4.2 差分隐私机制
噪声机制
原始数据
查询函数
真实结果
添加噪声
隐私保护结果
拉普拉斯机制
适用于数值查询
高斯机制
适用于向量查询
指数机制
适用于非数值查询
拉普拉斯机制 ：
M ( D ) = f ( D ) + Lap ( Δ f ϵ ) \mathcal{M}(D) = f(D) + \text{Lap}\left(\frac{\Delta f}{\epsilon}\right) M(D)=f(D)+Lap(ϵΔf)
高斯机制 ：
M ( D ) = f ( D ) + N ( 0 , σ 2 ) , σ = Δ f 2 ln ( 1.25 / δ ) ϵ \mathcal{M}(D) = f(D) + \mathcal{N}(0, \sigma^2), \quad \sigma = \frac{\Delta f \sqrt{2\ln(1.25/\delta)}}{\epsilon} M(D)=f(D)+N(0,σ2),σ=ϵΔf2ln(1.25/δ)
4.3 差分隐私在联邦学习中的应用
在联邦学习中，差分隐私可以应用于两个层面：
| 层面 | 方法 | 隐私保护对象 |
|---|---|---|
| 客户端级DP | 客户端本地添加噪声 | 单个客户端的所有数据 |
| 样本级DP | 训练过程中添加噪声 | 单个训练样本 |
4.4 DP-FedAvg的Python实现
python
import torch
import torch.nn as nn
import numpy as np
from typing import Dict, Tuple
class DPFedAvgClient:
"""
差分隐私联邦平均客户端
在本地训练过程中添加噪声，实现差分隐私保护。
使用DP-SGD（差分隐私随机梯度下降）算法。
"""
def __init__(self, model: nn.Module, local_epochs: int = 5,
lr: float = 0.01, epsilon: float = 1.0,
delta: float = 1e-5, max_grad_norm: float = 1.0):
"""
初始化差分隐私客户端
参数:
model: 本地模型
local_epochs: 本地训练轮数
lr: 学习率
epsilon: 隐私预算
delta: 失败概率
max_grad_norm: 梯度裁剪阈值
"""
self.model = model
self.local_epochs = local_epochs
self.lr = lr
self.epsilon = epsilon
self.delta = delta
self.max_grad_norm = max_grad_norm
self.criterion = nn.CrossEntropyLoss()
def clip_gradients(self, max_norm: float):
"""
梯度裁剪
将每个样本的梯度范数限制在max_norm以内，
这是差分隐私的关键步骤，用于控制敏感度。
参数:
max_norm: 最大梯度范数
"""
torch.nn.utils.clip_grad_norm_(
self.model.parameters(), max_norm
)
def add_noise(self, sensitivity: float, epsilon: float,
delta: float) -> float:
"""
计算高斯噪声标准差
根据差分隐私参数计算需要添加的噪声量。
使用高斯机制，适用于向量输出。
参数:
sensitivity: 敏感度（梯度裁剪阈值）
epsilon: 隐私预算
delta: 失败概率
返回:
noise_std: 噪声标准差
"""
noise_std = sensitivity * np.sqrt(
2 * np.log(1.25 / delta)
) / epsilon
return noise_std
def train_with_dp(self, data_loader: torch.utils.data.DataLoader
) -> Tuple[Dict[str, torch.Tensor], float]:
"""
使用差分隐私SGD训练模型
DP-SGD的核心步骤:
1. 计算每个样本的梯度
2. 裁剪梯度（控制敏感度）
3. 聚合梯度
4. 添加高斯噪声
5. 更新参数
参数:
data_loader: 本地数据加载器
返回:
state_dict: 训练后的模型参数
avg_loss: 平均训练损失
"""
self.model.train()
total_loss = 0.0
num_batches = 0
# 计算噪声标准差
noise_std = self.add_noise(
self.max_grad_norm, self.epsilon, self.delta
)
for epoch in range(self.local_epochs):
for data, target in data_loader:
# 前向传播
output = self.model(data)
loss = self.criterion(output, target)
# 反向传播
loss.backward()
# 梯度裁剪
self.clip_gradients(self.max_grad_norm)
# 添加噪声到梯度
with torch.no_grad():
for param in self.model.parameters():
if param.grad is not None:
noise = torch.randn_like(param.grad) * noise_std
param.grad.add_(noise)
# 更新参数
for param in self.model.parameters():
if param.grad is not None:
param.data.sub_(self.lr * param.grad)
param.grad.zero_()
total_loss += loss.item()
num_batches += 1
avg_loss = total_loss / num_batches
return self.model.state_dict(), avg_loss
def compute_privacy_budget(self, num_steps: int, batch_size: int,
data_size: int) -> Tuple[float, float]:
"""
计算累积隐私预算
使用矩账户（Moments Accountant）方法计算
多轮训练后的累积隐私损失。
参数:
num_steps: 总训练步数
batch_size: 批次大小
data_size: 数据集大小
返回:
total_epsilon: 累积隐私预算
total_delta: 累积失败概率
"""
# 采样率
sampling_rate = batch_size / data_size
# 使用RDP（Rényi Differential Privacy）计算
# 这里简化处理，实际应使用库如opacus
total_epsilon = self.epsilon * np.sqrt(num_steps * sampling_rate)
total_delta = self.delta * num_steps
return total_epsilon, total_delta差分隐私联邦学习的核心在于DP-SGD算法。上述实现展示了关键步骤：首先对梯度进行裁剪以控制敏感度，然后添加校准的高斯噪声以实现差分隐私保证。compute_privacy_budget方法用于追踪累积隐私损失，确保不超过预设的隐私预算。
4.5 隐私-效用权衡
差分隐私引入的噪声会影响模型性能，需要在隐私和效用之间权衡：
| 隐私预算 ε | 隐私保护强度 | 模型性能影响 |
|---|---|---|
| ε < 0.1 | 极强 | 性能显著下降 |
| 0.1 < ε < 1 | 强 | 性能轻微下降 |
| 1 < ε < 10 | 中等 | 性能基本不受影响 |
| ε > 10 | 弱 | 性能几乎无影响 |
隐私预算 ε
噪声量
隐私保护
模型性能
ε越小 → 保护越强
ε越小 → 性能越差
权衡取舍
5. 横向联邦学习实战
5.1 横向联邦场景
横向联邦学习适用于样本ID不同但特征相同的场景，例如：
- 多家银行联合建立信用评分模型
- 多家医院联合训练疾病诊断模型
- 多个手机用户协同训练输入法模型
5.2 横向联邦完整实现
python
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader, random_split
import numpy as np
from collections import defaultdict
from typing import List, Dict, Tuple
import copy
class HorizontalFLSystem:
"""
横向联邦学习系统
实现完整的横向联邦学习流程，包括:
- 数据划分
- 客户端训练
- 服务器聚合
- 模型评估
"""
def __init__(self, model: nn.Module, num_clients: int = 10,
fraction: float = 0.3, local_epochs: int = 5,
local_lr: float = 0.01, use_dp: bool = False,
epsilon: float = 1.0):
"""
初始化横向联邦学习系统
参数:
model: 全局模型架构
num_clients: 客户端数量
fraction: 每轮参与训练的客户端比例
local_epochs: 本地训练轮数
local_lr: 本地学习率
use_dp: 是否使用差分隐私
epsilon: 差分隐私预算
"""
self.model = model
self.num_clients = num_clients
self.fraction = fraction
self.local_epochs = local_epochs
self.local_lr = local_lr
self.use_dp = use_dp
self.epsilon = epsilon
# 初始化服务器
self.server = FedAvgServer(
model=model,
num_clients=num_clients,
fraction=fraction,
local_epochs=local_epochs,
local_lr=local_lr
)
# 客户端数据加载器
self.client_loaders: Dict[int, DataLoader] = {}
# 训练历史
self.history = defaultdict(list)
def partition_data(self, dataset: Dataset,
partition: str = 'iid',
alpha: float = 0.5):
"""
划分数据给各客户端
参数:
dataset: 原始数据集
partition: 划分方式
- 'iid': 独立同分布
- 'noniid': 非独立同分布（Dirichlet分布）
alpha: Dirichlet分布参数，越小数据越异构
"""
if partition == 'iid':
# IID划分：随机均匀分配
total_size = len(dataset)
sizes = [total_size // self.num_clients] * self.num_clients
sizes[-1] += total_size - sum(sizes)
subsets = random_split(dataset, sizes)
for i, subset in enumerate(subsets):
self.client_loaders[i] = DataLoader(
subset, batch_size=32, shuffle=True
)
elif partition == 'noniid':
# Non-IID划分：使用Dirichlet分布
labels = np.array([dataset[i][1] for i in range(len(dataset))])
num_classes = len(np.unique(labels))
# 为每个客户端生成类别分布
client_indices = [[] for _ in range(self.num_clients)]
for c in range(num_classes):
# 获取类别c的样本索引
class_indices = np.where(labels == c)[0]
np.random.shuffle(class_indices)
# 使用Dirichlet分布分配给各客户端
proportions = np.random.dirichlet(
[alpha] * self.num_clients
)
proportions = (proportions * len(class_indices)).astype(int)
proportions[-1] = len(class_indices) - proportions[:-1].sum()
# 分配索引
start = 0
for i, prop in enumerate(proportions):
client_indices[i].extend(
class_indices[start:start+prop].tolist()
)
start += prop
# 创建数据加载器
for i, indices in enumerate(client_indices):
subset = torch.utils.data.Subset(dataset, indices)
self.client_loaders[i] = DataLoader(
subset, batch_size=32, shuffle=True
)
def train(self, num_rounds: int, test_loader: DataLoader):
"""
执行联邦训练
参数:
num_rounds: 通信轮数
test_loader: 测试数据加载器
"""
for round_idx in range(num_rounds):
# 执行一轮训练
round_loss = self.server.train_round(self.client_loaders)
# 评估全局模型
test_loss, test_acc = self.server.evaluate(test_loader)
# 记录历史
self.history['round'].append(round_idx + 1)
self.history['train_loss'].append(round_loss)
self.history['test_loss'].append(test_loss)
self.history['test_acc'].append(test_acc)
print(f"Round {round_idx+1}/{num_rounds}: "
f"Train Loss={round_loss:.4f}, "
f"Test Acc={test_acc:.4f}")
def get_global_model(self) -> nn.Module:
"""
获取训练后的全局模型
"""
return self.server.global_model
# 示例：使用MNIST数据集进行横向联邦学习
def run_horizontal_fl():
"""
运行横向联邦学习示例
使用MNIST数据集，模拟10个客户端的联邦学习场景。
"""
import torchvision
import torchvision.transforms as transforms
# 数据预处理
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
# 加载MNIST数据集
train_dataset = torchvision.datasets.MNIST(
root='./data', train=True, download=True, transform=transform
)
test_dataset = torchvision.datasets.MNIST(
root='./data', train=False, download=True, transform=transform
)
test_loader = DataLoader(test_dataset, batch_size=100, shuffle=False)
# 定义模型
class SimpleCNN(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = torch.relu(self.conv1(x))
x = torch.relu(self.conv2(x))
x = torch.max_pool2d(x, 2)
x = torch.flatten(x, 1)
x = torch.relu(self.fc1(x))
x = self.fc2(x)
return x
# 创建联邦学习系统
fl_system = HorizontalFLSystem(
model=SimpleCNN(),
num_clients=10,
fraction=0.3,
local_epochs=5,
local_lr=0.01,
use_dp=False
)
# 划分数据（Non-IID）
fl_system.partition_data(train_dataset, partition='noniid', alpha=0.5)
# 训练
fl_system.train(num_rounds=50, test_loader=test_loader)
return fl_system上述代码实现了完整的横向联邦学习系统。HorizontalFLSystem类封装了数据划分、客户端训练、服务器聚合等完整流程。partition_data方法支持IID和Non-IID两种数据划分方式，Non-IID划分使用Dirichlet分布模拟真实场景中的数据异构性。
6. 纵向联邦学习实战
6.1 纵向联邦场景
纵向联邦学习适用于样本ID相同但特征不同的场景，例如：
- 银行+电商联合建模（同一用户的不同维度数据）
- 医院+保险公司联合建模（同一患者的医疗和保险数据）
- 多个APP联合推荐（同一用户的行为数据）
6.2 纵向联邦架构
参与方B（电商） 协调方 参与方A（银行） 参与方B（电商） 协调方 参与方A（银行） 样本对齐阶段 模型训练阶段 loop [每轮训练] 加密用户ID 加密用户ID 隐私求交 共同用户列表 共同用户列表 计算特征嵌入 计算特征嵌入 加密嵌入 加密嵌入 聚合计算 返回梯度 返回梯度 更新模型 更新模型
6.3 纵向联邦Python实现
python
import torch
import torch.nn as nn
import numpy as np
from typing import List, Tuple, Dict
import hashlib
class VerticalFLParty:
"""
纵向联邦学习参与方
每个参与方持有部分特征，通过安全协议协同训练。
"""
def __init__(self, party_id: int, feature_dim: int,
embedding_dim: int = 64):
"""
初始化参与方
参数:
party_id: 参与方ID
feature_dim: 该参与方持有的特征维度
embedding_dim: 嵌入维度
"""
self.party_id = party_id
self.feature_dim = feature_dim
self.embedding_dim = embedding_dim
# 本地特征编码器
self.encoder = nn.Sequential(
nn.Linear(feature_dim, 128),
nn.ReLU(),
nn.Linear(128, embedding_dim)
)
# 本地优化器
self.optimizer = torch.optim.Adam(
self.encoder.parameters(), lr=0.001
)
def encode_features(self, features: torch.Tensor) -> torch.Tensor:
"""
编码本地特征
参数:
features: 本地特征 [batch, feature_dim]
返回:
embedding: 特征嵌入 [batch, embedding_dim]
"""
return self.encoder(features)
def compute_gradients(self, features: torch.Tensor,
aggregated_grad: torch.Tensor):
"""
计算并应用梯度
参数:
features: 本地特征
aggregated_grad: 协调方返回的聚合梯度
"""
self.optimizer.zero_grad()
# 前向传播
embedding = self.encode_features(features)
# 反向传播（使用外部梯度）
embedding.backward(aggregated_grad)
# 更新参数
self.optimizer.step()
class VerticalFLCoordinator:
"""
纵向联邦学习协调方
负责协调各参与方，聚合嵌入特征，训练顶层模型。
"""
def __init__(self, num_parties: int, embedding_dim: int = 64,
num_classes: int = 2):
"""
初始化协调方
参数:
num_parties: 参与方数量
embedding_dim: 嵌入维度
num_classes: 分类类别数
"""
self.num_parties = num_parties
self.embedding_dim = embedding_dim
# 顶层分类器
self.classifier = nn.Sequential(
nn.Linear(num_parties * embedding_dim, 128),
nn.ReLU(),
nn.Dropout(0.3),
nn.Linear(128, num_classes)
)
self.optimizer = torch.optim.Adam(
self.classifier.parameters(), lr=0.001
)
self.criterion = nn.CrossEntropyLoss()
def aggregate_embeddings(self, embeddings: List[torch.Tensor]
) -> torch.Tensor:
"""
聚合各参与方的嵌入
参数:
embeddings: 各参与方的嵌入列表
返回:
aggregated: 拼接后的嵌入 [batch, num_parties * embedding_dim]
"""
return torch.cat(embeddings, dim=1)
def forward(self, embeddings: List[torch.Tensor],
labels: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
"""
前向传播并计算损失
参数:
embeddings: 各参与方的嵌入
labels: 标签
返回:
loss: 损失值
output: 模型输出
"""
# 聚合嵌入
aggregated = self.aggregate_embeddings(embeddings)
# 分类
output = self.classifier(aggregated)
# 计算损失
loss = self.criterion(output, labels)
return loss, output
def compute_embedding_gradients(self, embeddings: List[torch.Tensor],
labels: torch.Tensor
) -> List[torch.Tensor]:
"""
计算各嵌入的梯度（返回给各参与方）
参数:
embeddings: 各参与方的嵌入
labels: 标签
返回:
gradients: 各参与方嵌入的梯度列表
"""
# 转换为需要梯度的张量
embeddings_with_grad = [
e.clone().detach().requires_grad_(True)
for e in embeddings
]
# 前向传播
aggregated = self.aggregate_embeddings(embeddings_with_grad)
output = self.classifier(aggregated)
loss = self.criterion(output, labels)
# 反向传播
loss.backward()
# 收集梯度
gradients = [e.grad for e in embeddings_with_grad]
# 更新分类器
self.optimizer.zero_grad()
self.classifier.zero_grad()
# 重新前向传播更新分类器
aggregated = self.aggregate_embeddings([
e.detach() for e in embeddings
])
output = self.classifier(aggregated)
loss = self.criterion(output, labels)
loss.backward()
self.optimizer.step()
return gradients
class VerticalFLSystem:
"""
纵向联邦学习系统
实现完整的纵向联邦学习流程。
"""
def __init__(self, feature_dims: List[int], embedding_dim: int = 64,
num_classes: int = 2):
"""
初始化纵向联邦学习系统
参数:
feature_dims: 各参与方的特征维度列表
embedding_dim: 嵌入维度
num_classes: 分类类别数
"""
self.num_parties = len(feature_dims)
# 创建参与方
self.parties = [
VerticalFLParty(i, dim, embedding_dim)
for i, dim in enumerate(feature_dims)
]
# 创建协调方
self.coordinator = VerticalFLCoordinator(
self.num_parties, embedding_dim, num_classes
)
def psi_protocol(self, party_ids: List[np.ndarray]) -> np.ndarray:
"""
隐私集合求交（Private Set Intersection）
使用哈希方法找出共同样本ID，不泄露非共同样本。
参数:
party_ids: 各参与方的样本ID列表
返回:
common_ids: 共同样本ID
"""
# 哈希各参与方的ID
hashed_ids = []
for ids in party_ids:
hashed = set(
hashlib.sha256(str(id).encode()).hexdigest()
for id in ids
)
hashed_ids.append(hashed)
# 求交集
common_ids = set.intersection(*hashed_ids)
return np.array(list(common_ids))
def train_step(self, party_features: List[torch.Tensor],
labels: torch.Tensor):
"""
执行一步训练
参数:
party_features: 各参与方的特征列表
labels: 标签
"""
# 各参与方编码特征
embeddings = []
for i, (party, features) in enumerate(zip(self.parties, party_features)):
embedding = party.encode_features(features)
embeddings.append(embedding)
# 协调方计算梯度
gradients = self.coordinator.compute_embedding_gradients(
embeddings, labels
)
# 各参与方更新
for party, features, grad in zip(self.parties, party_features, gradients):
party.compute_gradients(features, grad)
def predict(self, party_features: List[torch.Tensor]) -> torch.Tensor:
"""
预测
参数:
party_features: 各参与方的特征列表
返回:
predictions: 预测结果
"""
embeddings = [
party.encode_features(features)
for party, features in zip(self.parties, party_features)
]
aggregated = self.coordinator.aggregate_embeddings(embeddings)
output = self.coordinator.classifier(aggregated)
return output.argmax(dim=1)纵向联邦学习的核心挑战在于样本对齐和特征聚合。上述实现中，psi_protocol方法使用哈希实现隐私集合求交，找出各参与方的共同样本。VerticalFLCoordinator负责聚合各参与方的嵌入特征并训练顶层分类器。各参与方只持有部分特征，通过嵌入向量的交换实现协同训练。
7. 横向联邦 vs 纵向联邦对比
7.1 架构对比
| 特性 | 横向联邦 | 纵向联邦 |
|---|---|---|
| 数据划分 | 按样本ID切分 | 按特征维度切分 |
| 参与方角色 | 平等，各持完整特征 | 不平等，各持部分特征 |
| 通信内容 | 模型参数/梯度 | 嵌入向量/中间结果 |
| 协调方 | 可选 | 必需 |
| 样本对齐 | 不需要 | 需要（PSI协议） |
7.2 适用场景对比
纵向联邦适用场景
横向联邦适用场景
多银行联合风控
多医院联合诊断
多设备协同训练
银行+电商联合建模
医院+保险公司
多APP联合推荐
选择依据: 数据分布特点
7.3 技术挑战对比
| 挑战 | 横向联邦解决方案 | 纵向联邦解决方案 |
|---|---|---|
| 数据异构 | 个性化联邦学习 | 特征对齐 |
| 通信效率 | 压缩、异步更新 | 嵌入压缩 |
| 隐私保护 | 差分隐私、安全聚合 | 同态加密、秘密分享 |
| 模型聚合 | FedAvg及变体 | 梯度聚合 |
8. 实际应用案例
8.1 金融风控案例
场景：多家银行联合建立信用评分模型
在金融风控领域，银行需要建立信用评分模型来评估贷款申请人的违约风险。然而，由于数据隐私法规和商业机密，银行之间无法直接共享客户数据。联邦学习为这一问题提供了理想的解决方案。
方案：横向联邦学习 + 差分隐私
python
# 金融风控联邦学习配置
config = {
'num_banks': 5,
'model': 'XGBoost', # 或神经网络
'privacy': {
'method': 'DP',
'epsilon': 2.0,
'delta': 1e-5
},
'aggregation': 'FedAvg',
'communication': {
'rounds': 100,
'local_epochs': 10
}
}实施步骤：
- 数据预处理：各银行对本地数据进行清洗、特征工程
- 模型初始化：服务器初始化全局模型参数
- 联邦训练：各银行在本地数据上训练，上传模型更新
- 模型聚合：服务器聚合各银行的模型更新
- 模型评估：在测试集上评估全局模型性能
关键考虑因素：
| 因素 | 说明 | 建议 |
|---|---|---|
| 数据异构性 | 不同银行的客户群体可能差异较大 | 使用个性化联邦学习 |
| 隐私保护 | 需要满足金融监管要求 | 使用差分隐私 |
| 模型可解释性 | 金融场景需要解释模型决策 | 使用可解释模型或解释技术 |
| 合规性 | 需要满足GDPR等法规 | 咨询法务团队 |
8.2 医疗诊断案例
场景：多家医院联合训练疾病诊断模型
医疗数据是最敏感的数据类型之一，受到HIPAA、GDPR等法规的严格保护。联邦学习可以让多家医院在不共享患者数据的情况下，联合训练更准确的诊断模型。
方案：纵向联邦学习 + 同态加密
| 参与方 | 数据类型 | 角色 |
|---|---|---|
| 医院A | 临床检验数据 | 参与方 |
| 医院B | 影像数据 | 参与方 |
| 研究机构 | 基因数据 | 参与方 |
| 云平台 | - | 协调方 |
技术架构：
研究机构
医院B
医院A
临床检验数据
特征编码器A
影像数据
特征编码器B
基因数据
特征编码器C
加密传输
协调方: 聚合计算
疾病诊断模型
隐私保护措施：
- 样本对齐：使用隐私集合求交（PSI）找出共同患者
- 加密传输：使用同态加密保护中间结果
- 差分隐私：添加噪声防止成员推断攻击
- 访问控制：严格的权限管理和审计日志
8.3 推荐系统案例
场景：多个APP联合训练推荐模型
现代用户通常使用多个APP，每个APP只能看到用户的部分行为。通过联邦学习，可以整合用户在不同APP上的行为数据，提供更精准的推荐。
方案：横向联邦学习 + 联邦迁移学习
新闻APP
联邦推荐模型
视频APP
电商APP
个性化推荐
新闻推荐
视频推荐
商品推荐
技术挑战与解决方案：
| 挑战 | 解决方案 |
|---|---|
| 用户ID对齐 | 使用模糊匹配或第三方ID映射服务 |
| 行为数据异构 | 使用联邦迁移学习 |
| 实时性要求 | 使用异步联邦学习 |
| 大规模用户 | 使用分层聚合架构 |
8.4 智慧城市案例
场景：多部门联合训练城市治理模型
智慧城市建设需要整合交通、环境、安防等多个部门的数据。联邦学习可以在保护各部门数据隐私的前提下，实现跨部门的数据协同。
应用场景：
- 交通流量预测：整合出租车、公交、地铁等数据
- 空气质量监测：整合环保、气象、交通等数据
- 公共安全预警：整合公安、消防、医疗等数据
架构设计：
python
class SmartCityFLSystem:
"""
智慧城市联邦学习系统
整合多个政府部门的数据，实现城市治理智能化。
"""
def __init__(self, departments):
"""
初始化智慧城市联邦学习系统
参数:
departments: 参与部门列表
"""
self.departments = departments
# 为每个部门创建客户端
self.clients = {
dept: HorizontalFLSystem(
model=self._build_model(dept),
num_clients=1, # 每个部门一个客户端
fraction=1.0,
local_epochs=10
)
for dept in departments
}
# 协调服务器
self.server = FedAvgServer(
model=self._build_global_model(),
num_clients=len(departments)
)
def _build_model(self, department):
"""根据部门特点构建模型"""
if department == 'traffic':
return TrafficPredictor()
elif department == 'environment':
return AirQualityPredictor()
elif department == 'security':
return SecurityPredictor()
else:
return GeneralPredictor()
def _build_global_model(self):
"""构建全局模型"""
return CityGovernanceModel()9. 联邦学习开源框架
9.1 主流框架对比
| 框架 | 开发者 | 特点 | 适用场景 | 支持语言 |
|---|---|---|---|---|
| TensorFlow Federated | 成熟稳定，生态完善 | 研究、生产 | Python | |
| PySyft | OpenMined | 隐私计算，支持多种协议 | 隐私敏感场景 | Python |
| FATE | 微众银行 | 工业级，支持纵向联邦 | 金融、医疗 | Python |
| Flower | Flower Labs | 轻量级，易上手 | 快速原型 | Python/Java/Rust |
| FedML | FedML Inc | 全栈解决方案 | 研究、生产 | Python |
| PaddleFL | 百度 | 国产框架，中文文档完善 | 国内企业 | Python |
| FederatedAI | VMware | 企业级，支持多种ML框架 | 企业部署 | Python |
9.2 框架选型指南
研究学习
TensorFlow生态
PyTorch生态
快速原型
生产部署
横向联邦
高
中
纵向联邦
金融医疗
国内企业
选择联邦学习框架
应用场景?
偏好?
TFF
FedML
Flower
数据类型?
隐私要求?
PySyft
FedML
FATE
FATE
PaddleFL
9.3 快速入门示例
python
# 使用Flower框架快速搭建联邦学习
import flwr as fl
import torch
import torch.nn as nn
# 定义模型
class Net(nn.Module):
def __init__(self):
super().__init__()
self.fc = nn.Linear(784, 10)
def forward(self, x):
return self.fc(x.view(-1, 784))
# 定义客户端
class FlowerClient(fl.client.NumPyClient):
def __init__(self, model, train_loader, test_loader):
self.model = model
self.train_loader = train_loader
self.test_loader = test_loader
def get_parameters(self, config):
return [val.cpu().numpy() for val in self.model.parameters()]
def fit(self, parameters, config):
# 加载参数
params_dict = zip(self.model.state_dict().keys(), parameters)
state_dict = {k: torch.tensor(v) for k, v in params_dict}
self.model.load_state_dict(state_dict, strict=True)
# 本地训练
optimizer = torch.optim.SGD(self.model.parameters(), lr=0.01)
for epoch in range(5):
for data, target in self.train_loader:
optimizer.zero_grad()
output = self.model(data)
loss = nn.CrossEntropyLoss()(output, target)
loss.backward()
optimizer.step()
return self.get_parameters({}), len(self.train_loader), {}
def evaluate(self, parameters, config):
# 加载参数并评估
params_dict = zip(self.model.state_dict().keys(), parameters)
state_dict = {k: torch.tensor(v) for k, v in params_dict}
self.model.load_state_dict(state_dict, strict=True)
correct, total, loss = 0, 0, 0.0
with torch.no_grad():
for data, target in self.test_loader:
output = self.model(data)
loss += nn.CrossEntropyLoss()(output, target).item()
pred = output.argmax(dim=1)
correct += (pred == target).sum().item()
total += target.size(0)
return loss, total, {"accuracy": correct / total}
# 启动服务器
fl.server.start_server(
server_address="0.0.0.0:8080",
config=fl.server.ServerConfig(num_rounds=10),
)上述代码展示了使用Flower框架快速搭建联邦学习系统的完整流程。FlowerClient类继承自NumPyClient，实现了get_parameters、fit和evaluate三个核心方法，分别负责参数获取、本地训练和模型评估。Flower框架的优势在于其简洁的API设计和良好的可扩展性。
9.4 FATE框架纵向联邦示例
python
# 使用FATE框架进行纵向联邦学习
from federatedml.nn.model.zoo import nn_model
from federatedml.nn.backend.fate_torch import FateTorch
from federatedml.nn.hetero_nn.hetero_nn_guest import HeteroNNGuest
from federatedml.nn.hetero_nn.hetero_nn_host import HeteroNNHost
# 定义参与方A的模型（银行方）
class BankModel(nn.Module):
"""银行特征编码器"""
def __init__(self, input_dim):
super().__init__()
self.encoder = nn.Sequential(
nn.Linear(input_dim, 64),
nn.ReLU(),
nn.Linear(64, 32)
)
def forward(self, x):
return self.encoder(x)
# 定义参与方B的模型（电商方）
class EcommerceModel(nn.Module):
"""电商特征编码器"""
def __init__(self, input_dim):
super().__init__()
self.encoder = nn.Sequential(
nn.Linear(input_dim, 64),
nn.ReLU(),
nn.Linear(64, 32)
)
def forward(self, x):
return self.encoder(x)
# 定义顶层模型
class TopModel(nn.Module):
"""顶层分类器"""
def __init__(self, input_dim):
super().__init__()
self.classifier = nn.Sequential(
nn.Linear(input_dim, 32),
nn.ReLU(),
nn.Linear(32, 2)
)
def forward(self, x):
return self.classifier(x)
# 配置纵向联邦学习
config = {
'guest': {
'model': BankModel,
'input_dim': 20
},
'host': {
'model': EcommerceModel,
'input_dim': 30
},
'top_model': {
'model': TopModel,
'input_dim': 64 # 32 + 32
},
'epochs': 50,
'batch_size': 256,
'learning_rate': 0.001
}FATE框架是国内最成熟的联邦学习开源框架之一，特别适合纵向联邦学习场景。上述代码展示了如何定义各参与方的特征编码器和顶层分类器，实现银行和电商数据的联合建模。FATE提供了完整的安全协议支持，包括隐私集合求交、同态加密等。
10. 联邦学习进阶话题
10.1 个性化联邦学习
在Non-IID数据场景下，全局模型可能无法满足所有客户端的需求。个性化联邦学习旨在为每个客户端学习定制化的模型：
| 方法 | 描述 | 适用场景 |
|---|---|---|
| FedProx | 添加近端项约束本地更新 | 数据异构场景 |
| Per-FedAvg | 基于MAML的个性化方法 | 需要快速适应 |
| Ditto | 全局模型+个性化微调 | 通用场景 |
| pFedMe | 学习个性化模型参数 | 高度异构数据 |
python
class FedProxClient(FedAvgClient):
"""
FedProx客户端
在本地训练中添加近端项，约束本地模型不要偏离全局模型太远。
这有助于在Non-IID数据上获得更好的收敛性。
"""
def __init__(self, model: nn.Module, local_epochs: int = 5,
lr: float = 0.01, mu: float = 0.01):
"""
初始化FedProx客户端
参数:
model: 本地模型
local_epochs: 本地训练轮数
lr: 学习率
mu: 近端项系数（控制偏离程度）
"""
super().__init__(model, local_epochs, lr)
self.mu = mu
self.global_params = None
def set_global_params(self, global_params):
"""设置全局模型参数"""
self.global_params = {
k: v.clone() for k, v in global_params.items()
}
def proximal_term(self):
"""
计算近端项
近端项约束本地模型参数接近全局模型参数：
(mu/2) * ||w - w_global||^2
"""
if self.global_params is None:
return 0.0
prox_term = 0.0
for name, param in self.model.named_parameters():
if name in self.global_params:
prox_term += torch.norm(param - self.global_params[name]) ** 2
return (self.mu / 2) * prox_term
def train(self, data_loader):
"""带近端项的本地训练"""
self.model.train()
total_loss = 0.0
num_batches = 0
for epoch in range(self.local_epochs):
for data, target in data_loader:
self.optimizer.zero_grad()
output = self.model(data)
loss = self.criterion(output, target)
# 添加近端项
loss = loss + self.proximal_term()
loss.backward()
self.optimizer.step()
total_loss += loss.item()
num_batches += 1
return self.model.state_dict(), total_loss / num_batches10.2 安全聚合协议
安全聚合（Secure Aggregation）是保护客户端更新隐私的重要技术，确保服务器只能看到聚合结果，无法看到单个客户端的更新：
安全聚合原理
成对掩码
每个客户端与其他客户端
共享随机种子
使用种子生成掩码
掩码在聚合时相互抵消
客户端1: 加密更新
服务器
客户端2: 加密更新
客户端3: 加密更新
只能解密聚合结果
无法获取单个更新
10.3 联邦学习的通信优化
通信开销是联邦学习的主要瓶颈之一，以下是常用的优化策略：
| 策略 | 描述 | 压缩比 |
|---|---|---|
| 梯度压缩 | 只传输重要梯度 | 10-100x |
| 量化 | 降低参数精度 | 4-8x |
| 稀疏化 | 只传输非零更新 | 10-50x |
| 知识蒸馏 | 传输知识而非参数 | 5-10x |
python
class CompressedFedAvgClient(FedAvgClient):
"""
支持梯度压缩的联邦学习客户端
使用Top-K稀疏化策略，只传输最重要的梯度更新。
"""
def __init__(self, model: nn.Module, local_epochs: int = 5,
lr: float = 0.01, compression_ratio: float = 0.1):
"""
初始化压缩客户端
参数:
model: 本地模型
local_epochs: 本地训练轮数
lr: 学习率
compression_ratio: 压缩比例（保留的梯度比例）
"""
super().__init__(model, local_epochs, lr)
self.compression_ratio = compression_ratio
def compress_gradients(self, gradients):
"""
压缩梯度
使用Top-K方法，只保留绝对值最大的K个梯度。
参数:
gradients: 原始梯度
返回:
compressed: 压缩后的梯度（稀疏格式）
"""
compressed = {}
for name, grad in gradients.items():
# 展平梯度
flat_grad = grad.flatten()
k = int(len(flat_grad) * self.compression_ratio)
# 找到Top-K索引
_, top_indices = torch.topk(flat_grad.abs(), k)
# 创建稀疏梯度
sparse_grad = torch.zeros_like(flat_grad)
sparse_grad[top_indices] = flat_grad[top_indices]
compressed[name] = sparse_grad.view(grad.shape)
return compressed
def train(self, data_loader):
"""带梯度压缩的本地训练"""
# 训练过程与基类相同
# 在上传前压缩梯度
state_dict, avg_loss = super().train(data_loader)
# 压缩更新
compressed_state = self.compress_gradients(state_dict)
return compressed_state, avg_loss10.4 联邦学习的未来趋势
联邦学习领域正在快速发展，未来可能的方向包括：
- 跨设备联邦学习：在数十亿设备上部署联邦学习
- 联邦学习标准化：制定行业标准和协议
- 可信执行环境：结合TEE增强安全性
- 联邦学习+区块链：去中心化的联邦学习
- 自动化联邦学习：自动调参和架构搜索
11. 总结
本文深入探讨了联邦学习的核心技术，包括联邦平均算法、差分隐私机制，以及横向联邦和纵向联邦的完整实现。核心要点如下：
- 联邦学习本质：数据不动模型动，实现隐私保护的协同训练
- FedAvg算法：本地训练+加权聚合，是最经典的联邦学习算法
- 差分隐私：通过添加噪声实现严格的隐私保护，需要权衡隐私与效用
- 横向联邦：适用于样本ID不同的场景，实现相对简单
- 纵向联邦：适用于特征维度不同的场景，需要样本对齐和协调方
思考题：
- 在你的行业中，哪些场景适合应用联邦学习？横向还是纵向？
- 差分隐私的噪声如何影响模型性能？如何选择合适的隐私预算？
- 联邦学习面临哪些安全威胁？如何防御？
参考资料
- Communication-Efficient Learning of Deep Networks from Decentralized Data (FedAvg原论文)
- The Algorithmic Foundations of Differential Privacy
- FATE: An Industrial Grade Federated Learning Framework
- TensorFlow Federated
- Flower: A Friendly Federated Learning Framework
- Advances and Open Problems in Federated Learning