RFed: Robustness-Enhanced Privacy-Preserving Federated Learning Against Poisoning Attack

来源

2024 TIFS
链接：IEEE
作者：$\text{Yinbin Miao},$ $\text{Xinru Yan},$ $\text{Xinghua Li},$ $\text{Shujiang Xu},$ $\text{Ximeng Liu},SeniorMember,IEEE,$ $\text{Hongwei Li},Fellow,IEEE,$ and $\text{Robert H. Deng},Fellow,IEEE$

Background

• With the widespread application of privacy-preserving federated learning, poisoning attacks threaten the model utility.
• The single-server model carries a very high risk of paralysis.
• Existing defense schemes suffer from a series of problems,including low accuracy, low robustness and reliance on strong assumptions, which limit the practicability of federated learning.

Contributes

• We propose a robust defense mechanism with scaled dotproduct attention, which not only reduces the success rate of poisoning attacks but also protects model security. //缩放点积注意力机制，投毒攻击
• We adopt a dual-server architecture in secure aggregation phase with less privacy leakage, which eliminates the strong assumption in single-server model architecture.
• We present formal security analysis to prove that our scheme achieves convergence and provides privacy protection, and conduct extensive experiments to demonstrate that our scheme ensures the the failure rate of poisoning attacks is higher than $96\%$. //收敛

服务器

• 双服务器架构

• 单服务器结构下常常需要强假设才能保证系统的安全，但在实际生活中常常不能满足这些强假设。
• 此外，单服务器架构在处理大量数据和请求时容易遇到性能瓶颈。硬件的限制将导致系统性能下降，从而影响模型训练。
• 本文提出了一种双服务器架构，这种架构通过增加第二台服务器创建了一种制衡机制，确保没有单一服务器能够单独操控或窃取数据。这种设计减少了对任何单一实体的信任依赖，从而显著提高了系统的整体安全性。
• 我们注意到，在四个实体中，云和客户端都是至少半诚实的（客户端可能为恶意客户端，此时为恶意的），因此，在整个处理过程中，我们必须确保所有操作都在密文数据上进行。在双服务器架构中，必须确保每台服务器无法获取明文模型，并且它们处理的是加密数据。即使其中一台服务器拥有解密的私钥，它也只能获得模糊化的数据，而不是原始数据。

使用双服务器，可以保证两个服务器互相无法获得正确的明文，实现了隐私保护。

加密方法

• CKKS – 全同态

实现拜占庭鲁棒性的方法

• scaled dotproduct attention mechanism – 缩放点积注意力机制

什么是注意力机制？

• 注意力机制（Attention Mechanism）是一种在计算机科学和机器学习中常用的技术，可以使模型在处理序列数据时更加准确和有效。在传统的神经网络中，每个神经元的输出只依赖于前一层的所有神经元的输出，而在注意力机制中，每个神经元的输出不仅仅取决于前一层的所有神经元的输出，还可以根据输入数据的不同部分进行加权，即对不同部分赋予不同的权重。这样可以使模型更加关注输入序列中的关键信息，从而提高模型的精度和效率。

注意力机制的原理

1. 计算注意力权重：注意力机制的第一步是计算每个输入位置的注意力权重。这个权重可以根据输入数据的不同部分进行加权，即对不同部分赋予不同的权重。权重的计算通常是基于输入数据和模型参数的函数，可以使用不同的方式进行计算，比如点积注意力、加性注意力、自注意力等。
2. 加权求和输入表示：计算出注意力权重之后，下一步就是将每个输入位置的表示和对应的注意力权重相乘，并对所有加权结果进行求和。这样可以得到一个加权的输入表示，它可以更好地反映输入数据中重要的部分。
3. 计算输出：注意力机制的最后一步是根据加权的输入表示和其他模型参数计算输出结果。这个输出结果可以作为下一层的输入，也可以作为最终的输出。

缩放点积注意力机制

