论文笔记（一）SecureML: A System for Scalable Privacy-Preserving Machine Learning

SecureML：A system for Scalable Privacy-Preserving Machine Learning

1 摘要及介绍

1.1　模型的大致架构

首先，主要模型中主要有客户端和两台服务器，假设这两台服务器不会恶意合作。
　　整个训练过程大致分为在线和离线两个阶段，在线阶段的主要任务就是利用本文提出的安全算数技术在共享的十进制数上进行模型的更新，根据混淆电路的思想，除了最后能得到的模型，什么数据也不会暴露出来；离线阶段的主要任务是服务于在线阶段的乘法运算——利用线性同态加密或者不经意传输生成必要的三元组，因为这个开销比较大，后期还提出了一种改进，用客户端来辅助生成三元组；

1.２ 主要贡献

  • 为线性回归、逻辑回归、神经网络这三种机器学习算法开发出了新型的隐私保护的深度学习协议
  • 开发出了支持在共享的十进制数上的安全算数操作的技术
  • 对于那些非线性激活函数，如sigmoid softmax，提出了一种支持安全多方计算的替代方案
  • 以上提出的所有技术相较于目前的技术，在保证安全的前提下，速度上都有很大的提升

1.2.1 为三种机器学习算法开发出的隐私保护的协议

线性回归、逻辑回归和神经网络这三种机器学习方案非常简单但也非常常用，而且他们之间思想类似且一种递进的趋势。
所谓思想类似指的是他们都是有监督的机器学习算法，思路都是先前馈，算出交叉熵之后，在利用随机梯度下降，再后馈更新模型。
所谓递进指的是，线性回归只涉及到了简单的加乘操作，本质上讲不考虑效率的情况下，只要能够实现隐私保护的线性操作即可实现线性回归，最简单的混淆电路即可实现，但本文考虑了效率，所以提出了一种更快的在共享的十进制数上的安全算法操作技术。而逻辑回归相较于线性回归，只是多了激活函数，所以作者提出了一种替代的解决方案。而神经网络在算法设计上虽然与逻辑回归不同，但是其“组件”上依然是线性操作＋激活函数。

1.2.2. 更快的安全两方乘法——在共享的十进制数上的算数操作

前人主要的性能瓶颈是在安全两方计算，比如姚氏混淆电路中，计算定点乘法操作开销非常大。

本文提出的方案：将这两个共享的十进制数表示成有限域上的整数，使用离线生成的三元组在共享的整数上执行乘法操作，每一方都截断它所拥有的积的那部分，因而固定数量的比特即可表示小数部分。经过验证，即使是用截断之后的share恢复出来的乘积，相较于定点乘法差距不大，误差几乎可以忽略不计。

1.2.3支持安全多方计算的激活函数

逻辑回归和神经网络必须使用sigmoid和softmax，但现在使用的用多项式去模拟激活函数的方式是低效。

本文提出了一种新的激活函数，类似于两个RELU函数之和并用小型混淆电路求和，来替代sigmoid，并用到了在算数分享和姚氏分享之间的切换。与之类似，为了替代softmax，提出了一种结合了RELU、加法和除法结合的激活函数。

1.2.4 其他提高效率的方法——向量化与客户端辅助生成三元组

​ 为了提高系统的整体效率，还提出了提高整体性能的方法，如向量化，提取数量数据的时候按batch来提取。离线阶段，提出一种更快的、每个客户帮助产生三元组的离线阶段。但是比起标准设定，安全性保证不够好，因为它需要客户端和服务器不会同流合污。

2 基础知识

2.1 机器学习

因为本文的重点在于隐私保护，所以涉及到的机器学习三个算法都是非常基础的，是机器学习中的"hello world"级的线性回归、逻辑回归和神经网络这三个算法。而且整体思路也几乎相同——先前馈，求出交叉熵，然后使用随机梯度下降再后馈来更新模型。以下是对于他们的简单回顾：

2.1.1　线性回归

