mpc_vertical

Documentation

Index

• func CalCost(costMap map[int]float64) float64
• func CalEncLocalGradient(localPart *RawLocalGradAndCostPart, tagPart *EncLocalGradAndCostPart, ...) (*common.EncLocalGradient, error)
• func CalEncLocalGradientTagPart(tagPart *RawLocalGradAndCostPart, otherPart *EncLocalGradAndCostPart, ...) (*common.EncLocalGradient, error)
• func CalGradient(gradMap map[int]float64) float64
• func CalGradientWithLassoReg(thetas []float64, gradMap map[int]float64, featureIndex int, regParam float64) float64
• func CalGradientWithReg(thetas []float64, gradMap map[int]float64, featureIndex int, regMode int, ...) float64
• func CalGradientWithRidgeReg(thetas []float64, gradMap map[int]float64, featureIndex int, regParam float64) float64
• func CalLassoRegCost(thetas []float64, trainSetSize int, regParam float64) float64
• func CalRidgeRegCost(thetas []float64, trainSetSize int, regParam float64) float64
• func DecryptCost(encCostMap map[int]*big.Int, privateKey *paillier.PrivateKey) map[int]*big.Int
• func DecryptGradient(encGradMap map[int]*big.Int, privateKey *paillier.PrivateKey) map[int]*big.Int
• func EvaluateEncLocalCost(localPart *RawLocalGradAndCostPart, tagPart *EncLocalGradAndCostPart, ...) (*common.EncLocalCost, error)
• func EvaluateEncLocalCostTag(localPart *RawLocalGradAndCostPart, otherPart *EncLocalGradAndCostPart, ...) (*common.EncLocalCost, error)
• func PreProcessDataSet(sourceDataSet *common.StandardizedDataSet, label string) *common.TrainDataSet
• func PreProcessDataSetNoTag(sourceDataSet *common.StandardizedDataSet) *common.TrainDataSet
• func PredictLocalPartNoTag(thetas, standardizedInput map[string]float64) float64
• func PredictLocalPartTag(thetas, standardizedInput map[string]float64) float64
• func RetrieveRealCost(decCostMap map[int]*big.Int, accuracy int, randomInt *big.Int) map[int]float64
• func RetrieveRealGradient(decGradMap map[int]*big.Int, accuracy int, randomInt *big.Int) map[int]float64
• func StandardizeDataSet(sourceDataSet *common.DataSet, label string) *common.StandardizedDataSet
• func StandardizeLocalInput(xbars, sigmas, input map[string]float64) map[string]float64
• type EncLocalGradAndCostPart
• type LocalGradAndCostPart
  • func CalLocalGradAndCostPart(thetas []float64, trainSet [][]float64, accuracy int, regMode int, ...) (*LocalGradAndCostPart, error)
  • func CalLocalGradAndCostTagPart(thetas []float64, trainSet [][]float64, accuracy int, regMode int, ...) (*LocalGradAndCostPart, error)
• type RawLocalGradAndCostPart

Functions

func CalCost

func CalCost(costMap map[int]float64) float64

CalCost 根据还原的损失信息计算损失值

func CalEncLocalGradient

func CalEncLocalGradient(localPart *RawLocalGradAndCostPart, tagPart *EncLocalGradAndCostPart, trainSet [][]float64, featureIndex, accuracy int, publicKey *paillier.PublicKey) (*common.EncLocalGradient, error)

CalEncLocalGradient 非标签方聚合双方的中间加密参数，为本地特征计算模型参数 计算本地加密梯度，并提交随机数干扰 参与方A执行同态运算 梯度的计算：Grad(i) = (predictValue(j) - realValue(j))*trainSet[j][i]

= (0.5 + x/4 - y)*x(i) = (0.5 + (preValA + preValB)/4 - y)*x(i)
= (0.5 + preValA/4 + (preValB/4 - y))*x(i)
= x(i)*preValA/4 + x(i)*(0.5 + preValB/4 - y)

- localPart 非标签方本地的明文梯度数据 - tagPart 标签方的加密梯度数据 - trainSet 非标签方训练样本集合 - featureIndex 指定特征的索引 - accuracy 同态加解密精度 - publicKey 标签方同态公钥

func CalEncLocalGradientTagPart

func CalEncLocalGradientTagPart(tagPart *RawLocalGradAndCostPart, otherPart *EncLocalGradAndCostPart, trainSet [][]float64, featureIndex, accuracy int, publicKey *paillier.PublicKey) (*common.EncLocalGradient, error)

