【隐私计算&大模型】MPC安全多方计算矩阵乘法算子的原理分析及模型推理应用介绍（涉及SPDZ、GMW、ABY、ABY2.0、ABY3、Cheetah、CipherGPT、VOLE、模型推理等）

源泉的小广场

已于 2024-10-08 08:31:33 修改

阅读量849

点赞数 22

分类专栏：隐私计算大模型文章标签：隐私计算大模型矩阵乘法安全乘法乘法加速多方安全计算 MPC乘法

于 2024-10-04 13:36:29 首次发布

本文链接：https://blog.csdn.net/weixin_65514978/article/details/142553415

版权

大模型同时被 2 个专栏收录

55 篇文章 18 订阅

订阅专栏

隐私计算

33 篇文章 13 订阅

订阅专栏

1. 背景介绍

提起隐私计算，主要就是涉及联邦学习(FL)、安全多方计算(MPC)、隐私集合求交(PSI)、匿踪查询(PIR)、差分隐私(DP)以及可信执行环境(TEE)。进一步地，对于每一个方向又可以细分多个子类别，比如联邦学习可以细分为横向联邦学习、纵向联邦学习、横纵向混合联邦学习、联邦迁移学习。

本篇文章，主要针对安全多方计算(MPC)进行细分领域的分析，具体的，是针对安全多方计算中的乘法算子（或者称矩阵乘法算子、张量积）的详细介绍。之所以对该算子分析，是因为随着大模型的流行和普及，大模型的数据安全被提升到了一定的高度，带动了隐私计算在该领域以及相关深度学习领域的探索和应用，可以参考《大模型的安全由隐私计算来保护》。常见的深度学习任务包括前向传播、反向传播等过程，都依赖于大规模的矩阵运算，涉及最多的基础算子就是矩阵乘法算子。如果能保证底层算子是计算安全的，那么也可以进一步提升上层算法应用的安全性。

在MPC中，乘法操作相对于加法算子要复杂得多，因为它涉及多方之间的密集通信和中间数据的共享。为了确保在安全前提下高效地执行乘法操作，MPC协议中的乘法算子成为研究热点。

2. 基础知识

2.1 MPC概念

在介绍具体的乘法算子之前，有必要对安全多方计算技术进行一定的分享。安全多方计算（MPC）是隐私计算的核心技术之一，其允许多个参与者在保留各自输入隐私的前提下，进行联合计算并得出函数的输出结果。各参与方只能知道自己的输入和输出，无法得知其他参与方的信息。这个过程的核心思想是，通过加密、秘密共享等技术实现隐私保护。公式所述：

$(y_1, ..., y_n) = f(x_1, ..., x_n)$

其中， $P_i$ 持有输入 $x_i$ ，并得到输出 $y_i$ ，除了自己的输入输出和整体函数的结果外，参与方对其他信息一无所知。MPC能够为多方合作的大数据分析、计算、建模中发挥重要作用。

2.2 MPC的安全性分类

为了应对不同的威胁模型，MPC协议有两类主要的对手模型：

半诚实对手：这些对手会遵循协议规则，但可能试图从通信中获取额外信息。半诚实对手往往通过窥探传输数据来尝试推断其他参与方的输入。
恶意对手：恶意对手不仅可能窥探传输信息，还可能主动破坏协议，进行任意攻击。为了应对这种威胁，MPC协议必须具备验证和安全机制，保证即便在对手恶意操作时，协议仍然能正确执行。

2.3 MPC的主要方法

【1】总结分析了MPC协议的实现主要有两种方法：

秘密共享方法：通过将各方输入的数据分割为多个份额，并在各方之间交换，这样即使单个方的份额泄露，也无法得出原始数据。这个方法能有效降低通信成本，且通信复杂度与电路深度线性相关。

混淆电路方法：参与方共同构建一个加密版本的电路，电路只能计算一次，且输出结果是加密的，轮数恒定。这个方法的通信量通常较大，但能有效保证恶意对手无法推断出其他参与方的输入。