线性回归是根据现有点，拟合出一个n元一次函数，所谓的模型就是系数向量w，把数据向量化表示之后，更新模型最核心的公式是：
$$
w:=w-{1over |B|}alpha X^T_B×(X_B×w-Y_B)
$$
其中，w为系数矩阵，也就是所谓的“模型”，每次训练时选出的那组数据叫做一个batch，|B|就是batch中数据的个数，(XB,YB)就是一个batch中所有的数据组成的向量组，物理意义其实就是函数图像上的很多点。

2.1.2　逻辑回归

逻辑回归在二分类问题上很常用，它一般得到的是一个介于0~1之间的数。逻辑回归和线性回归很类似，但是多了一个激活函数，就是这个激活函数使整个算法从线性飞跃到了非线性，把数据向量化之后，更新模型的公式和线性回归也很像，就是多了激活函数f：
$$
w:=w-{1over {|B|}}alpha X^T_B×(f(X_B×w)-Y_B)
$$
各个符号的意义和线性回归的几乎一样，激活函数f一般要么是logistic（这篇文章里叫logistic，但我看一般的机器学习资料里管他叫sigmoid）：
$$
y={1over {1+e^{-x}}}
$$
或者是softmax:
$$
y = {e^{-x_i} over sum e^{-x_i}}
$$
这都是很常见的激活函数了。

2.1.3　神经网络

这里提出的神经网络也是最常见的BP神经网络，整个过程和线性回归和逻辑回归大同小异。从本质上来说，线性回归只涉及到了线性的加乘操作，逻辑回归多了激活函数，神经网络相较于前两种算法在这个方面并没有什么本质上的突破，所以只要解决了线性和激活函数的隐私计算问题，这三种机器学习算法的运算问题都得到了解决。

作为深度学习的“hello world”任务，MNIST是所有新手的第一关，任务也非常简单，就是分类任务，不过是多分类。思路也类似，所谓的“模型”就是每一层神经网络之间的系数矩阵，先前馈，求出交叉熵，然后随机梯度下降，再后馈调整系数矩阵，最终达到一个比较理想的结果：
$$
W_i := W_i - {alphaover|B|}×f(X_{i-1}×W_i)×Y_i
$$

2.2 安全计算

2.2.1 不经意传输

​ 不经意传输是安全多方计算常用的技术：有一个发送者S,他有两个输入x0和x1，又有一个接收者R,它有一个选择比特b，得到xb（b∈{0,1}），但是S不知道b究竟是什么，而R也不可能知道除xb之外的另一个输入是什么。符号描述起来是：(null, xb) <- OT(x0,x1;xb)，伪代码描述起来是这样：

Parameter: Sender S and Receiver R

Main: On input (SELECT, sid, d) from R and (SEND, sid, x0, x1) from S, return (RECV, sid, xb) to R.

（：P8不经意传输的算法描述

我们在两个地方使用使用不经意传输：1、离线阶段产生三元组 2、计算激活函数

传统的不经意传输效率较低，这里使用了一种扩展的不经意传输correlated OT扩展，记作COT，能够允许接收和发送者执行m个OTs以n(n，一个安全参数)基、带有公钥操作的OTs和O(m)快速对称密钥操作的代价。在这里，两个输入是不独立的，s0是一个随机数，而s1=f(s0)，f是用户选定的一个系数矩阵。一个l-bit消息的COT，记作COTL，是n+l比特，计算由三个哈希组成。

2.2.2 混淆电路两方安全计算

混淆电路的目的是为了根据两方的输入x,y计算出f(x,y)的结果，但是参与运算的彼此不可能知道对方的输入，一套混淆方案大致由一下几部分组成：

参数１ 参数2 输出１ 输出２
混淆算法 随机种子$ 函数f 混淆电路F 解码表dec
解码表dec 随机种子$ x 混淆输入x^
评价(evaluation)算法 混淆输入x^ 混淆电路FZ[i] = UBi* V[i] 混淆输出z^
解码算法 混淆输出z^ 解码表dec f(x)