CalEncLocalGradientTagPart 标签方聚合双方的中间加密参数，为本地特征计算模型参数 计算本地加密梯度，并提交随机数干扰 参与方B计算加密梯度信息 梯度的计算：Grad(i) = (predictValue(j) - realValue(j))*trainSet[j][i]

= (0.5 + x/4 - y)*x(i) = (0.5 + (preValA + preValB)/4 - y)*x(i)
= (0.5 + preValA/4 + (preValB/4 - y))*x(i)
= x(i)*preValA/4 + x(i)*(0.5 + preValB/4 - y)

- localPart 标签方本地的明文梯度数据 - otherPart 非标签方的加密梯度数据 - trainSet 标签方训练样本集合 - featureIndex 指定特征的索引 - accuracy 同态加解密精度 - publicKey 非标签方同态公钥

func CalGradient

func CalGradient(gradMap map[int]float64) float64

CalGradient 根据还原的明文梯度数据计算梯度值

func CalGradientWithLassoReg

func CalGradientWithLassoReg(thetas []float64, gradMap map[int]float64, featureIndex int, regParam float64) float64

CalGradientWithLassoReg 使用L1正则(Lasso)计算梯度 定义总特征数量n，总样本数量m，正则项系数λ（用来权衡正则项与原始损失函数项的比重） Grad_new(i) = (Grad_new(i) + λ*sgn(θ(i)))/m 其中，trainSet[j][i] 表示第j个样本的的第i个特征的值

func CalGradientWithReg

func CalGradientWithReg(thetas []float64, gradMap map[int]float64, featureIndex int, regMode int, regParam float64) float64

使用批量梯度下降来计算实际下降的梯度，增加L1\L2正则化支持 批量梯度下降(batch gradient descent)，样本不多的情况下，相比较随机梯度下降(SGD,stochastic gradient descent)收敛的速度更快，且保证朝全局最优逼近

func CalGradientWithRidgeReg

func CalGradientWithRidgeReg(thetas []float64, gradMap map[int]float64, featureIndex int, regParam float64) float64

CalGradientWithRidgeReg 使用L2正则(Ridge)计算梯度 定义总特征数量n，总样本数量m，正则项系数λ（用来权衡正则项与原始损失函数项的比重） Grad_new(i) = (Grad_new(i) + λ*θ(i))/m 其中，trainSet[j][i] 表示第j个样本的的第i个特征的值

func CalLassoRegCost

func CalLassoRegCost(thetas []float64, trainSetSize int, regParam float64) float64

CalLassoRegCost 计算使用L1 Lasso进行正则化后的损失函数，来评估当前模型的损失 定义总特征数量n，总样本数量m，正则项系数λ（用来权衡正则项与原始损失函数项的比重） L1 = λ/m * (|θ(0)| + |θ(1)| + ... + |θ(n)|)，其中，|θ|表示θ的绝对值

- thetas 当前的模型参数 - trainSetSize 训练样本个数 - regParam 正则参数

func CalRidgeRegCost

func CalRidgeRegCost(thetas []float64, trainSetSize int, regParam float64) float64

CalRidgeRegCost 计算使用L2 Ridge进行正则化后的损失函数，来评估当前模型的损失 定义总特征数量n，总样本数量m，正则项系数λ（用来权衡正则项与原始损失函数项的比重） L2 = λ/2m * (θ(0)^2 + θ(1)^2 + ... + θ(n)^2)

- thetas 当前的模型参数 - trainSetSize 训练样本个数 - regParam 正则参数

func DecryptCost

func DecryptCost(encCostMap map[int]*big.Int, privateKey *paillier.PrivateKey) map[int]*big.Int

DecryptCost 为其他方解密带噪音的损失 - encCostMap 加密的损失信息 - privateKey 己方同态私钥

func DecryptGradient

func DecryptGradient(encGradMap map[int]*big.Int, privateKey *paillier.PrivateKey) map[int]*big.Int

DecryptGradient 为另一参与方解密加密的梯度 - encGradMap 加密的梯度信息 - privateKey 己方同态私钥

func EvaluateEncLocalCost

func EvaluateEncLocalCost(localPart *RawLocalGradAndCostPart, tagPart *EncLocalGradAndCostPart, trainSet [][]float64, accuracy int, publicKey *paillier.PublicKey) (*common.EncLocalCost, error)

