1. 论文基本信息

1.1. 标题

SecureGPT: 一种用于 GPT 中多方隐私保护 Transformer 推理的框架 (SecureGPT: A Framework for Multi-Party Privacy-Preserving Transformer Inference in GPT)

1.2. 作者

• Chenkai Zeng (曾晨凯)
• Debiao He (何德彪), Member, IEE
• Qi Feng (冯琪)
• Xiaolin Yang (杨晓琳)
• Qingcai Luo (罗清财)

机构:

• 曾晨凯、何德彪、冯琪隶属于武汉大学网络空间安全学院、教育部空天信息安全与可信计算重点实验室。
• 何德彪也隶属于齐鲁工业大学（山东省科学院）教育部计算力网络与信息安全重点实验室。
• 冯琪也隶属于国家信息安全重点实验室。
• 杨晓琳隶属于浪潮云信息技术有限公司。
• 罗清财隶属于浪潮科学技术研究院。

1.3. 发表期刊/会议

论文在正文部分（第一页脚注）明确指出：

• Received 12 May 2024; revised 14 August 2024; accepted 8 September 2024. Date of publication 16 September 2024; date of current version 14 October 2024.
• Associate editor coordinating the review of this article and approving it for publication was Prof. Chia-Mu Yu. (Corresponding authors: Debiao He; Qi Feng.) 这些信息表明该论文已通过同行评审并正式发表，尽管未直接给出期刊名称，但从作者所属机构和引用文献的格式来看，很可能发表于 IEEE 旗下的期刊，如 IEEE Transactions on Information Forensics and Security 等。

1.4. 发表年份

2024年。

1.5. 摘要

随着生成式预训练 Transformer (GPT) 模型在自然语言处理 (NLP) 领域越来越普及，并被广泛应用于云推理服务，用户数据隐私和安全性成为了一个重要挑战。为了解决这一问题，本文提出了 SecureGPT，一个针对 GPT 中多方隐私保护 Transformer 推理的框架。该框架设计了一系列基础构建模块，包括 M2A (乘法共享到加法共享的转换)、截断 (truncation)、除法 (division)、softmax 和 GELU 协议。具体而言，SecureGPT 借鉴了 SecureNLP 的工作，并进一步探索了用于 GELU 和 softmax 等非线性函数的 M2A 协议。作者还为 GPT 的 Transformer 子层设计了多方私有协议。在半诚实对手模型下，通过证明框架的安全性（支持除一人之外的所有方腐化），并评估了不同参与方设置下的运行时间。结果显示，SecureGPT 相较于现有最先进的工作，实现了高达 100 倍的性能提升。

1.6. 原文链接

/files/papers/692dc8a721c5d99fb7b327f0/paper.pdf (这是一个相对路径的文件链接)

2. 整体概括

2.1. 研究背景与动机

2.1.1. GPT 在云推理中的隐私挑战

生成式预训练 Transformer (GPT) 模型在自然语言处理 (NLP) 领域展现出卓越的理解和生成人类语言的能力。随着 ChatGPT 和 Bard 等大型预训练语言模型（LLMs）的广泛应用，越来越多的云推理服务被提供。然而，当用户将敏感数据上传到云服务器以使用这些推理服务时，如何确保其输入数据和模型输出的隐私性和安全性成为一个紧迫且具有挑战性的问题。

2.1.2. 现有隐私保护机器学习 (PPML) 解决方案的局限性

隐私保护机器学习 (PPML) 旨在解决模型推理中的数据隐私问题，允许用户在不暴露其私有数据的情况下完成任务。现有的主流方案包括：

• 同态加密 (Homomorphic Encryption, HE) 方案: 允许在加密数据上直接进行计算。然而，HE 方案通常仅支持两方协作计算，难以扩展到多方场景，且在处理复杂非线性函数时效率较低。
• 多方安全计算 (Multi-Party Computation, MPC) 方案: 允许多个参与方共同计算一个函数，同时保持各自输入的隐私。虽然 MPC 提供多方支持，但现有方法在处理 Transformer 模型中的非线性函数（如 softmax 和 GELU）时，常常依赖于比较协议 (comparison protocols) 和分段线性近似 (piecewise linear approximations)，这导致通信轮次和开销随神经网络层数增加而显著增长，效率低下。

2.1.3. 本文的切入点与创新思路

针对上述挑战，本文旨在开发一个高效、低延迟、支持任意多方参与的隐私保护 Transformer 推理框架，特别关注 GPT 模型。其核心思路是：