MPC技术的核心在于确保参与者能在不泄露隐私的前提下共同计算，满足数据隐私和安全性需求。针对半诚实和恶意对手的不同安全要求，MPC有不同的设计方法和优化策略。

3. MPC的特点分析

目前行业内最流行的MPC乘法算子，都是基于秘密共享机制实现，因此本文主要会从秘密共享方案出发，对相关实现原理进行分析，预期能够对当前业内的底层算子实现有一定的算法认知。另外，对于逻辑电路来说，与门的计算和算术电路中的乘法有相似性，也会有一定的介绍。

关于MPC的算子原理实现，首先关注两个基本点：计算方数量以及碎片分片形式。

3.1 计算方数量

这里我们分类为N方协议（比如SPDZ协议【2】）、两方协议（比如ABY【3】、Cryptflow2【4】、Cheetah协议【5】）、三方协议（比如ABY3【6】、Falcon【7】、 SecureNN【8】），甚至还有四方协议（Flash【9】、Trident【10】）。当然还有其他一些协议，参考下图的分析。

3.2 分片形式

秘密共享的分片形式一般有shamir秘密共享、加法秘密共享、同态加密分片、基于XOR的秘密共享等形式。

3.2.1 Shamir秘密共享方案

Shamir秘密共享是一种最经典、最广泛使用的秘密共享形式。它基于多项式插值的原理，具体方法是：

设有一个秘密 s，我们生成一个度为 t-1 的多项式 f(x)，其中常数项为 s。
随机选取多项式的系数，构造出多项式 f(x)。
为每个参与方 $P_i$ 计算出一个分片 f(i)，并将这些分片分发给各参与方。
要恢复秘密 s，需要至少 t 个参与方共同提交他们的分片，通过拉格朗日插值法恢复出多项式，从而得到 s。
安全性：当获得少于 t个分片时，攻击者无法获得任何关于秘密的信息。
阈值：可以设定参与方中的阈值 t，即至少需要 t 个参与方联合才能恢复秘密。

3.2.2 加法秘密共享

加法秘密共享是一种较为简单的分片方式，尤其适用于计算效率要求较高的场景。其原理是：

将秘密 s 随机分割成 n 份 $s_1, s_2, ..., s_{n-1}$ ，并设 $s_n = s - (s_1 + s_2 + ... + s_{n-1})$ 。
将每一个分片 $s_i$ 分发给一个参与方。
恢复时，将所有分片相加即可还原出秘密 s。
简单高效，计算量和通信量较小。

3.2.3 同态加密分片

在一些特殊场景下，为了实现更为灵活的计算，碎片可以以加密形式存储。通过同态加密，各方不仅持有数据碎片，还能在加密状态下直接对分片进行运算，而无需恢复原始数据。

能在保持数据加密状态下进行操作，从而减少计算中的隐私泄露风险。
适用于需要对数据进行计算但又不希望数据直接暴露的场景，如联邦学习中的多方计算。

3.2.4 基于XOR的秘密共享

这是另一种简单的秘密共享方式，特别适用于轻量级的MPC协议。原理如下：

将秘密 s 用一系列随机数 $r_1, r_2, ..., r_{n-1}$ 随机分片，生成最后一份为 $s_n = s \oplus r_1 \oplus r_2 \oplus ... \oplus r_{n-1}$ （即按位异或）。
分发各分片给各方。
恢复时，所有参与方提供其分片，最后通过异或操作还原原始秘密。

4. MPC乘法（与门）算子实现

接下来我们将分析主流的MPC协议中的乘法算子实现。

4.1 SPDZ协议乘法算子（面向N方）

SPDZ协议适用于处理密集计算和抗恶意行为的场景。SPDZ通过预处理和在线阶段的分离来优化计算过程，尤其针对抗恶意参与方的场景进行了优化。SPDZ协议中的预处理机制，在生产应用上，往往会做一定的调整。因为合作方之间，在现实场景下，会由于各种限制，很难去约定提前生成超大规模的预先准备数据。

SPDZ协议由两大阶段组成：