EvaluateEncLocalCost 非标签方根据损失函数来评估当前模型的损失，衡量模型是否已经收敛 TODO 增加泛化支持： L1 = λ/m * (|θ(0)| + |θ(1)| + ... + |θ(n)|)，其中，|θ|表示θ的绝对值 L2 = λ/2m * (θ(0)^2 + θ(1)^2 + ... + θ(n)^2)

参与方A执行同态运算ln(0.5) + encByB(y - 0.5)*preValA + encByB((y - 0.5)*preValB) - preValA^2/8

• encByB(preValB^2/8) - preValA*encByB(preValB/4) + ranNumA

- localPart 本地的明文损失数据 - tagPart 标签方的加密损失数据 - trainSet 非标签方训练样本集合 - accuracy 同态加解密精度 - publicKey 标签方同态公钥

func EvaluateEncLocalCostTag

func EvaluateEncLocalCostTag(localPart *RawLocalGradAndCostPart, otherPart *EncLocalGradAndCostPart, trainSet [][]float64, accuracy int, publicKey *paillier.PublicKey) (*common.EncLocalCost, error)

EvaluateEncLocalCostTag 标签方使用同态运算，根据损失函数来计算当前模型的加密损失 TODO 增加泛化支持： 参与方B执行同态运算encCostForB = ln(0.5) + (y - 0.5)*encByA(preValA) + (y - 0.5)*preValB - encByA(preValA^2/8)

• preValB^2/8 - encByA(preValA)*preValB/4 + ranNumB

- localPart 本地的明文损失数据 - otherPart 非标签方的加密损失数据 - trainSet 标签方训练样本集合 - accuracy 同态加解密精度 - publicKey 非标签方同态公钥

func PreProcessDataSet

func PreProcessDataSet(sourceDataSet *common.StandardizedDataSet, label string) *common.TrainDataSet

PreProcessDataSet 预处理标签方的标准化数据集 将样本数据集转化为一个m*(n+2)的矩阵, 其中每行对应一个样本，每行的第一列为编号ID，第二列为1（截距intercept），其它列分别对应一种特征的值

func PreProcessDataSetNoTag

func PreProcessDataSetNoTag(sourceDataSet *common.StandardizedDataSet) *common.TrainDataSet

PreProcessDataSetNoTag 预处理非标签方的标准化训练数据集 将样本数据集转化为一个m*(n+1)的矩阵, 其中每行对应一个样本，每行的第一列为编号ID，其它列分别对应一种特征的值

func PredictLocalPartNoTag

func PredictLocalPartNoTag(thetas, standardizedInput map[string]float64) float64

PredictLocalPartNoTag 非标签方使用经过标准化处理的本地数据进行预测 - thetas feature_name->feature_theta - standardizedInput feature_name->value

func PredictLocalPartTag

func PredictLocalPartTag(thetas, standardizedInput map[string]float64) float64

PredictLocalPartTag 标签方使用经过标准化处理的本地数据进行预测 - thetas feature_name->feature_theta，包含"Intercept" - standardizedInput feature_name->value

func RetrieveRealCost

func RetrieveRealCost(decCostMap map[int]*big.Int, accuracy int, randomInt *big.Int) map[int]float64

RetrieveRealCost 从解密后的梯度信息中，移除随机数噪音，恢复真实损失 - decCostMap 解密的损失信息 - accuracy 同态加解密精度 - randomInt 损失的噪音值

func RetrieveRealGradient

func RetrieveRealGradient(decGradMap map[int]*big.Int, accuracy int, randomInt *big.Int) map[int]float64

RetrieveRealGradient 从解密后的梯度信息中，移除随机数噪音，还原己方真实的梯度数据 - decGradMap 解密的梯度信息 - accuracy 同态加解密精度 - randomInt 己方梯度的噪音值

func StandardizeDataSet

func StandardizeDataSet(sourceDataSet *common.DataSet, label string) *common.StandardizedDataSet

StandardizeDataSet 将样本数据集合进行标准化处理，将均值变为0，标准差变为1 Z-score Normalization x' = (x - avgerage(x)) / standard_deviation(x) 特别注意：对于逻辑回归，标签值不做标准化处理

func StandardizeLocalInput

func StandardizeLocalInput(xbars, sigmas, input map[string]float64) map[string]float64