Input:a query $Q$ (of size $d_k$)，key $K$ (of size $d_k$)，value $V$ (of size $d_v$).
Output:注意力机制输出矩阵（matrix of the attention mechanism）$Attention(Q,K,V)$

---

步骤1：通过计算向量$Q$和$K$的点积来评估相似性。为了确保数值稳定性，注意力权重需要进行缩放,因此缩放后的点积注意力得分函数如公式所示:
$S(Q,K_i)=\frac{Q{K}_i^T}{\sqrt{d_k}}$
，其中$\frac{1}{sqrt{d}_k}$是缩放因子。

步骤2：通过softmax函数计算权重

$softmax(S(Q,K_i))=\frac{exr(S(Q,K_i))}{{\sum }_{j=1}^{m}exp(S(Q,K_i))}$

步骤3：将权重应用于 $V$，以获得注意力机制的输出矩阵。

$Attention(Q,K,V)=softmax\frac{Q{K}^T}{\sqrt{d_k}}V$

• 因为恶意客户端所提交的本地梯度向量与良性客户端所提交的梯度向量之间存在明显的区别，因此，与良性梯度的低相似度意味着这些梯度具有较高的恶意概率，这也是许多相关研究的共识。
  
• 在本文中，设定$K=V$，让协作服务器$S_1$收集一个小而干净的根数据集$D_0$，并使用其训练得到的梯度$g_0$作为基准来查询$Q$，以区分恶意梯度向量和良性梯度向量。也就是说，与$g_0$具有高相似度的梯度（更可能是良性梯度）将获得更大的权重，而与$g_0$相似度较低的梯度（可能是恶意梯度或由诚实客户端生成的极端值）将获得较小的权重。通过注意力机制输出矩阵为不同客户端分配权重。

投毒攻击的两种类型

• label-flipping attack
  • 标签翻转攻击
  • 攻击者故意翻转某些训练数据样本的标签，使其与真实标签相反，从而欺骗模型的训练。
• backdoor attack
  • 后门攻击
  • 旨在识别一组参数，这些参数在触发标签与目标标签之间建立强连接，同时对良性输入的分类影响最小。

System Model

• 模型由四个实体组成：
  • Key Generation Center (KGC).
    • KGC是一个独立且值得信赖的机构，负责生成和分发公钥/私钥对。
  • Clients.
  • Aggregation Server $S_0$.
  • Collaboration Server $S_1$.

$S_0$收集客户端发来的

威胁模型

• KGC被视为一个值得 信赖和可靠 的第三方。
• $S_0$ 和 $S_1$ 是两个被认为是半诚实的云服务器。这表明 %S_0 和 $S_1$ 将在诚实执行所有符合协议的活动的同时， 试图根据其可用的梯度获取更多信息 。
• 客户端
  • 客户可以被分类为半诚实客户或恶意客户。
  • 恶意客户可以通过投毒攻击污染预测结果，从而使模型训练失效。
  • 而半诚实客户通常参与训练，但同时也对其他模型数据感兴趣。
• 本文假设$S_0$与客户端的通信通道是完全可靠的。
• 本文假设四个实体互相不串通。

除了KGC，其他实体都不是完全可靠的。并且文章假设恶意客户端最多不到客户端总数的一半。

• 本文主要防范的威胁主要为：投毒攻击，隐私泄露。

设计目标

• 准确性
  • 设计的方案可以在不影响模型准确性的基础上保护隐私数据、抵抗投毒攻击。
• 鲁棒性
  • 设计的方案应具有抵御中毒攻击的强大能力，无论恶意客户端的行为是否不诚实，都应确保所有计算协议参与者所提供的输出是准确的。
• 隐私性
  • 方案应采取严格的隐私保护措施，以确保在半诚实的服务器和客户端环境中，充分保护所训练的数据，防止任何一方获取或泄露敏感信息。

方案设计