给定上述方案，则可以设计出一套安全两方计算协议，在一般的类似协议中，alice叫做generator，bob叫做evaluator。generator负责自己设计密钥，把整个真值表加密、混淆，然后和evluator利用不经意传输协议，evaluator做出选择之后，将选中的label和他的密钥还给evalator，两方再分别解密。一个例子如下:

  1. alice运行混淆算法：根据随机种子和函数f,生成混淆电路GC和解码表dec

  2. alice将x放入解码表dec编码之后得到混淆输入x^

  3. alice将混淆电路GC和混淆输入x^发送给bob

  4. bob通过不经意传输，得到了自己的混淆输入y^

  5. bob接着在GC上执行评价算法——通过x^ y和混淆电路GC得到混淆输出z

  6. 双方通过解码算法得到最终结果f(x)

    以上算法被记作：(za,zb) <- GarbledCircut(x;y,f)

2.2.3　秘密分享和三元组

​ 在我们的协议中，所有的中间结果都被两个服务器所秘密分享的。这里实现了三种不同的分享方案：加法、布尔和乘法分享。

一、加法分享

　　所谓将a加法分享，就是将a拆成两个数字，这两个数字之和是a，这两个数字由两方分别保存。记作(ShrA(.))。为了加法分享一个l-bit的值a，记作<.>，以alice和bob为例：

  1. alice随机产生一个2^l范围内的整数a0 (a0记作<a>A0 )

  2. alice计算出a1 = a - a0 mod 2^l

  3. alice将a1发送给bob (a1记作<a>A1)

    为了恢复RecA(.,.)已经被加法分享的值a，Pi将<a>i发送给P1-i，双方分别计算<a>0+<a>1

二、乘法分享

​ 所谓将c乘法分享，就是将c拆成两个数字，而这两个数字之积是c，这两个数字由两方分别保存。记作(MulA(.,.))。现在c已经被分享成了<a>和<b>，我们假设双方已经共享了<u> <v> <z>，其中：

  • u和v都是2^l整数域内的随机值

  • z = u*v mod 2^l

    乘法分享流程如下：

  1. Pi本地计算<e>i = <a>i - <u>i
  2. Pi本地计算<f>i = <b>i - <v>i
  3. Pi运行Rec(<e>0, <e>1)
  4. Pi运行Rec(<f>0, <f>1)
  5. Pi计算

$$
c_i = -i * e * f + f * _i + e * _i + _i
$$

三、布尔分享

布尔分享可以被视作在{0,1}整数域内的加法分享，其中异或被加法替代，逻辑与被乘法替代。
　　关于布尔分享和姚氏分享：此协议中不显式使用姚氏分享，因为它会被隐藏在混淆方案中，但是Y2B转换会被使用来将混淆输出变成布尔分享
　　可以把混淆电路协议视作操作姚氏分享的输入来产生姚氏分享的输出。特别地，在所有混淆方案中，generator为每个wire w产生两个随机字符串kw0,kw1。当使用点＆排序技术时，generator也产生随机排序比特rw，使Kw0 = kw0||rw，Kw1 = kw1 || (1-rw)。被排成串的比特流一会被用来排序每个被混淆真值表的行
　　比如，数字a的姚氏分享是<a>Y0 = Kw0, Kw1 & <a>Y1 = Kwa。为了恢复被分享的值，参与者交换他们的shares，异或或者逻辑与会被执行来评价相关的逻辑门。
　　从姚氏分享切换到布尔分享的操作记作Y2B(.,.)，其中，姚氏分享<a>Y0 = Kw0, Kw1 & <a>Y1 = Kwa，布尔分享则变成了P0拥有<a>B0＝Kw0[0]，P1拥有<a>B1= <a>Y1[0]=Kwa[0]换句话说，混淆方案中用来排序的比特可以被无缝切换到布尔分享。

3 隐私保护的机器学习

3.1　隐私保护的线性回归

​ 基于算数秘密分享和三元组的隐私保护的线性回归

