这是用户在 2024-8-15 8:21 为 https://app.immersivetranslate.com/pdf-pro/315ae432-44a0-42f8-9617-057e92903c1c 保存的双语快照页面,由 沉浸式翻译 提供双语支持。了解如何保存?
2024_08_15_41379d930d237705d9c4g


基于 FSS 的 GPU 安全训练与推理 Orca

 内哈·贾瓦勒卡
印度科学研究所,印度
jawalkarp@iisc.ac.in 尼尚特·钱德兰
微软研究院,印度
nichandr@microsoft.com

 卡纳夫·古普塔*
微软研究院,印度
kanav0610@gmail.com

 迪维亚·古普塔
微软研究院,印度
divya.gupta@microsoft.com

 阿尔卡帕拉·巴苏
印度科学研究所,印度
arkapravab@iisc.ac.in 拉胡尔·夏尔马
微软研究院,印度
rahsha@microsoft.com

 摘要


安全的两方计算(2PC)允许两方在不透露输入的情况下计算任何函数。在 2PC 的离线/在线模型中,独立于计算输入的相关随机性在预处理(离线)阶段生成,然后在输入可用时在在线阶段使用。大多数 2PC 工作都集中在优化在线时间,因为这个开销位于关键路径上。基于功能秘密共享(FSS)密码技术的高效 2PC 协议是一个新的范式。我们构建了一个端到端的系统 Orca,以加速使用 GPU 的 FSS 为基础的 2PC 协议的计算。接下来,我们观察到这种加速协议的主要性能瓶颈在于存储(由于大量的相关随机性),我们设计了新的基于 FSS 的 2PC 协议,用于机器学习中的几个关键功能,减少了高达 的存储。与先前在相同计算模型下使用 GPU 加速安全训练的最先进技术(Piranha, Usenix Security 2022)相比,Orca 的准确度 更高,通信量 更少,在 CIFAR-10 上的速度 更快。此外,在使用定点运算的同时保持训练准确度需要随机截断,之前所有关于安全定点训练的工作(包括 Piranha)都使用了不安全的协议。我们提供了第一个安全的随机截断协议,并基于此提供了第一个端到端安全训练的评估。对于安全的 ImageNet 推理,Orca 在 VGG-16 和 ResNet-50 上实现了亚秒级的延迟,并优于当前最先进技术

 1. 介绍


机器学习训练已经成为一个极其重要且需要大量数据的应用程序。尽管训练

模型通过更多和更多样的数据而变得更好,但这些数据往往高度敏感,例如财务、医疗保健或浏览数据。使用诸如安全多方计算(MPC)等隐私保护技术[29]、[68]可以对这些敏感数据进行安全训练[40]、[48]、[49]、[60]、[62]、[64]、[66]。使用 MPC 进行安全训练允许多个不互信的各方训练他们的联合数据模型,而不会泄露任何一方的数据,只有最终训练好的模型会被公开。然而,基于 MPC 的安全训练存在较高的性能开销。通过最近一系列的工作,在 CIFAR10 数据集上进行安全训练所需的端到端时间已经从数年[49]缩短到数月[64]、数周[60]、并最终达到一天[66]。Piranha 是目前加速安全训练使用 GPU 的最新成果。我们的目标是将这一时间缩短到不到一小时。

基于离线/在线模型,数据无关的相关随机性在离线预处理阶段生成,各方在数据相关的在线阶段使用这种相关随机性。包括 PiranhA 和我们在内的这一模型的工作都关注于降低在线复杂性。为实现高效的安全训练,PIRANHA 对 ML 做了多项 MPC 友好的近似,如用平均池替代最大池[60]、局部截断份额[49]、[60]和用分段线性函数近似指数运算。此外,仿效 Falcon[64]的做法,它也在安全性和效率之间做了权衡,在 softmax 运算中泄露了中间值,这是标准 MPC 安全要求不允许的。PiranhA 观察到它的特设近似导致了相对 PyTorch 训练的显著模型精度下降。例如,PiranhA 报告在 CIFAR-10 数据集上,VGG16 在 PyTorch 中的精度为 ,而在安全训练中降至 [66]。最后,所有依赖随机截断的之前的安全训练和推理工作[24]、[32]、[40]、[43]、[47]-[49]、[60]、[62]、[64]、[66],都使用便宜但不安全的协议来实现截断(如局部截断份额),这一点已被 45]指出。

 1.1. 我们的贡献


与[49]、[60]、[62]、[64]、[66]不同,我们的安全训练仍然忠实于机器学习文献[31]中已知模拟浮点 PyTorch 训练的量化训练算法。我们发现,对小型模型(参数为数千个)进行忠实的安全训练,其产生的模型精度更高,而使用 Piranha 对大型模型(参数为数百万个)进行安全训练则相反。Piranha 近似在小型模型上失效 - 使用这些近似(本地截断股份或指数函数的分段线性近似)训练我们的小型模型,会将训练模型的准确性降低到随机分类器的水平。在 CIFAR-10 数据集上,我们的安全训练在所有指标上都优于 PIRANHa。我们的方法既安全又产生 更高准确度的模型,同时 更快, 通信开销更低。ORCA 在 45 分钟内达到了 CIFAR-10 的准确率,而 Piranha 则在一天内只达到了 的准确率。

在技术方面,我们的起点是在预处理模型中最近在基于函数保密共享(FSS)的安全二方计算(2PC)协议方面的进展[16]、[19]、[30]。这些协议的一个关键特点是,它们在减少在线通信的同时,增加了计算和存储。FSS 的在线阶段需要大量 AES 计算,并需要读取在预处理期间生成的大量 FSS 密钥。因此,FSS 将性能瓶颈从外部网络转移到单台机器的计算和内存。在这项工作中,我们通过有效加速基于 GPU 的 FSS 2PC,大幅降低了安全训练的开销。然而,我们在系统和密码学方面都面临着几个挑战,我们将在下文中讨论。

1.1.1. 系统优化(详见第 3 节)。为了加速计算,我们创建了 FSS 协议的高效 GPU 实现,速度比基于 CPU 的协议快一个数量级。这个结果让人感到意外,因为之前试图用 GPU 加速 FSS 的工作只获得了边际改进[58]。我们加速实现的关键在于,结合 GPU 微架构进行的一系列独特的系统优化。我们利用了几种 GPU 微架构特性,例如使用 GPU 的 scratchpad 内存进行更快的 AES 计算、优化数据布局以提高 GPU 缓存命中率,以及利用 GPU 的锁步执行来将密码学计算的中间结果最优地打包到内存中。有趣的是,我们发现一旦 GPU 上的计算得到良好优化,从 SSD 读取 GB 级别 FSS 密钥到 GPU 内存就成为了瓶颈。为了解决这个问题,我们依赖于新的密码学协议(下一节讨论)来减小常见训练节点的 FSS 密钥大小。

1.1.2. 加密改进。忠实于量化训练,例如 Gupta 等人[31]中描述的那种,需要有效的协议来处理固定点值、ReLU、最大池化和浮点 softmax 的随机截断。随机截断、ReLU 和最大池化代价高昂,并导致密钥较大。Gupta 等人[31]表明,确定性截断无法在训练过程中维持准确性,因此提出使用随机截断。然而,所有先前用于安全训练的随机截断协议都是不安全的[45]。为了维持端到端安全性,我们提供了第一个安全的随机截断协议。这种更强的安全性是以巨大成本换取的。我们创造了新的协议,将密钥大小减少了高达 (第 5 节),这对于获得低端到端延迟至关重要。量化训练执行几乎所有操作都是在固定点上,但在 softmax 计算中使用浮点算术来维持准确性[31]。在安全训练文献中,有三种方法来计算 softmax 中出现的指数运算:第一,使用非常便宜的分段线性近似[41],[66];第二,使用更昂贵的固定点近似[39],[40];第三,使用更昂贵但更精确的浮点计算[54]。为了忠实于 Gupta 等人[31]的计算,我们选择了第三种选择。为此,我们创建了新的 FSS 协议,以有效地将固定点协议与浮点协议结合起来(第 6 节)。

1.1.3. 虎鲸。我们在 Orca 中实现了我们的技术,这是一个用于安全训练的按钮式工具,将公开发布 。ORCA 拥有一个 GPU 加速的 FSS 块库,未来该领域的研究可以在此基础上构建(第 77 节)。我们发现,使用 Orca 训练小模型同时保持忠实(见图 5)于量化训练[31],在精度(最高 )、时间( )和通信( )方面都优于 Piranha 的近似大模型训练(第 8.1 节)。在更公平的比较中,OrCA 在近似训练大模型方面优于 Piranha (第 8.2.1 节)。Orca 还在不使用 PIRANHA 近似的先前工作中表现优于 (第 8.2.2 节)。OrCA 的协议需要更小的 FSS 密钥(第 84 表),而且 ORCA 的基于 GPU 的协议比其 CPU 对应物快一个数量级(第 77 表)。最后,Orca 实现了有史以来首次亚秒级的 ImageNet 规模 VGG-16 和 ResNet-50 推理,并优于最先进的[30]、[41] (表 9)。

 2.准备工作

 2.1. 符號


表示计算安全参数。 表示输出 1 时谓词 为真,否则为 0 的指示函数。数组用粗体表示,其元素用同样的符号加上下标表示,从 0 开始。例如
 脚注内容
  1. https://github.com/mpc-msri/EzPC.git

数据类型。对于 代表 位无符号整数的集合。我们使用符号 表示实数集。对于 ,uint 分别表示 中相应的无符号和有符号数(采用 2 的补码表示)。

定点表示法。定点表示法由位宽 和标度 参数化,将实数 编码为 ,使得 。对于无符号(分别)定点数 的标度为 (分别为 ),其潜在的实值为 (分别为 )。

运算符。算术运算在 中,如加法和乘法,后跟 ,我们在上下文明确的情况下省略这一点。对于 ,我们使用表示 (分别,SignExt 来表示一个数 使得 (分别, )。我们使用 (分别, )来表示 向右(分别,向左)移位 位,使得输入和输出具有相同的位宽。对于一个 位数 ,截断-缩减操作,表示为 ,定义为丢弃输入的较低 位并将输出返回为一个 位数。对于一个数组 ,我们使用符号 分别表示该数组向右和向左旋转 步。

秘密共享。对于 ,我们将 的(加法)秘密共享定义为抽取两个随机数 ,使得 ,并将其表示为 share 。对于数组变量和元组,此操作逐元素应用。当秘密共享由两个方持有时,例如 持有 持有 ,我们将交换共享并将其相加的操作表示为 重建 ,对于

 2.2. 威胁模型


我们在预处理模型[30]、[41]、[58]、[66]中考虑 2 方安全计算(2PC)。在预处理阶段,生成独立于计算所有输入的相关随机数。这可以通过多种方式生成——通过可信交易商[16]、[19]、[30]、[41]、[58]、[66]、2PC 协议[29]、[68]或更高效的专门 2PC 协议[26]。在这项工作中,我们采用第一种方法。我们在标准模拟范式[20]、[29]、[46]中证明了我们协议的安全性,面对一个腐蚀其中一方的半诚实静态概率多项式时间(PPT)对手。为了完整性,我们在附录 K 中描述了详细的威胁模型。

我们的协议可以简单地扩展到"客户端-服务器"模型,其中 客户端对输入进行机密共享,将计算委托给这两个服务器 。在这种情况下,可以类似地定义安全性,并且我们可以获得对抗最多 个客户端与其中一个服务器勾结的半诚实安全性。


2.3. 功能机密共享和 DCFs


函数共享方案 (FSS) [17]、[18] 是一对算法 (Gen, Eval)。Gen 将函数 : 分割为两个函数 ,Eval 以当事人标识符 、函数份额 为输入,对输入 评估 。FSS 方案的正确性要求 。安全性要求每个函数 隐藏

定义 1 (FSS:语法[17]、[18])。一个(2 方)FSS 方案是一对算法(Gen, Eval),满足:

  • Gen 是一个 PPT 密钥生成算法,给定 (函数 的描述)输出一对密钥 。我们假设 明确包含输入和输出组的描述

  • 评估 是一种多项式时间评估算法,给定 (参与方索引)、 (定义 的密钥: )和 (输入 ),输出 (的值 )。

由 Gen 输出的密钥 称为 FSS 密钥。 的大小就是密钥大小,对应每个计算者需要存储的相关随机性。我们在附录 J 中正式定义了 FSS 方案的正确性和安全性属性。

分布式比较函数(DCFs)由 Boyle 等人[18]引入,并为特殊区间函数提供了一种 FSS 方案。

定义 2(DCF [16]、[18])。一个特殊的间隔函数 ,也称为比较函数,将 作为输入并输出 如果 为真,否则输出 0。这个函数 的相应 FSS 方案称为分布式比较函数。

我们所有的协议都使用 DCF 对于当 某些 的情况。下面,我们总结了使用[16]中优化构造的这种 DCF 的成本。

定理 1(DCF[16]的成本)。给定伪随机生成器 ,存在 的 DCF,其密钥大小为 。在 中的 调用次数为 ,在 中的 调用次数为

我们使用 和关键尺寸 来分别表示这种方案及其密钥大小。与前期工作 [16]、[30] 类似,我们设置 并使用 AES 的 4 次 128 位 CTR 模式输出实现所需的 PRG。接下来,正如在 [30] 中观察到的那样,在评估过程中只需进行 2 次 AES 调用,因为 [16] 中的评估算法只需要使用 4 个块中的 2 个,而 CTR 模式允许我们只生成所需的块。当我们需要一个输出长度较小的 DCF 时,我们使用 [18] 中的提前终止优化(移植到 DCF 上下文)并得到以下成本。

定理 2(小负载 DCF)。对于 的密钥大小为 中的 AES 调用次数为

评估 。当 时, 的密钥大小为 , 和评估 中的 AES 调用次数为 0。


2.4. 使用 FSS 的预处理安全双方计算


[16], 19]提出了一种使用 FSS 的半诚实静态安全 2PC 协议。考虑两个评估者想评估包含 门和 线的计算电路。该协议通过离线和在线两个阶段安全地评估该电路。

2.4.1. 离线阶段。对于计算电路中的每条线 ,随机采样一个掩码 。对于每个门 ,输入线 和输出线 ,生成偏移函数的 FSS 密钥 ,并向第 方提供 。对于第 方拥有的输入和输出线 ,第 方学习相应的掩码

的值为 ,由 方拥有。 方计算出遮蔽的线路值 ,并将其发送给另一方。现在,从输入门开始,两方按拓扑顺序处理门,以接收遮蔽的输出线路值。要处理门 ,其输入线路为 ,输出线路为 ,遮蔽的输入线路值为 , 方使用 Eval 与 来获得遮蔽输出线路值 的份额 ,他们通过一轮通信重构以获得 。对于输出线路,他们从预处理阶段减去相应的遮蔽,以获得明文输出。