• 初始化：在训练开始之前，KGC 为客户端和 $S_1$ 分别生成并分发密钥对 $(p{k}_C,s{k}_C)$ 和 $(p{k}_{S_1},s{k}_{S_1})$（第 2 行）。$S_1$ 收集一个小型且干净的根数据集 $D_0$，并基于 $D_0$ 训练根梯度 $g_0$（第 3 行）。$S_0$ 随机初始化全局模型 $w_1$，并将其加密为 $[[w_1]{]}_{p{k}_C}$ 发送给客户端 $\mathcal{C}$（第 4-7 行）。

算法1 RFed整体架构

输入：Dataset $D_0$，
   $n$ clients C = { C 1 , C 2 , . . . , C n } \mathcal{C} = \{C_1, C_2,...,C_n\} C={C1​,C2​,...,Cn​} with local training datasets D = { D 1 , D 2 , . . . , D n } D = \{D_1, D_2,...,D_n\} D={D1​,D2​,...,Dn​}，
   total communication rounds $T$，
   total local rounds $E$, the learning rate $\eta$,
   the attention weights set $W$,
   the obfuscated ciphertext updates set $\mathcal{G}$.
输出：加密的全局模型 $[[{\mathrm{w}}_{t+1}]{]}_{p{k}_C}$ 。

1： 初始化：
2： KGC 初始化密钥对 $(p{k}_C,s{k}_C)$ 和 $(p{k}_{S_1},s{k}_{S_1})$；
3：$S_0$基于$D_0$训练根梯度$g_0$；
4：//协作服务器$S_1$：
5：初始化模型 ${\mathrm{w}}_1$；
6：使用 $p{k}_C$ 对 ${\mathrm{w}}_1$ 进行加密，得到$[[{\mathrm{w}}_1]{]}_{p{k}_C}$；//$S_1$使用客户端的公钥加密全局模型
7：发送 $[[{\mathrm{w}}_1]{]}_{p{k}_C}$ 给 $\mathcal{C}$;   //就是把第一轮的全局模型发送给所有客户端
8：for $t\in [1,T]$ do  //对于每一轮迭代：
9： for $i\in [1,n]$ do  //对于每一个客户端
10：$[[g_{t+1}^i]{]}_{p{k}_{S_1}}=LocalTrain([[{\mathrm{w}}_{\mathrm{t}}]{]}_{p{k}_C},E,\eta ,D_i)$; //在每一次迭代，每一个客户端通过本轮的全局模型，使用训练参数（学习率、数据集、每次迭代的训练次数E）来训练，得到本次迭代的梯度
11：end for
12：$\mathcal{W}\leftarrow \varnothing ,\mathcal{G}\leftarrow \varnothing$; //初始化注意力权重集合$\mathcal{W}$和混淆密文更新集合$\mathcal{G}$
13：$\mathcal{W}=\text{ WeightCalcul }\left({\left\{[[{\mathbf{g}}_{t+1}^i{]]}_{p{k}_{S_1}}\right\}}_{i=1}^{i=n},\mathcal{W},\mathcal{G},{\mathbf{g}}_0\right)$;  $S_1$通过客户端上传的梯度，计算为客户端分配的权重
14：$[[{\mathrm{w}}_{t+1}]{]}_p{k}_{S_1}=\text{ModelAgg}(\mathcal{W},\mathcal{G},\eta ,{\mathrm{w}}_t)$; 注意，聚合操作是$S_0$进行的！
15：$[[{\mathrm{w}}_{p{k}_C}]]=Re-encryption([[{\mathrm{w}}_{t+1}]{]}_{p{k}_{S_1}})$;
16：end for
17：return [[\mathrm{w}]]_{pk_C}.

算法2 本地训练

输入：The encrypted global aggregation model $[[{\text{w}}_t]{]}_{p{k}_C}$ in t-th round,
   local iteration rounds $E$,
   local learning rate $\eta$,
   $C_i$’s local dataset $D_i$.
输出：The encrypted local update $[[g_{t+1}^i]{]}_{p{k}_{S_1}}$.

