论文笔记2 SwiftAgg

海豹熘鱼片

已于 2024-10-05 16:50:52 修改

阅读量1.1k

点赞数 26

分类专栏：联邦学习论文笔记文章标签：论文阅读

于 2024-07-19 19:10:06 首次发布

本文链接：https://blog.csdn.net/2301_79314503/article/details/140554628

版权

联邦学习论文笔记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文针对 SwiftAgg:Communication-Efficient and Dropout-Resistant Secure Aggregation for Federated Learning with Worst-Case Security Guarantees 这篇文章作笔记。

Abstract 摘要

在摘要中，作者简单介绍了这篇文章提出的一个新的联邦学习安全聚合协议：SwiftAgg，和现有的聚合协议相比，SwiftAgg可以在不牺牲安全性的前提下，显著降低通信开销。

I.INTRODUCTION 引言

文章首先简单介绍了什么是联邦学习（Federated Learning, FL）：简单来说，就是允许用户自己根据服务器下发的全局模型训练本地数据，生成一个局部模型，最后将聚合后的数据发给服务器；服务器聚合接收到的局部模型，最终实现全局模型的更新，并迭代。这样可以实现用户数据隐私的保护。

此外，文章提出，由于各种原因，用户可能存在掉线（丢包）的情况，服务器应具备鲁棒性，以应对这种情况。

文章提到了一些安全聚合协议，如SecAgg、TurboAgg、SecAgg+等，但是它们都有或多或少的问题。

文章提出SwiftAgg，既能降低通信负载，又可以对掉线实现鲁棒性：

不需要用户之间all-to-all的通信；

需要的通信成本低；

具有抗掉线能力（鲁棒性）；

对于一个好奇的服务器和任意 $T$ 个（ $T<N-D$ ）“共谋”的用户子集可以实现最坏情况下的信息论安全。

文章符号注释：矩阵用粗体字母表示；对于 $n \in \mathbb{N}$ ， $\left [ n \right ]$ 表示集合 $\left \{ 1,...,n \right \}$ ； $\left | \mathcal{S} \right |$ 表示集合 $\mathcal{S}$ 的基数（大小）；将属于集合 $\mathcal{A}$ ，而不属于集合 $\mathcal{B}$ 的元素的集合记为 $\mathcal{A} \textbackslash \mathcal{B}$ ； $H\left ( X \right )$ 表示随机变量 $X$ 的熵； $I\left ( X;Y \right )$ 表示随机变量 $X$ 和 $Y$ 的互信息。

II.PROBLEM FORMULATION 问题的形成

首先是对场景和符号的补充说明：

设想这么一种情况：由1个服务器和 $N$ 个用户（ $U_1,...,U_N$ ）组成的联邦学习系统的安全聚合问题。每个 $n \in \left [ n \right ]$ ，都有长度为 $L$ 的私有的局部模型，记为 $\mathbf{W}_n \in \mathbb{F}^L$ ；且每个 $n$ 都有一个随机变量的集合 $\mathcal{Z}_n$ ，其元素从 $\mathbb{F}^L$ 中随机均匀地选择，并且相互独立且独立于局部模型。用户之间和用户与服务器之间可以相互传送信息，且采用无差错的私有通信链路。

用 $\mathbf{M}_{n\to n^{\prime}}^{(L)}\in\mathbb{F}^{*}\cup\{\bot\}$ 表示用户 $n$ 发送给 $n'$ 的消息， $\mathbf{X}_{n}^{(L)}\in\mathbb{F}^{*}\cup\{\bot\}$ 表示用户 $n$ 发送给服务器的消息， $\bot$ 表示不发送消息的情况。

$\mathbf{M}_{n\to n^{\prime}}^{(L)}$ 是关于 $n$ 迄今为止收到的所有消息、 $\mathbf{W}_n$ 和 $\mathcal{Z}_n$ 的函数，记相应的编码函数为 $f_{n\to n^{\prime}}^{(L)}$ ；同理 $\mathbf{X}_{n}^{(L)}$ 也是关于 $n$ 迄今为止收到的所有消息、 $\mathbf{W}_n$ 和 $\mathcal{Z}_n$ 的函数，记相应的编码函数为 $g_{n}^{(L)}$ 。

对子集 $\mathcal{S}\subseteq \left [ N \right ]$ ，令 $\mathcal{X}_{\mathcal{S}}=\{\mathbf{X}_{n}^{(L)}\}_{n\in\mathcal{S}}$ 表示服务器收到从 $\mathcal{S}$ 包含的用户发来的消息的集合；假设有子集 $\mathcal{D}\subset \left [ N \right ]$ 的用户掉线（即在协议执行过程中保持沉默，或发送 $\bot$ ），令用户掉线数为 $D= \left | \mathcal{D} \right |$ 。

