论文状态:已完成

CipherGPT: Secure Two-Party GPT Inference

原文链接
价格:0.100000
已有 2 人读过
本分析由 AI 生成,可能不完全准确,请以原文为准。

TL;DR 精炼摘要

本论文提出CipherGPT框架,旨在解决用户隐私问题,特别是在GPT推理过程中。通过创新协议,优化了安全矩阵乘法和GELU计算,分别实现6.2倍和1.8倍的性能提升和带宽/通信量减少。此外,首次提出安全Top-K采样协议,提供全面的实现与基准测试,为未来研究奠定基础。

摘要

ChatGPT is recognized as a significant revolution in the field of artificial intelligence, but it raises serious concerns regarding user privacy, as the data submitted by users may contain sensitive information. Existing solutions for secure inference face significant challenges in supporting GPT-like models due to the enormous number of model parameters and complex activation functions. In this paper, we develop CipherGPT, the first framework for secure two-party GPT inference, building upon a series of innovative protocols. First, we propose a secure matrix multiplication that is customized for GPT inference, achieving up to 6.2× speedup and 4.1× bandwidth reduction over SOTA. We also propose a novel protocol for securely computing GELU, surpassing SOTA by 1.8× in runtime, 2.5× in communication and 7.4× in precision. Furthermore, we come up with the first protocol for secure top-k sampling. We provide a full-fledged implementation and comprehensive benchmark for CipherGPT. In particular, we measure the runtime and communication for each individual operation, along with their corresponding proportions. We believe this can serve as a reference for future research in this area.

思维导图

论文精读

中文精读

1. 论文基本信息

1.1. 标题

CipherGPT: Secure Two-Party GPT Inference (CipherGPT:安全两方GPT推理)

1.2. 作者

  • Xiaoyang Hou (侯晓阳), Jian Liu (刘健), Jingyu Li (李晶玉), Yuhan Li (李宇涵), Kui Ren (任奎) 隶属于浙江大学 (Zhejiang University)。
  • Wen-jie Lu (陆文杰), Cheng Hong (洪澄) 隶属于蚂蚁集团 (Ant Group)。

1.3. 发表期刊/会议

根据引用的参考文献 [30] (Bumblebee) 和 [33],该论文可能作为预印本发表在 IACR Cryptology ePrint Archive,具体编号为 Paper 2023/1678,表明它是一篇尚未经过同行评审或已在其他会议/期刊发表但同时发布在预印本库的学术文章。在提供的信息中,并未明确给出正式发表的期刊或会议名称。

1.4. 发表年份

2023年。

1.5. 摘要

ChatGPT 在人工智能领域取得了显著的革命性进展,但也引发了用户隐私方面的严重担忧,因为用户提交的数据可能包含敏感信息。现有的安全推理解决方案在支持类似 GPT 的模型时面临巨大挑战,原因在于模型参数数量庞大和激活函数复杂。本文开发了 CipherGPT,这是第一个用于安全两方 GPT 推理的框架,它建立在一系列创新协议之上。首先,我们提出了一种为 GPT 推理定制的安全矩阵乘法,相比最先进(SOTA)方法,实现了高达 6.2倍 的加速和 4.1倍 的带宽减少。其次,我们提出了一种用于安全计算 GELU 的新协议,在运行时性能上超越 SOTA 1.8倍,通信量减少 2.5倍,精度提高 7.4倍。此外,我们首次提出了安全 Top-K 采样协议。我们为 CipherGPT 提供了全面的实现和基准测试。特别是,我们测量了每个独立操作的运行时和通信量,以及它们各自的比例。我们相信这可以为该领域的未来研究提供参考。

1.6. 原文链接

/files/papers/692f0055713363b9c83c81fc/paper.pdf (这是一个相对路径,表明该论文是在特定文件系统或平台内部提供的链接)。

2. 整体概括

2.1. 研究背景与动机

  • 核心问题: ChatGPT 等大语言模型(LLMs)的广泛应用带来了巨大的用户隐私风险,因为用户提交的提示(prompts)或消息可能包含敏感信息。这限制了 GPT 在数据保密性至关重要的场景中的部署。
  • 重要性: 保护用户隐私是大模型落地应用的关键,尤其是在医疗、金融等强监管行业。
  • 现有挑战或空白:
    • 模型复杂度: 现有的安全推理协议难以有效支持类似 GPT 的大模型,原因在于其模型参数数量庞大以及使用了 GELU(Gaussian Error Linear Unit)复杂的激活函数
    • 生成式任务特性: GPT 等生成式 LLMs 需要重复推理(repeated inferences)以逐词生成句子,并且需要随机选择机制(random selecting mechanism)来确保文本的创造性和多样性,这些特性为安全推理带来了新的挑战。
    • 现有方案局限性:
      • Iron [27] 仅适用于基于 Transformer 的非生成任务(如 BERT)。
      • Bolt [40] 和 BumbleBee [30] 在通信方面优化了矩阵乘法,但增加了计算复杂度。
      • SOTA 的 GELU 计算方法(使用高阶多项式近似)难以同时实现高精度和高效率。
      • 之前的随机采样方法(如基于 Garbled Circuit [58])计算和通信开销极大,或者为了效率而牺牲了模型效用(仅选择最高分词语)。
  • 论文切入点与创新思路: 针对上述挑战,本文旨在开发一个专门为 GPT 架构量身定制的安全两方推理框架 CipherGPT,通过设计一系列创新的密码学协议来优化关键操作(矩阵乘法、GELU、Top-K 采样),以提高效率、降低通信并保证精度,从而首次实现对 GPT 模型的安全推理。

2.2. 核心贡献/主要发现

论文的主要贡献体现在以下几个方面:

  • 首个安全两方 GPT 推理框架: 提出了 CipherGPT,这是首个能够支持安全两方 GPT 推理的框架,解决了现有安全推理方案在支持 GPT 类模型时的诸多限制。
  • 定制化安全矩阵乘法: 提出了一种专为 GPT 推理定制的安全矩阵乘法协议,利用 GPT 模型重复使用相同权重矩阵的特性,将多次矩阵乘法批处理为一次非平衡矩阵乘法,并通过 sVOLE(Subfield Vector Oblivious Linear Evaluation)进行处理。相比 SOTA 方案,实现了高达 6.2倍的加速4.1倍的带宽减少
  • 新型安全 GELU 计算协议: 提出了一种基于样条(spline-based)近似和 LUT(Lookup Table)的新型安全 GELU 协议。该方法在运行时比 SOTA 提升 1.8倍,通信量减少 2.5倍,并显著提高了精度 7.4倍,解决了现有 GELU 近似方法在精度和效率上的权衡问题。
  • 首个安全 Top-K 采样协议: 首次提出了用于安全 Top-K 采样(选择 Top-K 概率并根据这些概率进行采样)的协议,以支持 GPT 生成文本的创造性和多样性需求。
  • 全面实施和基准测试: 提供了 CipherGPT 的完整实现,并进行了详细的基准测试,测量了每个独立操作的运行时和通信量及其所占比例,为该领域的未来研究提供了宝贵的参考。
  • 高精度保持: 实验结果显示,CipherGPT 生成的输出与原始 GPT 模型的输出有 99.22% 的一致性,即使不同的输出也落在原始 GPT 的 Top-5 结果中,表明其在保证安全性的同时,对模型效用(utility)的损失极小。

3. 预备知识与相关工作

3.1. 基础概念

为了理解 CipherGPT 框架,读者需要了解以下基础概念和密码学原语:

  • 安全推理 (Secure Inference): 这是一种两方密码学协议,允许客户端(C)和服务器(S)在保护各自隐私的前提下执行模型推理。具体来说,客户端的输入(如提示)对服务器保密,而服务器的模型参数(如权重)对客户端保密,客户端只能获得推理结果。
  • 威胁模型 (Threat Model): 本文假设攻击者是半诚实对手 (semi-honest adversary)。半诚实对手遵循协议的规范执行所有步骤,但会尝试从其接收到的数据中尽可能多地收集额外信息。这意味着对手不会恶意偏离协议,但会进行被动窃听和分析。
  • 秘密共享 (Secret Sharing): 一种密码学技术,将秘密数据(如一个整数 xx)分成多个份额,分发给不同的参与方。只有当足够数量的参与方(例如,在 2-out-of-2 方案中,需要所有两方)合作时,才能重建秘密。本文使用 2-out-of-2 加法秘密共享 (2-out-of-2 additive secret sharing) 方案,在模 2l2^l 的环 Z2l\mathbb{Z}_{2^l} 上进行。对于一个秘密 xZ2lx \in \mathbb{Z}_{2^l},它的份额表示为 xl=(xSl,xCl)\langle x \rangle^l = (\langle x \rangle_S^l, \langle x \rangle_C^l),满足 x=xSl+xCl(mod2l)x = \langle x \rangle_S^l + \langle x \rangle_C^l \pmod{2^l}
  • 不经意传输 (Oblivious Transfer, OT): 是一种两方协议,允许发送方向接收方发送 MM 条消息中的一条,接收方选择哪条消息接收,但发送方不知道接收方选择了哪条,而接收方只能了解其选择的那条消息。
    • 1-out-of-MM OT (1-out-of-M OT): 发送方有 MM 条消息,接收方选择其中一条。
    • 随机 OT (Random OT, rOT): 消息和选择位都是随机的。Ferret [57] 提供了一种高效生成大量随机 OT 的协议。
  • 理想功能 (Ideal Functionality): 在密码学中,理想功能是一种抽象模型,定义了一个安全协议应该实现的功能,而不考虑其具体实现细节。例如:
    • FMult: 用于乘法,输入 xg\langle x \rangle^g, yh\langle y \rangle^h,输出 zl\langle z \rangle^l,其中 z=xyz = x \cdot y
    • FCMP: 用于比较,输入 xl\langle x \rangle^l, yl\langle y \rangle^l,输出 b1\langle b \rangle^1,其中 b=1b=1 如果 xyx \ge y,否则 b=0b=0
    • FMUX: 用于多路选择器,输入 xl\langle x \rangle^l, b1\langle b \rangle^1,输出 yl\langle y \rangle^l,其中 y=xy=x 如果 b=1b=1,否则 y=0y=0
    • FTrunc: 用于截断,输入 xl\langle x \rangle^l, ss,输出 yl\langle y \rangle^l,其中 y=xsy = x \gg s(右移 ss 位)。
    • FTR: 用于截断然后缩小环,输入 xl\langle x \rangle^l, ss,输出 yls\langle y \rangle^{l-s},其中 y=xsy = x \gg s
    • FLUT: 用于查找表,输入 i\langle i \rangle,输出 T[i]\langle T[i] \rangle
    • FShuffle: 用于秘密共享洗牌,输入 xl\langle \mathbf{x} \rangle^l, π\langle \pi \rangle,输出 π(x)l\langle \pi(\mathbf{x}) \rangle^l
  • 子域向量不经意线性求值 (Subfield Vector Oblivious Linear Evaluation, sVOLE):VOLE 的泛化。VOLE 是一种两方功能,发送方输入一个标量 xFpx \in \mathbb{F}_p,接收方输入随机向量 u,vRFpn\mathbf{u}, \mathbf{v} \in_R \mathbb{F}_p^n,然后生成相关性 w=ux+v\mathbf{w} = \mathbf{u}x + \mathbf{v},发送方学习 w\mathbf{w},接收方学习 (u,v)(\mathbf{u}, \mathbf{v})sVOLE 推广到 uRFpn\mathbf{u} \in_R \mathbb{F}_p^n, xFqx \in \mathbb{F}_q, w,vRFqn\mathbf{w}, \mathbf{v} \in_R \mathbb{F}_q^n,其中 q=pmq = p^m。它以接近运行单个 VOLE 的成本完成 mm 个常规 VOLE 实例的任务,当 nkn \gg k 时效率更高。Baum et al. [6] 提出了在有限环 Z2l\mathbb{Z}_{2^l} 上工作的方法。
  • 同态加密 (Homomorphic Encryption, FHE): 一种允许在加密数据上直接执行计算而无需解密的技术。本文使用 全同态加密 (Fully Homomorphic Encryption, FHE),特别是 环-学习误差 (Ring-LWE, RLWE) 基础的方案,如 Brakerski-Fan-Vercauteren (BFV) 方案。在 FHE 中,明文通常编码为多项式,然后加密为密文。
    • SIMD (Single Instruction, Multiple Data) 槽 (SIMD slots):FHE 中,可以将多个明文元素打包到一个密文中,并对它们执行批处理运算。
    • 系数打包 (Coefficient Packing): 另一种 FHE 中的数据打包技术,将明文编码为多项式系数。
    • 噪声泛洪 (Noise Flooding): 一种保护电路隐私的技术,通过向返回的密文添加随机噪声来防止对手从密文的大小或结构推断信息。
  • 批不经意线性求值 (Batch Oblivious Linear Evaluation, BOLE): 一种两方功能,发送方输入向量 xFpn\mathbf{x} \in \mathbb{F}_p^n,接收方输入向量 yFpn\mathbf{y} \in \mathbb{F}_p^n,生成相关性 vi+wi=xiyi\mathbf{v}_i + \mathbf{w}_i = \mathbf{x}_i * \mathbf{y}_i,其中接收方学习 v\mathbf{v},发送方学习 w\mathbf{w}。可以将其解释为 Beaver 三元组,用于实现均匀位宽的乘法。

