Page 343 - 《软件学报》2026年第6期
P. 343

2662                                                       软件学报  2026  年第  37  卷第  6  期


                  2.4   威胁模型
                    本文采用了与之前工作相同的半诚实模型               [12,27] . 在这个模型下, 参与者在遵循协议的同时可能会尝试获取彼
                 此的额外信息. 假设模型的结构是公开的, 包括层的类型和数量以及内核的大小                         [13] . 攻击者可能会采用更高级的
                 攻击方式, 比如模型提取、模型入侵和成员推理. 然而, 该方案并不旨在防御这些攻击, 这超出了该框架的范围, 就
                 如同现有研究工作       [9,10,14] . 此外, 我们假设客户端和云服务器之间的所有数据通信都通过安全信道进行, 从而有效
                 阻止窃听攻击.

                  3   方案描述

                    本节提出方案框架, 该框架以秘密分享的方式计算线性和非线性层. 对于线性层, 提出了矩阵分解计算协议来
                 进行矩阵乘法. 对于非线性层, 设计了参数化二次多项式来近似计算                    ReLU  激活函数.
                  3.1   安全线性层
                    卷积深度神经网络中的层大都是卷积层, 例如               ResNet50  中的  49  个卷积层. 卷积层关键计算可以转换为矩阵

                 乘法   F = W · X, 其中  W  是通过重塑原始的四维张量得到的二维矩阵,           X  是通过将三维张量滑动成矩阵列而形成
                 的. 与此同时, 卷积深度神经网络中的全连接层也是通过矩阵乘法实现的. 然而, 现有工作为了完成矩阵乘法的安
                 全计算, 通常会涉及复杂的加密原语           (例如, 同态加密), 导致计算效率较低.
                    为了解决这个问题, 我们提出了基于秘密分享矩阵分解计算协议. 通过采用轻量级秘密分享, 加快了线性层矩
                 阵乘法的安全计算效率. 具体地, 在该框架中, 将线性层计算分为两个阶段: 离线阶段和在线阶段. 在离线阶段, 客
                 户端  C  和云服务器   S  预先计算数据. 这个阶段独立于客户端的输入执行, 这使得双方都能在客户端发起隐私保护
                 预测请求之前完成整个过程.
                    离线阶段: 此阶段包括       3  个步骤. 首先, 客户端生成随机掩码         R ∈ R y×z   和盲化矩阵  A ∈ R . 然后, 客户端持有
                                                                                        y×z
                             y×z
                 R ∈ R y×z   和   A ∈ R , 而云服务器持有  W ∈ R  x×y , 它们作为矩阵分解计算协议的输入  (见协议  1). 最后, 客户端和云服
                 务器都持有    W · R 的秘密分享份额    (即  M + N = W · R). 具体过程如下.
                    步骤   1: 客户端和云服务器需要进行本地数据处理, 即客户端生成随机矩阵                      R ∈ R , 并将  R  分成两个矩阵
                                                                                    y×z
                                                                                 ′
                                                                                            ′
                 R ∈ R y/2×z   和  R ∈ R y/2×z  , 它们分别是  R  的前半行和后半行; 云服务器生成随机矩阵  W ∈ R x×y  , 并将  W  分成两个矩
                                                                                   ′
                            ′
                  ′
                                                                                              ′
                                              ′
                            s
                  f
                                                 ′
                   W ∈ R x×y/2  W ∈ R x×y/2    W  的前半列和后半列.
                     ′
                               ′
                 阵   f      和   s    , 它们分别是
                    步骤   2: 客户端和云服务器进行数据交换, 即客户端计算               A· R , R 1 = R+ R + A 和  R 2 = R − R  并发送给云
                                                                    ′ −1
                                                                                              ′
                                                                                           ′
                                                                               ′
                                                                                              f
                                                                                           s
                                            ′ −1
                                                    ′
                                                                  ′
                                                                     ′
                 服务器; 云服务器计算      B = W · A· R , W 1 = W −W − B, W 2 = W +W  并发送给客户端.
                                                                  s   f
                    步骤  3: 客户端和云服务器完成本地计算, 即云服务器计算              M = W · R 1 +W · R 2 ; 客户端计算  N = W 1 · R −W 2 · R .
                                                                                                 ′
                                                                                                       ′
                                                                           ′
                                                                            f                          s
                 协议  1. 矩阵分解计算协议.
                 输入:   S  输入矩阵  W ∈ R ,  C  输入随机掩码  R ∈ R y×z   和盲化矩阵  A ∈ R ;
                                   x×y
                                                                      y×z
                                   x×z
                                                   x×z
                 输出:   S  得到矩阵  M ∈ R ,  C  得到矩阵   N ∈ R , 其中  M + N = W · R.
                 // 数据准备
                                    y×z
                 1.  C  生成随机矩阵   R ∈ R , 并将   R  分成两个矩阵  R ∈ R y/2×z  和  R ∈ R y/2×z  , 它们分别是  R  的前半行和后半行.
                                 ′
                                                                                     ′
                                            ′
                                                         ′
                                                                   ′
                                                         f
                                                                   s
                          ′ −1
                 2.  C  将   A· R , R 1 = R+ R + A 和  R 2 = R − R  发送给  .
                                    ′
                                                          S
                                                ′
                                                   ′
                                                s  f
                                    x×y
                 3.  S  生成随机矩阵  W ∈ R , 并将  W  分成两个矩阵    W ∈ R x×y/2   和  W ∈ R  x×y/2  , 它们分别是  W  的前半列和后半列.
                                                                                       ′
                                             ′
                                 ′
                                                          ′
                                                                     ′
                                                          f          s
                 4.  S  计算  B = W · A· R ′ −1 .
                 5.  S  将  W 1 = W −W − B 和  W 2 = W +W  发给  C.
                            ′
                                               ′
                                           ′
                                           s   f
                 // 结果计算
                 6.  S  计算  M = W · R 1 +W · R 2 .
                                    ′
                                    f
                 7.  C  计算  N = W 1 · R −W 2 · R .
                                      ′
                                ′
                                      s
   338   339   340   341   342   343   344   345   346   347   348