1. 改进非线性函数的 M2A 协议: 借鉴 SecureNLP 的思想，利用乘法共享到加法共享 (Multiplication to Addition, M2A) 的转换机制，并结合 Beaver 乘法三元组 (Beaver's triples)，来更精确、高效地实现 softmax 和 GELU 等非线性函数，避免传统分段线性近似带来的误差和效率问题。
2. 构建多方 Transformer 子层协议: 基于改进的 M2A 协议及其他基础构建模块，为 GPT 的各个 Transformer 子层（如层归一化、多头自注意力、前馈网络）设计高效的多方隐私保护协议。
3. 支持任意数量的参与方: 克服现有 HE 或部分 MPC 方案仅限于特定（如两方）参与方的限制。

2.2. 核心贡献/主要发现

本文的核心贡献可以总结如下：

1. 提出了 SecureGPT 框架: 设计了一个用于 GPT 中多方隐私保护 Transformer 推理的框架，并在具有除一人之外的所有方腐化 (all-but-one corruptions) 的静态半诚实 (semi-honest) 对手模型下证明了其安全性。
2. 设计了高效的基础构建模块: 引入了一系列新的隐私保护协议作为框架的基础构建模块，包括改进的 M2A 协议、截断 (truncation) 协议、除法 (division) 协议、softmax 协议和 GELU 协议。特别是在 M2A 协议方面，为 softmax 和 GELU 等非线性函数提供了更精确的计算方法。
3. 构建了多方 Transformer 子层协议: 利用这些基础模块，设计了 GPT Transformer 子层（如 Token 嵌入、层归一化 (Layer Normalization)、掩码自注意力 (Masked Self-Attention) 和前馈网络 (Feed Forward Network)）的多方私有协议。
4. 显著的性能提升: 通过实验评估，在不同参与方设置下，SecureGPT 框架相较于现有最先进的 CipherGPT 和 SecBERT 等工作，实现了高达 30 倍至 100 倍的运行时间性能提升。
5. 支持任意数量的参与方: 提出的框架能够支持任意数量的参与方进行协作计算，弥补了现有方案的不足。

3. 预备知识与相关工作

3.1. 基础概念

3.1.1. 生成式预训练 Transformer (GPT)

GPT 是一种先进的自然语言处理 (NLP) 模型，基于 Transformer 架构，擅长理解和生成人类语言。它通过在大规模文本语料库上进行预训练，学习语言的统计规律和语义信息，然后可以通过微调 (fine-tuning) 或少样本学习 (few-shot learning) 执行各种下游任务，如文本生成、问答、翻译等。

3.1.2. 安全多方计算 (Secure Multi-Party Computation, MPC)

MPC 是一种密码学原语，允许多个不互信的参与方在不泄露各自私有输入数据的前提下，共同计算某个函数的输出。MPC 的核心目标是保护输入隐私、计算正确性，并确保参与方无法从协议执行过程中获取除了函数输出之外的任何额外信息。

3.1.3. 秘密共享 (Secret Sharing)

秘密共享是 MPC 的基础技术之一，它将一个秘密值 $v$ 分割成 $n$ 份共享 (shares)，分发给 $n$ 个参与方。任何少于某个阈值 $t$ 的参与方无法恢复出秘密值，而多于或等于 $t$ 个参与方可以协作恢复。本文主要使用了两种秘密共享方式：

• 加法秘密共享 (Additive Secret Sharing): 将秘密值 $v$ 表示为 $n$ 个共享 $\langle v \rangle_1, \dots, \langle v \rangle_n$ 的和，即 $v = \sum_{i=1}^n \langle v \rangle_i \pmod{2^\ell}$。加法共享对加法运算具有同态性，即 $\langle u \rangle \pm \langle v \rangle = \langle u \pm v \rangle$。
• 乘法秘密共享 (Multiplicative Secret Sharing): 将秘密值 $v$ 表示为 $n$ 个共享 $\mathbb{I} v \mathbb{I}_1, \dots, \mathbb{I} v \mathbb{I}_n$ 的乘积，即 $v = \prod_{i=1}^n \mathbb{I} v \mathbb{I}_i \pmod{2^\ell}$。乘法共享对乘法运算具有同态性，即 $\mathbb{I} u \mathbb{I} \times \mathbb{I} v \mathbb{I} = \mathbb{I} u \times v \mathbb{I}$。 这两种共享方式是互补的，本文的 M2A 协议就是为了在它们之间进行转换。

3.1.4. Transformer 架构

Transformer 是由 Attention 机制构建的深度学习模型，是 GPT 的核心。它主要由多层编码器和解码器组成。在 GPT 中，主要是解码器部分，包含以下关键子层：

• Token 嵌入 (Token Embedding): 将输入的离散 token（如单词）转换为连续的向量表示。通常包括词嵌入 (word embedding) 和位置嵌入 (positional embedding)。
• 层归一化 (Layer Normalization, LN): 对神经网络层内的激活值进行归一化处理，加速训练收敛，提高模型泛化能力。其公式为： $$y_m = \gamma \cdot \frac{z_m}{\sqrt{\sum_{m=1}^{d_{model}} z_m^2 / d_{model} + \epsilon}} + \beta$$ 其中，z_m = u_m - E(\mathbf{u})，E(\mathbf{u}) = \sum_{m=1}^{d_{model}} u_m / d_{model} 是输入 $\mathbf{u}$ 的均值，$\gamma$ 和 $\beta$ 是可学习的缩放和偏移参数，$\epsilon$ 是一个小的常数用于防止除以零。
• 掩码多头自注意力 (Masked Multi-Head Self-Attention): Transformer 的核心机制，允许模型在生成输出时，对输入序列的不同部分赋予不同权重。在 GPT 中，Masked 表示每个 token 只能关注到其之前（包括自身）的 token，以防止信息泄露。其计算公式为： $$\mathrm{Attention}(\mathbf{Q}, \mathbf{K}, \mathbf{V}) = \mathrm{softmax}\left(\frac{\mathbf{Q} \circ \mathbf{K}^T}{\sqrt{d_{model}}}\right) \circ \mathbf{V}$$ 其中，$\mathbf{Q}$ (Query)、$\mathbf{K}$ (Key)、$\mathbf{V}$ (Value) 是由输入 $\mathbf{X}_{in}$ 经过线性变换得到的矩阵，即 $\mathbf{Q} = \mathbf{X}_{in} \circ \mathbf{W}_Q$, $\mathbf{K} = \mathbf{X}_{in} \circ \mathbf{W}_K$, $\mathbf{V} = \mathbf{X}_{in} \circ \mathbf{W}_V$。$d_{model}$ 是模型的维度。Multi-Head 表示将 $\mathbf{Q}, \mathbf{K}, \mathbf{V}$ 分割成多个“头”并行计算 Attention，然后将结果拼接起来。
• 前馈网络 (Feed Forward Network, FFN): 一个简单的全连接前馈网络，通常包含两个线性层和一个激活函数（如 GELU）。其公式为： $$\mathbf{Y} = \mathsf{GELU}(\mathbf{X} \circ \mathbf{W1} + \mathbf{B1}) \circ \mathbf{W2}^T + \mathbf{B2}$$ 其中，$\mathbf{X}$ 是输入，$\mathbf{W1}, \mathbf{B1}, \mathbf{W2}, \mathbf{B2}$ 是权重和偏置参数。

3.1.5. 非线性激活函数

• Softmax: 将一组实数转换为概率分布，通常用于分类任务的最后一层。 $$\mathsf{softmax}_m(\mathbf{u}) = e^{\mathbf{u}_m} / \sum_{j \in [1, k]} e^{\mathbf{u}_j}$$
• 高斯误差线性单元 (Gaussian Error Linear Unit, GELU): 一种常用的激活函数，通常在 Transformer 模型中表现优于 ReLU。 $$\mathsf{GELU}(u) = u \cdot \Phi(u)$$ 其中 $\Phi(x) = \int_{-\infty}^x \frac{1}{\sqrt{2\pi}} e^{-\frac{t^2}{2}} dt$ 是标准正态分布的累积分布函数。

3.1.6. 定点算术 (Fixed-point Arithmetic)

由于大多数 MPC 协议在整数环 $\mathbb{Z}_{2^\ell}$ 上操作，为了表示实数并保持计算精度，使用定点算术将实数转换为整数。一个实数 $a$ 可以表示为 $\lfloor a \cdot 2^{FP} \rfloor$，其中 FP 是小数部分的位数。在乘法后，需要进行截断 (truncation) 以保持小数位数不变。

3.1.7. 半诚实安全模型 (Semi-Honest Security Model)

在半诚实 (也称为“被动”或“遵循但不诚实”) 安全模型中，对手会严格遵循协议的规定步骤执行，但会试图从其接收到的所有信息中学习额外的私有输入。一个协议在半诚实模型下是安全的，如果存在一个模拟器 (simulator)，能够仅凭对手的私有输入和最终输出，生成一个与真实协议执行中对手视图在计算上不可区分 (computationally indistinguishable) 的视图。

3.2. 前人工作

3.2.1. 基于同态加密 (HE) 的隐私保护推理

• Hao et al. [14], Hou et al. [15], Zhang et al. [16], Pang et al. [17]: 这些工作利用 HE 技术在加密状态下对 Transformer 模型进行私有推理。例如，CipherGPT [15] 是首个基于全同态加密 (Fully Homomorphic Encryption, FHE) 的安全两方 GPT 推理框架。BOLT [17] 进一步优化了矩阵乘法和非线性函数操作。
• 局限性: HE 方案通常只能支持两方协作计算，难以扩展到涉及多方的通用场景。

3.2.2. 基于多方安全计算 (MPC) 的隐私保护推理

• Feng et al. (SecureNLP) [7]: 提出了一种多方隐私保护自然语言处理系统，利用多方 M2A 协议实现非线性激活函数，并基于秘密共享构建了隐私保护的 RNN 模型。
• MPCformer [18]: 提出了基于秘密共享和知识蒸馏 (Knowledge Distillation, KD) 的多方私有 Transformer 推理方法。
• Akimoto et al. (Privformer) [20]: 利用复制秘密共享 (Replicated Secret Sharing, RSS) 实现三方诚实多数 (honest majority) 设置下的 Transformer 安全推理。
• Huang and Wang (SecBERT) [24]: 提出了基于乘法三元组的两服务器隐私保护预训练模型推理协议 SecBERT。
• Microsoft 的工作 [25], [26], [27]: 利用遗忘传输 (Oblivious Transfer, OT) 和函数秘密共享 (Function Secret Sharing, FSS) 等基本密码学原语构建高效的隐私保护框架，支持浮点数计算。
• 局限性: 现有的 MPC 方案：
  • 部分仍限于特定数量的参与方（如 Privformer [20] 的三方，SecBERT [24] 的两方）。
  • 在计算非线性函数时，如 Privformer 和 SecBERT，常使用比较协议 (comparison protocols) 和线性近似 (linear approximations)，随着神经网络层数的增加，这会导致电路深度 (circuit depth) 增加，通信轮次和开销增大，效率较低。

3.3. 技术演进

隐私保护推理技术从最初的单方加密计算 (如 HE) 发展到多方协作计算 (MPC)。在 MPC 领域，从早期的特定方数、依赖简单线性近似的方案，逐步向支持任意多方、采用更精确非线性函数计算的方向发展。本文的工作正处于这一演进的关键节点，旨在通过改进 M2A 协议和 Beaver 三元组技术，为多方 Transformer 推理提供更高效、更精确的非线性函数处理能力。

3.4. 差异化分析

本文 SecureGPT 的方法与现有工作的主要区别和创新点在于：

• 多方支持: SecureGPT 支持任意数量的参与方进行协作，解决了 HE 方案和部分 MPC 方案仅限于两方或特定方数的限制。
• 高效且精确的非线性函数: 相较于 Privformer 和 SecBERT 等使用比较协议或分段线性近似来计算非线性函数（如 softmax 和 GELU）的方法，SecureGPT 借鉴 SecureNLP，并进一步探索改进的 M2A 协议，使其能够更精确地计算除法和指数函数，从而提高了非线性函数计算的精度和效率。
• 基于 Beaver 三元组的优化: 利用 Beaver 三元组实现高效的私有乘法，并将其扩展到矩阵乘法，显著降低了在线通信开销。
• 对 GPT 模型结构的适配: 针对 GPT 的具体 Transformer 子层（Token 嵌入、层归一化、掩码自注意力、前馈网络）设计了相应的多方私有协议。
• 性能优越性: 实验结果表明，SecureGPT 在性能上显著优于现有最先进的 MPC 和 HE 方案。

4. 方法论

本文提出的 SecureGPT 框架旨在为 GPT 模型提供多方隐私保护的 Transformer 推理。其核心思想是基于秘密共享 (additive 和 multiplicative) 和 Beaver 乘法三元组，设计一系列高效且安全的原子构建模块，并利用这些模块实现 GPT 模型中各个 Transformer 子层的隐私保护计算。

4.1. 方法原理

SecureGPT 的方法原理基于以下几个关键点：

1. 秘密共享: 将敏感数据（如用户输入、模型参数）分解成多个共享，分发给不同的参与方。单个参与方无法从其持有的共享中恢复原始数据。

2. 同态性: 利用秘密共享的同态性质，在共享上直接进行加法和乘法等操作，而无需恢复原始数据。

3. Beaver 乘法三元组: 引入 Beaver 乘法三元组来高效地实现加法共享上的安全乘法。这使得乘法操作可以在预计算阶段（离线阶段）分摊大部分计算和通信开销，从而降低在线阶段的成本。

4. M2A 协议: 针对 softmax 和 GELU 等需要进行指数运算的非线性函数，设计了高效的乘法共享到加法共享 (M2A) 转换协议，以利用乘法共享对乘法运算的同态性。

5. 定点算术: 在环 $\mathbb{Z}_{2^\ell}$ 上进行计算时，使用定点数来表示实数，并通过私有截断协议来保持精度。

6. Newton 迭代法: 在层归一化中，利用 Newton 迭代法结合私有除法协议来高效计算平方根的倒数。

   整个框架通过将 GPT 的复杂推理任务分解为一系列原子操作（如加法、乘法、截断、除法、softmax、GELU），并为这些原子操作设计安全的 MPC 协议，最终实现了 GPT 模型的端到端隐私保护推理。

4.2. 核心方法详解

4.2.1. 值的表示与基本操作

• 值的表示: 对于一个秘密值 $v \in \mathbb{Z}_{2^\ell}$：
  • $\langle v \rangle$ 表示 $v$ 的加法共享 (additive share)。参与方 $P_i$ 持有其对应的共享 $\langle v \rangle_i$。秘密值 $v$ 可以通过将所有共享相加来重构： $$v = \langle v \rangle_1 + \langle v \rangle_2 + \dots + \langle v \rangle_n \pmod{2^\ell}$$
  • $\mathbb{I} v \mathbb{I}$ 表示 $v$ 的乘法共享 (multiplicative share)。参与方 $P_i$ 持有其对应的共享 $\mathbb{I} v \mathbb{I}_i$。秘密值 $v$ 可以通过将所有共享相乘来重构： $$v = \mathbb{I} v \mathbb{I}_1 \times \mathbb{I} v \mathbb{I}_2 \times \dots \times \mathbb{I} v \mathbb{I}_n \pmod{2^\ell}$$
• 同态性质: 这两种共享都满足线性同态性质：
  • 加法共享: $\langle u \rangle \pm \langle v \rangle = \langle u \pm v \rangle$
  • 乘法共享: $\mathbb{I} u \mathbb{I} \times \mathbb{I} v \mathbb{I} = \mathbb{I} u \times v \mathbb{I}$ 此外，对于公共常数 $c$：
  • 加法共享: $c \cdot \langle v \rangle = \langle c \cdot v \rangle$
  • 乘法共享: $c^{\langle v \rangle} = \mathbb{I} c^v \mathbb{I}$ (注意此处原文符号表示为 $c^{\langle v \rangle} = \mathbb{I} c^v \mathbb{I}$，这可能是一个印刷错误或特定协议中的含义，通常乘法共享是对乘法同态，而不是指数。但此处应严格按照原文描述)
• 秘密值重构 ($ΠREC$): 所有参与方发送他们的共享（$\langle u \rangle_i$ 或 $\mathbb{I} v \mathbb{I}_i$）给其他方，然后通过求和或求积来重构秘密值。

4.2.2. 加性秘密共享的私有乘法 ($ΠMUL$)

为了实现加法共享上的私有乘法，本文采用了基于 Beaver 乘法三元组 [28] 的方法，以实现低的在线通信开销。

• 协议名称: $\Pi_{\mathsf{MUL}}$
• 输入: $\langle x \rangle$ 和 $\langle y \rangle$ (加法共享)
• 输出: $\langle z \rangle$ (加法共享)，其中 $z = x \cdot y$
• 流程:
  1. 设置阶段 (Setup Phase): 所有参与方预先准备好 Beaver 乘法三元组 $\{ \langle a \rangle, \langle b \rangle, \langle c \rangle \}$，其中 $c = a \cdot b$。
  2. 在线阶段 (Online Phase):
     • 每个参与方 $P_i$ 本地计算 $\langle e \rangle_i = \langle x \rangle_i - \langle a \rangle_i$ 和 $\langle f \rangle_i = \langle y \rangle_i - \langle b \rangle_i$。
     • 所有参与方共同重构 (reconstruct) $e$ 和 $f$。这意味着每个 $P_i$ 发送 $\langle e \rangle_i$ 和 $\langle f \rangle_i$ 给其他方，然后大家计算 $e = \sum \langle e \rangle_i$ 和 $f = \sum \langle f \rangle_i$。
     • 每个参与方 $P_i$ 本地计算 $\langle z \rangle_i = e \cdot f + e \cdot \langle b \rangle_i + f \cdot \langle a \rangle_i + \langle c \rangle_i$。
• 扩展: 该乘法协议可以很容易地向量化，用于计算向量内积 ($ΠSMUL$) 和矩阵乘法 ($ΠMMUL$)，这些操作只需要两轮通信。

4.2.3. 多方乘法到加法共享转换协议 ($ΠPrivM2A$)

M2A 协议是实现非线性函数（如 softmax 和 GELU 中的指数运算）的关键。本文借鉴 SecureNLP [7] 的工作，并提出一种利用树形结构的多方 M2A 协议，与 Beaver 三元组乘法协议保持一致。

Protocol IIPrivM2A

Setup Phase: In the setup phase, all the parties prepare the Beaver's triples used in ΠMUL.

Online Phase: On input multiplicative share [[x]], all parties execute the following steps:

1) For each $i \in [n]$, $P_i$ shares their multiplicative share `[[x]]_i` to obtain additive shares $\langle x \rangle = \{ \langle x_1 \rangle, \dots, \langle x_i \rangle, \dots, \langle x_n \rangle \} = \{ r_i^1, r_i^2, \dots, r_i^n \} \in \mathbb{Z}_{2^\ell}^n$ where $[[x]]_i = \sum_{j=1}^n r_j^i$.
   (Note: The original text has a possible typo in step 1, where it states "$\langle x \rangle = \{ \dots \}$" which seems to be the additive shares of the *multiplicative share* `[[x]]_i` for each party. Then it says "where $[[x]]_i = \sum_{j=1}^n r_j^i$". This implies that each party $P_i$ takes their multiplicative share `[[x]]_i` and additive-shares *that specific share* among all parties. However, the goal of M2A is to convert the *overall secret* $x = \prod [[x]]_i$ from multiplicative to additive. A common way this works is by having each party convert their own multiplicative share into an additive share, and then sum these additive shares. The paper description is a bit ambiguous. Assuming the common understanding of M2A where the goal is to get an additive share of the product of multiplicative shares, the step 1 wording is unusual. Given the context of a "tree structure" and "n private multiplications", it's more likely that the output of each node in the tree (which are multiplicative shares) are converted into additive shares, and then these additive shares are summed. The phrase "shares their multiplicative share" might mean converting their own component into an additive share. For strict adherence, I will reproduce the description as given.)

2) All the parties jointly execute $\Pi_{\mathsf{MUL}}$ in parallel in the form of the binary tree as shown in Figure 3 to compute the product $\langle z \rangle$ where $z = x = \prod_{i=1}^n [[x]]_i$.

