fun. 逗~

纵向联邦线性回归实现-Federated Machine Learning Concept and Applications论文复现

本实验的算法实现思路来自这篇论文Federated Machine Learning Concept and Applications

文章目录

场景介绍
同态加密算法
- python的phe库实现了加法同态加密
- - 角色1
  - 角色2
传统的线性回归
纵向联邦线性回归
纵向联邦线性回归代码实现
- 导入工具包
- 准备数据
- 使用普通线性回归训练
- - 搭建训练过程
- 纵向联邦线性回归实现
- - 垂直切分数据集
  - 客户端父类实现
  - 客户端A类实现
  - 客户端B类实现
  - 调度发C类实现
  - 搭建训练过程
  - 训练流程实现
  - 预测

场景介绍

现有同一个城市的两家公司A和B，A公司和B公司的业务范围不同，但所服务的业务对象大多都是该城市的人，所以A公司和B公司所持与的数据，样本ID重叠较多，样本特征重叠较少(因为业务逻辑不同)。而且B公司拥有标签y，A公司没有，所以A公司是无法单边建模的。B公司虽然可以单边建模，但由于样本特征数较少，建模效果不理想。现在出现了一种纵向联邦建模的技术，可以在保护参与方数据隐私的前提下进行联合学习，A和B这种情况的联邦学习属于纵向联邦学习。

同态加密算法

同态加密（英语：Homomorphic encryption）是一种加密形式，它允许人们对密文进行特定形式的代数运算得到仍然是加密的结果，将其解密所得到的结果与对明文进行同样的运算结果一样。分为半同态加密和全同态加密。
联邦学习通常采用半同态加密中的加法同态加密，即加密后加法和数乘的结果，与加密前一样
$\begin{array}{l} u + v = [[u]] + [[v]]\\ k*u = k*[[u]] \end{array}$

python的phe库实现了加法同态加密

使用以下命令进行安装

pip install phe

主要有两个角色，角色1：控制私钥和公钥。角色2：没有私钥，只有公钥。使用以下命令导入paillier包

from phe import paillier

角色1

生成公钥和私钥

public_key, private_key = paillier.generate_paillier_keypair()

有了公钥之后，可以对数字进行加密

secret_number_list = [3.141592653, 300, -4.6e-12]
encrypted_number_list = [public_key.encrypt(x) for x in secret_number_list]
encrypted_number = public_key.encrypt(3)

解密需要通过私钥

[keyring.decrypt(x) for x in encrypted_number_list]
>>>[3.141592653, 300, -4.6e-12]

角色2

角色2没有私钥，通常接受加密后的数字，然后与自己的未加密的数据进行运算，然后发送给角色1进行解密。可以通过一下两种方式实现：
1.显式的将加密数字的公钥取出，然后对自己的数据加密，进行运算

# 取出公钥
public_key = encrypted_number.public_key
# 对本地未加密的数据用公钥加密，然后将加密后的数据相加，发送给角色1进行解密
local_number = 10
encrypted_local_number = public_key.encrypt(local_number)
encrypted_sum = encrypted_local_number + encrypted_number

2.将为加密的数据与加密数据直接运算，phe库会帮你隐式的进行转换，这种运算支持以下三种方式

加密数字与标量相加
加密数字与加密数字相加
加密数字与标量相乘

 a, b, c = encrypted_number_list
 a_plus_5 = a + 5
 a_plus_b = a + b
 a_times_3_5 = a * 3.5

Numpy的array操作也支持，矩阵乘向量，向量加法等

import numpy as np
nc_mean = np.mean(encrypted_number_list)
enc_dot = np.dot(encrypted_number_list, [2, -400.1, 5318008])

传统的线性回归

传统的机器学习，若要联合多方进行建模，需要把数据合并到数据中心，然后再训练模型。设X为A和B合并后的数据， $\theta$ 为模型的参数，y为数据的标签。损失函数如下所示：
${\rm{L = }}\frac{1}{2n}\sum\limits_{i = 1}^n {{{({\theta ^T}{x_i} + b - {y_i})}^2} +\frac{ \lambda}{2} } ||\theta |{|^2}$
损失函数对 $\theta$ 的梯度为：
$\frac{{\partial {\rm{L}}}}{{\partial \theta }} = \frac{1}{n}\sum\limits_{i = 1}^n {({\theta ^T}{x_i} + b - {y_i}){x_i} + \lambda } \theta$
最后采用梯度下降法，对参数进行更新
${\theta ^{t + 1}} = {\theta ^t} - \eta \frac{{\partial {\rm{L}}}}{{\partial \theta }}$

纵向联邦线性回归

