🔐 隐私保护

class DPSGDTrainer:
    def __init__(self, model, epsilon, delta, clip_norm):
        self.model = model
        self.epsilon = epsilon
        self.delta = delta
        self.clip_norm = clip_norm
        self.noise_multiplier = self.compute_noise()
    
    def compute_noise(self):
        """计算噪声系数"""
        # 基于 (ε, δ)-DP 公式计算
        return (clip_norm * math.sqrt(2 * math.log(1.25 / delta))) / epsilon
    
    def train_step(self, batch):
        """差分隐私训练步骤"""
        # 1. 计算每个样本的梯度
        gradients = []
        for sample in batch:
            grad = compute_gradient(self.model, sample)
            # 2. 梯度裁剪
            grad = clip_gradient(grad, self.clip_norm)
            gradients.append(grad)
        
        # 3. 聚合梯度
        mean_grad = torch.stack(gradients).mean(dim=0)
        
        # 4. 添加高斯噪声
        noise = torch.randn_like(mean_grad) * self.noise_multiplier
        noisy_grad = mean_grad + noise
        
        # 5. 更新模型
        self.model.apply_gradient(noisy_grad)

class FedAvgServer:
    def __init__(self, model, n_clients, round_fraction=0.1):
        self.model = model
        self.n_clients = n_clients
        self.round_fraction = round_fraction
    
    def train_round(self, clients, local_epochs=5, batch_size=32):
        """单个联邦训练轮次"""
        # 1. 选择活跃客户端
        active_clients = random.sample(clients, 
            int(len(clients) * self.round_fraction))
        
        # 2. 发送全局模型
        global_weights = self.model.get_weights()
        
        # 3. 收集本地更新
        updates = []
        for client in active_clients:
            local_model = client.train(local_weights, 
                local_epochs, batch_size)
            update = local_model.get_weights() - global_weights
            updates.append((client.data_size, update))
        
        # 4. 加权聚合
        total_size = sum(size for size, _ in updates)
        aggregated = np.zeros_like(global_weights)
        for size, update in updates:
            aggregated += (size / total_size) * update
        
        # 5. 更新全局模型
        self.model.set_weights(global_weights + aggregated)
        
        return self.evaluate()

class PrivacyPreservingFedAvg:
    def __init__(self, server, dp_epsilon, secure_aggregation=True):
        self.server = server
        self.epsilon = dp_epsilon
        self.secure_agg = secure_aggregation
    
    def secure_aggregate(self, updates):
        """安全聚合：服务器只看到和，看不到单个更新"""
        # 使用同态加密或秘密共享
        encrypted_updates = [self.encrypt(u) for u in updates]
        # 服务器只能解密总和
        aggregated = self.decrypt_sum(encrypted_updates)
        return aggregated

class KAnonymizer:
    def __init__(self, k):
        self.k = k
    
    def anonymize(self, df: pd.DataFrame) -> pd.DataFrame:
        """实现 k-匿名"""
        # 1. 识别准标识符
        quasi_identifiers = self.identify_qi(df)
        
        # 2. 泛化函数
        generalization_hierarchy = {
            'age': [0, 10, 20, 30, 40, 50, 60, 70, 80, 90],
            'zip_code': ['*', '123', '1234', '12345'],
            'gender': {0: 'M', 1: 'F'}
        }
        
        # 3. 划分等价类
        equivalence_classes = df.groupby(quasi_identifiers)
        
        # 4. 确保每类大小 >= k
        for name, group in equivalence_classes:
            if len(group) < self.k:
                df = self.suppress_or_generalize(df, group)
        
        return df