Figure 3 展示了多方 M2A 协议的设计，它采用二叉树结构来聚合乘法共享。每个内部节点代表一次 $ΠMUL$ 运算，将两个乘法共享转换为一个加法共享。

**图 3:** 多方 `M2A` 协议的设计 (The design of Multi-Party M2A protocol)。

• 定理 1 (正确性 $ΠPrivM2A$): $ΠPrivM2A$ 协议可以输出正确的 M2A 结果，其中输入是所有参与方的共享 $\langle u \rangle$。

  • 证明: 为了证明 $ΠPrivM2A$ 的正确性，必须证明在执行 $ΠREC$ 协议后，输出共享会产生正确的秘密值 $x$，满足 $x = \sum_{i=1}^n \langle z \rangle_i = \prod_{i=1}^n \mathbb{I} x \mathbb{I}_i$。可以观察到，多方 M2A 协议本质上实现了 $n$ 次私有乘法，每个参与方持有 $x_1, \dots, x_n$ 的共享。可以得出 $\mathbb{I} x \mathbb{I}_1 \times \mathbb{I} x \mathbb{I}_2 = \sum_{i=1}^n \langle x_1 \rangle \times \sum_{i=1}^n \langle x_2 \rangle$ (原文此处应为 $\prod \mathbb{I} x \mathbb{I}_i$ 变为 $\sum \langle z \rangle_i$ 而非 $\sum \langle x_1 \rangle \times \sum \langle x_2 \rangle$)。如果存在 $n$ 个参与方，则 $x = \prod_{i=1}^n \mathbb{I} x \mathbb{I}_i = \sum_{i=1}^n \langle z \rangle_i$。