由于上述方法需要将数据移动到数据中心，对参与方的数据隐私造成了破坏，联邦学习的思想就是在不动参与发的数据的前提下将模型训练出来。对上面损失函数进行调整，令
$\begin{array}{l} {\theta ^T} = \left( \begin{array}{l} \theta _A^T\\ \theta _B^T \end{array} \right)\\ \\ {x_i} = (x_i^{\rm{A}},x_i^B) \end{array}$
$x_i^{\rm{A}}$ 和 $x_i^{\rm{B}}$ 分别表示A公司、B公司的本地数据， $\theta _A^T$ ， $\theta _B^T$ 分别表示A、B公司训练的本地模型
则目标函数变成：
${\rm{L = }}\frac{1}{{2n}}\sum\limits_{i = 1}^n {{{(\theta _A^Tx_i^{\rm{A}} + \theta _B^Tx_i^B + b - {y_i})}^2} + \frac{\lambda }{2}} (||\theta _A^T|{|^2} + ||\theta _B^T|{|^2})$
可以进一步简化，令
$\begin{array}{l} \theta _B^T = \left( \begin{array}{l} \theta _B^T\\ b \end{array} \right)\\ \\ x_i^B = (x_i^B,1) \end{array}$
将b合并到 $\theta _B^T$ 中
损失函数变成：
${\rm{L = }}\frac{1}{{2n}}\sum\limits_{i = 1}^n {{{(\theta _A^Tx_i^{\rm{A}} + \theta _B^Tx_i^B - {y_i})}^2} + \frac{\lambda }{2}} (||\theta _A^T|{|^2} + ||\theta _B^T|{|^2})$
令
$\begin{array}{l} u_i^A = \theta _A^Tx_i^{\rm{A}}\\ u_i^B = \theta _B^Tx_i^B \end{array}$
则加密后的损失函数为
${\rm{[[L]] = [[}}\frac{1}{{2n}}\sum\limits_{i = 1}^n {{{(u_i^A + u_i^B - {y_i})}^2} + \frac{\lambda }{2}} (||\theta _A^T|{|^2} + ||\theta _B^T|{|^2})]]$
令
$\begin{array}{l} [[{L_A}]] = {\rm{[[}}\frac{1}{2}\sum\limits_{i = 1}^n {{{(u_i^A)}^2} + \frac{\lambda }{2}} ||\theta _A^T|{|^2}]]\\ \\ [[{L_B}]] = {\rm{[[}}\frac{1}{2}\sum\limits_{i = 1}^n {{{(u_i^B - {y_i})}^2} + \frac{\lambda }{2}} ||\theta _B^T|{|^2}]]\\ \\ [[{L_{AB}}]] = {\rm{[[}}\sum\limits_{i = 1}^n {u_i^A(u_i^B - {y_i})} ]] \end{array}$
则
$\frac{1}{n}([[{L_A}]] + [[{L_B}]] + [[{L_{AB}}]])$
令
${d_i}]] = [[u_i^A]] + [[u_i^B - {y_i}]]$
则损失函数对 $\theta _A^T$ ， $\theta _B^T$ 的梯度分别为：
$\begin{array}{l} [[\frac{{\partial L}}{{\partial {\theta _A}}}]] = \sum\limits_i {[[{d_i}]]x_i^{\rm{A}} + [[\lambda {\theta _A}]]} \\ \\ [[\frac{{\partial L}}{{\partial {\theta _B}}}]] = \sum\limits_i {[[{d_i}]]x_i^B + [[\lambda {\theta _B}]]} \end{array}$
因为涉及到解密，所以私钥存放在调度方C，A和B都没有私钥进行解密，所以在交换中间结果是不会泄露隐私，发给C的加密梯度可以用一个随机数进行掩码，这个随机数只有A和B自己知道，所以梯度也不会直接暴露给C
训练过程整个算法流程如图所示

纵向联邦线性回归代码实现

导入工具包

from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split
from sklearn.linear_model import Ridge
import numpy as np
from sklearn.metrics import r2_score
from VFL_LinearRegression import *
from sklearn.metrics import mean_squared_error
from phe import paillier

准备数据

使用sklearn自带糖尿病数据集

dataset = load_diabetes()
X,y = dataset.data,dataset.target
X_train, X_test, y_train, y_test  = train_test_split(X,y,test_size=0.3)
# 堆叠一列1，把偏置合并到w中
X_train = np.column_stack((X_train,np.ones(len(X_train))))
X_test = np.column_stack((X_test,np.ones(len(X_test))))
# 打印数据形状
for temp in [X_train, X_test, y_train, y_test]:
    print(temp.shape)
>>>
(309, 11)
(133, 11)
(309,)
(133,)

使用普通线性回归训练

先不切分数据，用传统的线性回归训练一遍，相当于把数据集中到数据中心，记录损失
训练参数配置

config = {
    'lambda':0.4, #正则项系数
    'lr':1e-2,    # 学习率
    'n_iters':10, # 训练轮数
}

搭建训练过程

weights = np.zeros(X_train.shape[1])
loss_history = []
for i in range(config['n_iters']):
    L = 0.5 * np.sum(np.square(X_train.dot(weights) - y_train)) + 0.5 * config['lambda'] * np.sum(np.square(weights))
    dL_w = X_train.T.dot(X_train.dot(weights) - y_train) + config['lambda'] * weights
    weights = weights - config['lr'] * dL_w / len(X_train)
    loss_history.append(L)
    print('*'*8,L,'*'*8)
    print('weights:{}'.format(weights))