3.2. 前人工作

  • 早期的安全推理: 始于 2010 年代初,主要关注 SVM 和线性回归等简单机器学习算法 [39], [7], [55]。
  • 安全神经网络推理的开端: CryptoNets [22] 是首次尝试安全神经网络推理,完全依赖 FHE,但仅支持线性操作和低阶多项式,且层数受限。
  • 定制化 2PC 协议: MiniONN [34] 首次为安全神经网络推理定制 2PC 协议,提出了基于样条的非线性操作近似,这启发了 CipherGPT 的安全 GELU 方案。
  • 线性层优化:
    • GAZELLE [31] 通过将线性层映射到 SIMD 矩阵-向量乘法和卷积例程来降低成本。
    • Cheetah [29] 使用系数打包取代 SIMD,消除了昂贵的同态旋转。
    • Iron [27] 进一步降低了 Cheetah 的通信复杂度。
  • 激活函数优化:
    • CrypTFlow2 [44] 提供了高效的安全比较和除法协议。
    • SIRNN [43] 为指数、sigmoid、tanh 和倒数平方根等数学函数提供了密码学友好的近似以及相应的 2PC 实现。
  • 模型结构改变: 另一个方向是通过改变模型结构以使其更适合密码学计算。例如,DeepSecure [48]、XONN [46] 和 Quotient [2] 专为二值化神经网络设计。Delphi [37] 利用神经架构搜索自动生成性能-精度权衡的神经网络架构。然而,这些方法通常需要重新训练模型。
  • 加速技术:
    • GForce [38] 等解决方案利用 GPU 并行性加速在线阶段,但对预处理阶段效果不明显。
  • 多方计算设置: 某些工作 [47], [52], [5] 针对三方设置,其中模型在两个不串通的服务器之间秘密共享。这些协议通常比两方协议更高效,但对“不串通服务器”的假设在实践中往往不现实。

3.3. 技术演进

安全推理领域从最初为简单机器学习模型设计通用 2PCFHE 方案,逐步发展到为深度神经网络(DNN)定制高效协议。早期的 FHE 方案(如 CryptoNets)由于其计算开销和功能限制(只能处理低阶多项式)而难以扩展到复杂的 DNN。随后的工作转向混合协议,结合 FHE 和秘密共享,并针对 DNN 中的线性层(如矩阵乘法、卷积)和非线性激活函数(如 ReLUSigmoid)进行优化。

在处理线性层时,技术从最初的通用 FHE 乘法演进到利用 SIMD 或系数打包等 FHE 特定优化,以减少旋转和通信开销(如 GAZELLECheetahIron)。对于非线性激活函数,研究人员探索了基于查找表(LUT)或多项式近似的方法(如 MiniONNSIRNNCrypTFlow2)。

然而,随着 Transformer 架构和 GPT 等大型语言模型(LLMs)的兴起,新的挑战出现了:

  1. 巨大的模型规模: GPT 模型拥有数亿甚至数千亿参数,使得传统的安全推理方案效率低下。

  2. 复杂的激活函数: GELU 激活函数比 ReLUSigmoid 更复杂,需要更精细的近似方法。

  3. 生成式任务的特性: 逐词生成(autoregressive generation)需要重复推理,且为了多样性,需要随机采样机制。

    CipherGPT 正是在这一背景下,在现有技术的基础上,针对 GPT 模型的特定需求和挑战,提出了定制化的解决方案,包括批处理矩阵乘法、优化的 GELU 协议以及新颖的安全 Top-K 采样,标志着安全推理技术向支持复杂生成式 LLMs 的重要一步。

3.4. 差异化分析