• 定理 2 (安全性 $ΠPrivM2A$): 多方私有 M2A 协议 $ΠPrivM2A$ (参见图 4) 可以在静态半诚实对手存在的情况下，在 $ΠMUL$-混合模型中保证半诚实安全性。详细证明见论文 Section V-A。

4.2.4. 私有截断协议 ($ΠPrivTrunc$)

在定点算术中，每次乘法运算都会使小数位数加倍，因此需要截断来保持精度。

Protocol PrivTrunc Setup Phase: All the parties prepare the edaBits $\{ \langle r \rangle, \langle r[0] \rangle, \dots, \langle r[\ell-1] \rangle \}$ used in the online phase. Online Phase: On input additive share $\langle u \rangle$ and the truncated bit length $k$, all parties execute the following steps: 1) Each party locally computes $u' = u + r$. 2) All the parties jointly execute $\Pi_{\mathsf{REC}}$ to obtain $u' = u + r$ in clear. 3) Each party locally computes $\langle z \rangle = \mathsf{LRS}(u' + 2^{\ell-1}) - \sum_{j=k}^{\ell-1} \langle r[j] \rangle \cdot 2^{j-k} - 2^{\ell-1-k}$ where $z = u / 2^k \pm 1$.

• edaBits 解释: edaBits 是一种用于在 MPC 中进行位操作和比较的密码学原语，它提供随机值的加法共享和其每一位的加法共享，这对于精确截断非常有用。
• 截断原理: $ΠPrivTrunc$ 的核心思想是使用一个随机数 $\langle r \rangle$ 来掩盖秘密值 $\langle u \rangle$，然后公开掩盖后的值 $u' = u+r$。由于 $u'$ 是公开的，可以对其进行本地的逻辑右移 (Logical Right Shift, LRS) 操作。然后通过减去随机数 $r$ 的相应截断部分来恢复 $\langle u/2^k \rangle$ 的共享。这种方法可以精确截断，但可能引入一位的误差。
• 定理 3 (正确性 $ΠPrivTrunc$): $ΠPrivTrunc$ 协议可以输出截断结果，其中输入是所有参与方的共享 $\langle u \rangle$，并且以 $1 - 2^{\ell_x + 1 - \ell}$ 的概率发生一位误差，其中 $\ell_x$ 是有效比特长度。
  • 证明: 证明基于 SecureML [30] 中的定理 1，$ARS(u) = LRS(u' + 2^(ℓ-1)) - LRS(r) - 2^(ℓ-1-k) - e$，其中 $e \in \{0, 1\}$。通过代数推导，可以证明 $z = \sum_{i=1}^n \langle z \rangle_i = \mathsf{ARS}(u) = \mathsf{Tr}(u)$。
• 定理 4 (安全性 $ΠPrivTrunc$): 多方私有截断协议 $ΠPrivTrunc$ (参见图 5) 可以在静态半诚实对手存在的情况下，在 edaBits-混合模型中保证半诚实安全性。详细证明见论文 Section V-B。

4.2.5. 私有除法协议 ($ΠPrivDiv$)

除法操作对于层归一化和 softmax 等函数至关重要。

Protocol IPrivDiv Setup Phase: All the parties prepare the Beaver's triples used in IMUL. Online Phase: On input additive shares $\langle x \rangle$ and $\langle y \rangle$, all parties execute the following steps: 1) For each $i \in [n]$, $P_i$ randomly samples $r_i$ and can be written as $\langle r \rangle = r_i$. 2) All the parties jointly execute $\Pi_{\mathsf{MUL}}(\langle x \rangle, \langle r \rangle)$ and $\Pi_{\mathsf{MUL}}(\langle y \rangle, \langle r \rangle)$ with truncation to compute $\langle x \cdot r \rangle$ and $\langle y \cdot r \rangle$. 3) All the parties jointly execute $\Pi_{\mathsf{REC}}$ to obtain $y \cdot r$. 4) For each $i \in [n]$, $P_i$ locally computes $\langle z \rangle_i = \langle x \cdot r \rangle_i / (y \cdot r)$ where $z = x / y$.

• 除法原理: 该协议通过引入一个随机掩码 (random mask) $\langle r \rangle$，将秘密除法转换为一个部分公开的除法。首先，计算被除数和除数与随机掩码的乘积（$\langle x \cdot r \rangle$ 和 $\langle y \cdot r \rangle$），然后公开 $y \cdot r$。由于 $y \cdot r$ 是公开的，每个参与方可以本地计算 $\langle x \cdot r \rangle_i / (y \cdot r)$ 来得到商的共享。
• 定理 5 (正确性 $ΠPrivDiv$): $ΠPrivDiv$ 协议可以输出正确的除法结果，其中输入是所有参与方的共享 $\langle x \rangle$ 和 $\langle y \rangle$。
  • 证明: 可以观察到 $z = \sum_{i=1}^n \langle z \rangle_i = \frac{\sum_{i=1}^n \langle x \cdot r \rangle_i}{y \cdot r} = \frac{x \cdot r}{y \cdot r} = \frac{x}{y}$。
• 定理 6 (安全性 $ΠPrivDiv$): 多方私有除法协议 $ΠPrivDiv$ (参见图 6) 可以在静态半诚实对手存在的情况下，在 $ΠMUL$-混合模型中保证半诚实安全性。详细证明见论文 Section V-C。

4.2.6. 私有 Softmax 协议 ($ΠPriSoftmax$)

softmax 函数在 Transformer 的自注意力机制中用于生成注意力权重。

Protocol IPriSoftmax

Setup Phase: All the parties prepare the materials for subprotocol ΠPrivM2A.

Online Phase: On input additive sharing vector $\langle \mathbf{u} \rangle = \{ \langle \mathbf{u}_1 \rangle, \langle \mathbf{u}_2 \rangle, \dots, \langle \mathbf{u}_k \rangle \}$, all the parties execute the following steps:

1) For each $i \in [n]$, $P_i$ gets random share $[[\rho]]$ and $P_i$ locally computes $\mathbb{I} \rho \cdot e^{\mathbf{u}_m} \mathbb{I} = \mathbb{I} \rho \mathbb{I} \cdot e^{\langle \mathbf{u}_m \rangle}$ for $m \in [1, k]$.
   (Note: The expression $\mathbb{I} \rho \cdot e^{\mathbf{u}_m} \mathbb{I} = \mathbb{I} \rho \mathbb{I} \cdot e^{\langle \mathbf{u}_m \rangle}$ is crucial here. It leverages the multiplicative homomorphic property $c^{\langle v \rangle} = \mathbb{I} c^v \mathbb{I}$ implicitly mentioned earlier, where $e$ is the base, and $\langle \mathbf{u}_m \rangle$ is the additive share of the exponent. And a random multiplicative share $[[\rho]]$ is used to mask the intermediate values.)
2) For $m \in [1, k]$, all the parties execute $\Pi_{\mathsf{PrivM2A}}$ in parallel to get $\langle \phi_m \rangle$ where $\phi_m = \prod_{i \in [n]} [\rho \cdot e^{\mathbf{u}_m}]_i = \sum_{i \in [n]} \langle \phi_m \rangle_i$.
   (Note: The original text has a possible typo again: "$\sum_{i \in [n]} \langle \phi_m \rangle_i$" should be $\phi_m = \sum_{i \in [n]} \langle \phi_m \rangle_i$. Also, "$\prod_{i \in [n]} [\rho \cdot e^{\mathbf{u}_m}]_i$" should mean $\prod_{i \in [n]} \mathbb{I} (\rho \cdot e^{\mathbf{u}_m}) \mathbb{I}_i$ which is the full secret value $\rho \cdot e^{\mathbf{u}_m}$, and then converted to additive shares $\langle \phi_m \rangle$. The `[[...]]_i` notation is a bit inconsistent.)