2.5. GPU 加速计算


图形处理单元(GPU)最初是为加速图形处理而设计的,但现已成为加速并行计算的关键平台,包括深度神经网络训练、数据分析和图处理。即使是中档的 NVIDIA A6000 GPU,也可以同时执行超过五千个线程。此外,GPU 中还有超过十万个线程随时准备就绪,以便快速替换执行停滞的线程。像 CUDA 这样的 GPU 编程语言[2]要求程序员将线程排列成层次结构,以保持 GPU 的大规模并行性可控。通常由 32 个 GPU 线程组成的"线程束"(warp)以锁步方式执行,是最小的可调度工作单元。一个线程块(threadblock)最多由 32 个线程束组成。GPU 内核通常会启动数百个线程块,形成数十万个线程的网格。

图形处理器(GPU)的体系结构反映了其编程层次。线程束在单指令多数据(SIMD)单元上同步执行。多个这样的 SIMD 单元被放置在流式多处理器(SM)上。GPU 会有数十个这样的 SM;例如 A6000 有 84 个 SM。一个线程块的所有线程都被调度在同一个 SM 上;来自不同线程块的线程可以在不同的 SM 上运行。


GPU 的内存子系统呈现类似的层次结构。GPU 上的内存通常支持超过 的带宽,但容量仅限于几十 GB。这些内存内容被缓存在两级硬件缓存中。GPU 还具有几个专门的软件管理的硬件缓存。例如,每个 SM 都有一个刮板(也称为共享内存),用于同一个线程块中的线程之间轻松共享数据。这是可能的,因为同一个线程块的所有线程都保证在同一个 SM 上执行。同样,SM 中的常量缓存是专门用于存储频繁使用的只读数据的。CUDA 中的每个线程也有数十个快速寄存器。由于同一个 warp 的线程总是作为一个组执行,CUDA 可以使用这些寄存器在 warp 的线程之间进行集体操作,以交换和/或减少数据。

最后,我们注意到 GPU 总是伴随 CPU 而存在。它通过 PCIe 互连连接到主机 CPU [10]。 GPU 加速程序首先在 CPU 上运行。在 CPU 上运行的程序部分会在 GPU 上分配/释放内存,并通过 PCIe 总线在 GPU 内存和 CPU 内存之间传输数据。 CPU 还负责在网格中启动所需数量的线程,从而使 GPU"内核"(用 CUDA/OpenCL 编写的 GPU 加速函数)在 GPU 上进行计算。


在 GPU 上加速 FSS


加速基于 FSS 的安全计算在 GPU 上是 Orca 的重要目标。为此,我们在两个关键方面取得了进展。(1)我们展示了如何利用 GPU 架构来实现合理的 FFS 基础计算加速。(2)我们发现从存储读取 FSS 密钥的时间可能会掩盖 GPU 加速带来的好处。我们提出了一种新的加密技术和系统改进的组合方法来限制密钥读取时间。接下来,我们将详细阐述 Orca 设计中的这两个方面。


3.1. 加速基于 FSS 的 GPU 计算


之前试图在 GPU 上加速基于 FSS 的协议[58]的工作仅在没有全面策略利用 GPU 架构特点的情况下观察到了适度的加速效果。在 Orca 中,我们采用以下三种关键技术来利用 GPU 的运算能力。

(1) 更快的 AES 计算 (AES)FSS 基础计算的一个关键原语是分布式比较函数或 DCF(第 4 节)。我们经验性地发现,计算 DCF 可能占用整体计算时间的大部分,例如,在 CNN3 的正向传播中,DCF 占据了大约 的整体计算时间。对 进行 DCF 评估需要 次 AES 调用(第 2.3 节)。

考虑执行 1000 万个 DCF 评估作为微基准测试,以量化我们在本小节讨论的不同优化的加速潜力。这个选择是由于几个模型每层需要执行数百万次 DCF。

表 1 经验性地捕捉了微基准的计算时间,从下面讨论的基线开始。

为了在 GPU 上加速 AES,我们首先使用 PyTorch 的 csprng 扩展[11],遵循之前的研究[58]、[60]。AES 需要反复查找预先计算的查找表[61]。通过分析使用 NVIDIA 的 Nsight 工具[8]进行 PyTorch 的 csprng 性能分析,我们发现它在访问查找表时经常会停顿。它将查找表保存在 GPU 每个 SM 的常量缓存中。虽然对常量缓存的访问很快,但只有当 GPU 线程在任何给定周期访问相同的地址时才适合[3]。否则,访问将被串行化,从而导致计算停滞。不幸的是,不同的线程访问不同的索引(因此,不同的地址)。

为了减少这种停顿,我们按照先前工作[61]中提出的策略,为 SM 中的每个 warp(这里是 32 个)复制一次查找表。此外,复制的表格被放置在 GPU 中每个 SM 的 scratchpad(共享内存)上。这是因为 scratchpad 是有独立 bank 的,与常量缓存不同。不同 bank 中的数据可以同时访问,不会造成停顿。因此,AES 查找表的副本被放置在 scratchpad 的不同 bank 中,缓解了由于访问 AES 查找表而导致的停顿。

表 1 中的第一个条目显示,PyTorch 的 csprng 扩展[11]的 AES 实现需要 3305 毫秒。当我们使用优化的 AES 实现("表中的 AES")时,它减少到 840 毫秒,给出了 的加速比。

(2) 针对高速缓存局部性优化数据布局(LAYOUT) 计算 DCF 需要评估者执行 链式伪随机生成器(2n AES)[16]、[30]。然而,评估者在将输出馈送到 伪随机生成器调用之前,会稍微修改 伪随机生成器调用的输出,并使用纠正字 [16]。因此,每个 DCF 密钥都有 个纠正字。我们注意到,内存中这些纠正字的布局会影响性能。

在并行化的 CPU 实现中,每个线程都会独立在一个 CPU 内核上计算一个 DCF。因此,将 DCF 计算的校正词连续地布置在内存中更有利于缓存局部性。然而,在 GPU 实现中,一个包含 32 个线程的线程束以同步的方式执行,每个线程都在计算一个 DCF。在同步执行中,线程束中的线程只有在完成 PRG 计算后才能继续计算。因此,与 CPU 实现不同,将给定 DCF 的所有校正词连续存放会导致缓存命中率较低。相反,对于 GPU 实现,必须考虑线程束中所有线程的缓存局部性。因此,我们将线程束中每个线程给定轮次的 PRG 校正词连续存放。换句话说,就是将线程束中所有线程(DCF 计算)给定(比如第四)轮次的 PRG 校正词连续存放在内存中,然后是下一轮次的 PRG 校正词,以此类推。

我们发现优化的校正词布局将 L1 缓存命中率从 提高到 。如图所示
 天真的 AES  AES+布局  高级加密标准+布局+内存
 时间 3305 840 716 523
 加速

表 1:我们的优化处理 10M 个 DCFs 的加速效果

在表 1 中,这种优化(LAYOUT)进一步将计算 1000 万个 DCFs 的时间从 840 毫秒减少到 716 毫秒。(3)优化内存占用空间(MEM):基于 FSS 的协议降低了通信开销,但需要更大的密钥大小。包含密钥的文件通常存储在存储设备(如 SSD)上,在在线计算期间必须读取到内存中。从 SSD 读取大密钥可能会非常缓慢(参见第 3.2 节)。我们通过新的加密协议解决了这一挑战,大大减小了训练和推理中常见节点的密钥大小,详见第 4、5 和 6 节。密钥大小的减小不仅降低了 CPU 和 GPU 之间通过缓慢的 PCIe 互联网络移动数据的开销,也减少了对有限 GPU 内存的占用。减小密钥大小的一个关键技术是使用较小负载的 DCF(如 1 位而不是 64 位),并尽可能在较短的输入(如 40 位而不是 64 位)上进行比较。

然而,充分利用较小的 DCF 有效负载的全部优势并非易事。保持 1 位输出到标准数据类型(如字节)的简单实现会导致 内存膨胀。相反,在 Orca 中,一个 warp 的 32 个线程以同步的方式将它们的 1 位 DCF 输出写入到一个 32 位整数中。这避免了内存膨胀,但要求 warp 中的线程在不需要锁的情况下写入单个整数。在 GPU 上,锁的速度极慢[65]。OrcA 利用 CUDA 的 warp 同步原语来确保每个线程都可以写入输出而不会干扰 warp 中其他线程的写入。具体来说,它使用 CUDA 的__ballot_sync()和

_shfl_down_sync()用于在没有锁的情况下进行线程级同步数据交换的内置方法[13]。表 1 显示了由于此优化(MEM)而进一步加快了速度。执行一千万次 DCF 所需的时间降至 523 毫秒( 加速),这是相比原始实现有 的改善。


3.2. 缩短阅读 FSS 密钥的时间


基于 FSS 的安全计算协议的一个关键优势是它限制了各方之间的通信。但是,它需要在执行在线计算时读取大量预生成的密钥。我们发现,一旦通过上述策略在 GPU 上加速计算,从存储(这里是 SSD)到 GPU 内存读取 FSS 密钥的时间成为瓶颈。我们采取了三管齐下的方法来解决这个瓶颈。

绕过操作系统页缓存:默认情况下,操作系统会在 CPU 的 DRAM 上缓存文件内容,希望文件数据可以在一段时间内被重复访问。但是,页缓存会在访问文件内容的关键路径上增加开销。由于 FSS 密钥只使用一次,没有重复利用的情况。因此,包含 FSS 密钥的文件无法从页缓存中获益。


页面缓存但支付开销。例如,我们训练的一个模型,来自[31]的 CNN3,在加密改进之前每次迭代需要 34.7 GB 的密钥。绕过操作系统的页面缓存,可将读取此密钥的时间从 13.4 秒缩短至 6.2 秒。

(2) 重叠关键读取与计算:为进一步减少关键读取时间的影响,我们将 训练迭代的计算与 迭代的关键读取重叠进行。这确保了整个关键读取时间不在关键路径上。

(3) 新型密码术来限制密钥大小:即使在上述优化措施之后,从 SSD 读取密钥的时间仍可能超过 GPU 计算时间,对于更大的网络而言更是如此。我们发现,仅当计算在 GPU 上得到良好加速(如在 Orca 中)时,密钥读取时间才成为瓶颈。对于 CPU 单独实现的 FSS 协议或第 3.1 节中没有进行优化的 GPU 实现,情况并非如此。

我们构建新的 FSS 协议来减少流行的非线性激活函数(如 ReLU 和最大池化)中的密钥大小,同时在量化训练时与截断相结合时也可以减少在线通信(第 45 节)。例如,我们针对截断后的 ReLU 实现了 的密钥大小减少。总的来说,在训练过程中,我们实现了高达 的密钥大小减少(表 8)。对于 CNN3,我们将每次迭代读取密钥的时间从 6.2 秒减少到 1.9 秒,并且现在可以完全重叠 2.4 秒的 GPU 计算时间(表 12)。


4.基础建筑块协议


句法。我们使用(*)来表示被屏蔽的值,例如 。我们描述了我们的协议(用 表示),对应于评估者持有输入 (用 表示)的屏蔽值,以及评估者未知的屏蔽 (在预处理阶段生成)。在该协议之后,评估者持有输出 的屏蔽份额,即 。相应的协议 可以通过添加一个重构步骤从 中很容易构建,其中评估者以明文形式持有输出 的屏蔽值。我们将协议 (或 )所需的密钥大小表示为 keysize

与先前基于 FSS 的 2PC [16]、[19]、[30]的工作不同,其中门的在线阶段是非交互式的,我们构建了更复杂的协议,其中在线阶段被允许是多轮的。然而,这对于将协议拼凑在一起并没有问题,因为评估者最终仍会得到掩蔽的值或相同的份额。

以下,我们首先提供用于函数 Select 和 Signed Extension 的新的 FSS 协议,这些将用作后续章节中所述协议的基础块。

 4.1. 选择


选择功能,选择 ,需要输入一个选择器位 和一个 位有效负载 ,如果 则返回 ,否则返回 0。它相当于在 之间进行无符号混合位宽乘法。也就是说, 。使用表达式
Select \(\Pi_{n}^{\text {select }}\)
\(\operatorname{Gen}_{n}^{\text {select }}\left(\left(r_{1}^{\text {in }}, r_{2}^{\text {in }}\right), r^{\text {out }}\right):\)
    \(u=\operatorname{extend}\left(r_{1}^{\text {in }}, n\right)\)
    \(w=u \cdot r_{2}^{\text {in }}+\mathrm{r}^{\text {out }}\)
    \(z=2 \cdot u \cdot \mathrm{r}_{2}^{\text {in }}\)
    share \(\left(u, r_{2}^{\text {in }}, w, z\right)\)
    For \(b \in\{0,1\}, k_{b}=u_{b}|| r_{2, b}^{\text {in }}\left\|w_{b}\right\| z_{b}\)
\(\operatorname{Eval}_{n}^{\text {select }}\left(b, k_{b},(\hat{s}, \hat{x})\right):\)
    Parse \(k_{b}\) as \(u_{b}\left\|\mathrm{r}_{2, b}^{\text {in }}\right\| w_{b} \| z_{b}\)
    if \(\hat{s}=0\) then
        return \(\hat{y}_{b}=u_{b} \cdot \hat{x}+w_{b}-z_{b}\)
    else
        return \(\hat{y}_{b}=b \cdot \hat{x}-u_{b} \cdot \hat{x}-\mathrm{r}_{2, b}^{\mathrm{in}}+w_{b}\)
    end if

图 1:选择协议

来自[30]的无符号混合位宽乘法的偏移函数,select 的偏移函数为:

在这里,我们利用 作为 是单比特值这一事实。使用这个表达式,我们描述了图 1 中的选择协议

定理 3。 在图 1 中实现了安全的选择 ,密钥大小为 ,无需通信。

 4.2. 有符号扩展


[30]提供了以下表达式来描述 SignExt 功能的偏移函数(第 2 节):