CipherGPT 与现有相关工作的主要区别和创新点在于其对 GPT 模型的特定优化:

  • 针对 GPT 推理的定制化矩阵乘法:

    • 现有工作(如 CheetahIronBumbleBeeBolt 侧重于通用矩阵乘法的优化,通常使用 RLWE(Ring-LWE)同态加密,通过 SIMD 槽或系数打包技术来减少通信或计算。
    • CipherGPT 观察到 GPT 在自回归生成过程中会重复使用相同的权重矩阵进行多次矩阵乘法。它将这些独立的矩阵乘法批处理成一个大的、非平衡的矩阵乘法,并使用 sVOLE 进行高效计算。这种定制化方法显著降低了分摊成本 (amortized cost),在 tt 次迭代(例如生成 tt 个词)时实现了比 SOTA 高达 6.2倍的加速和 4.1倍的带宽减少,而现有方法无法直接利用这种批处理特性。
  • 新型高效高精度 GELU 协议:

    • 现有 SOTA(如 BoltBumbleBee 通常将 GELU 分割成多个部分,然后使用高阶多项式进行近似,并通过比较和多路选择器来确定正确的输出。SIRNNIron 则使用多个查找表来近似指数和倒数。这些方法普遍存在精度损失、误差累积或计算开销大的问题。
    • CipherGPT 采用了一种样条基近似 (spline-based approximation),将 GELU 曲线分解成多个小区间,并在每个区间内使用简单的线性函数进行近似。结合一个 LUT 来查找区间和对应的线性函数,并通过秘密共享方式计算。这种方法比多步 LUT 方法(如 SIRNNIron)使用更少的 LUT 和密码学原语,比高阶多项式方法(如 BoltBumbleBee)减少了乘法和比较操作。实验证明,CipherGPTGELU 协议在运行时快 1.8倍,通信少 2.5倍,并且精度提升 7.4倍,显著优于现有方案。
  • 首个安全 Top-K 采样协议:

    • 现有工作 对于随机采样通常要么使用计算开销极大的 Garbled Circuit,要么为了效率而直接选择最高分词语,牺牲了生成文本的多样性和创造性。
    • CipherGPT 首次提出了一个高效的安全 Top-K 采样协议,它首先安全地洗牌输入元素,然后使用一个修改版的 quicksort 算法来选择 Top-K 元素,并将比较结果在洗牌后公开,这不会泄露原始元素的信息。然后,它基于秘密共享的概率执行采样。这使得 GPT 能够生成更具创造性和多样性的文本,同时保护隐私。
  • 综合框架实现: CipherGPT 不仅仅优化了单个操作,而是将这些创新协议集成到一个完整的 GPT 推理框架中,并进行了全面的基准测试,提供了每个操作的细粒度性能分析,这为未来研究奠定了基础。

    总而言之,CipherGPT 通过深入理解 GPT 模型在隐私保护推理中的具体计算模式和需求,提供了比现有通用或部分优化方案更高效、更精确的定制化密码学协议,填补了安全 GPT 推理领域的空白。

4. 方法论

本节将详细阐述 CipherGPT 框架中用于实现安全 GPT 推理的关键协议和技术。

4.1. 安全矩阵乘法

MatrixMul 操作是 GPT 模型中最主要的计算之一。对于输入矩阵 XZ2ln×m\mathbf{X} \in \mathbb{Z}_{2^l}^{n \times m}YZ2lm×k\mathbf{Y} \in \mathbb{Z}_{2^l}^{m \times k},目标是计算秘密共享的 Z\langle \mathbf{Z} \rangle,其中 Z=XYZ2ln×k\mathbf{Z} = \mathbf{XY} \in \mathbb{Z}_{2^l}^{n \times k}

GPT 推理的特点与挑战: GPT 在自回归生成响应词时,需要进行多次模型推理。每次生成一个词后,该词会被添加到输入序列中,形成新的输入,再次送入模型以生成下一个词。在这个过程中,许多层的矩阵乘法会重复使用相同的权重矩阵 Y\mathbf{Y},而输入矩阵 X\mathbf{X} 则不断变化。现有的 RLWE(Ring-LWE)同态加密方法,如 SIMD 或系数打包,虽然各有优势,但并未充分利用这一特性。

CipherGPT 的创新点: CipherGPT 利用 GPT 的这一特性,在预处理阶段 (preprocessing phase) 将针对单个响应词的多次 MatrixMul 合并为一个非平衡矩阵乘法 (unbalanced MatrixMul),然后使用 sVOLE(Subfield Vector Oblivious Linear Evaluation)协议进行处理,从而显著降低了分摊成本 (amortized cost)

详细协议流程:

  1. 分解矩阵乘法: 矩阵乘法 Z=XY\mathbf{Z} = \mathbf{XY} 可以表示为对 X\mathbf{X} 的列向量和 Y\mathbf{Y} 的行向量进行外积求和。假设 X=[x1,x2,,xm]\mathbf{X} = [\mathbf{x}_1, \mathbf{x}_2, \dots, \mathbf{x}_m] (其中 xiZ2ln\mathbf{x}_i \in \mathbb{Z}_{2^l}^nX\mathbf{X} 的列向量)和 YT=[y1,y2,,ym]\mathbf{Y}^T = [\mathbf{y}'_1, \mathbf{y}'_2, \dots, \mathbf{y}'_m] (其中 yiZ2lk\mathbf{y}'_i \in \mathbb{Z}_{2^l}^kY\mathbf{Y} 的行向量)。那么, Z=i=1m(xiyi) \mathbf{Z} = \sum_{i=1}^m (\mathbf{x}_i \otimes \mathbf{y}'_i) 其中 \otimes 表示外积(outer product)。

  2. 批处理多轮推理: 假设 S 和 C 需要生成 tt 个响应词,对应有 tt 个输入矩阵 X1,X2,,Xt\mathbf{X}_1, \mathbf{X}_2, \dots, \mathbf{X}_t。 对于每个 i[1,m]i \in [1, m],将所有 tt 个输入矩阵的第 ii 列堆叠起来形成一个长向量 xi\mathbf{x}'_i: xi=x1,ix2,ixt,i \mathbf{x}'_i = \mathbf{x}_{1,i} || \mathbf{x}_{2,i} || \dots || \mathbf{x}_{t,i} 其中 || 表示向量拼接。 那么,对这些堆叠向量和 yi\mathbf{y}'_i 进行外积,可以得到批处理后的结果: xiyi=(x1,iyi)(x2,iyi)(xt,iyi) \mathbf{x}'_i \otimes \mathbf{y}'_i = (\mathbf{x}_{1,i} \otimes \mathbf{y}'_i) || (\mathbf{x}_{2,i} \otimes \mathbf{y}'_i) || \dots || (\mathbf{x}_{t,i} \otimes \mathbf{y}'_i) 将这些外积结果求和,即可得到所有 tt 个矩阵乘法的拼接结果: i=1m(xiyi)=Z1Z2Zt \sum_{i=1}^m (\mathbf{x}'_i \otimes \mathbf{y}'_i) = \mathbf{Z}_1 || \mathbf{Z}_2 || \dots || \mathbf{Z}_t 这意味着我们可以通过 mm 次外积操作来计算所有 ttMatrixMul

  3. 预处理阶段 (Preprocessing Phase): 由于权重矩阵 Y\mathbf{Y} 是预先知道的,S 和 C 可以共同生成 mmsVOLE 相关性。 对于每个 i[1,m]i \in [1, m],S 和 C 运行 sVOLE 协议,生成如下相关性: Wi=uiyi+Vi, i[1,m] \mathbf{W}_i = \mathbf{u}_i \otimes \mathbf{y}'_i + \mathbf{V}_i, \quad \forall \ i \in [1, m] 其中:

    • 客户端 C 持有 uiZ2ltn\mathbf{u}_i \in \mathbb{Z}_{2^l}^{t \cdot n} (一个长度为 tnt \cdot n 的向量)和 ViZ2l(tn)×k\mathbf{V}_i \in \mathbb{Z}_{2^l}^{(t \cdot n) \times k}
    • 服务器 S 持有 yiZ2lk\mathbf{y}'_i \in \mathbb{Z}_{2^l}^kY\mathbf{Y} 的第 ii 行向量)和 WiZ2l(tn)×k\mathbf{W}_i \in \mathbb{Z}_{2^l}^{(t \cdot n) \times k}。 这个阶段是输入无关的,可以在线阶段之前完成。
  4. 在线阶段 (Online Phase): 对于第 jj 个输入矩阵 Xj=[xj,1,xj,2,,xj,m]\mathbf{X}_j = [\mathbf{x}_{j,1}, \mathbf{x}_{j,2}, \dots, \mathbf{x}_{j,m}],S 和 C 协作计算其秘密共享乘法结果。

    • 客户端 C 的操作: 对于每个 i[1,m]i \in [1, m],客户端 C 从其持有的 ui\mathbf{u}_i 中提取对应于当前输入 xj,i\mathbf{x}_{j,i} 的片段,并计算一个掩码值,发送给 S: xj,iS:=xj,iui[(j1)n+1,,jn] \langle \mathbf{x}_{j,i} \rangle_S := \mathbf{x}_{j,i} - \mathbf{u}_i[(j-1)n+1, \dots, j \cdot n] 这个 xj,iS\langle \mathbf{x}_{j,i} \rangle_Sxj,i\mathbf{x}_{j,i} 在 S 端的秘密份额,C 已经减去了它自己知道的 ui\mathbf{u}_i 的对应部分。
    • 服务器 S 的操作: S 接收到 C 发送的 xj,iS\langle \mathbf{x}_{j,i} \rangle_S 后,结合自己已知的 yi\mathbf{y}'_i 进行外积计算: xj,iSyi=(xj,iui[(j1)n+1,,jn])yi=xj,iyiui[(j1)n+1,,jn]yi \langle \mathbf{x}_{j,i} \rangle_S \otimes \mathbf{y}'_i = (\mathbf{x}_{j,i} - \mathbf{u}_i[(j-1)n+1, \dots, j \cdot n]) \otimes \mathbf{y}'_i \\ = \mathbf{x}_{j,i} \otimes \mathbf{y}'_i - \mathbf{u}_i[(j-1)n+1, \dots, j \cdot n] \otimes \mathbf{y}'_i
    • 秘密共享结果重建: 利用预处理阶段的 sVOLE 相关性,S 和 C 可以各自计算 xj,iyi\mathbf{x}_{j,i} \otimes \mathbf{y}'_i 的秘密份额: xj,iyi=xj,iSyi+ui[(j1)n+1,,jn]yi=xj,iSyi+Wi[(j1)kn+1,,jkn]Vi[(j1)kn+1,,jkn] \mathbf{x}_{j,i} \otimes \mathbf{y}'_i = \langle \mathbf{x}_{j,i} \rangle_S \otimes \mathbf{y}'_i + \mathbf{u}_i[(j-1)n+1, \dots, j \cdot n] \otimes \mathbf{y}'_i \\ = \langle \mathbf{x}_{j,i} \rangle_S \otimes \mathbf{y}'_i + \mathbf{W}_i[(j-1)kn+1, \dots, j \cdot k \cdot n] - \mathbf{V}_i[(j-1)kn+1, \dots, j \cdot k \cdot n] 此时,S 持有 xj,iSyi+Wi[(j1)kn+1,,jkn]\langle \mathbf{x}_{j,i} \rangle_S \otimes \mathbf{y}'_i + \mathbf{W}_i[(j-1)kn+1, \dots, j \cdot k \cdot n] 作为 xj,iyi\mathbf{x}_{j,i} \otimes \mathbf{y}'_i 的秘密份额。 C 持有 Vi[(j1)kn+1,,jkn]\mathbf{V}_i[(j-1)kn+1, \dots, j \cdot k \cdot n] 作为 xj,iyi\mathbf{x}_{j,i} \otimes \mathbf{y}'_i 的秘密份额的负值。 (这里原文的表达式中 Vi\mathbf{V}_i 前面是减号,需要注意,这通常意味着 Vi\mathbf{V}_ixj,iyi\mathbf{x}_{j,i} \otimes \mathbf{y}'_i 的 C 端份额的负值,或者在实际的秘密共享协议中会进行调整,使其成为 C 端的加性份额。) 通过这种方式,S 和 C 秘密共享了所有的 xj,iyi\mathbf{x}_{j,i} \otimes \mathbf{y}'_i。由于加法是本地操作,他们可以本地计算 \mathbf{Z}_j = \sum_{i=1}^m (\mathbf{x}_{j,i} \otimes \mathbf{y}'_i) 的秘密份额。

优势分析:

  • 分摊成本显著降低: sVOLE 的通信复杂度几乎与 nn 无关,结合批处理,使得单个 MatrixMul 的分摊成本远低于其他 RLWE 同态加密方法,尤其当生成词数 tt 较大时。
  • 避免昂贵操作: 避免了 SIMD 槽方法中昂贵的同态旋转(homomorphic rotations)以及 Cheetah 等方法中可能需要的重加密或模切换。
  • 直接在 Z2l\mathbb{Z}_{2^l} 环上操作: 避免了 Bolt 等方法在素数域和 2l2^l 环之间的昂贵转换。

4.2. 安全 GELU

GELU (Gaussian Error Linear Unit) 是 GPT 模型中的激活函数,其定义如下: GELU(x)=0.5x(1+Tanh[2/π(x+0.044715x3)]) \mathsf{GELU}(x) = 0.5x(1 + \mathsf{Tanh}\left[ \sqrt{2/\pi} (x + 0.044715x^3) \right]) 其中 Tanh(x)=2Sigmoid(2x)1\mathsf{Tanh}(x) = 2 \mathsf{Sigmoid}(2x) - 1Sigmoid(x)=11+ex\mathsf{Sigmoid}(x) = \frac{1}{1+e^{-x}}

现有方法与挑战:

  • SIRNN [43] 和 Iron [27] 使用 LUT [18] 分别近似 exe^{-x} 和倒数,涉及多步计算,需要不断调整位宽以平衡精度和效率,且容易导致误差累积。
  • SOTA 方法 [40], [30] 将 GELU 分成几段,每段用高阶多项式近似,然后通过比较和多路选择器选择正确的输出。这种方法计算复杂度高(涉及多次乘法-截断和比较),且高阶多项式近似容易损失精度。

CipherGPT 的创新点:样条基 GELU (Spline-based GELU) CipherGPT 提出了一种基于样条(spline-based)近似的 GELU 协议,它利用线性函数来近似 GELU 曲线的不同部分,并通过 LUT 和秘密共享机制高效安全地完成计算。

方法直觉 (Intuition):

  1. 观察 GELU 曲线特性: GELU 函数在负值很大时接近零,在正值很大时接近 y=xy=x。在中间区域则呈现平滑的 S 形曲线。

    Fig. 1: GELU transformation. 该图像是GELU变换的示意图,展示了在不同参数设置下函数的图形变化。左侧为原始GELU函数,中间为插值点示意,右侧呈现了经过调整后的函数曲线,反映了其平滑性和特征变化。 Figure 1 (left) 展示了原始 GELU 曲线。

  2. 分段处理: 基于上述观察,将 GELU 曲线分为三个主要部分:

    • y=0 when x<αy = 0 \text{ when } x < -\alpha
    • y=GELU(x) when αxαy = \mathsf{GELU}(x) \text{ when } -\alpha \le x \le \alpha
    • y=x when x>αy = x \text{ when } x > \alpha 其中 α\alpha 是一个预设的阈值。第一部分和第三部分的计算相对简单。
  3. 样条近似中间部分: 对于第二部分 [α,α][-\alpha, \alpha],使用多项式样条 (polynomial splines) 进行近似。具体来说,将这一区间分成若干个等长的小区间,并在每个小区间内使用一个简单的线性函数 (y=ax+d)(y = ax + d) 来近似 GELU 曲线。 Figure 1 (middle) 示意了分段线性近似的思想。 寻找这些线性函数的详细过程可参考 Liu et al. [34] 的 5.3.2 节。这种近似不需要修改模型的训练阶段。

  4. 简化区间查找: 为了避免在查找 xx 所属区间时需要先判断 xx 的符号,然后分别在 [α,0][-\alpha, 0][0,α][0, \alpha] 中查找,CipherGPT 将整个曲线右移 (right-shift) α\alpha。这样,第二部分区间变为 [0,2α][0, 2\alpha],可以通过一次查找表操作完成区间定位。 Figure 1 (right) 展示了右移后的曲线。

详细协议算法 (Algorithm 1: Secure GELU: IIGELU):

  • 输入: S 和 C 持有 xl\langle x \rangle^l,公共值 α\alpha 用于分割,查找表大小 2s2^s
  • 输出: S 和 C 得到 y=GELU(x)y = \mathsf{GELU}(x) 的秘密份额 yl\langle y \rangle^l
  1. 缩放 α\alpha GPT 模型的初始输入已通过左移 LL 位进行缩放。为保持一致性,将 α\alpha 缩放 2L2^L 倍: α:=2Lα \alpha' := 2^L \alpha

  2. 右移输入 xx 客户端 C 和服务器 S (本地) 计算调整后的输入 xl\langle x' \rangle^lxl:=xl+α \langle x' \rangle^l := \langle x \rangle^l + \alpha' 这一步通过将 α\alpha' 加到 xx 的任何一个份额上来实现,是本地操作,无需通信。

  3. 处理中间小区间 [0,β][0, \beta]

    • 定义 β:=2α\beta := 2\alpha'。现在,GELU 的中间近似区间变为 [0,β][0, \beta]
    • 假设 xx' 落在此区间内。由于 β\beta2 的幂(或可调整为 2 的幂),S 和 C 可以(本地)提取 xl\langle x' \rangle^l 的低 h:=logβh := \log \beta 位,得到 xh\langle x' \rangle^h
    • 假设区间 [0,β][0, \beta] 已被划分为 2s2^s 个小区间。为了找到 xx' 所属的区间索引,S 和 C 调用 FTR(Truncate-then-Reduce)协议: isFTR(xh,hs) \langle i \rangle^s \gets \mathsf{F_{TR}}(\langle x' \rangle^h, h - s) 其中 iZ2si \in \mathbb{Z}_{2^s}xx' 所属小区间的索引。
    • 服务器 S 持有一个查找表 TT,其中每个条目存储了对应小区间的线性函数系数 (ai,di)(a_i, d_i)。S 和 C 调用 FLUT(Lookup Table)协议,秘密共享地获取第 ii 个条目: (ail,dil)FLUT(T,is) (\langle a_i \rangle^l, \langle d_i \rangle^l) \gets \mathsf{F_{LUT}}(T, \langle i \rangle^s)
    • S 和 C 调用 FMult(Multiplication with non-uniform bit-widths)协议计算 aixa_i x',然后调用 FTrunc(Secure Truncation)协议进行截断,以保持 LL 位的缩放: aixlFMult(ail,xl) \langle a_i x \rangle^l \gets \mathsf{F_{Mult}}(\langle a_i \rangle^l, \langle x' \rangle^l) klFTrunc(aixl,L) \langle k \rangle^l \gets \mathsf{F_{Trunc}}(\langle a_i x \rangle^l, L)
    • S 和 C (本地)计算潜在的 GELU 结果 zl\langle z \rangle^lzl:=kl+dil \langle z \rangle^l := \langle k \rangle^l + \langle d_i \rangle^l
  4. 处理大的分段(x<αx < -\alphax>αx > \alpha): 为了处理 xx' 不在 [0,β][0, \beta] 区间的情况,使用比较和多路选择器。

    • S 和 C 调用 FCMP(Secure Comparison)协议比较 xx'β\betab1FCMP(xl,β) \langle b \rangle^1 \gets \mathsf{F_{CMP}}(\langle x' \rangle^l, \beta) 其中 b=1b=1 如果 xβx' \ge \beta,否则 b=0b=0
    • S 和 C 调用 FCMP 协议比较 xx'0b1FCMP(xl,0) \langle b' \rangle^1 \gets \mathsf{F_{CMP}}(\langle x' \rangle^l, 0) 其中 b=1b'=1 如果 x0x' \ge 0,否则 b=0b'=0
    • 根据 bbbb' 的组合:
      • b=1 and b=1    xβb=1 \text{ and } b'=1 \implies x' \ge \beta (对应 y=xy=x)
      • b=0 and b=1    0x<βb=0 \text{ and } b'=1 \implies 0 \le x' < \beta (对应 y=zy=z)
      • b=0 and b=0    x<0b=0 \text{ and } b'=0 \implies x' < 0 (对应 y=0y=0)
    • S 和 C 调用 FMUX(Secure Multiplexer)协议,使用 bbb \oplus b' 作为控制信号来选择 zzulFMUX(zl,b1b1) \langle u \rangle^l \gets \mathsf{F_{MUX}}(\langle z \rangle^l, \langle b \rangle^1 \oplus \langle b' \rangle^1) 如果 bb=1b \oplus b' = 1 (即 0x<β0 \le x' < \beta),则 u=zu=z,否则 u=0u=0
    • S 和 C 再次调用 FMUX 协议,使用 bb 作为控制信号来选择原始 xxvlFMUX(xl,b1) \langle v \rangle^l \gets \mathsf{F_{MUX}}(\langle x \rangle^l, \langle b \rangle^1) 如果 b=1b=1 (即 xβx' \ge \beta),则 v=xv=x,否则 v=0v=0
    • S 和 C (本地)计算最终的 GELU 结果 yl\langle y \rangle^lyl:=ul+vl \langle y \rangle^l := \langle u \rangle^l + \langle v \rangle^l 注意,当 x<0x' < 0 时,ul=0\langle u \rangle^l = 0vl=0\langle v \rangle^l = 0,所以最终结果 yl=0\langle y \rangle^l = 0,无需额外的多路选择器处理。

优势:

  • 低开销: 相比 SOTA,我们的解决方案使用更少的乘法-截断和比较操作。始终只需要一个 FLUT 和一个乘法-截断来计算线性函数。
  • 高精度: CipherGPT 采用单步样条近似,避免了多步近似(如指数和倒数)带来的误差累积。同时,线性函数近似的精度也优于高阶多项式在计算高次幂时可能存在的精度损失。

4.3. 安全 Top-K 选择

vec2word 层中,GPT 模型会生成一个包含所有可能词语概率的向量。我们需要从这个向量中选择最高的 KK 个概率,然后根据这些选定的概率对最终响应词进行采样。本节关注从长度为 nn 的秘密共享向量中选择 Top-K 值的过程。

方法直觉:

  • 隐私保护洗牌: 为了保护原始元素的隐私,首先对输入元素进行安全洗牌 (securely shuffled)。洗牌后,元素之间的相对顺序被打乱,因此后续的比较结果不会泄露原始值。
  • 修改版快速选择: 在洗牌后的列表上应用一个修改版的比较基选择算法 (comparison-based selection)(类似 quicksort)。这个修改的关键在于,它只需要 O(n)O(n) 次比较而不是 O(nlogn)O(n \log n) 次完全排序。

详细协议算法 (Algorithm 2: Secure Top KK: TopK):

  • 输入: S 和 C 持有向量 x\langle \mathbf{x} \rangle,其中 xZ2ln\mathbf{x} \in \mathbb{Z}_{2^l}^n
  • 输出: S 和 C 得到向量 y\langle \mathbf{y} \rangle,其中 yZ2lK\mathbf{y} \in \mathbb{Z}_{2^l}^Kx\mathbf{x} 中最大的 KK 个值。
  1. 安全洗牌: S 和 C 调用 FShuffle(Secret-shared shuffle)协议对输入向量 x\langle \mathbf{x} \rangle 进行洗牌,得到 x\langle \mathbf{x}' \ranglexFShuffle(x) \langle \mathbf{x}' \rangle \gets \mathsf{F_{Shuffle}}(\langle \mathbf{x} \rangle) (注意:为了处理重复值,通常会给每个元素附加一个唯一的索引,在选择后截断掉。本文假设元素是不同的。)

  2. 选择函数 select (递归执行): yselect(x,K) \langle \mathbf{y} \rangle \gets \mathsf{select}(\langle \mathbf{x}' \rangle, K)

    • 函数 select 的定义:
      • 输入: 秘密共享向量 x\langle \mathbf{x}' \rangle 和整数 KK
      • 输出: 秘密共享的 Top-K 元素。
      • 初始化:n:=xn := |\langle \mathbf{x}' \rangle|
      • 选择轴值 (pivot): 选择向量的最后一个元素作为轴值: pivot:=x[n] \text{pivot} := \mathbf{x}'[n]
      • 分区 (partition): 将向量 x\mathbf{x}' 分成两部分:
        • SLS_L: 元素小于 pivot 的集合。
        • SRS_R: 元素大于或等于 pivot 的集合。 为了实现分区,对 x\mathbf{x}' 中的所有元素与 pivot 进行比较。S 和 C 调用 FCMP 协议: bj1FCMP(x[j],pivot) \langle b_j \rangle^1 \gets \mathsf{F_{CMP}}(\langle \mathbf{x}'[j] \rangle, \langle \text{pivot} \rangle) 关键洞察: 由于原始元素已被洗牌,比较结果 bjb_j (表示 x[j]\mathbf{x}'[j] 是否大于等于 pivot)可以被揭示 (revealed),而不会泄露原始元素的任何信息。这使得分区过程可以高效进行。
      • 递归处理:
        • 计算 SRS_R 的大小,记为 KK'
        • 情况 1: 如果 K=KK' = K,则 SRS_R 中的所有元素即为所需的 Top-K 元素,直接返回 SRS_R
        • 情况 2: 如果 K>KK' > K,这表示 Top-K 元素都在 SRS_R 中。递归地在 SRS_R 上调用 select 函数,以选择 KK 个元素: select(SR,K) \mathsf{select}(S_R, K)
        • 情况 3: 如果 K<KK' < K,这表示 SRS_R 中的所有元素都是 Top-K 元素的一部分,但还需要从 SLS_L 中选择剩余的 (KK)(K - K') 个元素。递归地在 SLS_L 上调用 select 函数,以选择 (KK)(K - K') 个元素,然后将这些元素与 SRS_R 合并: select(SL,KK)SR \mathsf{select}(S_L, K - K') \cup S_R

优势分析:

  • 计算效率: 传统的安全排序算法(如 Bitonic sorting network)需要 O(nlogn)O(n \log n) 次比较。而本文提出的 select 函数仅需要 O(n)O(n)CMP(Secure Comparison)操作,大大降低了计算开销。
  • 隐私保护: 通过预先的安全洗牌,比较结果的公开不会泄露原始数据信息。
  • 本地计算: 除了 CMP 操作需要 S 和 C 交互外,算法的其余步骤(如枢轴选择、分区、递归调用)都可以在本地完成,减少了通信开销。

4.4. 安全采样

本节详细介绍安全采样协议,用于从一个秘密共享的概率向量中采样一个元素。

问题定义:

  • 输入: KK 个秘密共享的概率 p1,,pK\langle p_1 \rangle, \dots, \langle p_K \rangle。这些概率已经通过乘以 2L2^L 并舍弃小数部分被缩放为整数 x1,,xK\langle x_1 \rangle, \dots, \langle x_K \rangle
  • 输出: 一个秘密共享的索引 j\langle j \rangle,其中 j[1,K]j \in [1, K]。采样概率为 Pr(j=i)=xi/k=1Kxk\mathrm{Pr}(j=i) = x_i / \sum_{k=1}^K x_k

方法直觉: 该协议基于以下观察:对于一个在 [0, 1] 之间均匀采样的随机数 pp',被选中的索引 jj 满足: k=1j1pkp<k=1jpk \sum_{k=1}^{j-1} p_k \le p' < \sum_{k=1}^{j} p_k 由于概率已被缩放为整数 xix_i,随机数 pp' 也需要相应地缩放为在 [0,2L1][0, 2^L - 1] 范围内采样的整数 vv

详细协议算法 (Algorithm 3: Secure Sampling):

  • 输入: S 和 C 持有 x\langle \mathbf{x} \rangle,其中 xZ2lK\mathbf{x} \in \mathbb{Z}_{2^l}^K 是一个由 2L2^L 缩放的概率向量。
  • 输出: S 和 C 得到 j\langle j \rangle,其中 j[1,K]j \in [1, K]Pr(j=i)=xi/k=1Kxk\mathrm{Pr}(j=i) = x_i / \sum_{k=1}^K x_k
  1. 服务器 S 采样随机数: 服务器 S (私下) 采样一个整数 vv[0,2L1][0, 2^L - 1] 范围,其中 vZ2lv \in \mathbb{Z}_{2^l}。 (强调 vv 只由 S 采样,但最终的输出 jj 对 S 保持未知,确保隐私)。

  2. 计算累积和并进行比较:

    • S 和 C (本地) 初始化累积和的秘密共享 s0:=0\langle s_0 \rangle := 0
    • 对于 i=1i = 1K-1
      • S 和 C (本地) 计算当前的累积和的秘密共享 si:=xi+si1\langle s_i \rangle := \langle x_i \rangle + \langle s_{i-1} \rangle
      • S 和 C 调用 FCMP 协议,将采样值 v\langle v \rangle 与累积和 si\langle s_i \rangle 进行安全比较: bi1FCMP(v,si) \langle b_i \rangle^1 \gets \mathsf{F_{CMP}}(\langle v \rangle, \langle s_i \rangle) 其中 bi=1b_i = 1 如果 vsiv \ge s_i,否则 bi=0b_i = 0
    • 经过这一步,将得到一个秘密共享的比特向量 b=(b1,,bK1)\langle \mathbf{b} \rangle = (\langle b_1 \rangle, \dots, \langle b_{K-1} \rangle)。如果被选中的索引是 jj,那么 bi=1b_i=1 对于所有 1i<j1 \le i < j,而 bi=0b_i=0 对于所有 jiK1j \le i \le K-1
  3. 构建指示向量: 目标是构建另一个秘密共享的比特向量 b=(b1,,bK)\langle \mathbf{b}' \rangle = (\langle b_1' \rangle, \dots, \langle b_K' \rangle),使得只有被选中的索引 jj 对应的比特 bjb_j'1,其他都为 0

    • S 和 C 初始化 b01:=1\langle b_0 \rangle^1 := 1bK1:=0\langle b_K \rangle^1 := 0
    • 对于 i=1i = 1KK
      • S 和 C (本地)计算: bi1:=bi11bi1 \langle b_i' \rangle^1 := \langle b_{i-1} \rangle^1 \oplus \langle b_i \rangle^1 (这里的 \oplus 是 XOR 运算)。
      • 通过这个运算,只有当 si1v<sis_{i-1} \le v < s_i 时,bib_i' 才会是 1
  4. 计算最终索引: S 和 C 调用 FMUX 协议,将索引 ii 与指示比特 bi1\langle b_i' \rangle^1 相乘(逻辑上是选择),然后求和: j:=i=1KFMUX(i,bi1) \langle j \rangle := \sum_{i=1}^K \mathsf{F_{MUX}}(i, \langle b_i' \rangle^1) 最终得到秘密共享的采样索引 j\langle j \rangle