训练数据被秘密分享于两个服务器S0 S1上，我们将其分别记为(<X>0, <Y>0) (<X>1, <Y>1)。s0可以使用它的公钥来加密第一个share，然后将加密后的结果和明文share上传S1上，S1把被加密的share传给S0来解密。

数据被秘密分享，模型也被秘密分享——系数矩阵w也被秘密分享于两个服务器上，初始阶段都是随机值，在两个服务器之间没有任何通信。每一轮GSD之后，它被更新但仍然保持秘密分享，直到训练的最后才会恢复。

在线阶段，我们进行线性回归的更新，公式是：
$$
w_j := w_j - alpha(sum^d_{k=1}x_{ik}w_k-y_i)x_{ij}
$$
因为没有向量化，所以这是一个个的数字，根据之前所述，这些数字都是被秘密分享在两个服务器上的，又因为只有加法和乘法，因此我们使用相应的、被分享值的加法和乘法算法给来更新系数：
$$
<w_j>　:= <w_j> - alpha MulA(sumd_{k=1}Mul ^A(<x_{ik}>,<w_k>)-<y_i>,<x_{ij}>)
$$
也就是说每个服务器用这个公式来分别更新自己本地的相应的值。

3.1.1　向量化

上面那个只是针对一个训练数据，举个例子，比如d=3，有这样一个训练数据([x1 x2 x3], y[1])，更新时就是i=1,j从1到3.

我们想要同时训练一个batch的数据，这样可以提高效率，所以可以使用向量化技术。所以我们将共享值上的线性操作推广到了共享矩阵上的线性操作。其实非常类似，就是把所有的值都换成了矩阵即可，矩阵中的每个元素视作共享值即可。如果mini-batch有B条数据，那么在线阶段的更新公式就是变成了：
$$
<old w> := <old w> - {1over|old B| } alpha Mul^A(<old XT_B>,MulA(<old X_B>,<old w>)-<old Y_B>)
$$
一个样本在不同的轮次上会被使用很多次，它满足用同样的随机三元组来掩盖它。因此离线阶段，一个共享的n*d随机矩阵<U>被用来生成掩盖数据样本<X>。

在线阶段的起始阶段，<E>i = <X>i - <Y>i被计算并被交换来重构E。此后，EB被选择而且被使用在乘法协议中，不带有任何更多的计算和交流。特别的，在离线阶段，一系列下标B1,B2...Bt在两个服务器间得到公认。仅仅需要n,d,t的知识或者一个上标而不需要真实数据。然后三元组<U>,<V>,<Z>,<V'>,<Z'>被提前计算：

维度 作用 备注
U n×d mask data X
V d×t 每一列用来mask w forward propagation
Z |B|×t 中间结果 Z[i] = UBi* V[i]
V' |B|×t 每一列用来mask Y* - Y backward propagation
Z' d×t 中间结果 Z'[i] = UTBi* V'[i]

将数据用矩阵形式表示，将大大降低交流和通信的效率.

3.1.2　被分享的十进制数上的算数操作

正如之前讨论的，前人工作的不高效主要来源于在共享/加密的十进制数上的计算，之前的解决方案主要有两种：
1、把共享的十进制数看成整数，做乘法后在很大的有限域上完全保留下所有的精度。缺点是只能支持一定数量的乘法，因为结果的范围会随着乘法的数量指数级增长。
２、在十进制数上利用安全两方计算的布尔电路来做定点或者浮点乘法。这带来了大量的负载，因为计算两个l-比特长的数的乘法就需要O(l^2)个门，在2PC（例如姚氏混淆电路中），这样的电路需要为每个乘法进都算一次。

本文提出了一种简单但有效的支持有限域上的十进制数的解决方案。考虑对两个小数部分最多有lD比特的两个十进制数x y的定点乘法，首先把通过x' = 2^lD×x,y' = 2^lD×y，把数字转化成整数，然后把他们相乘得到z = x'×y'，注意到z最多有2lD表示积的小数部分，所以我们简单粗暴地将最后z的最后lD比特砍掉，这样它最多有lD比特来表示小数部分。
z也可以被秘密分享，可以证明，两个服务器分别砍去自己的最后lD位比特，和想要的z其实最多相差一个最不重要的比特位，这对最后结果的影响可以说是微乎其微。换句话说，相较于标准的定点乘，我们只是缺少了小数部分最不重要的一个比特位。