预处理阶段：在这个阶段，协议参与方在不依赖具体输入的情况下，准备一系列的共享随机数据（称为“乘法三元组”），这些数据将帮助优化在线计算过程。预处理阶段是独立进行的，可以提前进行。

在线计算阶段：在预处理阶段完成后，参与方可以基于他们的私有输入和预处理阶段的乘法三元组来执行实际的计算。在这个阶段，参与方将通过加法和乘法操作来完成函数计算，乘法操作依赖于乘法三元组，从而避免复杂的交互。

SPDZ采用加法秘密共享机制，其处理的碎片形式和乘法逻辑如下所示，依赖于Beaver三元组，乘法三元组由三组秘密共享的随机数组成，记为(a, b, c)，并且它们满足 $c = a \times b$ 。这些三元组是预处理阶段生成的，不依赖任何具体的输入数据。在在线计算阶段，参与方可以通过这些三元组高效地执行私有数据的乘法运算。

【11】给出了相应的处理流程图：

MPC乘法算子实现逻辑

4.2 GMW协议中的与门计算（可面向2方场景）

GMW协议【12】的基本思路是将计算布尔电路（boolean circuits）划分为多个“门”（AND门、OR门、NOT门等），每个门的输入和输出都以秘密共享的形式表示。通过秘密共享，参与者能够在不知道具体输入值的情况下，协同完成电路的计算。

        整个计算可以表示为布尔电路，其中包含多个逻辑门（AND, OR, XOR 等）。对于每个逻辑门，参与各方将各自持有的共享值按照协议进行计算，逐步评估整个布尔电路。

        XOR门的计算：XOR操作是线性的，因此可以直接对共享值局部计算：

$x \oplus y = (x_1 \oplus y_1, x_2 \oplus y_2, ..., x_n \oplus y_n)$

        即每个参与方独立对共享值的局部部分执行XOR操作。

        AND门的计算：AND操作不是线性操作，因此需要参与者之间进行通信来协同计算。这部分是GMW协议的重点。GMW协议要求在计算AND门时，参与方之间进行通信，通常采用OT来交换部分信息，从而在不泄露私有输入的前提下，协同完成AND门的计算。

以下是关于与门的计算逻辑描述：

在GMW协议中，实现与运算的主要思路是通过秘密共享以及1-out-of-4的OT来计算布尔电路中的与门。在与门的计算中，参与方持有输入值的秘密共享，并希望通过通信计算出与门的结果，而又不暴露他们各自的输入。

与门中的交叉项具体步骤：

随机生成共享值：
$P_i$ 生成一个随机的比特 $z_{ij}$ ，并将其作为与门结果的部分秘密共享值。

OT消息设置：
$P_i$ 和 $P_j$ 需要通过OT操作来计算 $x_i \cdot y_j$ 和 $x_j \cdot y_i$ 。在这一步中， $P_i$ 将发送4个值给 $P_j$ ，这些值与 $x_i$ 和 $y_i$ 的比特相关。具体来说，发送方 $P_i$ 需要准备4个值 $z_{ji}^{00}, z_{ji}^{01}, z_{ji}^{10}, z_{ji}^{11}$ ，分别对应不同的 $x_j$ 和 $y_j$ 的组合，表示为：
$z_{ji}^{ab} = z_{ij} \oplus x_i \cdot a \oplus y_i \cdot b$
其中 $a, b \in \{0, 1\}$ 。

OT执行：
在1-out-of-4 OT过程中， $P_j$ 作为接收方，选择适合的消息。例如，如果 $P_j$ 的输入是 $x_j$ 和 $y_j$ ，则 $P_j$ 会选择相应的消息对 $(x_j, y_j)$ ，并从 $P_i$ 那里接收到相应的共享值。

这里的四选一OT可能理解起来不是那么直接，这里参考【13】来进一步解释下：

从P1的角度，要计算交叉项，那么可以先将自身知道的 $x_1, y_1$ 填入交叉项公式，剩下的两项无非是对方的0/1值，那么通过组合就有4种情况，提前在P1侧完成计算，得到4组消息，并且通过本地生成的随机数进行秘密共享，这样即使P2拿到的消息也不能单方知道结果。进一步，P2可以利用其对应 $x_2,y_2$ 作为选择比特，利用OT从P1侧的4组消息中选择出对应的正确的一组，得到的消息与P1保留的随机数形成了秘密共享的分片信息，这样就完成了交叉项的计算。