隐私保证:

  • 尽管随机数 vv 是由服务器 S 单独采样的,但最终的输出索引 j\langle j \rangle 是秘密共享的,S 无法直接得知其值。这确保了采样的隐私性。
  • 该协议仅需要 K-1 次安全比较和 KK 次多路选择器操作,效率较高。

4.5. CipherGPT 框架整合

CipherGPT 框架将上述创新协议与 GPT 模型的标准组件(如嵌入层、层归一化、自注意力机制、前馈网络)相结合,实现完整的安全推理流程。下面详细介绍每个组件在 CipherGPT 中的实现方式:

4.5.1. 嵌入 (Embedding)

  • 功能: 将输入单词映射为数值向量(词嵌入),并加上位置编码。
  • 实现: 使用加性同态加密 (Additively Homomorphic Encryption, AHE) 实现。
    1. 服务器 S 操作: S 使用 AHE 加密词嵌入矩阵的所有行(每个词嵌入向量 wiZ2lm\mathbf{w}_i \in \mathbb{Z}_{2^l}^m 被编码为多项式系数,然后加密为 RLWE 密文 E(wi)E(\mathbf{w}_i)),并传输给客户端 C。此步骤只需执行一次。
    2. 客户端 C 操作: C 根据其输入单词,定位对应的密文,并向每个密文添加一个随机向量 ri\mathbf{r}_i,得到 E(w1+r1),,E(wn+rn)E(\mathbf{w}_1 + \mathbf{r}_1), \dots, E(\mathbf{w}_n + \mathbf{r}_n),然后返回给 S。
    3. 服务器 S 操作: S 解密收到的密文,得到 w1+r1,,wn+rn\mathbf{w}_1 + \mathbf{r}_1, \dots, \mathbf{w}_n + \mathbf{r}_n。S 接着添加预定义的位置嵌入向量 p1,,pn\mathbf{p}_1, \dots, \mathbf{p}_n,得到 w1+r1+p1,,wn+rn+pn\mathbf{w}_1 + \mathbf{r}_1 + \mathbf{p}_1, \dots, \mathbf{w}_n + \mathbf{r}_n + \mathbf{p}_n
    4. 秘密共享结果: 此时,每个嵌入向量都被秘密共享。客户端 C 持有 xiC=ri\langle \mathbf{x}_i \rangle_C = -\mathbf{r}_i,服务器 S 持有 xiS=wi+ri+pi\langle \mathbf{x}_i \rangle_S = \mathbf{w}_i + \mathbf{r}_i + \mathbf{p}_i