假设协聚合协议执行前有身份未知的用户子集 $\mathcal{T}\subseteq \left [ N \right ]$ 是半诚实的，其中的用户诚实地遵循着协议，但是会好奇，它们可能与 $\mathcal{T}$ 中其他用户或者服务器“共谋”，以获取诚实的用户的本地模型的数据。假设对于某个安全参数 $T<N-D$ ，假设 $\left | \mathcal{T} \right | < T$ 。

由上述说明与假设得出，一个安全的聚合协议应满足以下条件：

1.正确性约束。服务器利用 $\mathcal{X}_{{[N]}\textbackslash \mathcal{D}}=\{\mathbf{X}_{n}^{(L)}\}_{n\in{[N]}\textbackslash \mathcal{D}}$ ，能够恢复 $\mathbf{W} = \sum_{n\in[N]\setminus\mathcal{D}}\mathbf{W}_{n}$ 的数据。由信息论知识可以进一步说明为：

$H\bigg(\sum\limits_{n\in[N]\setminus\mathcal{D}}\mathbf{W}_{n}\big|\mathcal{X}_{[N]\setminus\mathcal{D}}\bigg)=0$

这部分将在IV-C处加以证明。

2.隐私约束。服务器收到 $\mathcal{X}_{\mathcal{S}\textbackslash \mathcal{D}}$ 后，即使与 $\mathcal{T}$ 中用户共谋，也不能获取到本地模型聚合信息之外的其他诚实用户的所有信息，即

$I\bigg(\mathbf{W}_{n},n\in[N]\backslash\mathcal{T};\mathcal{X}_{[N]\setminus\mathcal{D}},\bigcup_{k\in\mathcal{T}}\{\mathbf{M}_{k^{\prime}\to k}^{(L)},k^{\prime}\in[N]\},\{\mathbf{W}_{k},\mathcal{Z}_{k},k\in\mathcal{T}\}\bigg|\sum_{n\in[N]\setminus\{\mathcal{D}\cup\mathcal{T}\}}\mathbf{W}_{n}\bigg)=0$

SwiftAgg应该实现有 $T$ 个用户共谋，且服务器好奇，但不与半诚实的用户共谋的前提下，也有可能保障隐私（对于诚实用户，服务器不能获取到聚合模型之外的任何信息，半诚实用户也不能获取到本地模型的任何信息）。

这部分将在IV-E处加以证明，但限于篇幅，另开一篇文章进行证明。

为满足上述2个约束，定义用户间通信负载和上行通信负载如下：

归一化的用户间通信负载 $R_{\mathrm{user}}^{(L)}$ ：用 $L$ 归一化用户之间通信的所有消息的聚合大小，即

$\displaystyle R_{\mathrm{uscr}}^{(L)}=\frac{1}{L}\sum_{n,n^{\prime}\in[N]}H(\mathbf{M}_{n\to n^{\prime}}^{(L)})$

归一化的上行通信负载 $R_{\mathrm{uplink}}^{(L)}$ ：用 $L$ 归一化用户向服务器发送的所有消息的聚合大小，即

$\displaystyle R_{\mathrm{uplink}}^{(L)}=\frac{1}{L}\sum_{n\in[N]}H(\mathbf{X}_{n}^{(L)})$

如果存在一组速率元组 $(R_{\mathrm{user}}^{(L)},R_{\mathrm{uplink}}^{(L)})$ ， $L=1,2,\ldots$ ，使得

$\displaystyle R_{\mathrm{uplink}}=\operatorname*{lim}_{L\to\infty}\sup R_{\mathrm{uplink}}^{(L)},\\R_{\mathrm{user}}=\operatorname*{lim}_{L\to\infty}\sup R_{\mathrm{user}}^{(L)}$

则称 $(R_{\mathrm{user}},R_{\mathrm{uplink}})$ 是可实现的。

安全聚合问题的容量区域被定义为所有可实现的速率元组 $(R_{\mathrm{user}},R_{\mathrm{uplink}})$ 的凸闭包，记为 $\mathcal{C}_{N,D,T}$ 。

注：sup指的是实数集合的上确界（最小上界）。

SwiftAgg的通信负载将在IV-D中给出。

III.MAIN RESULT 主要的结果

文章首先引出了一个定理：根据第二部分提出的内容，若令