4.3 ABY协议乘法算子（面向2方）

包括ABY、Crypten【14】、DELPHI【15】等协议在内，实现的乘法算子同样是基于Beaver三元组，不过三元组的生成方式上存在差异。SPDZ提供了基于同态加密的实现方案。而Crypten提供了可信第三方的模式（TTP），ABY提供了机遇COT的方案。

ABY乘法算子实现逻辑

Crypten乘法算子实现逻辑

TTP的方式，一般来说实际应用场景受限，因为很难在现实中说服某一方完全信赖该第三方。因此这里重点了解下基于同态的方案以及基于OT的方式实现Beaver三元组生成。

基于同态加密实现三元组逻辑

同态的方案很容易理解，这里重点讲一下OT的方案，ABY原论文采用了【16】中提及的OT实现x+y = a*b的方案，也就是将a表达成二进制的方式，然后每一个bit是否存在用 $a_i$ 来表示。

更具体的描述如下：

问题背景：

我们的目标是生成乘法三元组 $\langle a \rangle \cdot \langle b \rangle = \langle c \rangle$ ，其中 $\langle a \rangle, \langle b \rangle, \langle c \rangle$ 是基于秘密共享的值。
使用OT（Oblivious Transfer）来生成这些乘法三元组，而不是使用同态加密。

分解乘法：

首先， $\langle a \rangle$ 和 $\langle b \rangle$ 的秘密共享可以写成： $\langle a \rangle = \langle a_0 \rangle + \langle a_1 \rangle \quad$ 和 $\quad \langle b \rangle = \langle b_0 \rangle + \langle b_1 \rangle$ ；
乘法 $\langle a \rangle \cdot \langle b \rangle$ 可以展开为： $\langle a \rangle \cdot \langle b \rangle = (\langle a_0 \rangle + \langle a_1 \rangle) \cdot (\langle b_0 \rangle + \langle b_1 \rangle) = \langle a_0 \rangle \cdot \langle b_0 \rangle + \langle a_0 \rangle \cdot \langle b_1 \rangle + \langle a_1 \rangle \cdot \langle b_0 \rangle + \langle a_1 \rangle \cdot \langle b_1 \rangle$

OT步骤：

为了不泄露彼此的秘密共享值，使用OT来计算混合项：
$\langle a_0 \rangle \cdot \langle b_1 \rangle \quad$ 和 $\quad \langle a_1 \rangle \cdot \langle b_0 \rangle$

具体步骤如下：

$P_0$ 随机生成 $\langle a_0 \rangle$ 和 $\langle b_0 \rangle$ ，并且两者都是在模 $2^\ell$ 下的随机数。
$P_1$ 随机生成 $\langle a_1 \rangle$ 和 $\langle b_1 \rangle$ ，这些也是模 $2^\ell$ 下的随机数。

使用C-OT协议：

OT用于计算混合项 $\langle a_0 \cdot b_1 \rangle$ 和 $\langle a_1 \cdot b_0 \rangle$ 。

C-OT协议（Correlated OT） 是一种优化版本的OT协议，允许发送方生成相关的输出，而无需明确传输所有可能的消息。

C-OT协议的详细步骤：

在第 i 轮C-OT中，发送方 $P_0$ 生成一个随机值 $s_{i,0}$ ，然后计算关联函数 $f_{\Delta_i}(x) = \langle a_0 \rangle \cdot 2^i - s_{i,0}$ ，并作为其消息发送。
接收方 $P_1$ 输入选择比特 $\langle b_1[i] \rangle$ ，从OT协议中接收计算结果 $s_{i,1}$ ，其中 $s_{i,1} = f_{\Delta_i}(s_{i,0}) = (\langle a_0 \rangle \cdot 2^i - s_{i,0}) \mod 2^\ell$ 。
最终， $P_1$ 获得的值是 $\langle a_0 \cdot b_1 \rangle[i] = (\langle b_1[i] \rangle \cdot \langle a_0 \rangle \cdot 2^i - s_{i,0}) \mod 2^\ell$ 的部分。
对每个 i， $P_0$ 也得到与之对应的 $s_{i,0}$ 。
然后 $P_0$ , $P_1$ 分别将各自所有i对应的项进行求和，得到最终的交叉项乘积的碎片。