隐私保护的线性回归的在线部分的协议如图所示：

线性回归
协议假定了数据无关的共享矩阵<U><V><Z><V'><Z'>已经在离线阶段产生，除了共享十进制数的加乘，协议还需要将系数向量和学习率相乘，为了让乘法更有效率，将{alpha over |B|}变成2的幂次，比如{alpha over |B|} = 2^{-k}

3.2　离线阶段——产生三元组子

说到底我还是不理解，在线和离线阶段都分别用来干什么？我的理解是，所谓模型更新，所需要的不过是一次线性混淆计算，简单来讲，就是双方共同计算一个a*b即可，然后各自可以得到计算结果。这么讲吧，你自己也发现了，你自己其实可能根本不需要online就能做很多事情，你所需要online做的只是一小部分，很多事情没必要online做了，所以分成了online和offline。

那我们这里线下做了些什么呢？就是generate 三元组。对啊，我就是想问，为什么offline的一定是generate 三元组？而不是其他的工作？

回忆一下，给定共享随机矩阵（这里所谓的共享是什么意思？是两方拥有一样的矩阵？还是说这个矩阵被秘密分享，即可以用两个数字相加恢复出来？）<U>，<V>关键步骤是从<U>中选择一个|B|×d的子矩阵，和从<V>选择一个列并计算他们积的shares，这被重复t次来计算出<Z>,<Z'>被这样计算以相反的维度。

因此，简化起见，我们关于于基础步骤，给定|B|×d的矩阵<A>的shares，和一个d×1的矩阵<B>的shares，我们想要计算|B|×1的矩阵<C>的shares。我们利用接下来的关系：C = <A>0 ×<B>0 + <A>0 ×<B>1 +<A>1 ×<B>0 +<A>1 ×<B>1。<<A>0 ×<B>1> <<A>1 ×<B>0>可以合作计算，而 <A>0 ×<B>0 <A>1 ×<B>1即可在本地计算。

接下来就是如何合作计算<<A>0 ×<B>1> 、<<A>1 ×<B>0>>这两个式子的问题

3.2.1　基于同态加密的生成

为了计算<A>0 ×<B>1的shares，S1使用LHE加密<B>1的每个元素，并将它发送给S0。S0然后在密文上执行矩阵乘法，其中加法被乘法替代，乘法被幂运算取代。最后，S0将得到的密文用随机值掩盖，发送给S1解密。最终的结果就是S0和S1分别得到了<<A>0 ×<B>1>0和<<A>0 ×<B>1>1这两个shares。对于计算<<A>1 ×<B>0>>，方法是一样的。再用上可以本地计算的两个式子，C即可算出出来。说白了，线下阶段就是在计算无法本地计算的三元组子嘛？

我大概懂了什么叫generate 三元组，说白了就是根据本地存储的<A>和<B>计算出<C>，上面的分析是将求出<C>拆成四个式子的运算，一半可以offline做，一半需要交流。需要交流的那个两个式子的求解过程只需要传送一下两个被加密/混淆过的矩阵即可，通信开销小。计算开销通过分析是可以接受的.

3.2.2　基于不经意传输的生成

上面的问题——计算<<A>0 ×<B>1>的shares也可以用不经意传输来解决，步骤如下：

  1. S1使用bj个比特来选择从2个使用COT从aij中计算出来的值选一个出来（明明就是一个aij，为什么要变成两个，而且怎么变成两个的？？？）
  2. 对于k=1~l，S0设置COT的系数函数为fk(x)=aij*2^k+x mod 2^l
  3. S0执行COT(rk,fk(xj); bj[k])
  4. S1执行COT(rk, fk(x); bj[k])
    • 如果bj[k] = 0，S1得到　rk
    • 如果bj[k] = 1，S1得到　aij*2^k+x mod 2^l
    • 也可以写成bj[k] * aij * 2^k + rk mod 2^l