4.5.2. 层归一化 (Layer Normalization)

  • 功能: 对每个输入向量进行归一化处理。
  • 公式: 对于向量 xZ2lm\mathbf{x} \in \mathbb{Z}_{2^l}^m,其中元素 xix_i 归一化如下: xi:=xiE[x]Var[x]+ϵγ+β x_i := \frac{x_i - \mathrm{E}[\mathbf{x}]}{\sqrt{\mathrm{Var}[\mathbf{x}] + \epsilon}} \cdot \gamma + \beta 其中 E[x]=1nxi\mathrm{E}[\mathbf{x}] = \frac{1}{n}\sum x_i 是均值,Var[x]=1n1(xiE[x])2\mathrm{Var}[\mathbf{x}] = \frac{1}{n-1}\sum (x_i - \mathrm{E}[\mathbf{x}])^2 是方差,γ\gammaβ\beta 是可学习参数,ϵ\epsilon 是防止除以零的小值。
  • 实现:
    1. 计算方差项: 运行 FMult 协议计算每个方差项 (xiE[x])2(x_i - \mathrm{E}[\mathbf{x}])^2
    2. 计算倒数平方根: 运行 FLUT 协议计算 1Var[x]+ϵ\frac{1}{\sqrt{\mathrm{Var}[\mathbf{x}] + \epsilon}}
    3. 乘法操作: 运行 FMult 协议计算 xiE[x]Var[x]+ϵ\frac{x_i - \mathrm{E}[\mathbf{x}]}{\sqrt{\mathrm{Var}[\mathbf{x}] + \epsilon}}
    4. 乘可学习参数: 运行 FMult 协议计算 xiE[x]Var[x]+ϵγ\frac{x_i - \mathrm{E}[\mathbf{x}]}{\sqrt{\mathrm{Var}[\mathbf{x}] + \epsilon}} \cdot \gamma
    5. 截断: 运行 FTR 协议将比例因子(scale)降低到 LL 位,并将位宽截断到 ll 位。
  • 优化: 为了保证效率和精度,使用基于 BOLEFMult 进行乘法,且只在整个 LayerNorm 计算结束后执行一次 FTrunc 操作。