ABY原文中的描述如下：

C-OT协议通过生成相关的消息，避免了直接泄露秘密共享的中间值。参与方可以通过OT协议计算各自的混合项，然后将这些项结合，最终生成乘法三元组。

4.4 ABY2.0协议乘法算子（面向2方）

ABY2.0协议采用的碎片形式稍微有一些不同，需要引入掩码值。发送碎片的时候，会比正常的ABY协议多发送信息。

这里用一个图来描述该协议的秘密共享机制，帮助理解：

计算方 0 生成随机数 $\delta_v$ ，并对其进行分片：
计算方 0 生成 $\delta_v$ ，并进行分片： $[\delta_v]_0$ 和 $[\delta_v]_1$ ，其中 $\delta_v = [\delta_v]_0 + [\delta_v]_1$ 。类似于加法共享的基础操作。

计算方 0 发送 $[\delta_v]_1$ 和 $\Delta_v$ ：
接下来，计算方 0 将原始值 $v$ 用 $\delta_v$ 进行扰动，得到 $\Delta_v$ 。然后将 $[\delta_v]_1$ 和 $\Delta_v$ 发送给计算方 1。这样即便计算方 1 得到 $[\delta_v]_1$ 和 $\Delta_v$ ，也无法直接知道 $\delta_v$ 或原始值 $v$ 。

计算方 1 持有共享值：
计算方 1 收到了 $[\delta_v]_1$ 和 $\Delta_v$ 。

很显然，如果我们要恢复原始值，需要执行：

接下来来看下加法和乘法的计算逻辑，加法无需通信，直接各自本地处理即可。而乘法计算，由于秘密共享阶段发送了更多的信息给到对端节点，因此在线阶段，相对于ABY，可以用更少的通信完成计算。

左图的乘法示例部分参考自知乎patronuss

4.5 ABY3协议乘法算子（面向3方）

ABY3协议中的秘密共享方法采用了复制的秘密共享（Replicated Secret Sharing）技术，这是一种能够在多方计算中进行高效安全计算的机制。

1. 秘密共享方法：

秘密值 $x \in \mathbb{Z}_{2^k}$ 被分为三个随机值 $x_1, x_2, x_3$ ，满足 $x = x_1 + x_2 + x_3$ 。
这三个随机值被分配给各个参与方，每个参与方持有其中两对共享值。例如：
参与方1持有 $(x_1, x_2)$
参与方2持有 $(x_2, x_3)$
参与方3持有 $(x_3, x_1)$

        这种设计使得任意两个参与方即可重构秘密值 x，因此该方案最多容忍单点失效或任意一方的腐败。

2. 恢复秘密值：

当需要揭恢复某个秘密值 $x$ 时，参与方会将其持有的共享值传递给相邻方。例如，参与方 $i$ 向参与方 $i+1$ 发送其持有的共享值 $x_i$ ，并且每个参与方通过相加所有的共享值来重构秘密值 $x = x_1 + x_2 + x_3$ 。
如果仅需要恢复给特定的某个参与方，传递的过程稍微简化，且仅限于该方进行重构。

3. 算术操作：

该协议支持在共享值上进行基本的算术操作，例如加法和乘法。

加法操作：加法可以通过对所有共享值进行分步加法来实现。假设有两个共享的秘密值 ⟦x⟧和 ⟦y⟧，其中：⟦x⟧=(x1,x2,x3),⟦y⟧=(y1,y2,y3)，加法操作如下：⟦x+y⟧=(x1+y1,x2+y2,x3+y3)，每个参与方本地计算相应的共享值之和即可实现加法。