$$
<a_{ij},b_j>_0 = sum _{k=1}^l*(-r_k) (mod 2^l)
$$

$$
<a_{ij},b_j> 1= sum {k=1}l(b_j[k]*aij*2k+r_k)= a{ij}*b_j+sum{k=1}^lr_k (mod 2^l)
$$

3.3　隐私保护的逻辑回归

相较于线性回归，逻辑回归需要在共享数字上计算激活函数：
$$
f(u)={1over 1+e^{-u}}
$$
这其中有除法有幂运算，很难用算数或布尔电路来进行安全两方计算。之前使用的用多项式去近似的方法虽然可以行但是效率太低而无法使用。

3.3.1　安全计算友好型激活函数

所以作者提出用这样一种激活函数来作为替代方案：

$$
f(x)=egin{cases}0,&if quad x<-{1over 2}cr x+{1over 2},&if quad -{1over 2} leq x leq {1over 2}cr1,&ifquad x> {1over 2} end{cases}
$$
激活函数

之所以使用这个函数，一来是因为它在边界很容易收敛到0或1，而且和RELU函数很像。

一旦我们使用新的激活函数，在计算后馈阶段时，我们使用相同的更新函数作为逻辑函数，即继续使用逻辑函数计算偏导数，这种方法经过实验证明效率很好。作者页建议探索更多安全多方计算友好型可以被简单的布尔和算数电路计算的激活函数。

3.3.2　隐私保护协议

新的激活函数是电路友好型。它仅仅包含了测试输入是否在[-1/2,1/2]这个区间。但是，仅仅把姚氏混淆电路协议整个的直接用到激活函数中是不高效的。相反，我们利用在算数分享和姚氏分享之间切换的技术。逻辑回归和线性回归随机梯度下降的唯一不同就是逻辑回归在每个前馈过程都多了一个额外的激活函数。因此，首先我们和计算线性回归一样，先计算除了数据和系数矩阵的内积，然后将算数分享切换到姚氏分享并计算激活函数的值使用混淆电路。然后在切换回算数分享来继续后馈过程。具体训练过程如下：

逻辑回归

3.4　隐私保护的神经网络训练

在隐私保护的线性回归和逻辑回归都可以被很顺畅地扩展来支持隐私保护的神经网络的训练，我可以使用RELU函数作为每个神经元的激活函数，交叉熵作为损失函数。每个神经元的系数的更新函数都可以像表达成像2.1中讨论的那种封闭模式。除了激活函数的求值和偏导函数外，前馈和后馈阶段的所有函数都是简单的线性操作。为了给RELU函数求和和求导，我们像给逻辑函数那样转换到姚氏分享即可，混淆电路仅仅将两个shares相加并输出最重要的比特，比我们在逻辑函数中使用的电路还要简单。RELU的求值和求导函数可以在一轮之内一起求出来，求导的结果用在后馈阶段。
　　我们也提出了安全多方计算友好型的softmax的替代方案。然后我们将RELU所有的输出加起来求和，使用出发电路，将每个输出除以总和。这样，输出可以保证是概率分布。
　　根据实验中的观察，花在RELU混淆电路上的时间占了大量的在线训练时间。因此，我们也考虑将激活函数替换成平方函数。这样调整之后，我们达到了93.1%的准确率。现在，一个计算RELU函数的混淆电路被在共享值上的三元组子所替代，在线阶段的性能大大提高。但是，这种方法花费了更多的三元组也提高了在线阶段的开销。

3.4.1　效率讨论

在线阶段，计算复杂度是　使用矩阵算数操作的明文训练加上RELU求值和使用混淆电路和不经意传输的　两倍。
离线阶段，三元组的总数相较于增长了O(sum^m_{i=1}d_m)相较于回归，这其实是神经元的总数。一些三元组子可以为在线矩阵乘法以矩阵形式产生

3.5.1　隐私保护预测