4.5.3. 掩码自注意力 (Masked Self-Attention)

  • 功能: 捕获输入序列中不同位置之间的关系,生成上下文相关的表示。

  • 查询、键、值矩阵 (Q, K, V):

    • 通过将输入 XZ2ln×m\mathbf{X} \in \mathbb{Z}_{2^l}^{n \times m} 与三个权重矩阵 WQ,WK,WVZ2lm×m\mathbf{W}_Q, \mathbf{W}_K, \mathbf{W}_V \in \mathbb{Z}_{2^l}^{m \times m} 相乘得到: Q:=XWQ \mathbf{Q} := \mathbf{X}\mathbf{W}_Q K:=XWK \mathbf{K} := \mathbf{X}\mathbf{W}_K V:=XWV \mathbf{V} := \mathbf{X}\mathbf{W}_V
    • 实现: 由于 WQ,WK,WV\mathbf{W}_Q, \mathbf{W}_K, \mathbf{W}_V 是预先已知的模型参数,这些矩阵乘法可以使用本文第 III 节中提出的 sVOLE 基矩阵乘法协议高效计算。计算后需要运行 FTrunc 协议以保持 LL 位的缩放。
  • 多头注意力 (Multi-headed Attention):

    • Q,K,V\langle \mathbf{Q} \rangle, \langle \mathbf{K} \rangle, \langle \mathbf{V} \rangle 矩阵分别划分为 MM 个段(头),每个头处理 m=m/Mm' = m/M 维度的子矩阵。
    • 计算分数矩阵: 对于每个头 i[M]i \in [M],计算分数矩阵 si:=qikiT\mathbf{s}_i := \mathbf{q}_i \mathbf{k}_i^T
    • 实现: 此时 qi\mathbf{q}_iki\mathbf{k}_i 是在自注意力计算过程中生成的秘密共享中间值,不是预先已知的权重。因此,不能使用 sVOLE 方法。转而采用 Iron [27] 中提出的基于 AHE 的矩阵乘法
  • 自注意力掩码 (Self-attention Masking):

    • 功能: 将每个分数矩阵 si\mathbf{s}_i 的上三角形部分置零,确保模型在生成当前词时只关注之前的词。
    • 实现: 这可以由 S 和 C 本地执行,无需任何交互。
  • Softmax:

    • 功能: 对每个 si\mathbf{s}_i 的每一行应用 softmax 操作,将分数归一化为正值且和为 1 的概率分布。
    • 实现: 借鉴 BumbleBee [30] 的方法:
      1. 归一化: 给定输入行 xZ2Ln\mathbf{x} \in \mathbb{Z}_{2^L}^n,首先通过 xi:=ximax(x)x_i' := x_i - \max(\mathbf{x}) 对每个 xix_i 进行归一化,得到一个负值向量。
      2. 区间处理: 仅考虑区间 [16,0][-16, 0]。使用 FCMP 协议将 xix_i'16×2L-16 \times 2^L 比较,如果 xi<16×2Lx_i' < -16 \times 2^L,则使用 FMUX 协议将 exie^{x_i'} 的结果设为 0
      3. 指数近似: 计算 exie^{x_i'} 基于近似公式 exi(1+xi2n)2ne^{x_i'} \approx (1 + \frac{x_i'}{2^n})^{2^n},通过 FMultFTrunc 实现。
  • 输出:

    • 功能: 使用 softmax 后的分数矩阵对值矩阵进行加权,然后拼接所有头的输出。
    • 计算: zi:=sivi, i[M] \mathbf{z}_i := \mathbf{s}_i \mathbf{v}_i, \forall \ i \in [M]
    • 实现: 同样采用 Iron [27] 中提出的基于 AHE 的矩阵乘法
    • 拼接与残差连接: 将所有 zi\mathbf{z}_i 拼接起来形成 Z:=z1zM\langle \mathbf{Z} \rangle := \langle \mathbf{z}_1 \rangle || \dots || \langle \mathbf{z}_M \rangle。最后,通过残差连接将输出与原始输入相加: X:=X+Z \langle \mathbf{X} \rangle := \langle \mathbf{X} \rangle + \langle \mathbf{Z} \rangle

4.5.4. 前馈网络 (Feed Forward)

  • 功能: 自注意力输出之后,应用 LayerNorm,然后通过一个包含两个全连接层(FC layers)和一个激活层的网络。
  • 第一个 FC 层:
    • 计算: X1:=XW1+B1 \mathbf{X}_1 := \mathbf{X}\mathbf{W}_1 + \mathbf{B}_1
    • 其中 XZ2ln×m\mathbf{X} \in \mathbb{Z}_{2^l}^{n \times m}, W1Z2lm×k\mathbf{W}_1 \in \mathbb{Z}_{2^l}^{m \times k}, B1Z2ln×k\mathbf{B}_1 \in \mathbb{Z}_{2^l}^{n \times k}
    • 实现: W1\mathbf{W}_1 是预先已知权重,因此应用本文第 III 节中提出的 sVOLE 基矩阵乘法
  • 激活层:
    • 计算:X1\mathbf{X}_1 应用 GELU 激活函数,得到 X1\mathbf{X}_1'
    • 实现: 应用本文第 IV 节中提出的安全 GELU 协议
  • 第二个 FC 层:
    • 计算: X2:=X1W2+B2 \mathbf{X}_2 := \mathbf{X}_1'\mathbf{W}_2 + \mathbf{B}_2
    • 其中 X1Z2ln×k\mathbf{X}_1' \in \mathbb{Z}_{2^l}^{n \times k}, W2Z2lk×m\mathbf{W}_2 \in \mathbb{Z}_{2^l}^{k \times m}, B2Z2ln×m\mathbf{B}_2 \in \mathbb{Z}_{2^l}^{n \times m}
    • 实现: W2\mathbf{W}_2 是预先已知权重,因此再次应用本文第 III 节中提出的 sVOLE 基矩阵乘法
  • 残差连接: 最终输出同样与之前的输入进行残差连接。

4.5.5. Vec2word

  • 功能: 将 Transformer 解码器的输出向量转换为预测的响应词。

  • 初始矩阵乘法:

    • 计算: y0:=xW \mathbf{y}_0 := \mathbf{x}\mathbf{W}
    • 其中 WZ2lm×k\mathbf{W} \in \mathbb{Z}_{2^l}^{m \times k}y0Z2lk\mathbf{y}_0 \in \mathbb{Z}_{2^l}^kxZ2lm\mathbf{x} \in \mathbb{Z}_{2^l}^m 是 Transformer 解码器输出的最后一行(通常是最后一个词的表示)。kk 代表词汇表大小(例如 GPT-2 中为 50257)。
    • 实现: 由于 kk 值非常大,sVOLE 基矩阵乘法不适用。采用 Iron [27] 中提出的基于 AHE 的矩阵乘法
  • Top-K 选择:

    • 功能:y0\mathbf{y}_0 中选择 KK 个最大的值,以平衡多样性和准确性。
    • 计算: y1ΠTopK(y0) \langle \mathbf{y}_1 \rangle \gets \Pi_{\mathsf{TopK}}(\langle \mathbf{y}_0 \rangle) ,其中 y1Z2lK\mathbf{y}_1 \in \mathbb{Z}_{2^l}^K
    • 实现: 采用本文第 V 节中提出的安全 TopK 协议
  • 温度缩放 (Temperature):

    • 功能: 调整生成文本的创造性和多样性。温度 TT 是服务器 S 持有的超参数。
    • 实现: 使用 AHE 实现。
      1. C 将其 AHE 加密的份额 E(y1,1C),,E(y1,KC)E(\langle y_{1,1} \rangle_C), \dots, E(\langle y_{1,K} \rangle_C) 发送给 S。
      2. S 将其份额添加到密文中:E(y1,1C+y1,1S),E(\langle y_{1,1} \rangle_C + \langle y_{1,1} \rangle_S), \dots
      3. S 将所有密文乘以温度 TTE(Ty1,1),E(T \cdot y_{1,1}), \dots
      4. S 向每个密文添加一个随机数 rir_iE(Ty1,1+r1),E(T \cdot y_{1,1} + r_1), \dots
      5. S 将结果密文返回给 C。
      6. C 解密密文,现在温度缩放后的值 y2\mathbf{y}_2 以秘密共享形式存在:y2,iC:=Ty1,i+ri\langle y_{2,i} \rangle_C := T \cdot y_{1,i} + r_iy2,iS:=ri\langle y_{2,i} \rangle_S := -r_i
  • 随机采样 (Random Sampling):

    • 功能:y2\mathbf{y}_2 应用 softmax 操作得到概率向量 y3\mathbf{y}_3,然后根据该概率向量随机采样一个响应词。
    • Softmax: 使用本文第 VII-C 节中描述的 softmax 协议
    • 采样: 采用本文第 VI 节中提出的安全采样协议,得到索引 jΠSample(y3)\langle j \rangle \gets \Pi_{\mathsf{Sample}}(\mathbf{y}_3)
    • 揭示索引与隐私保护: 原始 TopKShuffle 过程中涉及的索引映射需要特别处理。为了在向 C 揭示最终单词索引时不泄露其他隐私信息:
      1. S 首先计算 i:=πS1(ti)i' := \pi_S^{-1}(t_i) 并秘密共享 ii',其中 tit_iTopK 过程中第 ii 个被选中的元素在洗牌后的向量中的原始索引,而 πS1\pi_S^{-1} 是 S 自己选择的逆置换。
      2. 然后,将 Algorithm 3 中计算最终索引的步骤替换为: j:=i=1KFMUX(i,bi1) \langle j \rangle := \sum_{i=1}^K \mathsf{F_{MUX}}(\langle i' \rangle, \langle b_i' \rangle^1)
      3. 现在,向 C 揭示 jj 不会泄露任何关于输入的信息,因为随机数 vv 是由 S 采样的,且 πS1\pi_S^{-1} 对 C 是未知的。
      4. C 收到 jj 后,计算 j:=πC1(j)j' := \pi_C^{-1}(j),这将是词向量中正确的索引,从而检索最终的响应词。

5. 实验设置

本节详细介绍 CipherGPT 的实验设置,包括实现细节、优化、实验环境、基准模型和评估指标。

5.1. 数据集

  • GPT-2 模型: 实验基准模型为 Radford 提出的 GPT-2 模型 [42],该模型包含 1.17 亿参数,12 个 Transformer 解码器,以及 768 的嵌入大小(embedding size)。
  • 文本数据集: 为了评估 CipherGPT 的准确性损失,随机选择了来自 WikiText-103 数据集 [36] 的 10,000 个句子。
    • WikiText-103 特点: 这是一个大型的维基百科文章集合,包含超过 1 亿个单词,常用于语言建模任务,以评估模型在真实世界文本上的性能。

5.2. 评估指标

论文中使用了以下评估指标:

  1. 运行时 (Runtime):

    • 概念定义: 指完成特定计算任务(如 GELU、矩阵乘法或整个 GPT 推理)所需的时间,通常以毫秒(ms)或秒(s)为单位。它量化了协议的计算效率。
    • 数学公式: 无标准化公式,通常通过计时器测量。
    • 符号解释:
      • Runtime: 运行时间。
      • ss: 秒。
      • ms: 毫秒。
  2. 通信量 (Communication):

    • 概念定义: 指协议执行过程中,各方之间交换的数据总量,通常以兆字节(MB)或千兆字节(GB)为单位。它量化了协议的网络开销。
    • 数学公式: 无标准化公式,通常通过网络流量监控或协议设计中传输的数据量进行计算。
    • 符号解释:
      • Comm.: 通信量。
      • MB: 兆字节。
      • GB: 千兆字节。
  3. 最大 ULP 误差 (Maximal ULP Error):

    • 概念定义: ULP (Units in the Last Place) 误差衡量了近似结果与精确真实结果之间以“可表示数字单位”计算的差异。对于将浮点数缩放为整数的情况,ULP 错误精确等于 yy~|y - \tilde{y}|,即近似结果与精确结果之间的绝对差值。此指标关注在所有测试点中,近似误差的最大值,反映了算法在最坏情况下的精度表现。
    • 数学公式: 当浮点数缩放为整数时,最大 ULP 误差为: maxkyky~k\max_{k} |y_k - \tilde{y}_k|
    • 符号解释:
      • yky_k: 第 kk 个测试样本的精确真实结果。
      • y~k\tilde{y}_k: 第 kk 个测试样本的近似结果。
      • maxk\max_k: 对所有测试样本取最大值。
  4. 平均 ULP 误差 (Average ULP Error):

    • 概念定义: 平均 ULP 误差是对所有测试样本的 ULP 错误进行求和,然后除以样本总数得到的值。它提供了算法在整个测试集上的平均精度表现。
    • 数学公式: 平均 ULP 误差为: 1Nk=1Nyky~k \frac{1}{N} \sum_{k=1}^N |y_k - \tilde{y}_k|
    • 符号解释:
      • NN: 测试样本的总数。
      • yky_k: 第 kk 个测试样本的精确真实结果。
      • y~k\tilde{y}_k: 第 kk 个测试样本的近似结果。
      • yky~k|y_k - \tilde{y}_k|: 第 kk 个测试样本的 ULP 误差。
  5. 准确性 (Accuracy) - 针对 GPT 输出:

    • 概念定义: 衡量 CipherGPT 生成的文本与原始 GPT-original 模型(使用浮点数,无截断或近似)生成的文本的匹配程度。
    • 指标 1: 相同输出百分比: CipherGPT 生成的输出与 GPT-original 完全相同的比例。
    • 指标 2: Top-5 输出: 对于 CipherGPTGPT-original 输出不同的情况,评估 CipherGPT 的“错误”输出是否仍在 GPT-original 预测的 Top-5 词汇范围内。
    • 数学公式:
      • 相同输出百分比:Number of identical outputsTotal number of outputs×100%\frac{\text{Number of identical outputs}}{\text{Total number of outputs}} \times 100\%
      • Top-5 匹配:Number of differing outputs within Top-5 of GPT-originalTotal number of differing outputs×100%\frac{\text{Number of differing outputs within Top-5 of GPT-original}}{\text{Total number of differing outputs}} \times 100\%
    • 符号解释:
      • GPT-original: 原始 GPT 模型。
      • Top-5: 概率最高的 5 个预测词。

5.3. 对比基线

论文将 CipherGPT 的各个组件和整体性能与以下基线模型进行了比较:

  • GELU 协议对比:

    • Iron [27]: 基于 LUT 的激活函数近似方法。
    • Bolt [40]: 使用高阶多项式近似 GELU,并结合 SIMD 槽的同态加密。
    • Bolt+Bolt+ [40], [30]: 在 Bolt 的基础上,用更高效的 BOLE 替换了其基于 OT 的乘法,以进行公平比较。
    • BumbleBee [30]: 同样使用高阶多项式近似 GELU,并优化了通信。
  • 矩阵乘法 (MatrixMul) 协议对比:

    • Cheetah [29]: 使用系数打包的 AHE 基矩阵乘法。
    • Iron [27]: 进一步优化了 Cheetah 的通信。
    • BumbleBee [30]: 结合密文压缩技术。
    • Bolt [40]: 使用 SIMD 槽和 baby-step giant-step 策略减少旋转,并进行素数域到 2l2^l 环的转换。
  • Top-K 选择协议对比:

    • Bitonic sorting network [28]: 这是一个常用的数据无关排序网络,可以用于安全排序,进而选择 Top-K 元素。
  • CipherGPT 整体准确性对比:

    • GPT-original: 原始的 GPT 模型,使用浮点数且不进行任何截断或近似,作为真实准确性的黄金标准。

5.4. 实施细节与优化

  • 编程语言与安全参数: CipherGPT 使用 C++C++ 完全实现,安全参数设置为 128 位。

  • 同态加密库: 采用 Microsoft SEAL (版本 4.0) 作为 AHE 库,使用 Brakerski-Fan-Vercauteren (BFV) [11], [19] 方案。N=4096N = 4096,并使用 SEAL 默认参数以确保 128 位安全。

  • 加速: 使用 hexl 加速 AVX-512 指令集下的 HE 操作。

  • 电路隐私: 对返回的密文执行噪声泛洪 (noise flooding) [45], [30] 以确保电路隐私。

  • 密码学原语实现:

    • 均匀位宽乘法: 使用 BumbleBee [30] 中开源的 BOLE(Batch Oblivious Linear Evaluation)代码。
    • 非均匀位宽乘法: 使用 SIRNN [43] 中开源代码。
    • 安全 GELU:SIRNN 的基础上进行实现,将 IKNP-OT [32] 替换为 Ferret OT [57],并将基于 OT 的乘法替换为基于 FHEBOLE [30]。
    • sVOLE 基矩阵乘法: 实现了基于 AHEreverse-VOLE,并结合了 Halftree [26], [25] 优化 PPRF(Puncturable Pseudorandom Functions)。此外,还整合了 [56], [6] 中的优化,并遵循了 [33] 中的建议来抵御已知攻击。
    • TopK: 自行实现了 Chase et al. [14] 提出的秘密共享洗牌协议。
    • Bolt [40] (对比基线): 由于 Bolt 的代码未开源,作者根据论文描述,使用 SIRNNFerret OT 重新实现,并遵循其论文中给出的参数。
  • HE 优化(传输密文):

    1. 对称版 FHE: 利用 FHE 的对称版本,新加密的密文包含两个多项式,其中一个可由种子表示,从而节省一半通信量
    2. 返回前模数切换 (Modulus Switch): FHE 密文的模数 qq 可以切换到更小的 qq',而不会影响解密结果。这通过模数缩减技术 [13] 实现,无需秘密密钥,可将密文压缩因子为 logqlogq\frac{\log q}{\log q'}
  • 实验环境:

    • 网络:局域网(LAN)设置,带宽 3000 Mbps,往返延迟(RTT)0.8 ms。
    • 硬件:AWS c5.9xlarge 实例,配备 Intel Xeon 8000 系列 CPU (3.6 GHz)。
    • 并发:所有实验均使用单线程执行。
    • 结果:所有结果均为 5 次运行的平均值,方差非常小。
  • 数值表示:

    • 浮点数通过左移 L=12L=12 位并舍弃小数部分来转换为整数。
    • 推理过程中,使用 FTrunc 协议确保最大值小于 2l12^l - 1,其中 l=37l=37 位。

6. 实验结果与分析

本节详细分析 CipherGPT 各组件及整体框架的实验结果。

6.1. GELU 评估

  • 设置: 评估 GELU 协议(Algorithm 1),将参数 α=3.25\alpha = 3.25s=6s = 6。由于 L=12L=12,实际近似区间为 [3.25×212,3.25×212][-3.25 \times 2^{12}, 3.25 \times 2^{12}]。该区间被划分为 26=642^6 = 64 个等长的小区间,每个区间长度为 416,并用线性函数近似。

  • 结果(Table IV): 以下是原文 Table IV: Evaluation of GELU (we use a 64-piece spline to approximate the curve within [3.25×212,3.25×212][-3.25 \times 2^{12}, 3.25 \times 2^{12}]) 的结果:

    GELU(Z237220\mathbb{Z}_{2^{37}}^{2^{20}}) Runtime(s) Comm.(MB) Maximal ULP Err. Average ULP Err.
    Iron[27] 694 12 225 9 1.93
    Bolt[40] 55.61 1 962.23 37 4.55
    Bolt+[40], [30] 52.22 559.28 37 4.55
    BumbleBee[30] 73.52 641.02 73 10.82
    Ours 30.56 (\downarrow1.8×) 764.96 (\downarrow2.5×) 5 (\downarrow7.4×) 1.06 (\downarrow4.3×)
    • 运行时: 对于一个长度为 2202^{20} 的向量,CipherGPTGELU 协议耗时 30.56s。相比 Bolt,实现了 1.8倍的加速;相比 Bolt+Bolt+(使用 BOLE 优化乘法),仍实现了 1.7倍的加速。
    • 通信量: 通信带宽为 764.96MB。相比 Bolt,通信量减少了 2.5倍。
    • 精度:
      • 最大 ULP 误差为 5,比 Bolt 提高了 7.4倍(37/5 ≈ 7.4)。
      • 平均 ULP 误差为 1.06,比 Bolt 提高了 4.3倍(4.55/1.06 ≈ 4.29)。
  • 分析: CipherGPTGELU 计算上取得了显著的性能和精度提升。这主要归因于:

    1. 单步样条近似: 避免了 IronSIRNN 等多步近似(如指数和倒数)中误差累积的问题。
    2. 线性函数近似: 相比 BoltBumbleBee 使用高阶多项式,我们的线性函数近似在计算高次幂时更稳定,减少了精度损失。
    3. 密码学原语优化: 我们的方案使用更少的密码学原语(如乘法和比较),进一步降低了计算开销。

6.2. 矩阵乘法评估

  • 设置: 评估 sVOLE 基矩阵乘法协议。考虑到 GPT 自回归生成 tt 个响应词的场景,批处理 tt 次矩阵乘法 XZ237256×768\mathbf{X} \in \mathbb{Z}_{2^{37}}^{256 \times 768}YZ237768×768\mathbf{Y} \in \mathbb{Z}_{2^{37}}^{768 \times 768}L=12L=12

  • 结果(Figure 3):

    Fig. 3: Evaluation of MatrixMul (we compute Z2276 \(\\mathbb { Z } _ { 2 ^ { 3 7 } } ^ { 7 6 8 \\times 7 6 8 }\) cost). 该图像是图表,展示了 amortized runtime 与迭代次数的关系(a)和 amortized communication 与迭代次数的关系(b)。在(a)中,sVOLE 的运行时间随着迭代次数的增加而显著降低。在(b)中,sVOLE 的通信量也呈下降趋势,显示出其在安全推理中的效率表现。 Figure 3 (a) 展示了分摊运行时随迭代次数的变化,Figure 3 (b) 展示了分摊通信量随迭代次数的变化。

    • t=256t=256 时(一个合理数量的生成词):
      • 分摊运行时: CipherGPT 协议的运行时为 1462ms,比 Iron 快 2.3倍,比 Bolt 快 6.4倍,比 BumbleBee 快 5.8倍。
      • 分摊通信量: CipherGPT 协议的通信量为 8.2MB,比 Iron 减少 3.7倍,比 Bolt 减少 3.0倍,比 BumbleBee 减少 1.4倍。
    • t=1024t=1024 时(常见的生成词数量): 性能优势更加显著。CipherGPT 协议在运行时上比 Iron 提升 2.5倍,通信量减少 11.2倍;运行时上比 Bolt 提升 6.9倍,通信量减少 8.9倍;运行时上比 BumbleBee 提升 6.2倍,通信量减少 4.1倍。
  • 分析: CipherGPTsVOLE 基矩阵乘法协议在批处理场景下展现出巨大优势。由于 sVOLE 的通信复杂度几乎与 nn 无关,通过将多个独立的 MatrixMul 合并为一个非平衡矩阵乘法,极大地分摊了预处理和在线阶段的成本。这种定制化设计充分利用了 GPT 自回归推理的特性,显著优于通用 HE 基方法。

6.3. TopK 评估

  • 设置: 评估 TopK 协议(Algorithm 2),从一个长度为 50257Z237\mathbb{Z}_{2^{37}} 向量中选择 100 个元素。
  • 结果: 耗时 3281ms,带宽 136.1MB。
  • 对比: 相比常用的 Bitonic sorting network [28],CipherGPT 实现了 8.8倍的运行时加速和 14.8倍的通信量减少。
  • 分析: 传统的安全排序网络开销巨大。CipherGPTTopK 协议通过结合安全洗牌和优化的比较基选择(仅需 O(N)O(N) 次比较),显著提升了效率,使得在大型词汇表场景下选择 Top-K 元素成为可能。

6.4. CipherGPT 整体评估

  • 设置: 运行 CipherGPT 框架,生成一个包含 256 个响应词的句子。

  • 结果(Table V): 以下是原文 Table V: The generation of 256 response words; the input is a vector of 256 words. 的结果:

    Layer Operation Output\leftarrowInput Method Times Runtime (ms) Comm. (MB)
    Total % Total %
    Embedding Embedding Z237256×768Z212166\mathbb{Z}_{2^{37}}^{256 \times 768} \leftarrow \mathbb{Z}_{2^{12}}^{166}, L = 12 §VII-A 1 46 < 0.01% 2.20 < 0.01%
    LayerNorm LayerNorm Z237256×768Z237256×768\mathbb{Z}_{2^{37}}^{256 \times 768} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 768}, L = 12 §VII-B 12 4756 ×\times 12 4.83% 65 ×\times 12 5.17%
    Self-attention MatrixMul (Z237256×768Z237256×768×Z237768×768\mathbb{Z}_{2^{37}}^{256 \times 768} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 768} \times \mathbb{Z}_{2^{37}}^{768 \times 768}) ×\times 3, L = 24 §III 12 4358 ×\times 12 4.43% 21.79 ×\times 12 1.73%
    Trunc (Z237256×768Z237256×768\mathbb{Z}_{2^{37}}^{256 \times 768} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 768}) ×\times 3, L = 12 [43] 12 3117 ×\times 12 3.17% 24.75 ×\times 12 1.97%
    Multi-head (Z237256×64\mathbb{Z}_{2^{37}}^{256 \times 64}) ×\times 12 \leftarrow (Z237256×768\mathbb{Z}_{2^{37}}^{256 \times 768}) ×\times 3, L = 12 plain 12 (< 1) ×\times 12 \approx 0% 0 0%
    MatrixMul (Z237256×256Z237256×64×Z23764×256\mathbb{Z}_{2^{37}}^{256 \times 256} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 64} \times \mathbb{Z}_{2^{37}}^{64 \times 256}) ×\times 12, L = 24 [30] 12 7614 ×\times 12 7.74% 29.77 ×\times 12 2.37%
    Trunc (Z237256×256Z237256×256\mathbb{Z}_{2^{37}}^{256 \times 256} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 256}) ×\times 12, L = 12 [43] 12 3262 ×\times 12 3.31% 30.61 ×\times 12 2.43%
    Masking (Z237256×256Z237256×256\mathbb{Z}_{2^{37}}^{256 \times 256} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 256}) ×\times 12, L = 12 plain 12 (< 1) ×\times 12 \approx 0% 0 0%
    Softmax (Z237256×256Z237256×256\mathbb{Z}_{2^{37}}^{256 \times 256} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 256}) ×\times 12, L = 12, (by row) §VII-C 12 14865 ×\times 12 15.10% 277.59 ×\times 12 22.06%
    MatrixMul (Z237256×64Z237256×256×Z237256×64\mathbb{Z}_{2^{37}}^{256 \times 64} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 256} \times \mathbb{Z}_{2^{37}}^{256 \times 64}) ×\times 12, L = 24 [30] 12 7570 ×\times 12 7.69% 10.62 ×\times 12 0.84%
    Trunc (Z237256×64Z237256×64\mathbb{Z}_{2^{37}}^{256 \times 64} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 64}) ×\times 12, L = 12 [43] 12 2910 ×\times 12 2.96% 13.03 ×\times 12 1.04%
    Reassemble Z237256×768\mathbb{Z}_{2^{37}}^{256 \times 768} \leftarrow (Z237256×64\mathbb{Z}_{2^{37}}^{256 \times 64}) ×\times 12, L = 12 plain 12 (< 1) ×\times 12 \approx 0% 0 0%
    MatrixMul Z237256×768Z237256×768×Z237768×768\mathbb{Z}_{2^{37}}^{256 \times 768} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 768} \times \mathbb{Z}_{2^{37}}^{768 \times 768}, L = 24 §III 12 1463 ×\times 12 1.49% 8.20 ×\times 12 0.65%
    Trunc Z237256×768Z237256×768\mathbb{Z}_{2^{37}}^{256 \times 768} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 768}, L = 12 [43] 12 2910 ×\times 12 2.96 % 13.03 ×\times 12 1.04%
    Matrix Add Z237256×768Z237256×768+Z237256×768\mathbb{Z}_{2^{37}}^{256 \times 768} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 768} + \mathbb{Z}_{2^{37}}^{256 \times 768}, L = 12 plain 12 (< 1) ×\times 12 \approx 0% 0 0%
    LayerNorm LayerNorm Z237256×768Z237256×768\mathbb{Z}_{2^{37}}^{256 \times 768} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 768}, L = 12 §VII-B 12 4756 ×\times 12 4.83% 65 ×\times 12 5.17%
    Feed-forward MatrixMul Z237256×3072Z237256×768×Z237768×3072\mathbb{Z}_{2^{37}}^{256 \times 3072} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 768} \times \mathbb{Z}_{2^{37}}^{768 \times 3072}, L = 24 §III 12 5997 ×\times 12 6.09% 28.5 ×\times 12 2.27%
    Trunc Z237256×3072Z237256×3072\mathbb{Z}_{2^{37}}^{256 \times 3072} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 3072}, L = 12 [43] 12 3204 ×\times 12 3.26% 30.61 ×\times 12 2.43%
    GELU Z237256×3072Z237256×3072\mathbb{Z}_{2^{37}}^{256 \times 3072} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 3072}, L = 12 §IV 12 20657 ×\times 12 20.99% 575.91 ×\times 12 45.78%
    MatrixMul Z237256×768Z237256×3072×Z2373072×768\mathbb{Z}_{2^{37}}^{256 \times 768} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 3072} \times \mathbb{Z}_{2^{37}}^{3072 \times 768}, L = 24 §III 12 5841 ×\times 12 5.94% 32.42 ×\times 12 2.58%
    Trunc Z237256×768Z237256×768\mathbb{Z}_{2^{37}}^{256 \times 768} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 768}, L = 12 [43] 12 2910 ×\times 12 2.96% 13.03 ×\times 12 1.04%
    Matrix Add Z237256×768Z237256×768+Z237256×768\mathbb{Z}_{2^{37}}^{256 \times 768} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 768} + \mathbb{Z}_{2^{37}}^{256 \times 768}, L = 12 plain 12 (< 1) ×\times 12 \approx 0% 0 0%
    LayerNorm LayerNorm Z237256×768Z237256×768\mathbb{Z}_{2^{37}}^{256 \times 768} \leftarrow \mathbb{Z}_{2^{37}}^{256 \times 768}, L = 12 §VII-B 1 4756 0.40% 65 0.43%
    Vec2Word MatrixMul Z23750257Z237768×Z237768×50257\mathbb{Z}_{2^{37}}^{50257} \leftarrow \mathbb{Z}_{2^{37}}^{768} \times \mathbb{Z}_{2^{37}}^{768 \times 50257}, L = 24 [30] 1 12000 1.02% 5.5 0.04%
    Trunc Z23750257Z23750257\mathbb{Z}_{2^{37}}^{50257} \leftarrow \mathbb{Z}_{2^{37}}^{50257}, L = 12 [43] 1 2834 0.24% 8.67 0.06%
    Shuffle Z23750257Z23750257\mathbb{Z}_{2^{37}}^{50257} \leftarrow \mathbb{Z}_{2^{37}}^{50257}, L = 12 [14] 1 4004 0.34% 51.3 0.34%
    TopK Z237100Z23750257\mathbb{Z}_{2^{37}}^{100} \leftarrow \mathbb{Z}_{2^{37}}^{50257}, L = 12 §V 1 1277 0.11% 84.8 0.56%
    Vec2Word Temperature Z237100Z237100\mathbb{Z}_{2^{37}}^{100} \leftarrow \mathbb{Z}_{2^{37}}^{100}, L = 24 §VII-E 1 6 < 0.01% 0.084 < 0.01%
    Trunc Z237100Z237100\mathbb{Z}_{2^{37}}^{100} \leftarrow \mathbb{Z}_{2^{37}}^{100}, L = 12 [43] 1 18 < 0.01% 0.11 < 0.01%
    Softmax Z237100Z237100\mathbb{Z}_{2^{37}}^{100} \leftarrow \mathbb{Z}_{2^{37}}^{100}, L = 12 §VII-C 1 1705 0.14% 0.71 < 0.01%
    Sampling Z2371Z237100\mathbb{Z}_{2^{37}}^{1} \leftarrow \mathbb{Z}_{2^{37}}^{100}, L = 12 §VI 1 7.843 < 0.01% 0.11 < 0.01%
    Total 1 180 933 15 096.82
    • 总体性能:
      • 生成一个词元(token)的延迟(Latency):1,180,933 ms \approx 20 分钟。
      • 生成一个词元的带宽(Bandwidth):15,096.82 MB \approx 15 GB。
    • 运行时(Runtime)贡献比例:
      • MatrixMul 占 34.39%
      • GELU 占 21%
      • Trunc 占 18.85%
      • Softmax 占 15.1%
      • LayerNorm 占 10.07%
    • 通信量(Communication)贡献比例:
      • GELU 占 45.78%
      • Softmax 占 22.06%
      • LayerNorm 占 10.76%
      • MatrixMul 占 10.49%
      • Trunc 占 10%
  • 准确性损失:

    • WikiText-103 数据集上随机选择 10,000 个句子进行测试。
    • CipherGPT 生成的输出与 GPT-original 模型的输出有 99.22% 是相同的。
    • 对于那些不同的输出(10,000 个句子中有 78 个),每个“错误”的输出仍然落在 GPT-original 模型预测的 Top-5 结果中。
  • 分析:

    • 成本高昂: 尽管单个组件有所优化,但整体 CipherGPT 推理的延迟和通信量仍非常高,20 分钟生成一个词元在当前看来确实不切实际。
    • 瓶颈识别: GELUMatrixMulSoftmaxTrunc 是主要的性能瓶颈,无论是在运行时还是通信量上都占据了大部分开销。特别是 GELU 在通信量中占比最高,达到了 45.78%。
    • 高精度: CipherGPT 在保持高精度的同时实现了隐私保护,仅有极低的输出差异,且差异都在合理范围内。这表明其近似和截断策略对模型效用影响很小。
    • 参考价值: 详细的组件级基准测试为未来改进安全 GPT 推理提供了清晰的优化方向,研究人员可以根据这些比例优先优化贡献最大的操作。