乘法操作：

        乘法涉及两个共享值的相乘。假设我们要计算 xy，其中 x 和 y 都是秘密共享值，乘法操作的展开如下：

$xy = (x_1 + x_2 + x_3)(y_1 + y_2 + y_3)$

        展开为：

$xy = x_1 y_1 + x_1 y_2 + x_1 y_3 + x_2 y_1 + x_2 y_2 + x_2 y_3 + x_3 y_1 + x_3 y_2 + x_3 y_3$

        因此每个参与方分别需要做的计算如下所示：

        其中：三个随机值 $\alpha_1, \alpha_2, \alpha_3$ 为零碎片形式，它们的和等于零，即：

$\alpha_1 + \alpha_2 + \alpha_3 = 0$

        这样，每个参与方持有其中一个 $\alpha_i$ ，彼此无法单独重构原始秘密。

4.6 Chameleon中提及的乘法算子（可面向3方）

Chameleon【17】本质上是一种混合MPC协议的安全机器学习框架，涉及Garbled Circuit、GMW、加法秘密共享机制。其中提及了一种面向有可信第三方参与的乘法协议The Du-Atallah Multiplication Protocol 。

计算逻辑比较简单，在这个协议中，两个参与方 $\mathcal{P}{0}$ （持有x）和 $\mathcal{P}{1}$ （持有y），以及第三方 $\mathcal{P}_{2}$ 可以一起执行乘法 $z=x\times y$ 。在这个协议结束时，z在所有三个参与方之间被加性地共享。协议的工作流程如下：

$\mathcal{P}{2}$ 随机生成 $a_{0}, a_{1}\in_{R} Z_{2^{l}}$ 并将 $a_{0}$ 发送给 $\mathcal{P}{0}$ ，将 $a_{1}$ 发送给 $\mathcal{P}_{1}$ 。

$\mathcal{P}{0}$ 计算 $(x+a_{0})$ 并将其发送给 $\mathcal{P}{1}$ 。同样， $\mathcal{P}{1}$ 计算 $(y+a_{1})$ 并将其发送给 $\mathcal{P}_{0}$ 。

$\mathcal{P}{0},\mathcal{P}{1}, \mathcal{P}{2}$ 可以分别计算他们的份额为 $\langle z\rangle{0}^{A}=-a_{0}\times(y+a_1),\langle z\rangle_1^A=y\times(x+a_0),\langle z\rangle_2^A=a_0\times a_1$ 。

可以观察到，这些结果是z的真实加性份额： $\langle z\rangle_{0}^{A}+\langle z\rangle_{1}^{A}+\langle z\rangle_{2}^{A}=z$ 。这个协议计算了两个参与方持有的两个数的乘法的份额,但有第三方参与。

4.5 CipherGPT协议乘法算子（面向2方GPT推理）

CipherGPT中描述了一种在隐私保护机器学习任务中提高矩阵乘法 (MatrixMul) 效率的方法，特别是在 GPT 推理场景中。该方法利用一种称为sVOLE的技术，将多次矩阵乘法批处理，从而减少与传统基于 RLWE（基于环学习误差）同态加密方法相比的通信和计算开销。

回顾一下，GPT 需要自回归地生成响应词。因此，GPT 推理需要在相同的 Y 上运行不同的 X 的 MatrixMul。通过利用 GPT 的这一特性来减少 MatrixMul 的摊销成本。

CipherGPT提出的矩阵乘法优化，主要是两个关键点：批量以及sVOLE。关于VOLE可以参考《隐私集合求交（PSI）原理深入浅出》。接下来我们分析一下算法原理：

