🌍 01 - 联邦学习概述

阶段：联邦学习基础 第1课

📖 什么是联邦学习

联邦学习（Federated Learning）是2016年由Google首次提出的一种分布式机器学习范式。其核心思想是：数据不动模型动——各参与方在本地数据上训练模型，只共享模型参数（梯度或权重），而非原始数据。这一范式彻底改变了传统集中式训练的模式，为隐私保护下的协作式机器学习开辟了新的道路。

Google最初的论文提出了FedAvg算法，应用于手机键盘输入预测场景。数千万部手机在本地训练语言模型，仅将模型更新上传到云端聚合，既保护了用户隐私，又充分利用了分布式数据的价值。这一突破性工作为后续的联邦学习研究奠定了理论基础。

随着数据隐私法规（如GDPR、CCPA、PIPL）的日益严格，以及数据孤岛问题的日益突出，联邦学习在金融、医疗、电商、政务等领域展现出巨大的应用潜力。微众银行推出的FATE框架已成为业界最广泛使用的开源联邦学习平台之一。

集中式 vs 联邦学习

三大分类

工作流程

1. 初始化：服务器初始化全局模型 w₀
2. 分发：广播 wₜ 给选中的客户端
3. 本地训练：每个客户端训练 E 个epoch
4. 上传：客户端上传 Δwₖ
5. 聚合：加权平均 wₜ₊₁ = Σ(nₖ/n)·wₖ
6. 迭代：重复直到收敛

隐私攻击与防御

核心挑战

发展时间线

🐍 Python实现

import numpy as np
import copy

class FLClient:
    def __init__(self, client_id, data, lr=0.01, local_epochs=3):
        self.client_id = client_id
        self.X, self.y = data
        self.lr = lr
        self.local_epochs = local_epochs
        self.n_samples = len(self.y)

    def sigmoid(self, z):
        return 1.0 / (1.0 + np.exp(-np.clip(z, -500, 500)))

    def train_local(self, global_w, global_b):
        w, b = copy.deepcopy(global_w), global_b
        for _ in range(self.local_epochs):
            pred = self.sigmoid(self.X @ w + b)
            err = pred - self.y
            w -= self.lr * (self.X.T @ err) / self.n_samples
            b -= self.lr * np.mean(err)
        return w, b

    def evaluate(self, w, b):
        pred = self.sigmoid(self.X @ w + b)
        acc = np.mean((pred >= 0.5).astype(int) == self.y)
        loss = -np.mean(self.y*np.log(pred+1e-8)+(1-self.y)*np.log(1-pred+1e-8))
        return {'accuracy': acc, 'loss': loss}

class FLServer:
    def __init__(self, n_features):
        self.global_w = np.random.randn(n_features) * 0.01
        self.global_b = 0.0
        self.clients = []
        self.history = []

    def register(self, client):
        self.clients.append(client)

    def fedavg(self, params):
        total = sum(n for _, _, n in params)
        new_w = sum(n/total * w for w, _, n in params)
        new_b = sum(n/total * b for _, b, n in params)
        return new_w, new_b

    def train_round(self):
        local_params = []
        for c in self.clients:
            w, b = c.train_local(self.global_w, self.global_b)
            local_params.append((w, b, c.n_samples))
        self.global_w, self.global_b = self.fedavg(local_params)
        return self._eval_global()

    def _eval_global(self):
        total = sum(c.n_samples for c in self.clients)
        acc = sum(c.evaluate(self.global_w, self.global_b)['accuracy']*c.n_samples for c in self.clients)/total
        loss = sum(c.evaluate(self.global_w, self.global_b)['loss']*c.n_samples for c in self.clients)/total
        return {'accuracy': acc, 'loss': loss}

    def train(self, n_rounds=20):
        print("Training: %d rounds, %d clients" % (n_rounds, len(self.clients)))
        for r in range(n_rounds):
            m = self.train_round()
            self.history.append(m)
            if (r+1) % 5 == 0:
                print("  Round %3d: Loss=%.4f, Acc=%.4f" % (r+1, m['loss'], m['accuracy']))
        return self.history

np.random.seed(42)
n_clients, n_features = 5, 10
datasets = []
for k in range(n_clients):
    shift = k * 0.5
    X = np.random.randn(300, n_features) + shift
    true_w = np.random.randn(n_features) + shift * 0.3
    prob = 1.0/(1.0+np.exp(-(X @ true_w + shift*0.5)))
    y = (prob > 0.5).astype(int)
    datasets.append((X, y))
    print("Client %d: %d samples, pos=%.1f%%" % (k, len(y), y.mean()*100))

server = FLServer(n_features)
for i, d in enumerate(datasets):
    server.register(FLClient(i, d, lr=0.05, local_epochs=5))
history = server.train(n_rounds=30)

all_X = np.vstack([d[0] for d in datasets])
all_y = np.concatenate([d[1] for d in datasets])
w_c, b_c = np.random.randn(n_features)*0.01, 0.0
for _ in range(150):
    pred = 1.0/(1.0+np.exp(-np.clip(all_X@w_c+b_c,-500,500)))
    err = pred - all_y
    w_c -= 0.05*(all_X.T@err)/len(all_y)
    b_c -= 0.05*np.mean(err)
central_acc = np.mean((1.0/(1.0+np.exp(-all_X@w_c-b_c))>=0.5).astype(int)==all_y)
final = server._eval_global()
print("Federated: %.4f vs Centralized: %.4f" % (final["accuracy"], central_acc))
print("Verified - FL framework runs correctly")

🔒 隐私分析

📝 练习

📚 扩展阅读

📐 数学基础

🔧 实现细节

🚀 进阶主题

📋 案例分析

📅 发展历程

📝 关键要点

📚 参考文献

❓ 常见问题