。 [30]还提供了一种非交互式协议来安全地实现它,但受到了较大的密钥大小(密钥大小为 )的影响。我们提供了一种密钥大小较小的协议,代价是需要一个额外的回合和 2 位在线通信。我们在图 2 中描述了该协议 。在该协议中,我们使用掩码 在第一轮计算 的掩码值 。交易员还发送了 ,具体取决于掩码 。评估者使用 之间选择 。由于我们只需要比较的输出作为一个位,我们实现了比[30]更小的密钥大小,因为有一个更小的 1 位有效载荷(和提前终止)。
Signed Extension \(\Pi_{m, n}^{\text {SignExt }}\)
\(\operatorname{Gen}_{m, n}^{\text {SignExt }}\left(r^{\text {in }}, r^{\text {out }}\right):\)
    \(t=r^{\text {out }}-\operatorname{extend}\left(\mathrm{r}^{\text {in }}, n\right)-2^{m-1}\)
    \(\left(k_{0}^{<}, k_{1}^{<}\right) \leftarrow \operatorname{Gen}_{m}^{<}\left(1^{\lambda}, \mathrm{r}^{\text {in }}, 1, \mathbb{U}_{2}\right)\)
    \(r^{(w)} \stackrel{\S}{\leftarrow} \mathbb{U}_{2}\)
    \(\boldsymbol{p}=\left\{t, t+2^{m}\right\} \ggg r^{(w)} \in \mathbb{U}_{N}^{2}\)
    share \(\left(r^{(w)}, \boldsymbol{p}\right)\)
    For \(b \in\{0,1\}, k_{b}=k_{b}^{<}\left\|r_{b}^{(w)}\right\| \boldsymbol{p}_{b}\)
    \({ }_{m, n}^{\text {SigExt }}\left(b, k_{b}, \hat{x}\right):\)
    Parse \(k_{b}\) as \(k_{b}^{<}\left\|r_{b}^{(w)}\right\| \boldsymbol{p}_{b}\)
    \(\hat{x}^{\prime}=\hat{x}+2^{m-1} \bmod 2^{m}\)
    \(\hat{w}_{b} \leftarrow \operatorname{Eval}{ }_{m}^{<}\left(b, k_{b}^{<}, \hat{x}^{\prime}\right)+r_{b}^{(w)} \bmod 2\)
    \(\hat{w}=\) reconstruct \(\left(\hat{w}_{b}\right)\)
    return \(\hat{y}_{b}=b \cdot \hat{x}^{\prime}+p_{b, \hat{w}}\)

图 2:SignExt 协议。

定理 4. 在图 2 中实现 可靠,使得密钥大小 密钥大小 1.在在线阶段,该协议需要 1 次 评估和 2 轮 1 比特的通信。


5. 安全培训协议


训练功能。为实现安全训练,我们需要以下功能的协议:a) 线性层,如矩阵乘法和卷积;以及 b) 激活函数,如 ReLU 和最大池化。线性层使用与 LLAMA [30] 相同的方法安全计算(即通过预处理阶段生成的 Beaver 三元组)。在定点算术中,乘法必须遵循截断操作以保持规模。也就是说,将两个定点值相乘,其隐式比例尺为 ,因此我们需要进行 的截断以获得比例尺 的结果。文献考虑了在实施定点算术的安全计算中的三种截断方式:忠实截断或算术右移、随机截断 [31]、[32]、[40] 和局部截断 [49]。大多数先前关于安全训练的研究 [49]、[60]、[62]、[66] 使用局部截断,因为它们是最高效的,因为它们是局部操作。LLAMA [30] 提供了一种 FSS 协议用于忠实截断。Gupta 等人 [31] 论证了在量化训练中需要使用随机截断,我们提供了随机截断的 FSS 协议(在第 5.2 节中定义)。在 ML 推理和训练中,线性层后跟有激活函数。在实现定点训练时,这将对应于线性层后跟一个截断,然后再跟 ReLU 和有时还有最大池化。在这种情况下,我们发现将这些节点融合在一起计算更加高效。

章节概述。我们首先描述了我们对 ReLU(第 5.1 节)和随机截断的新协议。


第 5.2 节)采用较小的密钥大小。接下来,在第 5.3 节中,我们展示了如何将随机截断节点与诸如 ReLU 和 ReLU+Maxpool 等激活函数相融合,以获得较小的密钥大小和计算量,相比于顺序计算的朴素方法。我们的重点一直是降低密钥大小(即使稍微增加了在线通信轮数)。

5.1. ReLU


对于一个有符号值 ,ReLU 功能返回 。AriaNN [58]提供了一个 1 轮协议,用于 (具有 1 位误差),密钥大小为 ,而[16]构造了一个非交互协议(无误差),具有相同的密钥大小。在这里,我们构建了一个 1 轮 协议(无误差),密钥大小为 ,与[16]相比,需要额外 2 位在线通信。具体而言,对于 ,这导致 的密钥大小减少。

是表示基础符号值的 位二进制补码表示时,

其中 称为 的导数。使用此表达式,我们在第一轮计算 ,输出为单比特,然后使用协议 根据比较结果输出 或 0。由于我们只需要单比特的比较输出,这个协议的密钥大小小于文献 [16] 中带 位比较输出的基于样条的协议。

我们证明了以下表达式, 适用于 附录 H 中的 偏移函数

基于此,我们在图 3 中描述了 的协议。 的协议是通过运行 并对 进行一轮重建来获得的。

定理 5。 安全地实现 。 在线阶段,该协议需要评估 2 次,并在 1 轮中进行 2 位的通信。


5.2. 随机截断


在随机截断中,无论是保持位宽还是减少位宽,截断的结果都会向上或向下四舍五入,其概率取决于被截断的小数部分。我们在下面提供了这两种版本的全新安全协议。


5.2.1. 随机截断-缩减。

DReLU \(\Pi_{n}^{\text {DReLU }}\)
\(\operatorname{Gen}_{n}^{\text {DReLU }}\left(r_{n}^{\text {in }}, r^{\text {out }}\right):\)
    \(:\left(k_{0}^{<}, k_{1}^{<}\right) \leftarrow \operatorname{Gen}_{n}^{<}\left(1^{\lambda}, \mathrm{r}^{\text {in }}, 1, \mathbb{U}_{2}\right)\)
    share \(r^{\text {out }}\)
    For \(b \in\{0,1\}, k_{b}=r_{b}^{\text {out }}|| k_{b}^{<}\)
\(\operatorname{Eval}_{n}^{\text {DReLU }}\left(b, k_{b}, \hat{x}\right):\)
    Parse \(k_{b}\) as \(r_{h}^{\text {out }} \| k_{b}^{<}\)
    \(\hat{y}=\hat{x}+2^{n-1} \bmod 2^{n}\)
    \(u_{b} \leftarrow \operatorname{Eval}_{n}^{<}\left(b, k_{b}^{<}, \hat{x}\right)\)
    \(v_{b} \leftarrow \operatorname{Eval}_{n}^{<}\left(b, k_{b}^{<}, \hat{y}\right)\)
    return \(\hat{y}_{b}=v_{b}-u_{b}+b \cdot 1\left\{\hat{y} \geqslant 2^{n-1}\right\}+\mathrm{r}_{b}^{\text {out }}\)
    \(\bmod 2\)

图 3:DReLU 协议

定义 3。对于 ,用 表示的随机截断减少过程为 ,其中

现在,stTR 可以按如下方式计算:随机选择一个值 ,其概率为 为 1,否则为 0,并输出 。接下来我们注意到 可以计算为 ,其中 是随机的。

我们证明了以下引理附录 C,它使我们能以 的代价提供随机截断减少的安全协议。

引理 1。对于具有潜在值 和随机掩码 的被掩码值 ,令 。那么,
 因此,

对于上述引理中的最终表达式,第一项可由评估人员本地计算,第二项和第三项可由交易商计算,最后一项可使用 计算。有趣的是,我们还注意到,从上述引理来看,(忠实的)截断还原和随机截断还原都可以以单个 的类似成本计算。我们在附录 C 中提供了随机截断还原的正式协议 及其安全性证明,其成本总结如下。

定理 6。 安全地实现了随机截断-缩减,使得密钥大小为 位。在线阶段需要评估 一次,并在 1 轮中传输 2 位。


5.2.2. 随机截断。


定义 4. 对于 ,由 进行的随机截断,表示为 ,是一个 位的数字 ,使得:

使用与上述类似的思想,计算随机截断的一种方法是 ,其中 是一个随机变量,位于 中。这里,第一项 可以使用 Boyle 等人[16]的算术右移协议计算,第二项 可以使用引理 1 中的表达式计算。总的来说,这种方法需要一个 ,一个 ,这是昂贵的。我们在附录 I 中证明了以下引理,这使我们能够以 的随机截断和从 的有符号扩展的成本安全实现随机截断。

引理 2。对于 满足 ,

协议 。首先执行使用 的随机截断-缩减协议,接着是被遮蔽输出的重建,即 ,然后是扩展到 位的签名协议,即

定理 7. 安全实现随机截断,使得密钥大小 。在在线阶段,该协议需要 1 次评估 ,并在 3 轮中传输 比特。

与上述直接方法相比,对于 ,我们的密钥大小 更低,在在线阶段的 AES 调用次数 更少。


5.3. 随机截断 + 激活函数


正如前面讨论的,当线性层后跟激活函数如 ReLU 和最大池化时,我们将随机截断节点与 ReLU(或 ReLU 和最大池化,取决于存在的节点)进行融合,以获得单一的融合功能协议。在本节中,我们描述了针对 ReLU 情况的实现方式;在附录 B 中,我们描述了 ReLU+最大池化的情况。

如前所述,线性层是在 上计算的,然后通过公共尺度 进行随机截断。我们定义了一个融合功能,即随机截断 ,它以 为输入,通过 对其进行随机截断,并返回截断后的值的 。正式地,

上述表达式可以通过运行协议 然后运行 来实现,耗时 5 轮。我们在下面描述的 2 个步骤中大幅改进了这一过程。

首先,根据引理 2,在随机截断中,通过 位随机截断-约简,然后进行 位有符号扩展。接下来,对 位输入进行 ReLU 计算。我们观察到,我们可以交换 ReLU 和扩展的顺序,从而在 位上计算 ReLU,而不是 位,从而减小密钥大小和在线计算。此外,由于 ReLU 输出始终为非负数,我们可以使用零扩展,其协议与第 4.2 节中的有符号扩展非常相似。

其次,我们通过提供一种新的协议来改进上述方法,该协议通过利用针对 DReLU 和 ZeroExt 进行的类似比较来一起执行 ReLU 和零扩展。这进一步减小了密钥大小。我们将此功能称为 ReLU-Extend,用 ZeroExt 表示。

对于 ,遮罩 和掩盖值 ,令 。此外,从 [30] 出发,

然后, 的偏置门可以写为

我们需要根据 的值计算 1 出 4 的选择。现在, 都使用与 的比较,因此可以使用单个 DCF 密钥来计算,并且可以在单轮互动中获得它们的掩码值。现在,选择可以通过 2 次连续调用来完成,从而得到一个总共 2 轮的协议。我们将其进一步改善为 1 轮。

而不是 。设 为这 1 个出 4 个选择的索引。我们将 的遮蔽值和密钥掩码分别表示为 。请注意,上述表达式中的下划线值对双方都是已知的。为了隐式地在这 4 个值之间进行选择,交易商会发出一个数组 的共享,使得 时为 1,否则为 0。在线上阶段,评估者将 向右旋转 个位置,以获得一个一热编码数组的共享,该数组在位置 处为 1。该数组与 的内积产生所选下划线值的共享。

根据 的值,评估人员需要盲目地在 之间进行选择,这两个值对于交易商是已知的。为此,交易商分发一个数组 的份额,其元素为 ,当 时进行交换。在在线阶段,评估人员在数组 中索引 。将两个选定的份额相加,得到所需掩蔽输出的份额。
ReLU-Extend \(\Pi_{n-f, n}^{\mathrm{ReLUEx}}\)
\(\operatorname{Gen}_{n-f, n}^{\text {ReLUExt }}\left(r^{\text {in }}\right.\), rout \(\left.^{\text {out }}\right):\)
    \(:\left(k_{0}^{<}, k_{1}^{<}\right) \leftarrow \operatorname{Gen}_{n-f}^{<}\left(1^{\lambda}, \mathrm{r}^{\text {in }}, 1, \mathbb{U}_{4}\right)\)
    \(r^{(d)} \stackrel{\&}{\leftarrow} \mathbb{U}_{4}\)
    \(r^{(w)} \stackrel{\&}{\leftarrow} \mathbb{U}_{4}\)
    \(r^{(i)}=2 \cdot r^{(d)}+r^{(w)}\)
    \(\boldsymbol{p}=\{1,0,0,0\} \lll r^{(i)} \in \mathbb{U}_{N}^{4}\)
    \(\boldsymbol{q}=\left\{r^{\text {out }}, r^{\text {out }}-r^{\text {in }}\right\} \ggg\left(r^{(d)} \bmod 2\right) \in \mathbb{U}_{N}^{2}\)
    share \(\left(r^{(d)}, r^{(w)}, \boldsymbol{p}, \boldsymbol{q}\right)\)
    For \(b \in\{0,1\}, k_{b}=k_{b}^{<}\left\|r_{b}^{(d)}\right\| r_{b}^{(w)}\left\|\boldsymbol{p}_{b}\right\| \boldsymbol{q}_{b}\)
\(\operatorname{Eval}_{n-f, n}^{\mathrm{ReLUExt}}\left(b, k_{b}, \hat{x}\right):\)
    Parse \(k_{b}\) as \(k_{b}^{<}\left\|r_{b}^{(d)}\right\| r_{b}^{(w)}\left\|\boldsymbol{p}_{b}\right\| \boldsymbol{q}_{b}\)
\(\hat{y}=\hat{x}+2^{n-} \bmod 2^{n-f}\)
    \(w_{b} \leftarrow \operatorname{Eval}_{n-f}^{<}\left(b, k_{b}^{<}, \hat{x}\right)\)
    \(\hat{w}_{b} \leftarrow w_{b}+r_{b}^{(w)} \bmod 4\)
    \(\hat{d}_{b} \leftarrow \operatorname{Eval}_{n-f}^{<}\left(b, k_{b}^{<}, \hat{y}\right)-w_{b}+b \cdot 1\left\{\hat{y} \geqslant 2^{n-f-1}\right\}+\)
    \(r_{b}^{(d)} \bmod 4\)
    \((\hat{w}, \hat{d})=\) reconstruct \(\left(\hat{w}_{b}, \hat{d}_{b}\right)\)
    \(\hat{i}=2 \cdot \hat{d}+\hat{w} \bmod 4\)
    \(\boldsymbol{p}_{b}^{\prime}=\boldsymbol{p}_{b} \ggg \hat{i}\)
    \(\hat{j}=\hat{d} \bmod 2\)
    return \(\hat{u}_{b}=p_{b, 3}^{\prime} \cdot\left(\hat{x}+2^{n-f}\right)+p_{b, 2}^{\prime} \cdot \hat{x}+q_{b, \hat{j}}\)
    \(\bmod N\)

图 4:ReLUExt 协议。

我们在图 4 中呈现了 协议用于 ,并在附录 F 中证明了其安全性。使用这个,我们可以通过运行 后跟 来轻松获得 的协议。

定理 8。 安全实现 ,使得 密钥大小 。在线阶段需要 1 次评估 和 2 次评估 ,并在 3 轮中传输 比特。