3) Each party locally computes $\langle \Phi \rangle = \sum_{m \in [1, k]} \langle \phi_m \rangle$ and executes $\Pi_{\mathsf{REC}}$ to get $\Phi = \sum_{m \in [1, k]} \rho \cdot e^{\mathbf{u}_m}$.
4) Each party locally computes $\langle z_m \rangle = \langle \phi_m \rangle / \Phi$ for each $m \in [1, k]$ and outputs $\langle \mathbf{z} \rangle = \{ \langle \mathbf{z}_1 \rangle, \langle \mathbf{z}_2 \rangle, \dots, \langle \mathbf{z}_k \rangle \}$ which satisfies $\mathbf{z} = \mathsf{softmax}(\mathbf{u})$.

• softmax 原理: 传统的 softmax 涉及指数运算和除法。协议首先利用乘法共享的性质，计算 $\mathbb{I} \rho \cdot e^{\mathbf{u}_m} \mathbb{I}$，其中 $\rho$ 是随机值用于掩盖。然后使用 $ΠPrivM2A$ 将这些乘法共享转换为加法共享 $\langle \phi_m \rangle$。接着，通过公开 $\Phi = \sum \phi_m$，参与方可以本地计算最终的除法操作，得到 softmax 结果的共享。
• 定理 7 (正确性 $ΠSoftmax$): $ΠSoftmax$ 协议可以输出正确的 softmax 结果，其中输入是所有参与方的共享向量 $\langle \mathbf{u} \rangle$。
  • 证明: 对于每个 $m \in [1, k]$，证明 $\mathbf{z}_m = \sum_{i=1}^n \langle \mathbf{z}_m \rangle_i = \mathbf{\rho} \cdot e^{\mathbf{u}_m} / \sum_{j \in [1, k]} \mathbf{\rho} \cdot e^{\mathbf{u}_j} = e^{\mathbf{u}_m} / \sum_{j \in [1, k]} e^{\mathbf{u}_j}$。
• 定理 8 (安全性 $ΠSoftmax$): 多方私有 softmax 协议 $ΠSoftmax$ (参见图 7) 可以在静态半诚实对手存在的情况下，在 $ΠPrivM2A$-混合模型中保证半诚实安全性。详细证明见论文 Section V-D。

4.2.7. 私有 GELU 协议 ($ΠPrivGELU$)

GELU 函数是 Transformer 中常用的激活函数。由于其涉及标准正态分布的累积分布函数，通常需要近似。本文采用 Bowling et al. [32] 提出的 logistic 近似：$\Phi(x) \approx \mathsf{sigmoid}(1.7017449 \cdot x)$。

Protocol IPrivGELU

Setup Phase: All the parties prepare the materials for subprotocols $\Pi_{\mathsf{PrivSigm}}$ and $\Pi_{\mathsf{PrivTrunc}}$, and prepare the Beaver's triples used in $\Pi_{\mathsf{MUL}}$.

Online Phase: On input additive share $\langle u \rangle$, all the parties execute the following steps:

1) Each party locally computes $\langle k \rangle = \lfloor 1.7017449 \cdot 2^{\mathsf{FP}} \rfloor \cdot \langle u \rangle$ with truncation.
   (Note: Here, `1.7017449` is a public constant, and $2^{\mathsf{FP}}$ scales it to fixed-point representation. The product with $\langle u \rangle$ (an additive share) is local.)
2) All the parties jointly execute $\Pi_{\mathsf{PrivSigm}}(\langle k \rangle)$ to obtain $\langle s \rangle$ where $s = \mathsf{Sigmoid}(1.7017449 \cdot u)$.
   (Note: The paper refers to $ΠPrivSigm$ as a subprotocol and mentions that $ΠPrivSigm$ replaces $ΠMUL^(nP)$ with their `PrivM2A`. $ΠPrivSigm$ is from SecureNLP [7].)
3) All the parties jointly execute $\Pi_{\mathsf{MUL}}(\langle u \rangle, \langle s \rangle)$ with truncation to obtain $\langle z \rangle = \langle u \cdot s \rangle$ which satisfies $z = \mathsf{GELU}(u)$.

Figure 8 展示了近似 GELU 的相对误差，表明该近似方法可以实现较低的误差。

**图 8:** 近似 `GELU` 的相对误差 (Relative errors of approximate GELU)。

• GELU 原理: 协议首先将输入 $\langle u \rangle$ 乘以一个常数，得到近似 sigmoid 函数的输入 $\langle k \rangle$。然后调用 $ΠPrivSigm$ 协议计算 $\mathsf{sigmoid}(k)$ 的共享 $\langle s \rangle$。最后，通过 $ΠMUL$ 协议计算 $u \cdot s$ 的共享 $\langle z \rangle$，得到近似 GELU 的结果。
• 定理 9 (正确性 $ΠPrivGELU$): $ΠPrivGELU$ 协议可以输出正确的 GELU 结果，其中输入是所有参与方的共享 $\langle u \rangle$。
  • 证明: 基于 Bowling et al. [32] 的近似公式 $GELU(u) ≈ u · sigmoid(1.7017449 · u)$ 和 SecureNLP [7] 中 $ΠPrivSigm$ 的正确性，可以证明 $z = \sum_{i=1}^n \langle u \rangle_i \cdot \sum_{i=1}^n \langle s \rangle_i = u \cdot \mathsf{Sigmoid}(1.7017449 \cdot u)$。
• 定理 10 (安全性 $ΠPrivGELU$): 多方私有 GELU 协议 $ΠPrivGELU$ (参见图 9) 可以在静态半诚实对手存在的情况下，在 ${ΠPrivSigm, ΠMUL, ΠPrivTrunc}$-混合模型中保证半诚实安全性。详细证明见论文 Section V-E。

4.2.8. 隐私保护 Transformer 框架 ($ΠPrivTrans$)

SecureGPT 框架将上述基础构建模块整合到 GPT 的 Transformer 子层中。

Protocol IIPrivTrans

Setup Phase: All the parties prepare the materials for subprotocols $\Pi_{\mathsf{PrivM2A}}$, $\Pi_{\mathsf{PrivDiv}}$ and $\Pi_{\mathsf{PrivTrunc}}$, and prepare the Beaver's triples used in $\Pi_{\mathsf{MUL}}$, $\Pi_{\mathsf{SMUL}}$ and $\Pi_{\mathsf{MMUL}}$.

Token Embedding Layer:
1) The client $\mathcal{C}$ secret shares its private word embedding matrix $\mathbf{T} \in \mathbb{Z}_{2^\ell}^{V \times d_{model}}$ and position matrix $\mathbf{P} \in \mathbb{Z}_{2^\ell}^{V \times d_{model}}$, distributing $\langle \mathbf{T} \rangle$ and $\langle \mathbf{P} \rangle$ to $n$ servers.
2) Each party (the servers) locally computes the share of the embedding matrix $\langle \mathbf{E} \rangle = \langle \mathbf{T} \rangle + \langle \mathbf{P} \rangle$.

Layer Normalization: On input additive sharing vector $\langle \mathbf{u} \rangle = \{ \langle \mathbf{u}_1 \rangle, \langle \mathbf{u}_2 \rangle, \dots, \langle \mathbf{u}_{d_{model}} \rangle \}$, the model parameters $\langle \gamma \rangle, \langle \beta \rangle \in \mathbb{Z}_{2^\ell}^{d_{model}}$ and $\langle \epsilon \rangle$, all the parties execute the following steps:

1) Each party locally computes $\langle e \rangle = \lfloor \frac{1}{d_{model}} \cdot 2^{\mathsf{FP}} \rfloor \sum_{m=1}^{d_{model}} \langle \mathbf{u}_m \rangle$ and computes $\langle \mathbf{z} \rangle \in \mathbb{Z}_{2^\ell}^{d_{model}}$ where $\langle \mathbf{z}_m \rangle = \langle \mathbf{u}_m \rangle - \langle e \rangle$.
   (Note: This step computes the mean and subtracts it from the input vector.)
2) For all $m \in [1, d_{model}]$, all parties jointly execute $\Pi_{\mathsf{SMUL}}(\langle \mathbf{z} \rangle, \langle \mathbf{z} \rangle)$ with truncation and obtain $\langle z^2 \rangle$ where $z^2 = \sum_{m=1}^{d_{model}} \mathbf{z}_m^2$. Then locally compute $\langle \sigma \rangle = \lfloor \frac{1}{d_{model}} \cdot 2^{\mathsf{FP}} \rfloor \langle z^2 \rangle + \langle \epsilon \rangle$.
   (Note: This computes the variance term for normalization.)