4.5.1 批量处理

        设 $X = [x_1, x_2, \dots, x_m]$ （其中 $x_i \in \mathbb{Z}^n_{2^l}$ 是 X 的每一列）， $Y^T = [y'_1, y'_2, \dots, y'_m]$ （其中 $y'_i \in \mathbb{Z}^k_{2^l}$ 是 Y 的每一行），则 $Z = \sum_{i=1}^m (x_i \otimes y'_i)$ 。假设 S 和 C 需要生成 t 个响应词，因此有 t 个输入矩阵：

         $X_1 = [x_{1,1}, x_{1,2}, \dots, x_{1,m}], X_2 = [x_{2,1}, x_{2,2}, \dots, x_{2,m}],\cdots,X_t = [x_{t,1}, x_{t,2}, \dots, x_{t,m}]$

        设 $x'_i = x_{1,i} || x_{2,i} || \dots || x_{t,i}, \forall i \in [1, m]$ ，则

$x'_i \otimes y'_i = (x_{1,i} \otimes y'_i) || (x_{2,i} \otimes y'_i) || \dots || (x_{t,i} \otimes y'_i)$

        然后，

$\sum_{i=1}^m (x'_i \otimes y'_i) = Z_1 || Z_2 || \dots || Z_t$

        因此，我们可以通过 m 次外积计算 t 次 MatrixMul。

思路很简单，用白话文解释一下：在 GPT 推理中，通常需要生成多个响应词（即多个矩阵运算），每次生成的词对应于不同的输入矩阵 $X_1, X_2, \dots, X_t$ 。这些矩阵之间有共同的特性，即它们与相同的权重矩阵 Y 相乘。因此，可以通过批处理技术来减少重复计算的开销。

具体操作如下：

对于 t 个输入矩阵 $X_1, X_2, \dots, X_t$ ，它们共享同一个矩阵 Y。
将这些输入矩阵的列向量按列合并为更大的批处理向量。例如，将 $X_1, X_2, \dots, X_t$ 中的第 i 列合并为一个更长的向量 $x'_i$ ，其中 $x'_i = [x_{1,i}, x_{2,i}, \dots, x_{t,i}]$ 。
然后，对每一个 i 来说，只需进行一次外积 $x'_i \otimes y'_i$ 计算，即可以同时完成 t 次矩阵乘法的对应部分。

4.5.2 基于sVOLE实现乘法计算

        由于 Y 事先已知，可以引入一个预处理阶段，让 S 和 C 生成 m 个 sVOLE 相关项：

$W_i = u_i \otimes y'_i + V_i, \forall i \in [1, m]$ .

        其中，C 持有 $u_i \in \mathbb{Z}^{(t \cdot n)}_{2^l}$ （这是一个长度为 $t \cdot n$ 的向量）， $V_i \in \mathbb{Z}^{(t \cdot n) \times k}_{2^l}$ ，而 S 持有 $y'_i \in \mathbb{Z}^k_{2^l}$ 和 $W_i \in \mathbb{Z}^{(t \cdot n) \times k}_{2^l}$ 。

        在在线阶段，对于输入矩阵 $X_j = [x_{j,1}, x_{j,2}, \dots, x_{j,m}]$ ，C 发送

$\langle x_{j,i} \rangle_S := x_{j,i} - u_i [(j-1)n + 1, \dots, j \cdot n] \quad \forall i \in [1, m]$

        给 S，然后 S 计算：

$\langle x_{j,i} \rangle_S \otimes y'_i = (x_{j,i} - u_i [(j-1)n + 1, \dots, j \cdot n]) \otimes y'_i = x_{j,i} \otimes y'_i - u_i [(j-1)n + 1, \dots, j \cdot n] \otimes y'_i$

        接着，我们得到：

         $x_{j,i} \otimes y'_i = \langle x_{j,i} \rangle_S \otimes y'_i + u_i [(j-1)n + 1, \dots, j \cdot n] \otimes y'_i$

$= \langle x_{j,i} \rangle_S \otimes y'_i + W_i [(j-1)kn + 1, \dots, j \cdot k \cdot n] - V_i [(j-1)kn + 1, \dots, j \cdot k \cdot n]$ .

        注意 S 持有：

$\langle x_{j,i} \rangle_S \otimes y'_i + W_i [(j-1)kn + 1, \dots, j \cdot k \cdot n]$

        而 C 持有：

$V_i [(j-1)kn + 1, \dots, j \cdot k \cdot n]$

        这意味着 S 和 C 对 $x_{j,i} \otimes y'_i$ 进行了秘密共享，因此可以局部计算出 $Z_j = \sum_{i=1}^m (x_{j,i} \otimes y'_i)$

的秘密共享。可以通过这种方式计算出所有 Z。

这一段初看起来很复杂，但其实理解之后也挺简单的。这里参考【19】给出简化的版本：

假设：

Client 拥有向量/矩阵 x。
Server 拥有模型参数 y（这里 y 是 Server 端的已知参数）。
目标是计算 $z = x \cdot y$ 。

预处理阶段：

生成 VOLE 关系：
使用 VOLE（Vector Oblivious Linear Evaluation）生成器构造关系： $w = u \cdot y + v$
其中，Client 拥有 (u, v)，Server 拥有 (y, w)。

在线阶段计算 $z = x \cdot y$ ：

Client 计算：

Client 计算： $x_s = x - u$
Client 将 $x_s$ 发送给 Server。

Server 计算：

Server 计算： $x_s \cdot y = (x - u) \cdot y = x \cdot y - u \cdot y$
于是，得到： $x \cdot y = (x_s + u) \cdot y = x_s \cdot y + u \cdot y$

利用 VOLE 关系：

根据 VOLE 关系，Server 可以写出： $u \cdot y = w - v$
将上述结果代入： $x \cdot y = x_s \cdot y + (w - v)$
最终得出： $x \cdot y = x_s \cdot y + w - v$

所以，Server只需计算 $x_s \cdot y + w$ ， Client只需计算 $-v$ 。通过这种方法，Client 和 Server 可以安全地计算乘法 $z = x \cdot y$ 而无需直接暴露 x 或 y。这种技术利用了 VOLE 和秘钥共享的机制来保持计算的隐私性。

当然这种处理方式，不是通用的乘法计算，是需要一方乘子y固定的情况下，提前计算出vole元组，然后在线阶段消费，比较适合GPT等类似算法推理的场景。另外一些协议的性能数据对比如下：

4.6 Cheetah协议（基于同态，面向2方卷积神经网络推理）

Cheetah【5】将明文编码到多项式系数中，并通过点积计算矩阵乘法，Cheetah 消除了昂贵的 SIMD 旋转操作，并直接在 $\mathbb{Z}_{2^l}$ 环上进行计算。全连接层中的核心计算是矩阵-向量乘法 $u = Wv$ ，这可以分解为向量的内积。映射函数 $\pi_w^{fc}$ 和 $\pi_i^{fc}$ 专门用于使用多项式算术计算内积。直观地说，当乘以两个度为 N 的多项式时，结果多项式的 (N - 1)-th 系数是两个系数向量的内积，且顺序相反。可以很容易地将这一想法扩展到一批内积。现在给出以下定义：

$\pi_w^{fc} : \mathbb{Z}^{n_o \times n_i}_p \rightarrow A_{N,p}$
$\pi_i^{fc} : \mathbb{Z}^{n_i}_p \rightarrow A_{N,p}$

这里我们首先假设 $n_i^o \leq N$ 以简化讨论。

输入向量映射： $\hat{v} = \pi_i^{fc}(v) \quad$ 其中， $\quad \hat{v}[j] = v[j] \quad$
权重矩阵映射： $\hat{w} = \pi_w^{fc}(W) \quad$ ，其中 $\quad \hat{w}[i \cdot n_i + n_i - 1 - j] = W[i, j]$ ,其中 $i \in [[n_o]]$ ， $j \in [[n_i]]$ ，而 $\hat{v}$ 和 $\hat{w}$ 的所有其他系数设置为 0。

多项式的乘法 $\hat{u} = \hat{w} \cdot \hat{v} \in A_{N,p}$ 直接给出了矩阵-向量乘法 $Wv \equiv u \mod p$ 在某些系数中的值。HE将明文加密为密文多项式，即一维向量。然而，深度神经网络（DNN）操作的是高维张量。为了弥补这一差距，必须通过打包将张量编码为多项式。Cheetah提出，多项式乘法本质上执行矩阵-向量乘法，并引入了一种HE系数打包方法。在这种方法中，张量元素被编码为系数，正确的结果可以从多项式乘法的结果中提取【20】。