成本对比。我们认为,我们新的融合协议构建方法可降低成本。使用 LLAMA[30]中的协议实现此功能的简单方法(通过截断后跟随 ReLU)需要密钥大小为 。另一方面,使用我们改进的协议的直接(非融合)方法的密钥大小为 。具体而言,对于 ,我们的密钥大小比这两种方法分别低 。我们的方法在联机阶段也有 更少的 AES 评估。

 6.Softmax 协议


为了模仿[31]中的量化训练,我们使用浮点运算准确计算 softmax。为了安全地实现这一目标,


我们利用了最先进的 2PC 浮点库 SecFloat[54]。但是,为了让各方能够调用该库中的 softmax 协议,他们必须持有输入的浮点表示的秘密份额。因此,我们需要一个协议,将掩码后的定点值(来自 FSS 方案)转换为相应浮点值的秘密份额,根据[54]中的表示方式。同样地,为了在训练协议的其余部分使用 softmax 计算的输出,我们需要一个协议,将浮点值的秘密份额转换回相应的(掩码)定点值。我们首先介绍浮点表示和 softmax 的背景知识,然后在第 6.1 节和第 6.2 节中介绍我们的 FixToFloat 和 FloatToFix 协议。

浮点数表示。SECFLOAT [54]使用 4 个值来表示 32 位浮点数 ,其中 表示零位(在 时设置), 表示符号位(在 时设置), 表示无偏签名指数,值在范围 之间, 表示归一化的无符号定点小数部分,取值在范围内。此外, 表示实数 。当 时, 成立。

软最大化。对于一个 维向量 的实数,softmax 计算一个向量 使得:

其中 。后者表达式通常更受偏好,因为前者表达式中的指数可变得任意大,从而导致溢出。而后者表达式则将指数输出限制在范围 内。

 6.1. 整数转浮点数


要将定点数 转换为等价的浮点数 ,我们必须找到 ,使底层的真实值相近。因此,以下关系 成立:

作为 分别表示零位和符号位,使用以下关系计算它们很简单:

  1. 对于真实值 ,我们滥用 来表示


    注意当 成立时。在 的情况下,只需找到 使得:

计算 。对于给定的 ,此方程可能有多个解。但是由于 必须归一化,即在范围 内,因此有唯一的一对 满足这两个约束条件。设 为一个数,使得 。那么, 。将 乘到上式两边,

作为 LHS 和 uint 都位于范围 内,上述方程式只能在以下条件下成立:

计算机 。现在我们有:

注意 可以使用关系 计算为 位数字。要计算 ,我们有:

在上面的分数中,我们注意到当 时,分子 可以被准确地表示为一个 位无符号数。要将 计算为 24 位数,只需将分子截断并减少 位即可获得 的准确近似值。

综合起来,对于给定的 位固定点数 ,精度为 ,我们定义了 FixToFloat 功能,它计算出浮点数 ,其中:

使用了 定义类似于上述。与计算涉及与单独 DCF 键进行比较的每个子表达式的自然方法相比,我们提供了一种仅使用 2 个 DCF 键的新协议。总体而言,对于 ,我们获得了相对于简单方法的 的减少。我们在附录 D 2 中详细描述了我们的协议,实现了下面总结的成本。

定理 9。 以安全的方式实现了 FixToFloat 。其中,密钥大小 等于密钥大小 。在在线阶段,该协议需要执行 评估,并在 2 轮中传输 位。

 6.2. 浮点数到定点数转换


给定一个秘密共享的浮点值 ,我们需要计算其中一个最接近的 -位定点数 的份额,其比例为 。我们的协议 ,它实现了上述 FloatToFix 功能用于 softmax 输出,采用了类似的思路,由于空间限制,我们将详细信息委托给完整版本 [34]。以下定理总结了其成本,其中 是由 [16] 提供的用于将 位值算术右移 位的协议。

安全地实现了 FloatToFix ,使得密钥大小 ToFix 密钥大小 密钥大小 。在在线阶段,该协议需要 1 次 的求值,并且通信成本为 位,分 3 轮进行。

 6.3. 端到端训练


如前文第 5 节所述,用于卷积、矩阵乘法、ReLU、最大池化等的基于 FSS 的单个协议可以组合起来构建端到端协议。当卷积(或矩阵乘法)后跟 ReLU(或 ReLU+最大池化)时,它们被替换为卷积(相应地为矩阵乘法)后跟 (或分别为 )的协议。训练协议需要在正向传递的最后进行 softmax 计算,这里我们首先使用 将掩码固定点输出转换为秘密共享的浮点数,调用 SecFloat [54]中的 softmax 协议,然后再使用 将秘密共享的浮点数转换回掩码固定点数。为了计算 ReLU 和最大池化的反向传递,我们重复使用正向传递中的比较输出,并将其与 和按位与进行组合;因此,在这里没有将节点融合的好处。端到端协议的安全性可以在仿真范例中进行论证。详细信息请参见附录 E。

预处理成本。在预处理阶段,交易商必须计算并传输密钥到 。几乎所有计算密钥的成本来自计算 Beaver 三元组和 DCF 密钥,这可以大致估计为在线运行协议的成本的 。但是,如果计算的密钥需要通过网络传输到 ,那么这种成本将占主导地位,并取决于网络带宽。例如,在 CIFAR-10 数据集上训练 Piranha 的 VGG16 模型的单次迭代,批量大小为 128,需要传输约 15.1 GB 大小的密钥,在我们的 9.4 Gbps 网络设置中,这需要约 12.8 秒。相比之下,执行相同基准测试的在线阶段只需 2.5 秒。在带宽为 293 Mbps 的 WAN 环境中,传输密钥需要 422 秒,而在线阶段需要 38.4 秒。

 7.实施


我们将 Orca 作为一个易于使用的 C++库来实现。它包含了第 4 节和第 5 节中描述的 FSS 门的优化 GPU 内核。Orca 的软件框架支持实现 GPU 优化 FSS 协议所需的关键功能。我们利用 NVIDIA 的 CUDA 库中可用的优化内核,并在必要时编写自己的 CUDA 内核。与先前的 CryptGPU [60]不同,我们没有将 64 位整数嵌入 64 位浮点数中,以利用 NVIDIA 的 cuBLAS [1]和 cuDNN [7]库中的优化浮点内核。相反,与 Piranha [66]类似,我们坚持使用整数内核,以避免嵌入的开销。

表 2 列出了我们的框架实现为 GPU 内核的关键功能。它还报告了哪些是我们编写的(Orca)。我们使用来自 NVIDIA CUTLASS[5]的经过良好优化的 CUDA 内核来进行卷积和线性层中的矩阵乘法。其余的优化内核是作为本工作的一部分实现的。在第 33 节中,我们描述了我们执行的各种优化(AES、布局、内存)来加速 DCF。正如表中所注明的,我们将许多相同的面向 GPU 的优化应用于其他合适的内核。

我们框架的某些部分在 CPU 上运行。如第 6 节所述,我们使用 SecFloat [12]在浮点数上计算 softmax,只有 CPU 实现。此外,为了从定点转到浮点再转回,我们在 CPU 上实现了 FixToFloat 和 FloatToFix 协议,因为这些转换的成本很低,与浮点数 softmax 相比。

除了第 3 节提到的设计优化外,我们还通过以下几个实际考虑来确保软件栈的优化实现。对于 GPU 上每个 FSS 函数(如 DCF)的调用,需要分配 GPU 内存来保存该函数的密钥。在函数执行完成后,需要释放该内存。反复的 GPU 内存分配/释放会增加开销。为此,我们利用 CUDA 11.2 中引入的一种新功能 CUDA 内存池 [6],为密钥的快速分配/释放预留 GPU 内存。此外,我们在 CPU 上预分配主机端通信缓冲区,以避免运行时动态内存分配的开销。我们还将 CPU 主机内存页锁定,使用 DMA [9] 在 GPU 和 CPU 之间实现更快的数据传输。我们使用多个 CPU 线程来重叠读取 SSD 上的密钥到 CPU DRAM、启动 GPU 内核以及与其他方通信的 CPU 任务。

除了加快 FSS 评估之外,我们还使用 GPU 加快离线密钥生成。我们使用 cuRAND 库[4]在 GPU 上为交易商生成随机性,从而缩短离线计算时间。

我们扩展了 LLAMA [30],这是一个用于在 CPU 上进行基于 FSS 的推理的最先进工具,以支持训练。我们执行其推理协议来处理训练中出现的定点运算,并使用 ORCA 的实现来处理 softmax。我们将这个扩展后支持训练的 LLAMA 称为 LLAMA-T。
 函数  描述  源文  优化

矩阵 乘法
 乘两个矩阵  短剑
 卷积  执行卷积  剑刃
DCF
如 16]中所述的折现现金流
ORCA

AES, 布局, 内存
 放缓线性整流
图 3 中的 DReLU 协议
ORCA

AES, 布局, 内存
 选择

第 1 图中的选择协议和 它在图 2 和图 4 中的变体
ORCA  布局, 内存

位运算 和

对两个比特的安全 AND 计算
ORCA  布局,内存

表 2:加速金融科技系统的关键组件

作为续集中的 LLAMA,并在第 8.3 节中量化地展示我们的系统和密码学贡献。

 8. 评估


我们将 OrCA 与支持与我们相同威胁模型的最先进的安全 2PC 培训工具进行比较,即受信任的交易商在离线阶段向两方提供输入无关的相关随机性,然后两方在在线阶段运行用于敏感数据的 2PC 协议进行 ML 任务。我们提供了一个经验性评估来证明以下声明:

  • OrCA 忠实地实施了机器学习文献[31]中的量化训练算法,混合使用浮点和定点运算(图 5)。ORCA 在 更短的时间内和 更少的通信量下,超越了 Piranha(当前最先进的加速安全训练的 GPU 模型)的精度(表 3)。

  • 在相同的训练和推理任务中,Orca 在延迟方面的性能比(基于 GPU 的)PIRANHA 高出最多 ,在通信方面的性能也高出最多 (表 4)。OrcA 在 CPU 安全训练[40]方面的性能也高出最多 (表 6)。

  • OrCA 的基于 GPU 的协议比它们的 CPU 对应物(表 7)高达 的效率。此外,OrCA 协议所需的 FSS 密钥的大小(见表 8)比最先进的 FSS 机器学习工具 LLAMA 低达

  • Orca 能够在亚秒级别进行 ImageNet 规模的 VGG-16 和 ResNet-50 模型推理(表 9),并且其性能比当前最先进水平高出一个数量级。

参数设置。我们评估了基于定点表示的 Orca 和 Piranha,位宽为 ,精度为 。CPU 基准[40]和 CrypTen[41]也使用了位宽

数据集和模型。我们使用与 PIRANHA 相同的训练评估数据集,即 10 类 MNIST 和 CIFAR。MNIST 的训练集有 60,000 张单色 图像,测试集有 10,000 张图像。CIFAR 的训练集有 50,000 张 RGB 图像,测试集有 10,000 张图像。我们用下标标注 MNIST 和 CIFAR 的模型名称 和 C。PiranHa[66]使用以下模型:PSecureML 和 P-Lenet 用于 MNIST,P-AlexNet


P-VGG16c 用于 CIFAR。P-VGG16c 拥有超过 1 亿个参数,是 Piranha 最大的模型。这些模型使用近似方法,例如局部截断,这些方法未被最先进的基于 CPU 的安全训练工具所使用。为了与它们进行比较,我们使用了以下来自[40]的模型:Model-B 和 AlexNet [60]。对于来自 Gupta 等人[31]的模型,我们使用了 36k 参数的模型,它有 2 个卷积层,以及 200k 参数的 CNN 3 c 模型,它有 3 个卷积层。

最后,我们还评估了 ImageNet-1000 [25]数据集的安全推理。这里的模型比 MNIST/CIFAR 模型大得多,因为它们操作的是 RGB 图像,这些图像比 CIFAR 图像 大得多。特别是,与 相比,在 Piranha 中最大的模型 VGG16 for ImageNet 有 更多乘法运算和 更多比较。我们评估了带有最大池化和随机截断的安全 ImageNet 推理,以匹配其浮点准确性。我们忽略了安全的 ImageNet 训练,因为它目前是不切实际的;即使有 OrCA 的加速,在 ImageNet1000 上的端到端训练也需要数年时间。

实验设置。我们在两台虚拟机上进行实验,它们连接在一个局域网设置中,带宽为 9.4 Gbps,RTT 为 0.05 ms,每台机器都配备有一个 NVIDIA RTX A6000 GPU,拥有 46 GB 的板载内存和一个 AMD Epyc 7742 处理器。每台机器都有将近 1 TB 的 RAM 和一个支持约 6 GBps 顺序读取带宽的 Samsung 980 PRO NVMe SSD。我们使用 4 个 CPU 内核来进行纯 CPU 实验。在 GPU 评估中,我们使用 4 个 CPU 内核来支持在 CPU 上运行的计算部分。此外,我们还使用另一个 CPU 内核从 SSD 读取密钥到 RAM。

据报告,ORCA 的训练时间包括将 FSS 密钥从 SSD 转移到 RAM 所需的时间,因为在许多迭代和时期的训练过程中,无法将所需的密钥全部储存在 RAM 中。这对于推理并不是问题,推理时间测量假设密钥已在 RAM 中。请注意,对于基线的训练和推理时间,均不包括将预处理材料加载到 RAM 中的时间。与[66]类似,对于所有基线和 OrCA,我们只报告在线时间。


8.1. 端到端 OrCA 训练


我们的目标是证明对于给定的分类任务,Orca 可以训练出与 Piranha 训练的模型精度相匹配的模型,同时所需的时间和通信大大减少。回忆一下,PiranHA 的 softmax 实现会泄露私人信息[64],而 OrCA 使用安全的浮点 softmax,有助于提供端到端的安全性。
 准确性  时间 (分钟)  通信(单位:GB)
 数据集 PIRANHA ORCA PIRANHA ORCA PIRANHA ORCA
MNIST
96.8
97.1
56
14
50.2
CIFAR-10
55
59.6
1170
45
65231.3
662.4
55
69
1170
112
65231.3
1656.1

表 3:OrCA 在更短的时间内和更低的通信下在 MNIST 和 CIFAR-10 上的匹配精度与 PiranHA 相当。

图 5:测试集上的交叉熵损失随训练迭代次数的变化。

在 MNIST 数据集上,Piranha 报告了一个准确度


在训练时间和大约 2TB 的通信量。表 3 显示 OrCA 在训练 CNN 模型[31]时匹配这一精度,需要 更少的时间和 更少的通信量。我们在表 4 中评估了 P-LeNet 上的 Orca。