3) Each party locally sets $\langle x_0 \rangle = \langle \sigma \rangle$. For $j = \{0, 1, 2, 3, 4\}$ do:
   a) All the parties jointly execute $\Pi_{\mathsf{PrivDiv}}(\langle \sigma \rangle, \langle x_j \rangle)$ to obtain $\langle \frac{\sigma}{x_j} \rangle$.
   b) For each $i \in [n]$, $P_i$ locally computes `\langle x_{j+1} \rangle = \lfloor \frac{1}{2} \cdot 2^{\mathsf{FP}} \rfloor (\langle x_j \rangle + \langle \frac{\sigma}{x_j} \rangle)`.
   End for
   (Note: This is Newton's method for computing $1/\sqrt{v}$ using the iterative formula $x_{j+1} = \frac{1}{2}(x_j + \frac{v}{x_j})$ to find the inverse square root of $\sigma$. The paper states $x_{j+1} = \frac{x_j}{2}(3 - \hat{v} x_j^2)$ in Section II.B, but then mentions "the iterative formula will then become $x_{j+1} = \frac{1}{2}(x_j + \frac{v}{x_j})$ with initial value $x_0 = v$." for improved efficiency. The protocol explicitly uses the second form.)
4) Let $\langle \frac{1}{\sqrt{\sigma}} \rangle = \langle \frac{1}{x_4} \rangle$.
5) Each party locally sets $\langle \mathbf{V} \rangle = \{ \langle \frac{1}{\sqrt{\sigma}} \rangle \}$ where $\mathbf{V} \in \mathbb{Z}_{2^\ell}^{1 \times 1}$ and $\langle \mathbf{Z} \rangle = \{ \langle \mathbf{z}_1 \rangle, \langle \mathbf{z}_2 \rangle, \dots, \langle \mathbf{z}_{d_{model}} \rangle \}$ where $\mathbf{Z} \in \mathbb{Z}_{2^\ell}^{1 \times d_{model}}$.
6) All the parties jointly execute $\Pi_{\mathsf{MMUL}}^{\mathsf{v}}(\langle \mathbf{Z}^T \rangle, \langle \mathbf{V} \rangle)$ with truncation and obtain $\langle \mathbf{Y}^T \rangle$ where $\mathbf{Y}^T = \mathbf{Z}^T \circ \mathbf{V}$ and $\mathbf{Y} = \{ \frac{\mathbf{z}_m}{\sqrt{\sigma}} \}_{m \in [1, d_{model}]}$.
   (Note: This step normalizes the input by multiplying with $1/\sqrt{\sigma}$.)
7) All the parties jointly execute $\Pi_{\mathsf{MUL}}(\langle \frac{\mathbf{z}_m}{\sqrt{\sigma}} \rangle, \langle \gamma_m \rangle)$ in parallel and locally compute $\langle \mathbf{y}_m \rangle = \langle \gamma_m \cdot \frac{\mathbf{z}_m}{\sqrt{\sigma}} \rangle + \langle \beta_m \rangle$, where $\mathbf{y}_m = \gamma \cdot \frac{\mathbf{z}_m}{\sqrt{\sum_{m=1}^{d_{model}} \mathbf{z}_m^2 / d_{model} + \epsilon}} + \beta$ for $m \in [1, d_{model}]$.
   (Note: This applies the learnable scaling and shifting parameters $\gamma$ and $\beta$.)

Multi-Head Self-Attention: On input additive sharing matrix $\langle \mathbf{X} \rangle \in \mathbb{Z}_{2^\ell}^{V \times d_{model}}$, the weight matrices $\langle \mathbf{W}_K \rangle, \langle \mathbf{W}_Q \rangle, \langle \mathbf{W}_V \rangle \in \mathbb{Z}_{2^\ell}^{d_{model} \times d_{model}}$:

1) All the parties jointly execute $\Pi_{\mathsf{MMUL}}(\langle \mathbf{X} \rangle, \langle \mathbf{W}_K \rangle)$, $\Pi_{\mathsf{MMUL}}(\langle \mathbf{X} \rangle, \langle \mathbf{W}_Q \rangle)$ and $\Pi_{\mathsf{MMUL}}(\langle \mathbf{X} \rangle, \langle \mathbf{W}_V \rangle)$ in parallel and obtain the sharing $\langle \mathbf{K} \rangle = \langle \mathbf{X} \circ \mathbf{W}_K \rangle$, $\langle \mathbf{Q} \rangle = \langle \mathbf{X} \circ \mathbf{W}_Q \rangle$ and $\langle \mathbf{V} \rangle = \langle \mathbf{X} \circ \mathbf{W}_V \rangle \in \mathbb{Z}_{2^\ell}^{V \times d_{model}}$.
   (Note: This computes the Query, Key, Value matrices.)
2) Each party $P_i$ locally splits the matrices:
   $$\begin{array}{r}
   \langle \mathbf{K}_{head_1} \rangle || \ldots || \langle \mathbf{K}_{head_M} \rangle = \langle \mathbf{K} \rangle \\
   \langle \mathbf{Q}_{head_1} \rangle || \ldots || \langle \mathbf{Q}_{head_M} \rangle = \langle \mathbf{Q} \rangle \\
   \langle \mathbf{V}_{head_1} \rangle || \ldots || \langle \mathbf{V}_{head_M} \rangle = \langle \mathbf{V} \rangle
   \end{array}$$
   where $M$ is the number of heads.
   (Note: This is the "multi-head" part, splitting the full matrices into sub-matrices for each head.)
3) For $j \in [M]$ in parallel do:
   a) All parties jointly execute $\Pi_{\mathsf{MMUL}}(\langle \mathbf{Q}_{head_j} \rangle, \langle \mathbf{K}_{head_j}^T \rangle)$ with truncation to obtain $\langle \mathbf{T}_j \rangle$ where $\mathbf{T}_j = \mathbf{Q}_{head_j} \circ \mathbf{K}_{head_j}^T$.
      (Note: This computes the raw attention scores before scaling and softmax.)
   b) All parties jointly execute $\Pi_{\mathsf{PriSoftmax}}(\lfloor \frac{1}{\sqrt{d_{model}}} \cdot 2^{\mathsf{FP}} \rfloor \langle \mathbf{T}_j \rangle)$ to obtain $\langle \mathbf{S}_j \rangle$ where $\mathbf{S}_j = \mathsf{softmax}(\frac{\mathbf{T}_j}{\sqrt{d_{model}}})$.
      (Note: This scales the attention scores and applies softmax.)
   c) All parties jointly execute $\Pi_{\mathsf{MMUL}}(\langle \mathbf{S}_j \rangle, \langle \mathbf{V}_{head_j} \rangle)$ with truncation to obtain $\langle \mathbf{Y}_{head_j} \rangle$ where $\mathbf{Y}_{head_j} = \mathbf{S}_j \circ \mathbf{V}_{head_j}$.
      (Note: This multiplies the attention weights with the Value matrix.)
   End for
4) For each $i \in [n]$, $P_i$ locally combines and outputs $\langle \mathbf{Y} \rangle = \langle \mathbf{Y}_{head_1} \rangle || \ldots || \langle \mathbf{Y}_{head_M} \rangle$ where $\mathbf{Y} = \mathbf{Y}_{head_1} || \ldots || \mathbf{Y}_{head_M}$ and $\mathbf{Y}_{head_m} = \mathrm{Attention}(\mathbf{Q}_{head_m}, \mathbf{K}_{head_m}, \mathbf{V}_{head_m})$ for $m \in [M]$.
   (Note: This combines the outputs from all attention heads.)

Feed Forward Network: On input additive sharing matrix $\langle \mathbf{X} \rangle \in \mathbb{Z}_{2^\ell}^{V \times d_{model}}$, the weight matrices $\langle \mathbf{W1} \rangle, \langle \mathbf{W2} \rangle \in \mathbb{Z}_{2^\ell}^{d_{model} \times w}$ and the bias matrices $\langle \mathbf{B1} \rangle \in \mathbb{Z}_{2^\ell}^{V \times w}$, $\langle \mathbf{B2} \rangle \in \mathbb{Z}_{2^\ell}^{V \times d_{model}}$:

1) All the parties jointly execute $\Pi_{\mathsf{MMUL}}(\langle \mathbf{X} \rangle, \langle \mathbf{W1} \rangle)$ with truncation to obtain $\langle \mathbf{T1} \rangle$ where $\mathbf{T1} = \mathbf{X} \circ \mathbf{W1} \in \mathbb{Z}_{2\ell}^{V \times w}$.
   (Note: First linear layer.)
2) All the parties jointly execute $\Pi_{\mathsf{PrivGELU}}(\langle \mathbf{T1} \rangle + \langle \mathbf{B1} \rangle)$ to obtain $\langle \mathbf{T2} \rangle$ where $\mathbf{T2} = \mathsf{GELU}(\mathbf{T1} + \mathbf{B1}) \in \mathbb{Z}_{\gamma\ell}^{V \times w}$.
   (Note: Add bias and apply GELU activation.)