1.//$C_i$ :
2.从 $S_0$ 获取全局模型 $[[{\text{w}}_t]{]}_{p{k}_C}$；
3.使用 $s{k}_C$ 解密 $[[{\text{w}}_t]{]}_{p{k}_C}$ 以获得 ${\text{w}}_t$；
4.${\text{w}}_1^i\leftarrow {\text{w}}_t$; //将解密的全局模型定义为第一次迭代的模型，然后进行E次本地迭代；
5.for $j\in [1,E]$ do //客户端$C_i$在本地迭代训练E次；
6.  从$D_i$中随机抽样出样本$z_{t,j}^i$;
7.  ${\mathbf{w}}_{t,j+1}^i\leftarrow {\mathbf{w}}_{t,j}^i-\eta \nabla \mathcal{L}\left({\mathbf{w}}_{t,j}^i,z_{t,j}^i\right)$; //迭代训练$E$次;
8.end for
9.$g_{t+1}^i\leftarrow {\text{w}}_{t,j}^i-{\text{w}}_{t,E+1}^i$; //使用减法计算出梯度；
10.使用$p{k}_{S_1}$加密$g_{t+1}^i$得到$[[g_{t+1}^i]{]}_{p{k}_{S_1}}$;
11.发送$[[g_{t+1}^i]{]}_{p{k}_{S_1}}$给$S_0$;
12.return  $[[g_{t+1}^i]{]}_{p{k}_{S_1}}$.

算法3 权重计算

输入：Uploaded gradient ciphertexts set $\{[[g_{t+1}^i]]{\}}_{i=1}^{i=n}$,
   the obfuscated ciphertext updates set $\mathcal{G}$,
   root gradient $g_0$,
   the attention weights set $\mathcal{W}.$
输出：The attention weights set $\mathcal{W}$.

1.// Aggregation Server $S_0$:
2.随机选择一个非零整数 $r$;
3.for $i\in [1,n]$ do  //对于每一个客户端发来的加密梯度;
4.  $[[G_i]{]}_{p{k}_{S_1}}\leftarrow [[g_{t+1}^i]{]}_{p{k}_{S_1}}+[[r]{]}_p{k}_{S_1}$. //对于每一个加密梯度，$S_0$随机选择一个非零整数$r$注入到加密梯度中，使$S_1$无法通过私钥$s{k}_{S_1}$解密得到梯度明文数据。
5.  将$[[G_i]{]}_{p{k}_{S_1}}$添加到混淆密文更新集$\mathcal{G}$;
6.end for
7.将$\mathcal{G}$发送给$S_1$;
8.//Collaboration Server $S_1$:
9.$\mathcal{A}\leftarrow \varnothing$; //初始化注意力得分集$\mathcal{A}$;
10.接受到从$S_0$发来的混淆密文更新集$\mathcal{G}$;
11.for $i\in \mathcal{G}$ do  //$S_1$遍历每一个混淆梯度;
12.  使用$s{k}_{S_1}$解密$[[G_i]{]}_{p{k}_{S_1}}$后得到$G_i$;
13.  ${\alpha }_i\leftarrow \frac{G_i\odot g_0}{\sqrt{d}}$; 计算注意力得分;
14.  将 ${\alpha }_i$ 添加到注意力得分集合$\mathcal{A}$;
15.end for
16.for $i\in \mathcal{A}$ do
17.  ${\omega }_i\leftarrow \frac{exp({\alpha }_i)}{{\sum }_{i=1}^{n}exp({\alpha }_i)}$; //计算注意力权重${\omega }_i$;
18.  使用公钥$p{k}_{S_1}$加密${\omega }_i$后得到$[[{\omega }_i]{]}_{p{k}_{S_1}}$;
19.  将$[[{\omega }_i]{]}_{p{k}_{S_1}}$添加到注意力权重集合$\mathcal{W}$;
20.end for
21.将$\mathcal{W}$发送给$S_0$;
22.return $\mathcal{W}$.

算法4 模型聚合

输入：The obfuscated ciphertext updates set $\mathcal{G}$,
   the perturbation value $r$,
   the attention weights set $\mathcal{W}$,
   the learning rate $\eta$,
   the global model ${\text{w}}_t$ in $t$-th round.