在 CIFAR 数据集上,这是比 MNIST 更难的分类问题,改进效果更加显著。在训练 C [31]时,OrCA 的准确率优于 PIRANHA 训练 P-VGG16c 的 准确率, 的延迟,以及 的通信。我们通过训练 CNN 3 c 2 个 epoch 获得了 的准确率。在训练 5 个 epoch 时,我们获得了更高的 准确率( 比 PIRANHA 高),同时仍然比 Piranha 快 并需要 更少的通信。我们在表 4 中评估了 Orca 在 P-VGG16c 上的性能。

准确性。由于 Orca 忠实地评估 Gupta 等人[31]的模型,因此在(PyTorch)明文训练和安全训练之间没有准确性差距。我们也在图 5 中经验性地展示了这一点。相反,使用 PIRANHA 近似训练这些模型会导致 准确性,即随机分类器的准确性。


8.2.与基准的比较


接下来,我们在相同的模型上比较 OrCA 和基准线。特别是,我们在第 8.2.1 节将 OrCA 与 GPU-based Piranha 进行比较。在第 8.2.2 节中,我们将 OrCa 与最先进的基于 CPU 的安全训练[40]进行比较。

8.2.1.GPU 基线。我们在表 4 中将 OrCA 和 PIrANHA 与 Piranha 使用的基准进行比较。
 时间 (毫秒)  通信。(兆字节)
 模型  任务  食人鱼 ORCA  食人鱼 ORCA
P-SecureML  培训
166
76
31
5.45
 推理
57
6
21
2.56
P-LeNet  培训
720
174
474
63
 推理
402
45
335
38
P-AlexNet C  培训
984
193
606
109
 推理
424
59
324
36
P-VGG16C  培训
18096
2489
17083
1854
 推理
14106
1387
13589
911

表 4:与 GPU 基准 PIRANHA 进行比较,进行一次训练迭代和批量大小为 128 的推理。
 时间(秒)  通信。(兆字节)
 模型  任务 PIRANHA ORCA PIRANHA ORCA
P-SecureML  培训
3.4
1.3
31
5.45
 推理
2.3
0.28
21
2.56
 培训
12.3
2.5
474
63
 推理
8.6
0.97
335
38
P-AlexNet  培训
19.9
4
606
109
 推理
12.2
1.4
324
36
 培训
332.9
38.4
17083
1854
 推理
258.6
19
13589
911

表 5:与 GPU 基线 PIRANHA 在 WAN 环境(带宽 293 Mbps,延迟 60ms)下,批大小 128 的单次训练迭代和推理进行比较。

训练和推理任务。我们观察到 Orca 在延迟方面最高可达 更好,在通信方面最高可达 更好。在此,为了公平比较,Orca 和 Piranha 都使用平均池化,对 softmax 使用线性近似,以及局部截断。关于这些近似的 ORCA 协议在附录 G 中提供。由于 Orca 的通信量比 Piranha 低得多,在带宽较低(例如,WAN 设置)的情况下,这些改进通常更高(表 5)。

8.2.2. CPU 基线。最新的 CPU 安全训练工作由 Keller 和 Sun[40]完成,在表 6 中显示为 KS。KS 中的安全训练使用忠实的 maxpools 和随机截断,但不支持局部截断。为了测量 KS 的运行时间,我们在 MP-SPDZ[38]中添加了仪表,以测量预处理材料已经加载到 RAM 中后在在线阶段的一次迭代所需的时间。表 6 显示,OrCA(使用随机截断、maxpools 和浮点 softmax)比 KS 快 倍,同时通信量最多减少
 时间(秒)  通信量 (以兆字节为单位)
 模型 KS ORCA KS ORCA
10
1.42
3102
86
 模型 B
17.2
1.47
5796
121
 阿历克斯网
299.3
2.01
46213
443
1685
2.43
177152
678

表 6:与 CPU 基线 KS [40]相比,批量大小为 100 的单次训练迭代。
 数据集  模型  任务 LLAMA  我们的 CPU  我们的 GPU
MNIST CNN2  培训
3.54
2.57
1.42
 推理
1.57
0.93
0.05
CNN3  培训
38.58
18.85
2.43
 推理
31.89
14.77
0.76

表 7:LLAMA、我们的 CPU 和 GPU 实现在训练和推理(批量大小 100)单次迭代的延迟(以秒为单位)的对比。


8.3. 改进分类


LLAMA [30]是基于 FSS 的协议在 ML 任务中的最新技术,并且优于其他工具如 AriaNN [58]。从概念上讲,ORCA 在 LLAMA 的基础上做了两个性能改进。首先,它提供了新的协议,在 ML 任务中使用更小的 FSS 密钥并减少计算开销。其次,它使用 GPU 加速这些协议。在表 7 中,我们研究了协议和 GPU 分别对相比 LLAMA 的总体加速的贡献。在附录 A.2)中,我们比较了 LLAMA 和 Orca 的具体通信,注意到 Orca 的通信略有增加(最高 25%)。

整体而言,第 5 节中描述的 OrcA 协议相比 LLAMA 提供了大约 的密钥尺寸减少(见表 8),并且需要较少的 AES 调用次数。由于密钥读取不是 CPU 实现中的性能瓶颈,新协议可转化为在表 7 中 CPU 上运行 ORCA 相比 LLAMA 的运行时间改善。我们协议的 GPU 加速进一步将运行时间降低高达 。在使用 GPU 加速计算后,读取庞大的 FSS 密钥成为性能瓶颈,我们新协议带来的密钥尺寸减小至关重要。例如,在 c 训练中,密钥尺寸为 11.51 GB(表 88),使用 OrcA 的 GPU 运行时间为 2.43 秒(表 7)。如果没有 OrcA 的密钥尺寸减小,将需要 6.2 秒从 SSD 移动 34.66 GB 的密钥(表 8)到 RAM,这将使整体延迟从 2.43 秒恶化到 6.2 秒。即使密钥尺寸较小,也需要将密钥读取与其他计算重叠来保持低延迟(附录 A.4 表 12)。

推理任务比训练任务表现更好加速,因为使用了浮点型 softmax。回忆一下,softmax 仅存在于训练中,而不存在于推理中,softmax 的指数运算使用了浮点型 2 PC 协议。
 数据集  模型  任务 LLAMA ORCA
MNIST  培训
2.18
0.75
 推理
1.54
0.51
CIFAR-10  培训
34.66
11.51
 推理
29.27
9.32

表 8:与 LLAMA 在单次训练和推理(批量 100)中的关键尺寸(以 GB 为单位)的比较。
 模型 LLAMA  加密元 ORCA
 时间
VGG-16
54.93
13.19
1.21
 残差网络-50
45.83
5.76
0.93
 用深层剩余网络的 ResNet-18
12.03
2.97
0.28

表 9:使用 LLAMA(CPU)、CrypTen(GPU)、ORCA(位宽 和精度 )以及 ORCA(较小的位宽和精度 ,足以维持浮点模型精度)进行安全 ImageNet 推理的运行时间(单位:秒)。

从先前的工作[54]中发现,这些工作还未采用 FSS 或 GPU 进行加速。我们发现,一旦其他计算部分已通过 GPU 进行加速,softmax 即占据了相当大的训练运行时间。例如,一旦密钥存储在 RAM 中,在 的 1 个训练迭代中,有 1.4 秒的计算时间被 softmax 占用。

我们在附录 A 图 6 中显示 GPU 可以将线性层和非线性层的速度提高一个数量级。


8.4. 安全的 ImageNet 推理


表 9 显示,Orca 实现了亚秒级 ImageNet-1000 安全推理。我们与采用相同威胁模型的最先进的安全 ImageNet 推理工作进行了定量比较。其中,CrypTen[41]使用 GPU,LLAMA[30]仅使用 CPU。我们将 CrypTen 的运行时间低估,方法是将其报告的通信除以我们设置的网络带宽。

使用比特宽度 的 Orca 的安全推理的准确性与 50,000 个 ImageNet 图像验证集上的明文浮点精度相匹配。众所周知,较小的比特宽度就足以维持推理精度[24]、[56]。我们运行 OrcA 时使用更小的比特宽度,以获得比比特宽度 64 的 ORCA 更快 的速度,同时保持准确性。由于 CrypTen 不支持这些更小的比特宽度,我们保持基准线的比特宽度为 64。我们在附录 A.3 中的表 11 中报告了这些任务中 Orca 的密钥大小。总体而言,ORCA 比基线快

尽管 OrCA 的 ResNet-50 的时间已经过去 了,并且比 CryptGPU [60]和 Cheetah [32]报告的延迟 更好,但这些比较对这些基线不公平,因为它们的威胁模型不同。

这项工作关键地建立在几种现有技术的基础之上。Gupta 等人[31]提供了保留精度的量化训练算法和模型,这些成为我们安全实现的明文功能。另一方面,也可以不量化而在浮点数上运行完整的训练算法[53],但是这种选择成本更高。各种研究表明,GPU 在加速 MPC 协议方面非常有效[41]、[60]、[66]。由于通信开销无法通过 GPU 加速来减少,自然要考虑像 FSS[17]这样的低通信协议。我们使用 Piranha's[66]提出的评估线性层的高效 GPU 方法。对于 ReLU,已知存在非交互式协议[16]。我们在减少键大小和常见的机器学习操作(如 ReLU 和 ReLU 之后的 Maxpool)之间进行权衡。

安全训练是一个丰富的领域,有各种各样的技术。有一些缺乏加密安全保证的解决方案,如可信执行环境[69]和联邦学习[59]。还有一些补充性的技术,如差分隐私(DP)[14],[63]规定了哪些训练算法可以保护隐私,ORCA 可以安全地运行这些算法。在用于安全多方训练的加密技术中,已探索了各种威胁模型:

两方训练。两方持有秘密数据,使用 2PC 协议[15]、[37]、[49]训练联合模型。

两方培训与经销商。一位值得信赖的经销商为两方提供相关的随机性,它们可以更高效地运行其 2PC 协议。基于 FSS 的协议属于这一类[58]、[67]。

3 方诚实多数。三个非串谋方运行一个安全的培训协议[42]、[48]、[51]、[60]、[62]、[64]。M 方不诚实多数。 方各自持有秘密数据,培训一个联合模型,而诚实方可免受任何数量的不诚实方的侵害[23]、[40]、[41]、[70]。

关于不涉及安全训练的安全推理的先前研究包括[21]、[22]、[30]、[32]、[35]、[36]、[43]、[44]、[47]、[55]-[57]。利用 GPU 加速非 FSS 协议的研究包括[28]、[33]、[47]、[50]、[52]、[60]、[66]。特别是 GFORCE[50]加速了基于 GPU 的安全 MNIST/CIFAR 推理,但未评估 ImageNet 推理和训练。与之前所有涉及神经网络安全训练的工作类似,我们将自己限制在半诚实对手模型中,因为恶意安全会带来额外的性能开销[24]、[27]、[38]、[42]、[51]、[70]。

 10. 结论


奥卡通过在 GPU 上进行系统的改进以及利用新的密码技术来减小 FSS 密钥的大小,迈出了在实践中实现安全推理和训练的一步。这些措施使得安全训练 CIFAR 模型的时间缩短至 52 分钟,ImageNet-1000 模型的推理运行时间缩短至亚秒级。


我们还确定了未来工作的具体挑战:集成更新的 PCIe5 硬件和基于 GPU 加速的 FSS 协议,以实现准确的 softmax。

 参考文献


[1] "NVIDIA GPU 上的基本线性代数," https://developer.nvidia. com/cublas

[3] "CUDA C++ 编程指南",https://docs.nvidia.com/cuda/ cuda-c-programming-guide/

[6] "使用新的 NVIDIA CUDA 11.2 功能增强内存分配," https://developer.nvidia.com/blog/ enhancing-memory-allocation-with-new-cuda-11-2-features/
[8] "NVIDIA Nsight Compute," https://developer.nvidia.com/ nsight-compute

[9] "页面锁定的主机内存",https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#page-locked-host-memory

[11] "PyTorch/CSPRNG",https://github.com/pytorch/csprng

[12] "SecFloat:准确的浮点运算满足安全的两方计算," https://github.com/mpc-msri/EzPC

[13] "使用 CUDA Warp 级原语",https://developer.nvidia.com/ 博客/使用 CUDA Warp 级原语/

[14] M. Abadi、A. Chu、I. Goodfellow、H. B. McMahan、I. Mironov、K. Talwar 和 L. Zhang,"具有差分隐私的深度学习",收录于 2016 年 ACM SIGSAC 计算机与通信安全会议论文集,2016 年。

[15]N. Agrawal, A. S. Shamsabadi, M. J. Kusner 和 A. Gascón,"QUOTIENT:两方安全神经网络训练和预测",CCS, 2019。

[16] E. Boyle, N. Chandran, N. Gilboa, D. Gupta, Y. Ishai, N. Kumar, and M. Rathee, "面向混合模式和固定点安全计算的函数秘密共享," EUROCRYPT, 2020.

[17] E. Boyle, N. Gilboa 和 Y. Ishai, "功能保密共享," 发表于 EUROCRYPT, 2015.

[18] 功能密钥共享: 改进与扩展, 在 CCS, 2016 中.

[19] —, "通过函数密钥共享进行预处理的安全计算," 收录于《密码理论与应用学会》, 2019 年.

[20] R. Canetti, "多方密码学协议的安全性与组合", 密码学期刊, 2000

[21] N. 陈德伦, D. 古普塔, S. L. B. Obbattu 和 A. 沙, "Simc: 在半诚实成本下提供抵御恶意客户的 M1 推理",《USENIX 安全研讨会》,2022 年.

[22] H. Chaudhari、A. Choudhury、A. Patra 和 A. Suresh, "Astra: 基于环的高吞吐量 3PC,应用于安全预测", 发表于 2019 年 CCSW 会议。

[23] 陈洪、金敏、拉泽恩斯泰因、罗塔鲁、宋元和瓦格,"恶意安全矩阵乘法及其在私人深度学习中的应用",2020 年亚洲密码学会议论文集。

[24] A. P. K. Dalskov, D. Escudero, 和 M. Keller, "量化神经网络的安全评估," PoPETs, 2020.

[25] J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, 和 L. Fei-Fei, "ImageNet: 一个大规模的层次化图像数据库," in CVPR, 2009.

[26] J. Doerner 和 A. Shelat,"为安全计算扩展 ORAM",收录于

[27] D. Escudero、S. Ghosh、M. Keller、R. Rachuri 和 P. Scholl,"面向混合算术-二进制电路的 MPC 的改进原语",《密码学》,2020 年。

[28] T. K. Frederiksen, T. P. Jakobsen 和 J. B. Nielsen,"利用 GPU 实现更快速的恶意安全的两方计算",载于《SCN》, 2014 年.

[29]奥. 戈德赖克,S. 米卡利和 A. 维格特森,"如何玩任何精神游戏或诚实多数协议的完全性定理,"载于 STOC, 1987。
[30] K. Gupta, D. Kumaraswamy, N. Chandran, and D. Gupta, "Llama: A low latency math library for secure inference," in PETS, 2022.