3) All the parties jointly execute $\Pi_{\mathsf{MMUL}}(\langle \mathbf{T2} \rangle, \langle \mathbf{W2} \rangle^T)$ with truncation to obtain $\langle \mathbf{T3} \rangle$ where $\mathbf{T3} = \mathbf{T2} \circ \mathbf{W2}^T \in \mathbb{Z}_{2^\ell}^{V \times d_{model}}$ and output $\langle \mathbf{Y} \rangle = \langle \mathbf{T3} \rangle + \langle \mathbf{B2} \rangle \in \mathbb{Z}_{2^\ell}^{V \times d_{model}}$.
   (Note: Second linear layer, add bias and output.)

图 10: 多方私有 Transformer 框架 (Multi-party private Transformer framework)。 (此图在原文中是以文本形式描述的协议，而非图像文件)

5. 实验设置

5.1. 数据集

论文中没有明确说明在评估 SecureGPT 推理框架时使用了具体的公开数据集（如 GLUE 或 SQuAD）。实验主要关注框架本身的性能，而非特定任务的准确性。

• 输入特征: 实验使用了输入 token 长度为 128 (input token length set to 128)，特征维度 $d_{model} = 768$ (feature dimension $d_{model} = 768$)，词汇表大小 $V = 256$ (vocabulary size $V = 256$)。
• 数据形态: Token Embedding 层的输入是 word embedding matrix $\mathbf{T} \in \mathbb{Z}_{2^\ell}^{V \times d_{model}}$ 和 position matrix $\mathbf{P} \in \mathbb{Z}_{2^\ell}^{V \times d_{model}}$ 的秘密共享。
• 样本示例: 原文未提供具体的数据样本示例。

5.2. 评估指标

本文的评估主要关注性能，包括运行时间 (Runtime) 和通信开销 (Communication Overhead)。

5.2.1. 运行时间 (Runtime)

• 概念定义: 衡量协议或框架完成一次计算任务所需的时间。在 MPC 中，通常分为离线阶段（设置阶段）和在线阶段。本文主要关注在线阶段的运行时间，因为它直接影响用户体验。
• 数学公式: 运行时间通常以毫秒 (ms) 或秒 (s) 为单位，没有统一的数学公式，而是通过实验计时器记录。
• 符号解释:
  • ms: 毫秒。
  • $s$: 秒。

5.2.2. 通信开销 (Communication Overhead)

• 概念定义: 衡量协议执行过程中，参与方之间交换的数据总量。在 MPC 中，通信是主要的瓶颈之一，因此降低通信开销至关重要。
• 数学公式: 通信开销通常以比特 (bits) 或字节 (Bytes) 为单位，没有统一的数学公式，而是通过记录网络传输量来统计。
• 符号解释:
  • $B$: 字节 (Byte)。
  • bps: 比特每秒 (bits per second)。

5.3. 对比基线

本文将 SecureGPT 框架与以下最先进的隐私保护推理工作进行了比较：

• BOLT [17]: 一个基于同态加密 (HE) 的 Transformer 高效、准确、隐私保护推理框架。它优化了矩阵乘法和非线性函数的操作，并利用了 HE 的打包优势。

• CipherGPT [15]: 首个基于全同态加密 (FHE) 的安全两方 GPT 推理框架。

• SecBERT [24]: 一个基于乘法三元组的两服务器隐私保护预训练模型推理系统，主要针对 BERT 等 Transformer 模型。

  选择这些基线的原因在于它们代表了 HE 和 MPC 领域在 Transformer 模型隐私保护推理方面的先进水平，涵盖了不同的密码学原语和实现策略。

5.4. 实验环境

• 硬件:
  • Ubuntu 个人电脑 (Ubuntu PC)。
  • 处理器: Intel(R) Core(TM) i7-10700。
  • 内存: 16GB RAM。
• 网络:
  • 局域网 (LAN): 带宽高达 1 Gbps，延迟 0.1 ms。
  • 广域网 (WAN): 带宽高达 200 Mbps，延迟 100 ms。
• 软件与库:
  • emp-toolkit [34]: 用于实现 MPC 协议的开源工具包。
  • Eigen [35]: 用于线性代数操作的 C++ 模板库。
• 算术表示:
  • 在环 $\mathbb{Z}_{2^\ell}$ 上进行所有算术运算，其中 $\ell = 64$。
  • 使用定点算术 (fixed-point arithmetic) 表示实数，其中最后 13 位表示小数部分 (FP bits)。
  • 为了防止数据溢出（例如，在 $ΠPrivDiv$ 中 $x \cdot r$ 和 $y \cdot r$ 的乘积可能超过 64 位），输入值的有效比特长度 (effective bit length) 选择为 $\ell_x = 26$。

6. 实验结果与分析

6.1. 核心结果分析

本文通过一系列基准测试来验证 SecureGPT 框架及其构建模块的有效性和效率。

6.1.1. 构建模块的性能

下表展示了在不同参与方数量下，所提出的 M2A (Multiplication to Addition)、截断 (Truncation)、除法 (Division)、Softmax 和 GELU 协议的在线阶段运行时间。

以下是原文 TABLE II 的结果：

表 II: 在线阶段构建模块的性能 (毫秒) (Performance of the Online Phase of Our Building Blocks (Ms))

• 分析:

  • 数量效应: 所有协议的运行时间都随着参与方数量的增加而增加。这是多方计算协议的普遍特点，因为需要更多的通信和协调。

  • 网络效应: 在 LAN (局域网) 环境下，运行时间显著低于 WAN (广域网) 环境。这表明通信延迟对协议性能有很大影响，SecureGPT 更适合低延迟的局域网环境。

  • 协议复杂度: $ΠPrivGELU$ 和 $ΠPrivSoftmax$ 由于涉及多次内部调用其他协议（如 $ΠPrivM2A$、$ΠPrivSigm$、$ΠMUL$），其运行时间通常高于简单的 $ΠPrivM2A$、$ΠPrivTrunc$ 和 $ΠPrivDiv$。

  • Softmax 输入大小: $ΠPrivSoftmax$ 的测试是在输入向量长度为 20 的情况下进行的。

    下图展示了构建模块的在线通信开销，也反映了协议随着参与方数量的增加而增加的通信量。

**图 11:** 构建模块的通信开销 (Communication overhead of our building blocks)。

以下是原文 TABLE III 的结果：

表 III: 乘法三元组生成的时间和通信开销 (Runtime and Communication of the Multiplication Triple Generation)

• 分析: Beaver 乘法三元组是 MPC 协议的关键预计算资源。
  • TP-aided (第三方辅助) 方式在运行时和通信开销上表现最佳，因为它假定一个可信第三方生成三元组。
  • OT (Oblivious Transfer) 和 LHE (Linear Homomorphic Encryption) 方式在运行时和通信开销上更高，但它们不需要可信第三方。这表明 SecureGPT 通过预计算阶段分摊了乘法三元组的生成成本。

6.1.2. SecureGPT 推理框架的性能对比

论文将 SecureGPT 框架与 BOLT [17]、CipherGPT [15] 和 SecBERT [24] 进行了比较。

以下是原文 TABLE IV 的结果：

表 IV: 与 BOLT [17] 的运行时间比较 (Runtime Comparison with BOLT [17])

• 测试条件: 输入 token 长度为 128，在 2 方设置下，生成 Transformer 推理的输出（重复 Transformer 层 12 次）。BOLT [17] 的数据来源于其原始论文，实验环境是 AWS EC2 上的两个 c6i.16xlarge 实例。
• 分析: SecureGPT 在 Layer Normalization、Multi-Head Attention 和 Feed Forward Network 这三个 Transformer 核心层上，运行时间均显著优于 BOLT [17]。这表明 SecureGPT 在处理 Transformer 模型时，比基于 HE 的 BOLT 更高效。

以下是原文 TABLE V 的结果：

表 V: 推理框架的运行时间比较 (Comparison of the Runtime for Inference Framework)