6.5. 讨论与局限

  • 当前不可行性: 论文坦承,当前 CipherGPT 的成本(20分钟延迟,15GB带宽/词元)在实际应用中是不可行的。
  • 未来前景: 随着计算能力、网络技术的发展以及新应用场景的出现,未来有望实现实用化的安全 GPT 推理。
  • 并行计算: 当前单线程实现有很大的并行加速空间(GPU、FPGA、存内计算、存算一体)。
  • 网络带宽: 100 千兆以太网等技术有望解决带宽瓶颈。
  • 非实时场景: 尽管实时响应性是挑战,但在某些非实时关键的场景(如模型评估、敏感数据分析)中,长延迟是可以接受的,此时隐私保护的价值更高。

7. 总结与思考

7.1. 结论总结

本文提出了 CipherGPT,这是首个用于安全两方 GPT 推理的框架,旨在解决 ChatGPT 等大型语言模型在应用中面临的用户隐私泄露问题。为了克服现有安全推理方案在处理 GPT 庞大模型参数和复杂激活函数时的挑战,CipherGPT 引入了一系列创新协议。具体而言:

  • 通过定制化的 sVOLE 基矩阵乘法,显著降低了 GPT 自回归推理中重复权重矩阵的计算开销,实现了显著的加速和带宽减少。
  • 开发了一种新颖的样条基 GELU 协议,在运行时、通信和精度方面均超越了现有最先进的方法。
  • 首次提出了安全 Top-K 采样协议,在保护隐私的同时,支持了 GPT 生成文本的多样性。
  • 提供了全面的实现和细粒度的基准测试,详细量化了每个操作的运行时和通信成本,为未来研究提供了宝贵的参考点。
  • 尽管整体性能在当前尚不实用,但 CipherGPT 在保持高模型准确性(99.22% 的输出与原始模型一致)的同时,验证了安全 GPT 推理的可行性。