[31] S. 古普塔, A. 阿格拉瓦尔, K. 戈帕拉克里希南和 P. 那拉亚南, "有限数值精度的深度学习."在 ICML, 2015.

[32] Z. Huang, W. jie Lu, C. Hong, 和 J. Ding, "Cheetah: 精简和快速的安全两方深度神经网络推理," 在 USENIX 安全研讨会, 2022.

[33] N. Husted, S. Myers, A. Shelat 和 P. Grubbs, "诚实但好奇的安全两方计算的 GPU 和 CPU 并行化," 在 ACSAC, 2013.

[34] N. Jawalkar, K. Gupta, A. Basu, N. Chandran, D. Gupta 和 R. Sharma,"Orca: 基于 FSS 的 GPU 安全训练",密码学 ePrint 档案,文章 2023/206,2023 年。

[35] C. Juvekar, V. Vaikuntanathan 和 A. Chandrakasan, "Gazelle:一个低延迟的安全神经网络推理框架,"在 USENIX Security Symposium, 2018.

【36】G. Kaissis, A. Ziller, J. Passerat-Palmbach, T. Ryffel, D. Usynin, A. Trask, I. Lima, J. Mancuso, F. Jungmann, M.-M. Steinborn, A. Saleh, M. Makowski, D. Rueckert, and R. Braren, "面向跨机构医学影像的隐私保护深度学习",《自然机器智能》, 2021 年。

[37] M. Kelkar, P. H. Le, M. Raykova 和 K. Seth, "安全泊松回归",2022 年 USENIX 安全研讨会。

[38] M. Keller, "MP-SPDZ: 一个多方计算的通用框架," 收录于 CCS, 2020.

[39]M. Keller 和 K. Sun,"MPC 友好型 softmax 替换的有效性",arXiv 预印本 arXiv:2011.11202,2020。

[40] ——, "深度学习的安全量化训练," 在 ICML, 2022.

[41] B. 诺特, S. 文卡特拉曼, A. 韩楠, S. 森格普塔, M. 易卜拉欣, 以及 L. 范德·马滕, "CrypTen: 安全的多方计算与机器学习", 发表于 NeurIPS, 2021

[42] N. Koti, M. Pancholi, A. Patra 和 A. Suresh, "SWIFT: 超快和强大的隐私保护机器学习",USENIX 安全研讨会, 2021.

[43] 库玛尔, N.,拉提, M.,钱德兰, N.,古普塔, D.,拉斯托吉, A.,以及夏尔马, R.,"Cryptflow: 安全的 TensorFlow 推理",在 IEEE 中发表,2020 年。

[44] R. Lehmkuhl, P. Mishra, A. Srinivasan, 和 R. A. Popa, "Muse: 抵御恶意客户端的安全推理", 在 USENIX Security Symposium, 2021 年.

[45] 李扬、段玉、黄兆、洪程、张晨、宋佑, "使用于恶意安全 DNN 推理的二进制电路高效 3PC", 2023 年 USENIX 安全研讨会.

[46] Y. 林德尔, "如何模拟它 - 模拟证明技术教程," 密码学基础教程, 2017 年。

[47] P. Mishra, R. Lehmkuhl, A. Srinivasan, W. Zheng 和 R. A. Popa,"Delphi:神经网络的一种加密推理服务",收录于 2020 年 USENIX 安全研讨会论文集。


[48] P. Mohassel 和 P. Rindal, "ABY"一种用于机器学习的混合协议框架,"在 CCS,2018 年。

[49] P. Mohassel 和 Y. Zhang, "SecureML: 一种可扩展的隐私保护机器学习系统," IEEE S&P, 2017.

[50] L. K. L. Ng 和 S. S. M. Chow, "Gforce: 面向 GPU 的隐私保护和快速神经网络推理," 发表于 USENIX Security Symposium, 2021.

[51] A. Patra 和 A. Suresh, "Blaze: 极速隐私保护机器学习," 在 NDSS, 2020.

[52] R. Poddar,G. Ananthanarayanan,S. Setty,S. Volos,和 R. A. Popa,"Visor:隐私保护的视频分析即服务",在 USENIX 安全研讨会上,2020 年。

[53] D. Rathee, A. Bhattacharya, D. Gupta, R. Sharma, 和 D. Song, "安全浮点训练," 载于 USENIX Security Symposium 2023.

[54] D. Rathee, A. Bhattacharya, R. Sharma, D. Gupta, N. Chandran, and A. Rastogi, "SecFloat: Accurate Floating-Point meets Secure 2-Party Computation," in IEEE . 人工智能: [54] D. Rathee, A. Bhattacharya, R. Sharma, D. Gupta, N. Chandran, 和 A. Rastogi, "SecFloat: 精确浮点运算与安全二方计算", 在 IEEE 中.

[55] 德. 拉特希、M. 拉特希、R. K. K. 高利、D. 古普塔、R. 夏尔马、N. 钱德兰和 A. 拉斯托吉, "SIRNN: 用于安全推断 RNNs 的数学库," 发表于 IEEE

[56] D. Rathee, M. Rathee, N. Kumar, N. Chandran, D. Gupta, A. Rastogi 和 R. Sharma, "CrypTFlow2: 实用的 2 方安全推理,"发表于 CCS, 2020 年。
[57] M. S. Riazi, C. Weinert, O. Tkachenko, E. M. Songhori, T. Schneider, and F. Koushanfar, "Chameleon: A hybrid secure computation framework for machine learning applications," in ASIACCS, 2018.

[58] T. Ryffel、D. Pointcheval 和 F. Bach,"ARIANN:通过函数隐秘共享实现低交互性隐私保护深度学习",在 PETS,2022 年。

[59] S. Sav, A. Pyrgelis, J. R. Troncoso-Pastoriza, D. Froelicher, J. Bossuat, J. S. Sousa, and J. Hubaux, "POSEIDON: 隐私保护联邦神经网络学习," in NDSS, 2021.

[60] 陈昆, 布兰特·诺特, 田阳和吴敦杰, "CryptGPU: 在 GPU 上快速实现隐私保护机器学习," 于 IEEE 中发表.

[61] C. Tezcan, "在图形处理单元上优化高级加密标准," IEEE Access, 第 9 卷, 第 67315-67326 页, 2021 年

[62] 瓦格、古普塔和钱德兰,"SecureNN:神经网络训练的三方安全计算",PoPETs,2019。

[63] S. Wagh, X. He, A. Machanavajjhala, 和 P. Mittal, "Dpcryptography: 在新兴应用中融合差分隐私和密码学," Commun. ACM, 2021.

[64] 瓦格、托普利、本哈穆达、库希雷维茨、米塔尔和拉宾. "Falcon:基于诚实多数的恶意安全的私有深度学习框架",隐私增强技术, 2021 年.

[65] 王康、付赛尔和林超, "GPU 上快速细粒度全局同步", 收录于 ASPLOS, 2019.

[66] J.-L. Watson, S. Wagh, and R. A. Popa, "Piranha: A GPU Platform for Secure Computation," in USENIX Security Symposium, 2022. 简体中文翻译: [66] J.-L. Watson、S. Wagh 和 R. A. Popa, "Piranha: 用于安全计算的 GPU 平台," 发表于 USENIX 安全研讨会, 2022 年.

[67] 杨蓬、姜志林、高嵩、庄剑、王昊、方剑、姚圣、吴源,"Fssnn:通过功能密钥共享实现高效安全神经网络训练",密码学电子打印档案,论文 2023/073, 2023.

姚晓春,"安全计算的协议",载于 1982 年计算机基础理论学术年会。

[69]P. Yuhala、P. Felber、V. Schiavoni 和 A. Tchana,"Plinius:机器学习模型培训的安全和持久性",收录于 2021 年 DSN 会议.

[70] W. 郑, R. A. 普帕, J. E. 冈萨雷斯和 I. 斯托伊卡, "Helen: 用于线性模型的恶意安全合作式学习," 载于 IEEE , 2019 年

(a) 在 输入上使用 5 个核心、64 个输出通道、步长 1 和填充 1 的卷积。

(b) 随机截断 + ReLU 在输入大小递增的情况下。输入大小

图 6:CPU 和 GPU 上的在线时间对比

(c) 随机截断 + ReLU + 最大池化在一个 输入上使用 3 个内核和步长为 1 的卷积。

(d) 随机截断 + ReLU + 最大池化在一个 输入上使用 11 个内核和步长 1。


附录 A.
额外的实证结果

 A.1. 微基准测试


我们在图 6 中分别展示了 GPU 在线性层和非线性层的加速情况。在不同大小的微基准中,ORCA 中基于 GPU 的协议比其 CPU 对应物快一个数量级。


网上交流


我们在表 10 中显示,Orca 的在线通信略高于 LLAMA。
 数据集  模型  任务 LLAMA ORCA
MNIST CNN2  培训
76
86
 推理
22
28
CIFAR-10 CNN3  培训
579
678
 推理
365
411

表 10:LLAMA 和 OrcA 单次训练和推理的通信量(单位:MB)比较,批量大小为 100。


ImageNet 推理任务的关键尺寸


表 11 显示了 ORCA 和 LLAMA 所需的各种 ImageNet 推理任务的关键尺寸。
 模型 LLAMA  奥尔卡
 密钥大小
VGG-16 50.54 13.13
 残差网络-50 47.69 9.9
 用深层剩余网络的 ResNet-18 11.43 2.78

表 11:LLAMA(CPU)中具有位宽 的安全 ImageNet 推理、位宽 和精度 的 ORCA,以及小于此位宽和精度 但足以维持浮点模型精度的 ORCA 的关键尺寸(以 GB 为单位)。
 模型

密钥大小 (以百万 GB 计)

关键读取

计算

奥尔卡
P-SecureML 0.03 5 76
P-LeNet 0.36 63 174
CNN2 0.75 129 1415
 模型 B 1.27 219 1466
P-AlexNet 0.34 64 193
 阿历克斯网 8.34 1387 2011
CNN3 11.51 1911 2432
P-VGG16 15.1 2310 2489

表 12:ORCA 不同模型一次训练迭代的密钥大小、密钥读取时间和计算时间(包括通信)。最后一列报告密钥读取时间和计算时间中较大的一个。


重叠的关键读取


表 12 显示了 OrCA 在一次训练迭代中读取密钥以及进行计算(包括通信时间)所花费的时间。由于在 Orca 中密钥读取和计算是重叠的,一次训练迭代的时间取决于这两者中较大的时间。


附录 B.随机截断+ReLU+最大池化


在许多网络中,连续使用卷积层、ReLU 层和 MaxPool 层是很常见的。因为在固定点训练的情况下,卷积总是被截断所跟随,因此截断、ReLU 和 MaxPool 是连续发生的。因此,我们需要一个关于随机截断+ReLU+MaxPool 的协议。我们注意到,这种融合操作的结果并不取决于 ReLU 和 Maxpool 的应用顺序。因此,许多现有的工作在 MaxPool 之后执行 ReLU[43]、[56],因为这减少了需要计算 的元素数量。

LLAMA [30]提供了一种用于 MaxPool 的协议,该协议在内部使用来自[16]的基于样条的 ReLU 协议来计算两个元素的最大值。首先,我们将这个 ReLU 替换为我们的协议 ,并采用三步方法来实现具有位宽 和精度 的随机截断 MaxPool 协议:

  1. 随机截断将输入减少到 位。

  2. 将修改后的统一位宽 MaxPool 协议应用于 位截断输出。

  3. 协议应用于生成的 位值,以获得 位结果。

在上述协议中,所有比较都是在( )位上完成的,而不是 位,并且使用我们优化的 ReLU 协议,相比于使用[30]中的构建块设计的协议,我们节省了大量成本。该定理总结了对 个元素进行 MaxPool 的成本。

定理 11. 存在一种协议 实现 元素的安全随机截断 ,其关键大小为 。它的在线阶段需要 评估、 评估和 评估以及通信 比特 轮次。

相比之下,基线[30]的关键大小大约为 关键大小 关键大小 。对于 在我们的基准测试中使用的,对于 MaxPool 大小为 的情况,也就是 ,我们获得了 的关键大小减少。


附录 C。
随机截断-降维


引理 1 的证明


引理 1。对于具有潜在值 和随机掩码 的被掩码值 ,令 。那么,
 因此,

证明。要推导出第一个方程式,我们有:

。因此, , 。 将这些方程代入,我们得到
Stochastic Truncate-Reduce \(\prod_{n, f}^{\text {stTR }}\)
\(\operatorname{Gen}_{n, f}^{\text {stTR }}\left(r^{\text {in }}, r^{\text {out }}\right):\)
    \(s \stackrel{\&}{\leftarrow} \mathbb{U}_{2 f}\)
    \(r^{(t)}=\mathrm{r}^{\text {in }} \bmod 2^{f}\)
    \(\hat{s}=s+r^{(t)} \bmod 2^{f}\)
    \(\left(k_{0}^{>}, k_{1}^{>}\right) \leftarrow \operatorname{Gen}_{f}^{>}\left(1^{\lambda}, \hat{s}, 1, \mathbb{U}_{2}\right)\)
    \(z \stackrel{\&}{\leftarrow} \mathbb{U}_{2} ; r^{(w)}=\operatorname{extend}(z, n-f)\)
    \(r=r^{\text {out }}-\operatorname{TR}\left(\mathrm{r}^{\text {in }}, f\right)-1\left\{\hat{s}<r^{(t)}\right\}\)
    share \(r, r^{(w)}\)
    For \(b \in\{0,1\}, k_{b}=k_{b}^{>}\left\|r_{b}^{(w)}\right\| r_{b}\)
\(\mathrm{Eval}_{n, f}^{\mathrm{stTR}}\left(b, k_{b}, \hat{x}\right):\)
    Parse \(k_{b}\) as \(k_{b}^{>}\left\|r_{b}^{(w)}\right\| r_{b}\)
    \(\hat{t}=\hat{x} \bmod 2^{f}\)
    \(\hat{w}_{b} \leftarrow \operatorname{Eval}_{f}^{>}\left(b, k_{b}^{>}, \hat{t}\right)+r_{b}^{(w)} \bmod 2\)
    \(\hat{w}=\operatorname{reconstruct}\left(\hat{w}_{b}\right)\)
    \(c_{b}=r_{b}^{(w)}+\operatorname{extend}(\hat{w}, n-f) \cdot\left(b-2 r_{b}^{(w)}\right)\)
    return \(\hat{y}_{b}=b \cdot \operatorname{TR}(\hat{x}, f)+r_{b}+c_{b}\)

图 7:stTR 的协议。

请注意,术语 仅可取值 0 或 作为 。因此,我们有:

现在,我们得出第二个表达式,即随机抽取的 表达式。令 。这意味着,计算 相当于在 起点到 终点之间的区域内返回 1,并处理换行。考虑两种情况:

  1. 在这种情况下,

  2. 在这种情况下,

两种情况相差 1,可以由此简单组合:

我们通过添加两个表达式(根据定义)来推导出 的表达式来完成证明:


C.2. 随机截断缩减协议


我们在图 7 中提供了一个正式的协议

 安全性证明


为了简化证明,我们考虑了一个真实交互,其中除了 外,还有一个参数化为 的,其中 是随机截断减少的相关随机性。同样地,我们考虑一个也由 参数化的理想世界。在真实交互中, 运行 Eval 。在理想交互中, 发送到理想功能中,该功能揭示它并计算输出。也就是说,计算 ,并将 的份额发送给 。下面,我们描述了模拟这种真实交互中的真实世界对手视图的模拟器。

模拟器。对于 的模拟器 给出了随机截断减少 ,并且必须模拟当事方 的视图,即来自交易商的消息 和来自 。模拟器遵循以下步骤:

  1. 中随机挑选
  2.  

  3. 调用 来获得
  4.  设置

  5. 随机挑选 并设置

  6. 运行步骤 5 来计算
  7.  设置

很容易论证在存在上述模拟器的情况下,真实交互中的对手视图和诚实方输出的联合分布与理想交互中的是不可区分的。


附录 D.固定和浮点之间的相互转换


我们的固定到浮动协议使用了一个 FSS 门来实现来自[16]的多个区间包含,总结如下。


多区间包含


对于公共参数数组 ,多个区间包含函数 ,计算给定输入 的向量 ,使得 ,我们有:

[16]提供了一种协议 ,用于 。我们将讨论局限于特殊情况下 的情况。

定理 12(多区间包容[16])。 以安全方式实现 ,其中密钥大小为 。在在线阶段,需要 次评估


D.2. 协议为


请记住,我们需要使用第 6.1 节中的表达式来计算 。一种安全计算 FixToFloat 的自然方法是使用现有的 Zero-Test [19]、DReLU、多区间包含(用于计算 )和 ReLU 协议。然而,这些协议中的每个都需要一个 DCF 密钥(Zero-Test 情况下为 DPF 密钥),因此整体协议将需要 位的密钥大小。我们描述了一种使用两个 DCF 密钥和 位密钥大小实现相同结果的替代方法。

为两个长度为 的常数序列,表示 个互不重叠的区间,使得:

。我们观察到对于所有位于区间 内的 值, 都保持恒定值。因此,我们可以使用多间隔包含协议(第 D.1 节)来获取指定 所属区间的独热向量的共享。然后,我们可以通过将向量的共享与相应区间内的正确恒定值逐元素相乘并相加来获得 的共享。接着,我们可以通过重复利用符号位来便宜地计算 。将结果值与 相乘并截断减少到 后,就得到尾数 。对于截断减少,我们使用与第 5.2.1 节中的随机截断减少协议类似的协议 ,具有相同的成本。

我们在图 8 中描述了 FixToFloat 协议,该协议实现了定理 13 中的成本

定理 13。 安全地实现 FixToFloat ,使得 。在在线阶段,该协议需要评估 各 1 次,并在 3 轮中传输 比特。

安全性证明。对于 ,FixToFloat 的模拟器 被给定 ,并且必须模拟 方的视图,即来自交易商的消息 和来自另一个评估者的消息 。模拟器遵循以下步骤:

  1. 随机抽取

  2. 随机抽取
  3.  集合

  4. 随机采样 ,条件为 的最低有效位为 0。
FixToFloat \(\Pi_{n}^{\text {FixToFloat }}\)
\(\operatorname{Gen}_{n, f}^{\text {FixToFloat }}\left(r^{\text {in }}\right)\) :
    Let \(\boldsymbol{p}=\boldsymbol{p}^{(n)}\) and \(\boldsymbol{q}=\boldsymbol{q}^{(n)}\)
    \(\left(k_{0}^{(\mathrm{MIC})}, k_{1}^{(\mathrm{MIC})}\right) \leftarrow \operatorname{Gen}_{n, \boldsymbol{p}, \boldsymbol{q}}^{\mathrm{MIC}}\left(\mathrm{r}^{\text {in }}, 0\right)\)
    \(r^{(s)} \stackrel{\&}{\leftarrow} \mathbb{U}_{2}\)
    \(r^{(u)} \stackrel{\&}{\leftarrow} \mathbb{U}_{N}\)
    \(r^{\text {(select) }} \stackrel{8}{\leftarrow} \mathbb{U}_{N}\)
    \(\left(k_{0}^{\text {(select) }}, k_{1}^{\text {(select) }}\right) \leftarrow \operatorname{Gen}_{n}^{\text {select }}\left(r^{(s)}, r^{\text {in }}, r^{\text {(select) }}\right)\)
    \(r^{(y)}=2 \cdot r^{(\text {select })}-r^{\text {in }}\)
    \(r^{(z)} \stackrel{8}{\leftarrow} \mathbb{U}_{N}\)
    \(c=r^{(u)} \cdot r^{(y)}+r^{(z)}\)
    \(\left(k_{0}^{\mathrm{TR}}, k_{1}^{\mathrm{TR}}\right) \leftarrow \operatorname{Gen}_{n, n-24}^{\mathrm{TR}}\left(r^{(z)}, 0\right)\)
    share \(\left(r^{(s)}, r^{(u)}, r^{(y)}, c\right)\)