我们迭代我们可以隐藏输入数据、模型、预测结果和他们的任意组合，因为在我们的协议中他们可以秘密分享。如果要么输入数据、要么模型可以被揭露出来，效率可以进一步提升，例如，如果模型是明文，带有矩阵的输入数据的乘法可以被直接计算在shares，不需要直接计算的三元组

4 客户端辅助的离线协议

主要的性能瓶颈是离线阶段，它包含大量的密码学操作例如OT或者LHE，，当然会比在线阶段的在有限域上的简单的加乘操作慢。这刺激我们去寻找另外一种产生三元组的替代方案。尤其，我们让客户端产生三元组。既然客户端首先需要秘密分享他们的数据，进一步让他们秘密分享一些额外的三元组也是自然而然的事情。现在，一些三元组可以在没有任何秘密学操作、以可信任的方式产生。这大大提高了效率，尽管他有好处，也改变了安全模型。

4.1　客户端辅助的三元组

简单起见，注意到在整个训练过程中，每个数据样本中的特征在两个三元组子中用到了——一次是在前馈阶段，一次是在后馈阶段。因此，它suffices for客户端持有这个值来产生2E三元组。尤其，对于每个样本中的每个特征，客户端处理数据来产生随机值u来掩盖数据，产生随机值vk，vk'　for k = 1~E并计算zk=u*vk，zk'=u* vk'　最后，客户端将<u>, <vk>, <vk'>, <zk>, <zk'>的shares分布在两个服务器上。这次操作我肯定在哪里见过，如果是服务器做，该怎么做呢？服

我们不假定客户端在产生三元组的时候知道数据是如何partitioning的，这意味着我们无法从在线阶段的向量化中获益。举个例子，在线性回归的前馈阶段，我们使用之前计算的和在线阶段具有一样的维度的矩阵三元组U×V=Z。现在，当三元组被客户端产生时，在mini-batch Xb中的数据或许属于不同的，且不知道他们拥有相同的训练batch的客户端，因此不同共认一个共同的随机矩阵V来计算Z
相反的，如果不进行向量化，即对于在XB中的每个数据样本x,双方使用独立产生的三元组计算<y*>=MulA(<x,w))。因此，在线阶段的通信、计算开销和两台服务器的存储负载都提高了。
客户端辅助三元组产生因为没有密码学操作参与其中，虽然提高了离线阶段的效率，但是因为矩阵三元组被向量的内积所替代，它将负载引入了在线阶段。所要执行的乘法的总数是相同的，总体上，矩阵相乘算法比使用编程语言中的矩阵库要快。这是最大的被客户端辅助产生三元组引入的负载。
通信的开销也同样上升了，以前系数矩阵被一个随机矩阵所掩盖来计算一个矩阵乘法，现在每计算一个内积就要被很多不同的随机矩阵来掩盖。被掩盖的值要用安全计算协议在两方之间传输。
　　最后，存储开销也提升了。先前，矩阵V和矩阵Z比数据大小要远远地小，矩阵U和数据一样的大小。现在，因为三元组子被独立产生，V的大小变成了|B|*d*t=n*d*E，比数据的大小要多出一个E。U的大小仍然一样，因为每个数据仍然被一个随机值所掩盖，Z的大小仍然相同因为一旦服务器从所有的客户端那里收到了shares，值将会被聚合。
　　尽管有这样负载，因为离线阶段被大大提升，在线阶段仍然是有效率的，所以整体的性能被大大提升。这种客户端辅助产生三元组的架构也是是现在最有前景的一种架构。

4.2　新的安全模型

安全模型也随之发生改变，仅仅记下改变的那一部分。先前，用户只负责上传数据，因此服务器当然无法知道任何信息当它和一小部分客户端同流合污时。现在，因为客户端也产生三元组，如果一小部分客户端和服务器联合起来时，他们或许可以恢复出系数矩阵，这损害了诚实客户端的利益。因此在这个安全模型中不允许服务器和客户端同流合污。

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/huangming-zzz/p/12007155.html