7.2. 局限性与未来工作

  • 当前性能瓶颈: CipherGPT 在生成单个词元时需要约 20 分钟的延迟和 15 GB 的通信量,这在当前看来是“不切实际”的。作者认为,现有密码学工具实现实用化仍具挑战。
  • 未来技术进步的依赖: 实用化的实现有赖于计算和网络技术的持续进步,以及新应用场景的出现。
  • 并行计算潜力: 当前实现是单线程的,未来可以通过 GPUFPGA 加速、存内计算(in-memory computing)和存算一体(in-storage computing)等并行计算技术来显著提升速度。
  • 网络带宽提升: 100 千兆以太网(100 Gigabit Ethernet)等高速网络标准的普及将有效缓解带宽压力。
  • 实时性挑战: 安全 GPT 推理引入的显著延迟是其在需要实时响应的场景中部署的挑战。
  • 非实时应用场景: 作者指出,在一些非实时但对数据保密性要求高的场景(例如,机构评估 LLM 性能以保护提示和模型隐私),长延迟是可接受的。

7.3. 个人启发与批判

  • 个人启发:

    1. 任务特定优化是关键: 这篇论文最重要的启发在于,对于复杂模型(如 GPT),通用的安全多方计算(MPC)或同态加密(HE)方案往往效率低下。深入分析模型的计算图和特定行为(如 GPT 的自回归性),并设计定制化的密码学协议,是实现效率突破的关键。sVOLE 基矩阵乘法利用了权重重用的特性,是一个非常优雅的优化。
    2. 精度与效率的平衡: GELU 的样条基近似方案展示了在确保高精度的同时提升效率的可能性。这对于许多机器学习模型而言至关重要,因为过于激进的近似会导致模型效用(utility)的显著下降。
    3. 细粒度基准测试的价值: 论文提供的详细分层基准测试(各个操作的运行时、通信量及其占比)对于领域内的研究者而言是极其宝贵的资源。它清晰地指明了未来的优化方向和主要瓶颈所在,避免了盲目优化。
    4. 填补空白: 首次提出安全 Top-K 采样协议,解决了生成式 LLM 在安全推理中的一个独特且关键的需求,即在保护隐私的同时保持生成内容的多样性。
  • 批判与潜在改进:

    1. 可扩展性挑战: GPT-2 仅有 1.17 亿参数。对于参数量更大的 GPT-3 (1750亿) 或 GPT-4,当前框架的“不切实际”的成本可能会以更快的速度增长。论文没有探讨框架在大规模 LLM 上的可扩展性分析或理论预测。

    2. 交互轮次: 论文详细分析了通信量和运行时,但在 MPC 协议中,交互轮次(rounds of interaction)也是一个关键性能指标,尤其是在高延迟网络环境下。如果某些核心协议的交互轮次较多,即使单轮通信量不大,总延迟也可能很高。论文对此提及较少。

    3. 密钥管理与设置开销: 论文未详细讨论 AHEsVOLE 的密钥生成、分发和管理开销,这些在实际部署中也可能带来不小的挑战。

    4. 理论分析与证明: 尽管描述了协议,但论文没有提供详细的安全性证明(例如,在半诚实模型下的可组合安全性),也没有对协议的理论复杂性进行更深入的分析,例如与下界进行比较。

    5. 误差分析的更深层含义: ULP 误差和 Top-5 准确率是很好的指标,但对于生成式任务,除了字面匹配,生成文本的“质量”和“流畅性”等更主观的指标也是评估模型效用的重要方面。这些在当前框架下难以量化,但可能是未来安全生成式 AI 领域需要探索的方向。

    6. 通用性与灵活性: 尽管 CipherGPT 针对 GPT 进行了优化,但对于其他 Transformer 变体或不同架构的 LLM,这些定制化协议的通用性或需要多大程度的修改仍需进一步探讨。

      总的来说,CipherGPT 是安全 GPT 推理领域的一个里程碑式工作,它清晰地展示了为特定 AI 模型进行密码学协议定制的巨大潜力,同时也明确了当前技术距离大规模实用化仍存在的巨大鸿沟和未来研究的广阔空间。

相似论文推荐

基于向量语义检索推荐的相关论文。

暂时没有找到相似论文。