输出：The encrypted global aggregation model $[[{\text{w}}_{t+1}]{]}_{p{k}_{S_1}}$ in $(t+1)$-th round.

1.//Aggregation Server $S_0$:
2.接受来自$S_1$的注意力权重集合$\mathcal{W}$;
3.$[[{\text{w}}_{t+1}]{]}_{p{k}_{S_1}}=[[{\text{w}}_t]{]}_{p{k}_{S_1}}-{\sum }_{i\in \mathcal{W}}^{}[[\eta {\omega }_i]{]}_{p{k}_{S_1}}\cdot [[g_{t+1}^i]{]}_{p{k}_{S_1}}$; //${\omega }_i$就是注意力权重;
4.return $[[{\text{w}}_{t+1}]{]}_{p{k}_{S_1}}$.

算法5  Re-encryption. 重新加密

输入：The encrypted global aggregation model $[[{\text{w}}_{t+1}]{]}_{p{k}_{S_1}}$ in $(t+1)$-th round.
输出：The encrypted global aggregation model $[[{\text{w}}_{t+1}]{]}_{p{k}_C}$ in $(t+1)$-th round.

1.// Aggregation Server $S_0$:
2.随机生成一个非零整数 $r^{\prime }$；
3.$[[M]{]}_{p{k}_{S_1}}=[[{\text{w}}_{t+1}]{]}_{p{k}_{S_1}}+[[r^{\prime }]{]}_{p{k}_{S_1}}$; //将$r^{\prime }$注入到${\text{w}}_{t+1}$中，当然这个操作是在密文下进行的。
4.Send $[[M]{]}_{p{k}_{S_1}}$ to server $S_1$;
5.// Collaboration Server $S_1$:
6.Receive $[[M]{]}_{p{k}_{S_1}}$ sent by $S_0$;
7.Use $s{k}_{S_1}$ to decrypt $[[M]{]}_{p{k}_{S_1}}$ to get $M$;
8.Use $p{k}_C$ to encrypt $M$ to get $[[M]{]}_{p{k}_C}$;
9.Send $[[M]{]}_{p{k}_C}$ to $S_0$;
10.// Aggregation Server $S_0$:
11.Receive $[[M]{]}_{p{k}_C}$ sent by $S_1$;
12.$[[{\text{w}}_{t+1}]{]}_{p{k}_C}=[[M]{]}_p{k}_C-[[r^{\prime }]{]}_{p{k}_C}$; //$S_0$移除$[[M]{]}_{p{k}_C}$中的随机数$[[r^{\prime }]{]}_{p{k}_C}$后得到$[[{\text{w}}_{t+1}]{]}_{p{k}_C}$;
13.Send $[[{\text{w}}_{t+1}]{]}_{p{k}_C}$ to all clients;
14.return $[[{\text{w}}_{t+1}]{]}_{p{k}_C}$.

• 算法有一些总结：
• 1. 算法1说参预训练的是属于$\mathcal{C}$的客户端，属于$\mathcal{C}$的客户端拿到全局模型再进行训练，而算法5却说$S_0$直接将全局模型发送给所有客户端，那么$\mathcal{C}$的作用就是随机选取一部分客户端进行训练，从而减少系统计算开销和通信开销。
• 2. 由算法1-5，$S_0$只需要密钥$p{k}_C、p{k}_{S_1}$,$S_1$只需要密钥$p{k}_{S_1}、p{k}_C、s{k}_{S_1}$，客户端只需要密钥$p{k}_C、s{k}_C、p{k}_{S_1}$。$S_0$因为在系统中没有解密操作，所以不需要为他分配任何密钥，这样也保证了客户端上传梯度后保证数据安全；$S_0$在于$S_1$的交互中，为了因为$S_1$的计算是不能在密文下进行的，需要对密文加密成明文，为了保护隐私，$S_0$总会在将数据发送给$S_1$前为加密数据添加一些额外数据，以混淆密文。
• 3. 算法3中，$S_1$在计算注意力得分时，会不会因为随机整数$r$的加入而影响输出值？