$\mathcal{R}=\begin{Bmatrix}(R_{uplink},R_{user})&|R_{uplink}\geq(T+1),R_{user}\geq(N-1)(T+D+1)\end{Bmatrix}$

则有 $\mathcal{R}\subset \mathcal{C}_{N,D,T}$ 。后续将给出证明。

文章提出SwiftAgg将用户划分为不同的组，且有两个主要阶段：组内秘密共享与聚合以及组间交流与聚合。

IV.THE PROPOSED SCHEME 提出的方案

A.Motivation Example 实例

文章首先引入一个实例去说明SwiftAgg的主要思想：

设置参数 $N=12$ ，即有12个客户端，分别是 $U_1,\ldots,U_{12}$ ； $D=1$ ，即有一个客户端出现了掉线； $T=2$ ，即至多2个半诚实用户。每个用户除有长度为 $L$ 的私有的局部模型 $\mathbf{W}_n$ （向量）外，还各自拥有2个随机向量 $\mathcal{Z}_n=\left \{ \mathbf{Z}_{n,1},\mathbf{Z}_{n,2} \right \}$ ，它们从 $\mathbb{F}^L$ 中随机均匀地选择。

这里假设用户 $n=7$ 为掉线用户。

每个用户采取如下步骤：

1.分组：用户被任意划分为 $\Gamma=3$ 组，每组大小为 $D+T+1=4$ ，分别记为 $\mathcal{G}_{1},\mathcal{G}_{2},\mathcal{G}_{3}$ ，并对每组中的用户随机排序。记第 $\gamma$ 组第 $t$ 个用户为 $(\gamma,t)$ 。

2.组内秘密共享与聚合：首先定义一个多项式 $\mathbf{F}_{n}(x)$ ：

$\mathbf{F}_n(x)=\mathbf{W}_n+\mathbf{Z}_{n,1}x+\mathbf{Z}_{n,2}x^2$

其中， $\mathbf{F}_{n}(0)=\mathbf{W}_n$ 。