![](https://cdn.mathpix.com/cropped/2024_08_15_41379d930d237705d9c4g-20.jpg?height=94&width=722&top_left_y=813&top_left_x=273)
    \(\mathrm{al}_{n, f}^{\text {FixToFloat }}\left(b, k_{b}, \hat{x}\right):\)
    Let \(\boldsymbol{p}=\boldsymbol{p}^{(n)}\) and \(\boldsymbol{q}=\boldsymbol{q}^{(n)}\)
    Parse \(k_{b}\) as \(k_{b}^{(\text {MIC })}\left\|k_{b}^{(\text {select })}\right\| r_{b}^{(s)}\left\|r_{b}^{(u)}\right\| r_{b}^{(y)}\left\|c_{b}\right\| k_{b}^{\text {TR }}\)
    \(\boldsymbol{t}_{b} \leftarrow \operatorname{Eval}_{n, \boldsymbol{p}, \boldsymbol{q}}^{\mathrm{MIC}}\left(b, k_{b}^{(\mathrm{MIC})}, \hat{x}\right)\)
    \(z_{b}=t_{b, 0} \bmod 2\)
    \(s_{b}=\sum_{i=n}^{2 n-1} t_{b, i} \bmod 2\)
    \(\hat{s}_{b}=s_{b}+r_{b}^{(s)}\)
    \(e_{b}=-126 \cdot t_{b, 0}+(n-f-1) \cdot t_{b, n}+\sum_{i=1}^{n-1}\left(t_{b, i}+\right.\)
    \(\left.t_{b, 2 n-i}\right) \cdot(i-f-2)\)
    \(\hat{u}_{b}=r_{b}^{(u)}+t_{b, n}+\sum_{i=1}^{n-1}\left(t_{b, i}+t_{b, 2 n-i}\right) \cdot 2^{n-i}\)
    \((\hat{s}, \hat{u})=\) reconstruct \(\left(\hat{s}_{b}, \hat{u}_{b}\right)\)
    \(\hat{y}_{b} \leftarrow 2 \cdot \operatorname{Eval}_{n}^{\text {select }}\left(b, k_{b}^{\text {(select) }}, 1-\hat{s}, \hat{x}\right)-b \cdot \hat{x}\)
    \(\hat{y}=\) reconstruct \(\left(\hat{y}_{b}\right)\)
    \(\hat{z}_{b}=b \cdot \hat{y} \cdot \hat{u}-r_{b}^{(y)} \cdot \hat{u}-r_{b}^{(u)} \cdot \hat{y}+c_{b}\)
    \(\hat{z}=\) reconstruct \(\left(\hat{z}_{b}\right)\)
    \(m_{b} \leftarrow \operatorname{Eval}_{n, n-24}^{\top R}\left(b, k_{b}^{\top R}, \hat{z}\right)\)
    return \(\left(z_{b}, s_{b}, e_{b}, m_{b}\right)\)

图 8:FixToFloat 的协议。

  1. 调用 输入 和输出 来生成
  2.  集合

  3. 随机采样
  4.  集合
  5.  设置

  6. 调用 并输入 和输出 来获得

  7. 随机从受制于第 4、5 和 7 行中所述的约束的 科目中抽取样本 ,在 Eval 中进行

  8. 根据 Eval 第 8 行计算

  9. 调用 以输入 和输出 来生成

 D.3. 浮点数到固定点数


对于给定的浮点数 ,功能 Float ToFix 计算出精度为 的定点数 ,满足以下条件:

但是,由于我们只关注 softmax 输出,我们将讨论局限于当 时的情况。注意,该协议可以通过调用选择协议来轻松地推广到其他情况。因此,我们可以将上述等式简化为:

是一个 24 位值, 时,即 。同时,softmax 输出的是 0 到 之间的实数值。因此,我们只对计算 时感兴趣,当范围 时,并在其他情况下返回 0。为了使指数为正,我们设置 ,我们在 时重写上述表达式为:

我们放弃了 符号,因为我们现在只处理正指数。我们合并其他情况,并将联合表达式写为 :

我们现在讨论如何安全地评估上述计算。请注意,由于 是一个 24 位数字,我们需要 位输出,因此需要使用混合位宽乘法。因此,为了获得 (以及 的偏移表达式,我们需要处理由 掩码造成的溢出。

考虑上述表达式中的四个术语:

  1. : 为计算此术语的份额,交易商提供了一个 的一热向量的秘密份额。然后,评估者只需将向量的份额旋转 即可获得 的一热向量的份额。评估者现在可以计算此向量与包含 的向量的点积,对于索引 为 1,否则为 0。结果值是 的一个份额,可以与 局部乘以以获得所需的份额。

  2. :由于评估人员已经拥有一个独热向量共享,他们可以以与 相同的方式计算 的共享。

  3. :正如交易商所知,它秘密分享包含 的向量,对于所有索引 ,否则为 0。评估者只需在 处索引数组即可获得所需的份额。

  4. :这个术语的股份可以简单地使用 DCF 关键字进行计算,就像我们的其他协议一样。

FixToFloat 的最终表达式可以通过调用乘法协议和这些项目的本地加法安全计算,然后再调用 ARS 协议的最终调用。请注意,上述讨论会自动处理当 范围之外的情况,并为每个项目返回零。对于 ARS,我们使用 协议[16|。我们在图 9 中提供了 FloatToFix 的完整协议 。与其他不同的是
FloatToFix \(\Pi_{n, f}^{\text {FloatToFix }}\)
\(\operatorname{Gen}_{n, f}^{\text {FloatToFix }}\left(r^{\text {out }}\right):\)
    \(r^{(m)} \stackrel{8}{\leftarrow} \mathbb{U}_{2^{24}}\)
    \(r^{\left(e^{\prime}\right)} \stackrel{8}{\leftarrow} \mathbb{U}_{1024}\)
    \(r^{(w)} \stackrel{\S}{\leftarrow} \mathbb{U}_{2}\)
    \(r^{(h)} \stackrel{\$}{\leftarrow} \mathbb{U}_{N}\)
    \(r^{(t)} \stackrel{\otimes}{\leftarrow} \mathbb{U}_{N}\)
    \(\left(k_{0}^{<}, k_{1}^{<}\right) \leftarrow \operatorname{Gen}_{24}^{<}\left(1^{\lambda}, r^{(m)}, 1, \mathbb{U}_{2}\right)\)
    Let \(\boldsymbol{p}=\left\{1\left\{i=1024-r^{\left(e^{\prime}\right)}\right\}\right\}_{i} \in \mathbb{U}_{N}^{1024}\)
    Let \(\boldsymbol{q}=\left\{r^{(t)}-r^{(m)} \cdot \operatorname{pow}_{f}\left(i-r^{\left(e^{\prime}\right)}\right)\right\}_{i} \in \mathbb{U}_{N}^{1024}\).
    share \(\left(r^{(m)}, r^{\left(e^{\prime}\right)}, r^{(w)}, r^{(h)}, \boldsymbol{p}, \boldsymbol{q}\right)\)
    \(\left(k_{0}^{\text {(select) }}, k_{1}^{\text {(select) }}\right) \leftarrow \operatorname{Gen}_{n}^{\text {select }}\left(r^{(w)}, r^{(h)}, 0\right)\)
    \(\left(k_{0}^{(\mathrm{ARS})}, k_{1}^{(\mathrm{ARS})}\right) \leftarrow \operatorname{Gen}_{n, 23}^{\text {ARS }}\left(r^{(t)}, \mathrm{r}^{\text {out }}\right)\)
    For \(b \in\{0,1\}, k_{b}=k_{b}^{<}\left\|k_{b}^{\text {select }}\right\| r_{b}^{(m)}\left\|r_{b}^{\left(e^{\prime}\right)}\right\| r_{b}^{(w)} \|\)
    \(r_{b}^{(h)}\left\|\boldsymbol{p}_{b}\right\| \boldsymbol{q}_{b} \| k_{b}^{(\text {ARS })}\)
\(\operatorname{Eval}_{n, f}^{\text {FloatToFix }}\left(b, k_{b},\left(m_{b}, e_{b}\right)\right):\)
    Parse \(k_{b}\) as \(k_{b}^{<}\left\|k_{b}^{\text {select }}\right\| r_{b}^{(m)}\left\|r_{b}^{\left(e^{\prime}\right)}\right\| r_{b}^{(w)}\left\|r_{b}^{(h)}\right\| \boldsymbol{p}_{b} \| \boldsymbol{q}_{b}\)
    \(\| k_{b}^{(\text {ARS })}\)
    \(\hat{m}_{b}=m_{b}+r_{b}^{(m)}\)
    \(\hat{e}_{b}^{\prime}=e_{b}+r_{b}^{\left(e^{\prime}\right)}+b \cdot f\)
    \(\left(\hat{m}, \hat{e}^{\prime}\right)=\) reconstruct \(\left(\hat{m}_{b}, \hat{e}_{b}^{\prime}\right)\)
    \(\hat{w}_{b} \leftarrow \operatorname{Eval}_{24}^{<}\left(b, k_{b}^{<}, \hat{m}\right)+r_{b}^{(w)} \bmod 2\)
    \(\boldsymbol{p}_{b}^{\prime}=\boldsymbol{p}_{b} \ggg \hat{e}^{\prime}\)
    \(d_{b}=\sum_{i=0}^{1023} \operatorname{pow}_{f}(i) \cdot p_{b, i}^{\prime}\)
    \(\hat{h}_{b}=r_{b}^{(h)}+2^{24} \cdot d_{b}\)
    \((\hat{w}, \hat{h})=\operatorname{reconstruct}\left(\hat{w}_{b}, \hat{h}_{b}\right)\)
    \(\hat{t}_{b}=q_{b, \hat{e}^{\prime}}+\operatorname{Eval}_{n}^{\text {select) }}\left(b, k_{b}^{\text {(select) }}, \hat{w}, \hat{h}\right)+\hat{m} \cdot d_{b}\)
    \(\hat{t}=\) reconstruct \(\left(\hat{t}_{b}\right)\)
    \(\hat{x}_{b} \leftarrow \operatorname{Eval}_{n, 23}^{\mathrm{ARS}}\left(b, k_{b}^{\mathrm{ARS}}, \hat{t}\right)\)
    return \(\hat{x}_{b}\)

图 9:FloatToFix 协议。这里, 如果 则返回 ,否则返回 0。

协议, 以秘密共享开始,因为 SECFLOAT 返回 的份额。我们在定理 10 中总结了协议的成本并提供了其安全性证明。


定理 10. 安全地实现了 FloatToFix ,使得密钥大小 密钥大小 。在在线阶段,该协议需要评估 1 次 ,并且在 3 轮中花费 比特的通信。

安全性证明。对于 ,为 FloatToFix 提供了模拟器 ,并给出了 ,需要模拟参与方 的视图,即来自交易商的消息 和来自另一个评估方的消息 。模拟器遵循以下步骤:

  1. 中随机选取

  2. 随机抽取

  3. 集合

  4. 随机抽取

  5. 使用 生成 并计算

  6. 随机采样
  7.  集合
  8.  集合

  9. 中随机抽样

  10. 计算
  11.  集合
  12.  集合

  13. 中随机抽取

  14. 使用 和输入 生成 并输出
  15.  集合

  16. 使用 和输入 生成 并输出

注意。 ToFix 的密钥大小可以通过仅发送在评估中需要访问的数组 中的元素来进一步减小,这取决于 的值的约束条件。此外,由于数组 被设置为单个索引上的 1,它可以被替换为分布式点函数键[17]以进一步减小键大小,但代价是增加了计算。我们在这里省略了这些优化。

 附录 E.


端到端训练协议


基于前面讨论的协议,我们现在探讨如何将它们组合起来,以获得一个用于安全计算任意函数的端到端协议。假设明文函数由两个顺序执行的功能 组成,并且它们相应的安全协议分别是 。为了设计一个安全协议 ,交易商只需将 的输入随机掩码设置为 的输出随机掩码,并运行相应的 Gen 算法生成 FSS 密钥。然后,评估者可以将 的输出传递给


输入到 以获取所需的遮蔽输出。也可以以类似的方式组合任意数量的协议。可以在模拟范式中论证该协议的安全性,如下所示。由于每个单独的协议都返回由随机值遮蔽的值,因此只需在模拟过程中将这些中间值设置为随机值(来自相应的群)即可。然后可以顺序调用组成协议的模拟器来完成对整个协议的模拟。

现在我们考虑固定点训练的情况。设全局固定点尺度为 。典型的机器学习模型包含像卷积、矩阵乘法、ReLU、MaxPool 等层次,其中卷积和矩阵乘法后会进行截断。单次训练迭代包括三个步骤:前向传递、Softmax 计算和反向传播。一旦我们有了输出更新掩蔽权重的单次迭代协议,多次迭代就可以很容易地组合在一起。

正向传递。任何形式为卷积-ReLU-最大池化的序列都可以使用卷积的协议后跟着 来安全计算。剩余层中形式为卷积-ReLU 的序列可以使用卷积的协议后跟着 来安全计算。类似的计算也适用于矩阵乘法(取代卷积)。对于剩余的截断和 ReLU 层,我们分别使用协议

Softmax。正向传播协议的掩码固定点输出然后使用协议 转换为秘密共享的浮点数。这些秘密共享然后输入到来自 SECFloAT 的软最大值协议中,它以秘密共享的浮点数形式返回输出,这些输出再次使用 转换回掩码固定点数。训练标签的掩码一热向量从输出中局部减去,以计算反向传播的输入。

反向传递。在前向传递期间计算的 DReLU 的输出可以在反向传递期间重复使用;ReLU 因此通过调用 来实现,而对于 MaxPool,位与和 就足够了(以及存储的前向传递值)。因此,不像前向传递过程中那样,融合层并没有什么好处。卷积和矩阵乘法的反向传递是通过使用卷积、矩阵乘法和 的协议来实现的。


附录 F. ReLU-Extend 的安全证明


对于 ,ReLUExt 的模拟器 给出 ,并且必须模拟第 方的视图,即来自交易商的消息 和来自其他评估员的 。模拟器执行以下操作:

  1. 通过调用 来生成 。运行 以获得

  2. 随机采样

  3. 使用 中的步骤 在 Eval 中计算

  4. 集合
  5.  集合

  6. 随机采样 并设置
  7.  集合

  8. 随机采样
  9.  集合
  10.  集合


附录 G。
使用 FSS 协议的食人鱼功能


我们展示了如何建立基于 FSS 的协议来实现 PiranHA[66]所使用的功能。这些功能在我们的库中实现,以直接比较 Orca 和 Piranha 在相同基准上的性能。


局部截断 + ReLU


正如几项先前的安全训练工作中所讨论的,各方本地截断了他们的秘密份额。在 FSS 设置中,这意味着交易商截断了遮罩,而评估者则截断了遮罩值。在与这些工作进行比较时,为了做到苹果对苹果,我们提供了基于 FSS 的协议和这种设置的优化方案。我们将截断与非激活函数(如 ReLU 或 ReLU+Maxpool)融合的想法也适用于本地截断,并且相比于顺序计算的简单方法,结果密钥尺寸更小。

一个实现 局部截断协议的简单方法,用于 位输入 和公开尺度 ,其误差与局部截断协议 [49] 类似,是将 局部截断为 ,并将结果作为 [16] 中 ReLU 协议的输入。在此协议上,我们进行两项优化:

  1. 我们将来自[16]的单轮 ReLU 协议替换为第 5.1 节中的双轮协议,密钥大小更小。

  2. 由于值 可以准确地表示在 位中,我们优化了计算 DReLU 位所需的比较,使之在 位宽度上进行。

我们在图 10 中展示了 LocalTruncate + ReLU 全部协议,并总结了其成本如下定理:

定理 14。 安全地实现局部截断 ,其中密钥大小为 。在在线阶段,该协议需要 2 个 的评估,并且通信成本为 2 位,需要 1 轮。

天真的未优化的方法需要 比特的密钥大小。对于 。当局部截断后跟着 MaxPool 和 ReLU 时,我们
Local-Truncate + ReLU \(\Pi_{n, f}^{\text {localTrReLU }}\left(\mathbb{G}^{\text {out }}=\mathbb{U}_{N}\right)\)
\(\operatorname{Gen}_{n, f}^{\text {localTrReLU }}\left(\mathrm{r}^{\text {in }}, \mathrm{r}^{\text {out }}\right):\)

![](https://cdn.mathpix.com/cropped/2024_08_15_41379d930d237705d9c4g-23.jpg?height=56&width=229&top_left_y=346&top_left_x=273)
    \(\left(k_{0}^{<}, k_{1}^{<}\right) \leftarrow \operatorname{Gen}_{n-f}^{<}\left(1^{\lambda}, r^{\prime}, 1, \mathbb{U}_{2}\right)\)
    \(r^{(d)} \stackrel{8}{\leftarrow} \mathbb{U}_{2}\)
    share \(r^{(d)}\)
    \(\left(k_{0}^{\text {(select) }}, k_{1}^{\text {(select) }}\right) \leftarrow \operatorname{Gen}_{n}^{\text {select }}\left(r^{(d)}, r^{\prime}, r^{\text {out }}\right)\)
    For \(b \in\{0,1\}, k_{b}=k_{b}^{<}\left\|r_{b}^{(d)}\right\| k_{b}^{(\text {select })}\)
Eval \({ }_{n, f}^{\text {localTrReLU }}\left(b, k_{b}, \hat{x}\right):\)
    Parse \(k_{b}\) as \(k_{b}^{<}\left\|r_{b}^{(d)}\right\| k_{b}^{(\text {select) }}\)
    \(\hat{x}^{\prime}=\hat{x} \gg_{L} f\)
    \(\hat{y}^{\prime}=\hat{x}^{\prime}+2^{n-f-1} \bmod 2^{n-f}\)
    \(t_{b} \leftarrow \operatorname{Eval}_{n-f}^{<}\left(b, k_{b}^{<}, \hat{y}^{\prime}\right)-\operatorname{Eval}_{n-f}^{<}\left(b, k_{b}^{<}, \hat{x}^{\prime}\right)\)
    \(\hat{d}_{b}=t_{b}+b \cdot 1\left\{\hat{y}^{\prime} \geqslant 2^{n-f-1}\right\}+r_{b}^{(d)} \bmod 2\)
    \(\hat{d}=\) reconstruct \(\left(\hat{d}_{b}\right)\)
    return \(\hat{u}_{b} \leftarrow \operatorname{Eval}_{n-f}^{\text {select }}\left(b, k_{b}^{\text {(select) }}, \hat{d}, \hat{x}^{\prime}\right)\)

图 10:Local-Truncate + ReLU 协议。 表示参与方 id。

根据附录 B 中描述的想法,在较小的位宽上计算所有内部 DReLU 位。

 逼近 Softmax


皮拉尼亚使用等式 1 来实现带有以下指数和逆近似的 softmax。

的表达式可以使用本地截断+ReLU 协议 G.1 轻易实现。对于 ,Piranha 安全地计算了 ,但是明确披露了其值,泄露了 的范围。为了模仿这种行为,我们首先使用区间包含多项式协议 D.1 计算 并向评估者披露其值。然后,可以使用乘法和局部截断协议轻易评估上述多项式。


附录 H.
正确的 DReLU 偏移功能


从偏移函数的定义开始,我们得到:

。根据上面的方程式,当 位于从 的区域内时,该指示函数返回 1,并考虑到包裹情况。现在,我们通过考虑两种情况来简化这个表达式。

案例 1: : 这意味着 。因此,表达式变为:

案例 2: :这意味着 。因此,表达式变为:

由于两种情况下的表达式恰好相差 1,合并这两种情况,得到:

现在,为进一步简化 项,我们使用[16]中的以下引理:

引理 3(来自[16]的引理 1)。设 ,其中 。在 上定义 4 个布尔谓词如下。 表示 表示 表示 表示 。那么,以下成立:

在上面的引理中,如果我们设置 ,我们得到:

我们观察到 就是我们需要的术语。所以:

把这个结果代入方程式 2,我们得到:


附录 I.
引理 2 的证明


引理 2。对于 满足 ,

证明。如 stTR 所示, 表示与 相同的整数值,但位宽更小。因此,只需将 扩展到 位以获得 即可。但是,当 时, 的随机截断可能会产生 输出,这表示二进制补码表示中最小的负数,这是错误的。因此,当 时,

 附录 J.


FSS 方案的正确性和安全性


并且 ,如果满足以下条件。

  • 正确性:对于所有 描述 ,并且对每个 ,如果

  • 安全性:对于每个 都有一个 PPT 算法 (模拟器),使得对于来自 的任何多项式大小的函数描述序列 的多项式大小输入序列 ,以下真实和理想实验的输出在计算上是无法区分的:

  • 真实的 ;输出

  • 理想的 输出


附录 K.我们的威胁模型


2 方安全计算(2PC)使得两个当事方 分别拥有私密输入 ,可以计算任何公共联合函数 。非正式地说,安全性要求他们只能了解 ,而通过交互协议执行过程中什么其他信息也不能获知。我们在可信经销商模型中考虑 2PC。也就是说,存在一个可信的经销商在预处理阶段(计算输入可用之前)提供相关的随机性给两个当事方。采用模拟范式[20]、[29]、[46]证明了针对半诚实静态概率多项式时间(PPT)对手的安全性,其中对手可能腐蚀其中一方。也就是说,在协议开始之前,对手可能腐蚀 。被腐蚀的一方保证遵守协议规范,但可能试图从协议中获取更多信息。通过定义两个世界来建模安全性:现实世界,其中 通过协议与对手 和环境 交互;理想世界,其中各方将输入发送给诚实计算 的可信功能。安全性要求对于每一个现实世界中的对手,都存在一个理想世界中的对手(称为模拟器 ),使得任何环境 都无法区分这两个世界。


附录 L.
来自 IEEE S&P 2024 的综述

 L.1. 概要


本论文描述了利用函数密码共享(FSS)和 GPU 计算来加速安全机器学习(ML)训练的方法,适用于双方(2PC)场景。为了加速 FSS,本文提出了几种针对 GPU 内部结构设计的优化/工程步骤。此外,该系统还提出了 FSS 原语的变体,旨在优化原始实现中观察到的性能瓶颈。


二、科学贡献


  • 创造新工具以促进未来科学发展

  • 为成熟领域提供了宝贵的前进一步

  • 开创了一个新的研究方向


获得认可的原因


  1. 创造一种新的工具来推动未来科学:该提议的系统通过利用 GPU 和新的密码学技术的进步来加速基于 FSS 的协议,从而向实用的安全推断和训练迈进。

  2. 为已有领域提供了宝贵的进步:所提出的系统在所有测试的性能和准确性指标上都超越了竞争对手。

  3. 确立了一个新的研究方向:作者基于初步分析确定的 GPU 使用过程中的瓶颈,开发了实用的优化方案。审稿人认可了作者在集成包括功能保密分享(FSS)在内的先进技术所付出的可嘉努力。


    固定点和浮点算术,以及 GPU 加速,开发了本研究中提出的综合系统。

 值得注意的关切


  1. 审阅者建议在正文中增加一些关于 2 个 PC 预处理的细节,这将非常有益。

  2. 评审员一致认为,该协议的写作风格过于密集,使得每个协议的关键贡献难以理解。如果相应部分的表述方式更加通俗易懂,这篇论文将会受益。


  1. 这个版本报告了改善的延迟,这是由于解决了评估设置中使用的固态硬盘中的问题,与将出现在 2024 年 IEEE S&P 中的版本相比
    •  同等贡献。

    该工作的一部分在微软研究院印度分部完成

    1. 我们注意到,通常会假设计算中出现的最大值可以用比所用比特宽度更少的位数表示。尽管如此,为了确保安全性对于运行时出现的任意值都成立,我们将明文/理想功能更改为也使用引理 2 中右侧的表达式。

    1. 由于 ORCA 中的密钥生成经过 GPU 优化,ORCA 的离线时间几乎全部用于将表 8 中给出的大小的密钥从经销商运行的机器移动到保持秘密数据的机器上。