总结

方法描述

• 本文提出的RFed是一种基于隐私保护的联邦学习框架，旨在解决联邦学习中的攻击问题和隐私泄露问题。
• 该框架采用了双服务器架构，通过加密技术保证数据传输的安全性和隐私性，并使用加权聚合算法来提高模型的鲁棒性。
• 具体来说，RFed包括初始化、本地训练、权重计算、模型聚合和重新加密协议等五个主要过程。
  • 在初始化阶段，KGC生成并分发公钥和私钥，$S_0$收集一个干净的小根数据集并训练出初始梯度向量。
  • 然后，在每个通信轮次中，客户端获取全局模型并根据本地更新方程进行多次迭代训练，得到新的本地模型。
  • 接下来，客户端将加密后的本地梯度向量发送给$S_0$，$S_0$将其混淆后发送给$S_1$，$S_1$对其进行解密并计算缩放点积注意力得分，最后将注意力得分集合发送给$S_0$。
  • $S_0$根据注意力得分集合与自己的梯度向量一起进行加权聚合，得到全局模型的更新版本。
  • 最后，$S_0$对全局模型进行重新加密并将其发送回所有客户端进行下一轮训练。

方法创新点

• 相比于传统的联邦学习方法，RFed引入了隐私保护技术和加权聚合算法，提高了模型的鲁棒性和安全性。此外，RFed还采用了双服务器架构，增加了系统的安全性和可靠性。
• 本文的主要创新点在于：
  • 提出了基于缩放点积注意力机制的防御策略，可以有效抵抗恶意客户端攻击，并提高模型的安全性和鲁棒性。
  • 采用了Cheon-Kim-Kim-Song（CKKS）加密算法，相对于其他隐私保护机制，具有更高的计算效率和更低的通信开销。
  • 通过采用双服务器架构，将数据处理和存储分散到多个节点上，降低了系统单点故障的风险，提高了系统的可靠性和稳定性。

解决的问题

• RFed解决了联邦学习中的攻击问题和隐私泄露问题。
• 通过对数据进行加密处理，RFed可以有效地防止中间人攻击和重放攻击，同时也可以保护用户的隐私信息不被泄露。
• 此外，RFed还采用了加权聚合算法，能够有效抵抗针对局部数据的恶意攻击，提高模型的鲁棒性和准确性。

个人见解

• RFed的双服务器方法与引入审计的所谓单服务器方法类似，都是一个服务器负责聚合，更新全局模型，另一个服务器（审计员）负责判断梯度的好坏，本文是为客户端分配权重，审计方法可能会直接选择恶意梯度为无效梯度。
• 为了处理恶意客户端的影响，常常不会使用单服务器，就算使用了单服务器，也是该模型的审计实体并没有取名服务器，实质上审计机构还是一个服务器。
• 本文创新型地引入了注意力机制，使用这一机制将梯度与干净梯度计算注意力得分，以此来实现对恶意客户端的判断，为了减少误判行为，本文并没有选择直接无效化数据，而是使用softmax函数为“恶意”梯度分配一个小权重，为“良性”梯度分配一个大权重。
• 对于双服务器架构，依目前来看已是比较好的方案，暂无创新方法。
• 对于梯度的判断，可以更换许多方法，比如判断梯度可以改用高斯混合模型与马氏距离的结合使用，可以利用 GMM 根据本地梯度和聚集梯度之间的关系来区分良性梯度和恶意梯度，从而区分良性客户端与恶意客户端，使用MD计算梯度距离，注意到MD越大表示梯度越有可能是恶意的，所以我们可以使用对计算后的马氏距离使用softmax函数得到权重 ${\omega }_i$ ，但在梯度聚合时要对权重 ${\omega }_i$ 做 $(1-{\omega }_i)$ 操作。
• 如果有比$CKKS$更好的FHE方法，那么就可以减少计算开销。