令 $\alpha_{t}\in\mathbb{F}, t\in[4]$ 为四个不同的常数（这里是因为每组有4个用户），将 $\alpha_{t}$ 分配给每组第 $t$ 个用户。随后，每个用户 $(\gamma,t)$ 将估值 $\mathbf{F}_{n}(x)\mid _{n=(\gamma,t),x={\alpha_{t'}}}$ 发送给 $(\gamma,t')$ 。如果 $(\gamma,t)$ 掉线或保持沉默，则 $\mathbf{F}_{(\gamma,t)}(\alpha_{t^{\prime}})$ 恰好被假定为0。

由于在本实例中，假设 $(2,3)$ 为掉线用户，则相应的， $\mathbf{F}_{(2,3)}(\alpha_{t^{\prime}})=0$ 。

每个用户计算：

$\mathbf{Q}_{(\gamma,t)}=\mathbf{F}_{(\gamma,1)}(\alpha_t)+\mathbf{F}_{(\gamma,2)}(\alpha_t)+\mathbf{F}_{(\gamma,3)}(\alpha_t)+\mathbf{F}_{(\gamma,4)}(\alpha_t)$

在本实例中，每组内最多通信 $A_4^2=12$ 次。

3.组间交流与聚合：在这一阶段，用户 $(1,t)$ 计算如下信息：

$\mathbf{S}_{(1,t)}=\mathbf{Q}_{(1,t)}$

并将 $\mathbf{S}_{(1,t)}$ 发送给 $(2,t)$ ；

用户 $(2,t)$ 计算：

$\mathbf{S}_{(2,t)}=\mathbf{S}_{(1,t)}+\mathbf{Q}_{(2,t)}$

用户 $(2,t)$ 接收到 $\mathbf{S}_{(1,t)}$ 后会将 $\mathbf{S}_{(2,t)}$ 发送给 $(3,t)$ ，若没有接收到 $\mathbf{S}_{(1,t)}$ ，它也会对协议的其他部分保持沉默。由于实例中 $\Gamma=3$ ，若 $\Gamma>3$ ，则用户 $(3,t),\ldots,(\Gamma-1,t)$ 以此类推。

本实例中，因为 $(2,3)$ 为掉线用户，所以 $(3,3)$ 也会保持沉默。

4.与服务器通信：最后一组用户，即 $(3,t)$ 计算：

$\mathbf{S}_{(3,t)}=\mathbf{S}_{(2,t)}+\mathbf{Q}_{(3,t)}$

并将 $\mathbf{S}_{(3,t)}$ 发送给服务器。

5.恢复结果：定义

$\displaystyle \mathbf{F}(x)\triangleq\sum\limits_{\overset{n=1}{n\neq7}}^{12}\mathbf{F}_{n}(x)=\sum\limits_{\overset{n=1}{n\neq7}}^{12}\mathbf{W}_{n}+x\sum\limits_{\overset{n=1}{n\neq7}}^{12}\mathbf{Z}_{n,1}+x^{2}\sum\limits_{\overset{n=1}{n\neq7}}^{12}\mathbf{Z}_{n,2}$

可以验证，在本实例中，对于 $t=1,2,4$ ， $\mathbf{S}_{(3,t)}$ 确实等于 $\mathbf{F}(\alpha_{1}),\mathbf{F}(\alpha_{2}),\mathbf{F}(\alpha_{4})$ （用户 $(3,3)$ 保持沉默，没有发送数据）。

由于 $\mathbf{F}(x)$ 是一个二次多项式函数，因此可以使用拉格朗日插值法，服务器便能恢复该多项式所有系数。特别地， $\mathbf{F}(0) = \sum_{\overset{n=1}{n\neq7}}^{12}\mathbf{W}_{n}$ ，服务器便可以恢复聚合后的存活用户本地模型，并满足正确性约束。隐私约束的证明将在后面详述。

B.General case 一般情况

本节中，将对SwiftAgg进行一般化描述。

考虑一个服务器与 $N$ 个用户组成的网络，其中至多 $T$ 个半诚实用户，且有 $D$ 个用户可能会掉线，其索引的集合用 $\mathcal{D}$ 表示；第 $n$ 个用户包含本地模型 $\mathbf{W}_n \in \mathbb{F}^L$ 和从 $\mathbb{F}^L$ 中随机均匀地选择的一组随机变量 $\mathcal{Z}_{n}=\{\mathbf{Z}_{n,j},j\in[T]\}$ 。在这种情况下，服务器希望能恢复聚合的存活用户的本地模型，即 $\mathbf{W} = \sum_{n\in[N]\setminus\mathcal{D}}\mathbf{W}_{n}$ ，而每个用户的本地模型仍是隐私的。为实现这一目标，SwiftAgg的做法为：

1.分组：将 $N$ 个用户任意划分为 $\Gamma$ 个大小为 $\nu\triangleq D+T+1$ 的组，且 $N$ 可被 $\nu$ 整除，分别记为 $\mathcal{G}_{1},\mathcal{G}_{2},...,\mathcal{G}_{\Gamma}$ ，并对每组中的用户随机排序。为简单起见，记第 $\gamma$ 组第 $t$ 个用户为 $(\gamma,t)$ 。

2.组内秘密共享与聚合：用户 $n \in \left [ N \right ]$ 构成如下多项式：

$\displaystyle \mathbf{F}_{n}(x)=\mathbf{W}_{n}+\sum_{j=1}^{T}\mathbf{Z}_{n,j}x^{j}$

其中， $\mathbf{F}_{n}(0)=\mathbf{W}_n$ ，每个用户使用 $\mathbf{F}_{n}(\cdot )$ 去与其他用户共享局部模型。

令 $\alpha_{t}\in\mathbb{F}, t\in[\nu]$ 为四个不同的常数，将 $\alpha_{t}$ 分配给每组第 $t$ 个用户。随后，每个用户 $(\gamma,t)$ 将估值 $\mathbf{F}_{n}(x)\mid _{n=(\gamma,t),x={\alpha_{t'}}}$ 发送给 $(\gamma,t')$ 。如果 $(\gamma,t)$ 掉线或保持沉默，则 $\mathbf{F}_{(\gamma,t)}(\alpha_{t^{\prime}})$ 恰好被假定为0。

注：后续内容中，如无特殊说明， $\gamma=1,2,\ldots,\Gamma$ ， $t \in [\nu]$ 。

每个用户计算：

$\displaystyle \mathbf{Q}_{(\gamma,t)}=\sum_{t'\in[\nu]}\mathbf{F}_{(\gamma,t')}(\alpha_{t})$

在这一阶段中，每组内最多通信 $A_\nu^2=\nu(\nu-1)$ 次。

3.组间交流与聚合：在这一阶段，用户 $(\gamma,t)$ 计算一条消息，记为 $\mathbf{S}_{(\gamma,t)}$ ，并将它发送给 $(\gamma+1,t)$ ， $\gamma=1,2,\ldots,\Gamma-1$ 。

第一组用户 $(1,t)$ 计算如下信息：

$\mathbf{S}_{(1,t)}=\mathbf{Q}_{(1,t)}$

并将 $\mathbf{S}_{(1,t)}$ 发送给 $(2,t)$ ；

第 $\gamma$ 组用户 $(\gamma,t)$ ， $2\leq \gamma\leq\Gamma-1$ 计算：

$\mathbf{S}_{(\gamma,t)}=\mathbf{S}_{(\gamma-1,t)}+\mathbf{Q}_{(\gamma,t)}$

用户 $(\gamma,t)$ 接收到 $\mathbf{S}_{(\gamma-1,t)}$ 后会将 $\mathbf{S}_{(\gamma,t)}$ 发送给 $(\gamma+1,t)$ ，若没有接收到 $\mathbf{S}_{(\gamma-1,t)}$ ，它也会对协议的其他部分保持沉默。

4.与服务器通信：最后一组用户，即 $(\Gamma,t)$ 计算：

$\mathbf{S}_{(\Gamma,t)}=\mathbf{S}_{(\Gamma-1,t)}+\mathbf{Q}_{(\Gamma,t)}$

并将 $\mathbf{S}_{(\Gamma,t)}$ 发送给服务器。

5.恢复结果：接收到至少 $T+1$ 个用户子集的结果，服务器便可恢复聚合的局部模型。

C.Proof of correctness 正确性证明

这部分是对SwiftAgg正确性的证明，如无需要，可以直接略过。

为证明正确性，必须证明服务器可以从第 $\Gamma$ 组接收到的消息中恢复出 $\sum_{n\in[N]\setminus\mathcal{D}}\mathbf{W}_{n}$ 。利用上一节中第3/4步的公式， $\mathbf{S}_{(\gamma,t)}(\alpha_{t})$ 要么等为0，要么为：

$\displaystyle \mathbf{S}_{(\gamma,t)}(\alpha_{t})=\sum_{\gamma'=1}^{\gamma}\sum_{n\in\mathcal{G}_{\gamma'}\setminus\mathcal{D}}\mathbf{W}_{n}+\sum_{j=1}^{T}\alpha_{t}{}^{j}\sum_{\gamma'=1}^{\gamma}\sum_{n\in\mathcal{G}_{\gamma'}\setminus\mathcal{D}}\mathbf{Z}_{n,j}$

因此，若 $(\Gamma,t)$ 将信息发送给服务器，则等价于 $\mathbf{S}_{(\Gamma,t)}(\alpha_{t})$ ，从上式中，可以看出 $\mathbf{S}_{(\Gamma,t)}(\alpha_{t})=\mathbf{F}(\alpha_{t})$ ，其中

$\displaystyle \mathbf{F}(x)=\sum_{n\in[N]\setminus\mathcal{D}}\mathbf{W}_{n}+\sum_{j=1}^{T}x^{j}\sum_{n\in[N]\setminus\mathcal{D}}\mathbf{Z}_{n,j}$

由于 $\mathbf{F}(x)$ 是一个 $T$ 次多项式函数，特别地， $\mathbf{F}(0)=\sum_{n\in[N]\setminus\mathcal{D}}\mathbf{W}_{n}$ ，只要服务器至少接收到第 $\Gamma$ 组 $T+1$ 条消息，便可以使用拉格朗日插值法，恢复 $\mathbf{F}(x)$ 和 $\sum_{n\in[N]\setminus\mathcal{D}}\mathbf{W}_{n}$ 。

对于 $\mathcal{D}$ 中任意用户 $(\gamma,t)$ ，所有的 $\mathbf{S}_{(\gamma',t)}(\alpha_{t})$ ， $\gamma\leq \gamma'\leq \Gamma$ 都是空的，特别地，所有的 $\mathbf{S}_{(\Gamma,t)}(\alpha_{t})$ 都是空的。因此，最后一组中至多 $D$ 个用户向服务器发送空消息，又由于每组大小为 $D+T+1$ ，服务器便至少收到 $T+1$ 条非空消息 $\mathbf{S}_{(\gamma,t)}(\alpha_{t})$ ，从而可以恢复 $\mathbf{F}(x)$ 。

D.The communication loads 通信负载

根据C中的公式和结论，服务器需要接收的消息总数为 $(T+1)$ ，因此SwiftAgg归一化的上行通信负载 $R_{\mathrm{uplink}}^{(L)}=(T+1)$ ；每组内，至多发送 $\nu(\nu-1)$ 条消息，每组中有 $\frac{N}{\nu}$ 个用户，此外，每个相邻组中至多发送 $\nu$ 条消息，因此SwiftAgg归一化的用户间通信负载 $R_{\mathrm{user}}^{(L)}\leq(N-1)\nu$ ，其中 $\nu= D+T+1$ 。