• 测试条件: $V=256$, $d_{model}=768$ (token dimension). CipherGPT 的数据来源于其原始论文，其测试环境为 Intel(R) Xeon(R) Gold 6348 @ 2.60 GHz，128GB RAM，8000 系列，3.6 GHz。
• 分析:
  • SecureGPT 在 2PC (两方计算) 和 3PC (三方计算) 设置下，在所有关键层（Layer Normalization、Multi-Head Attention 中的 MatMul 和 Softmax、Feed Forward Network 中的 MatMul 和 GELU）的运行时间都远低于 CipherGPT。
  • 总运行时间方面，SecureGPT 在 2PC 下为 $3.752 \times 10^4$ ms (约 37.5 秒)，在 3PC 下为 $6.477 \times 10^4$ ms (约 64.8 秒)。而 CipherGPT-2PC 则高达 $1.141 \times 10^6$ ms (约 1141 秒)。这表明 SecureGPT 比 CipherGPT 实现了约 30 倍的性能提升 ($1.141 \times 10^6 / 3.752 \times 10^4 \approx 30.4$)。
  • 即使在 3PC 设置下，SecureGPT 的性能也远优于 CipherGPT-2PC。这突显了 MPC 方法在多方场景下，以及 SecureGPT 特别是其改进的 M2A 和非线性函数协议的优势。

以下是原文 TABLE VI 的结果：

表 VI: 与 SecBERT [24] 的运行时间比较 (Runtime Comparison with SecBERT [24])

• 测试条件: 输入 token 长度为 128，在 2 方设置下。SecBERT [24] 的数据来源于其原始论文，其测试环境为 Intel(R) Xeon(R) CPU E5-2620 v2 (2.10 GHz)，32G RAM。
• 分析: SecureGPT 在所有层（Layer Normalization、Multi-Head Attention、Feed Forward Network）的运行时间上，比 SecBERT [24] 快了两个数量级。例如，Layer Normalization 从 18 秒降至 0.076 秒，Multi-Head Attention 从 59 秒降至 0.649 秒。整体性能提升达到约 100 倍。这主要是因为 SecBERT [24] 可能依赖于效率较低的比较协议和线性近似来处理非线性函数，而 SecureGPT 采用了更高效的 M2A 协议。

6.1.3. 总结

实验结果有力地证明了 SecureGPT 框架的卓越效率。相较于基于 HE 的 CipherGPT 和基于 MPC 但依赖传统方法的 SecBERT，SecureGPT 实现了显著的性能提升（分别为 30 倍和 100 倍）。这种性能提升主要归因于其精心设计的 M2A 协议及其他构建模块，特别是在处理 Transformer 模型中的非线性函数方面。此外，结果也强调了 SecureGPT 更适用于低通信延迟的局域网环境。

6.2. 消融实验/参数分析

论文中没有进行明确的消融实验，但提供了一些关于设计选择和限制的讨论：

• GELU 协议的优化: 提到由于设备性能限制，当前的 GELU 协议实现只能实现 $256 \times 64$ (或 $128 \times 64$) 矩阵的并行通信。但可以通过优化实现，使得 GELU 函数为矩阵中的每个元素并行计算，从而仅需一轮通信。这表明未来仍有优化空间。
• 定点精度与溢出: 为了防止数据溢出，选择输入有效比特长度 $\ell_x = 26$。这暗示了在 MPC 中精度、比特长度和潜在溢出之间的权衡。
• 非线性函数近似的精度: GELU 函数使用 logistic 近似，并通过图 8 展示了其较低的相对误差。这体现了在效率和精度之间做出的工程选择。

6.3. 准确性评估

论文主要聚焦于性能评估 (运行时间、通信开销)，并未直接报告 SecureGPT 在具体 NLP 任务上的准确性 (accuracy) 损失。然而，通过改进 M2A 协议实现更精确的非线性函数计算（而不是依赖线性近似），SecureGPT 旨在减小由于隐私保护计算引入的精度损失，从而间接保证了模型在隐私保护环境下的可用性。GELU 近似函数图 8 的相对误差很小，也暗示了在精度上的良好控制。

7. 总结与思考

7.1. 结论总结

本文提出了 SecureGPT，一个用于 GPT 模型的多方隐私保护 Transformer 推理框架。为了应对云推理服务中用户数据隐私泄露的挑战，SecureGPT 设计了一系列高效的秘密共享基础构建模块，包括改进的 M2A (Multiplication to Addition) 协议、截断 (truncation)、除法 (division)、softmax 和 GELU 协议。特别是，通过借鉴 SecureNLP 的思想并结合 Beaver 乘法三元组，SecureGPT 能够更精确、高效地实现 softmax 和 GELU 等非线性函数，避免了传统线性近似方法带来的精度和效率问题。这些构建模块被进一步用于设计 GPT Transformer 子层（如 Token 嵌入、层归一化、掩码多头自注意力、前馈网络）的隐私保护协议。

在静态半诚实对手模型下，SecureGPT 的安全性得到了理论证明（支持除一人之外的所有方腐化）。实验评估显示，在多方设置下，SecureGPT 框架相较于现有最先进的 CipherGPT 和 SecBERT 等工作，实现了高达 30 倍到 100 倍的运行时间性能提升，证明了其在局域网环境下处理大型 Transformer 模型推理任务的卓越效率。

7.2. 局限性与未来工作

作者在论文的 Conclusion 部分明确指出了当前工作的局限性，并提出了未来的研究方向：

• 安全漏洞风险: 当前协议可能存在安全漏洞，原因在于为防止数据溢出和限制随机共享的比特长度所采用的方法。这可能导致生成的随机数不那么均匀随机 (less than uniformly random)，从而引发安全隐患。
• 未来工作 (解决安全漏洞): 计划通过采用非线性函数的近似算法来解决这一问题，这有助于缓解相关的风险。
• 半诚实安全模型: 当前模型基于半诚实安全模型，适用于由社会信任背书的云服务器框架。在这种模型下，参与方会遵循协议，但会试图学习额外信息。
• 未来工作 (恶意对手模型): 在众包或物联网 (IoT) 等场景中，参与方可能出于自身利益而采取恶意行为（例如恶意中断或篡改），因此，未来的研究重点将是增强安全性以应对恶意对手 (malicious adversary) 模型。
• 安全与效率的权衡: 作者指出，平衡安全性和效率仍然是一个重要且发人深省的问题。

7.3. 个人启发与批判

7.3.1. 个人启发

• MPC 在 LLM 推理中的潜力: SecureGPT 的工作再次证明了 MPC 在保护大型语言模型（LLM）云推理隐私方面的巨大潜力。在 LLM 广泛应用的今天，用户数据的隐私保护至关重要，MPC 提供的理论保障和实际性能提升是解决这一难题的关键路径。
• 非线性函数处理的精细化: 论文在 M2A 协议以及 softmax 和 GELU 等非线性函数处理上的创新是其成功的关键。相较于简单的线性近似，这种更精细化的处理方式在保证效率的同时，能够更好地维持模型精度，这对于 LLM 的性能至关重要。
• 工程实现的重要性: 即使有了理论上的协议，高效的工程实现（如利用 emp-toolkit 和 Eigen）以及对定点算术、比特长度和溢出控制的细致考量，对于将理论转化为实用系统是不可或缺的。性能的显著提升也证明了这些工程努力的价值。
• 多方场景的实用性: 克服了 HE 和部分 MPC 方案仅限于两方的限制，支持任意多方参与，使得 SecureGPT 在实际部署中更具灵活性和适用性，例如在多云或联盟学习 (federated learning) 等场景。

7.3.2. 批判与思考

• 安全漏洞的潜在影响: 作者坦诚指出的因溢出预防和随机共享比特长度限制可能导致随机数非均匀性，进而引发安全漏洞，是需要高度重视的问题。尽管未来工作计划通过近似算法解决，但这暗示了在当前版本中可能存在的实际风险，这在安全协议中是一个严重的关注点。对于初学者而言，需要理解安全协议的任何细微偏差都可能被恶意攻击者利用。
• 恶意对手模型的缺失: 仅在半诚实模型下提供安全性证明是 MPC 领域的常见起点。然而，在云服务或众包等现实场景中，恶意行为是普遍存在的。因此，将框架扩展到恶意对手模型是其走向实际部署的必要一步，但这也通常会带来显著的性能开销，平衡将是巨大挑战。
• 精度与性能的权衡: 尽管论文强调了效率提升，但对特定 NLP 任务的准确性（例如，与非隐私保护版本相比的准确性损失）缺乏直接的量化评估。在 LLM 领域，即使微小的精度损失也可能影响用户体验。未来的工作应该结合任务精度指标进行综合评估。
• 实际部署的复杂性: 即使性能得到大幅提升，MPC 框架的实际部署仍面临诸多工程挑战，例如密钥管理、参与方动态加入/退出、网络不稳定、大规模数据传输的可靠性等。这些在论文中没有深入探讨，但在实际应用中是必须考虑的因素。
• 通用性与特定性: SecureGPT 专注于 GPT 的 Transformer 架构。虽然 Transformer 是当前主流，但 LLM 领域技术发展迅速，模型架构不断演变（例如混合专家模型 MoE）。框架的通用性，即是否能轻松适应未来新的 LLM 架构，也是一个值得关注的问题。