StandardizeLocalInput 各参与方使用之前训练集合的标准化参数对本地的要进行预测的数据进行标准化处理 - xbars feature_name->样本均值 - sigmas feature_name->样本标准差 - input feature_name->样本值

Types

type EncLocalGradAndCostPart

type EncLocalGradAndCostPart struct {
	EncPart1   map[int]*big.Int // 对每一条数据（ID编号），有标签方：计算y - 0.5，无标签方: 计算preValA; 并使用公钥pubKey-B进行同态加密;
	EncPart2   map[int]*big.Int // 对每一条数据（ID编号），有标签方：计算(y - 0.5)*preValB，无标签方:计算preValA^2/8; 并使用公钥pubKey-B进行同态加密
	EncPart3   map[int]*big.Int // 对每一条数据（ID编号），有标签方：计算preValB^2/8，并使用公钥pubKey-B进行同态加密
	EncPart4   map[int]*big.Int // 对每一条数据（ID编号），有标签方：计算preValB/4，并使用公钥pubKey-B进行同态加密
	EncPart5   map[int]*big.Int // 对每一条数据（ID编号），有标签方：计算0.5 + preValB/4 - y，并使用公钥pubKey-B进行同态加密
	EncRegCost *big.Int         // 正则化损失，被同态加密
}

EncLocalGradAndCostPart 迭代的中间同态加密参数，用于计算梯度和损失

type LocalGradAndCostPart

type LocalGradAndCostPart struct {
	EncPart *EncLocalGradAndCostPart // 加密参数
	RawPart *RawLocalGradAndCostPart // 原始参数
}

LocalGradAndCostPart 迭代的中间参数，包含未加密的和同态加密参数，用于计算梯度和损失

func CalLocalGradAndCostPart

func CalLocalGradAndCostPart(thetas []float64, trainSet [][]float64, accuracy int, regMode int, regParam float64, publicKey *paillier.PublicKey) (*LocalGradAndCostPart, error)

CalLocalGradAndCostPart 非标签方为计算本地模型中，每个特征的参数做准备，计算本地同态加密结果 对于梯度：A计算preValA/4，再用自己的同态公钥加密数据，获得encByA(preValA/4)，将加密数据发送给B 对于损失：A计算preValA、preValA^2/8，再用自己的同态公钥加密数据，获得encByA(preValA)、encByA(preValA^2/8)，将加密数据发送给B

- thetas 上一轮训练得到的模型参数 - trainSet 预处理过的训练数据 - accuracy 同态加解密精确到小数点后的位数 - regMode 正则模式 - regParam 正则参数 - publicKey 非标签方同态公钥

func CalLocalGradAndCostTagPart

func CalLocalGradAndCostTagPart(thetas []float64, trainSet [][]float64, accuracy int, regMode int, regParam float64, publicKey *paillier.PublicKey) (*LocalGradAndCostPart, error)

CalLocalGradAndCostTagPart 标签方为计算本地模型中，每个特征的参数做准备，计算本地同态加密结果 对每一条数据（ID编号j），计算y - 0.5，(y - 0.5)*preValB，preValB^2/8，preValB/4，并对它们分别使用公钥pubKey-B进行同态加密 注意：高性能的同态运算仅能处理整数，对于浮点数有精度损失，所以必须在参数中指定精度来进行处理

- thetas 上一轮训练得到的模型参数 - trainSet 预处理过的训练数据 - accuracy 同态加解密精确到小数点后的位数 - regMode 正则模式 - regParam 正则参数 - publicKey 标签方同态公钥

type RawLocalGradAndCostPart

type RawLocalGradAndCostPart struct {
	RawPart1   map[int]*big.Int // 对每一条数据（ID编号），有标签方：计算y - 0.5, 无标签方: 计算preValA
	RawPart2   map[int]*big.Int // 对每一条数据（ID编号），有标签方：计算(y - 0.5)*preValB， 无标签方: 计算preValA^2/8
	RawPart3   map[int]*big.Int // 对每一条数据（ID编号），有标签方：计算preValB^2/8
	RawPart4   map[int]*big.Int // 对每一条数据（ID编号），有标签方：计算preValB/4
	RawPart5   map[int]*big.Int // 对每一条数据（ID编号），有标签方：计算0.5 + preValB/4 - y
	RawRegCost *big.Int         // 正则化损失
}

RawLocalGradAndCostPart 迭代中间同态加密参数，用于计算梯度和损失