mpc_vertical

package
v0.0.0-...-ebe581b Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 22, 2024 License: Apache-2.0 Imports: 11 Imported by: 3

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func CalCost 

func CalCost(costMap map[int]float64) float64

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

func CalEncLocalGradient 

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

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

  • encByB(predictValue(j-B) - realValue(j)) * xAj(i)
  • encByB(RanNumA)

其中，encByB(predictValue(j-A)*xAj(i))是A用B的公钥加密得到的，A自己产生随机数RanNumA再用B的公钥加密，得到encByB(RanNumA)

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

func CalEncLocalGradientTagPart 

func CalEncLocalGradientTagPart(localPart *RawLocalGradientPart, otherPart *EncLocalGradientPart, trainSet [][]float64, featureIndex, accuracy int, publicKey *paillier.PublicKey) (*common.EncLocalGradient, error)

CalEncLocalGradientTagPart 标签方聚合双方的中间加密参数，为本地特征计算模型参数 计算本地加密梯度，并提交随机数干扰 参与方B执行同态运算encGraForB = encByA(predictValue(j-A))*xBj(i)

  • encByA((predictValue(j-B) - realValue(j)) * xBj(i))
  • encByA(RanNumB)

其中，encByA(predictValue(j-B) - realValue(j))是B用A的公钥加密得到的，B自己产生随机数RanNumB再用A的公钥加密，得到encByA(RanNumB)

- 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 DeStandardizeBothThetas 

func DeStandardizeBothThetas(trainDataSetA, trainDataSetB *common.TrainDataSet, originalThetasA, originalThetasB []float64) []float64

DeStandardizeBothThetas 利用两方训练的模型结果逆标准化模型参数 trainDataSetA 非标签方训练数据集 trainDataSetB 标签方训练数据集 originalThetasA 非标签方模型 originalThetasB 标签方模型

func DeStandardizeOutput 

func DeStandardizeOutput(ybar, sigma, output float64) float64

DeStandardizeOutput 逆Z-Score标准化：标签方使用之前训练集合的标签的标准差和均值，对通过标准化模型预测的结果进行逆标准化处理 - ybar 目标特征对应的样本均值 - sigma 目标特征对应的样本标准差 - output 标准化样本的预测结值

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 *RawLocalGradientPart, tagPart *EncLocalGradientPart, trainSet [][]float64, accuracy int, publicKey *paillier.PublicKey) (*common.EncLocalCost, error)

EvaluateEncLocalCost 非标签方根据损失函数来评估当前模型的损失，衡量模型是否已经收敛 增加泛化支持： 参与方A执行同态运算encCostForA = encByB(predictValue(j-A)^2)

  • encByB((predictValue(j-B) - realValue(j))^2)
  • 2*predictValue(j-A)*encByB(predictValue(j-B) - realValue(j))
  • encByB(RanNumA)
  • encByB(L_A)
  • encByB(L_B)

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

func EvaluateEncLocalCostTag 

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

EvaluateEncLocalCostTag 标签方使用同态运算，根据损失函数来计算当前模型的加密损失 增加泛化支持： 参与方B执行同态运算encCostForB = encByA(predictValue(j-A)^2)

  • encByA((predictValue(j-B) - realValue(j))^2)
  • 2*encByA(predictValue(j-A))*(predictValue(j-B) - realValue(j))
  • encByA(RanNumB)
  • encByA(L_A)
  • encByA(L_B)

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

func Intersect 

func Intersect(sampleID []string, reEncSetLocal *EncSet, reEncSetOthers []*EncSet) []string

Intersect 加密样本对齐，支持多方求交

func PreProcessDataSet 

func PreProcessDataSet(sourceDataSet *common.StandardizedDataSet, targetFeatureName 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) *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 Empty 

type Empty struct{}

Empty 定义一个空struct，用来降低map的存储开销

type EncLocalGradientPart 

type EncLocalGradientPart struct {
	EncGradPart       map[int]*big.Int `json:"enc_grad_part"`        // 对每一条数据（ID编号），计算predictValue(j-A)，并使用公钥pubKey-A进行同态加密
	EncGradPartSquare map[int]*big.Int `json:"enc_grad_part_square"` // 对每一条数据（ID编号），计算predictValue(j-A)^2，并使用公钥pubKey-A进行同态加密
	EncRegCost        *big.Int         `json:"enc_reg_cost"`         // 正则化损失，被同态加密
}

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

type EncSet 

type EncSet struct {
	EncIDs map[string]int
}

EncSet 样本加密集合

func EncryptSampleIDSet 

func EncryptSampleIDSet(sampleID []string, publicKey *ecdsa.PublicKey) *EncSet

EncryptSampleIDSet 参与方分别对自己的样本特征ID进行计算，通过如下方式获得每个样本特征ID的加密集合： Alice: Pub'Ai=HP(ID-Ai)^Prv'A=Hash(ID-Ai)*G^Prv'A=Hash(ID-Ai)*Pub'A Bob: Pub'Bi=HP(ID-Bi)^Prv'B=Hash(ID-Bi)*G^Prv'B=Hash(ID-Bi)*Pub'B

func ReEncryptIDSet 

func ReEncryptIDSet(encSet *EncSet, privateKey *ecdsa.PrivateKey) *EncSet

ReEncryptIDSet 参与方使用自己的私钥对其它方的样本特征ID加密集合进行二次加密，如： Alice: Pub'Bi-A=Pub'Bi^Prv'A=Hash(ID-Bi)*G^Prv'B^Prv'A Bob: Pub'Ai-B=Pub'Ai^Prv'B=Hash(ID-Ai)*G^Prv'A^Prv'B

type LocalGradientPart 

type LocalGradientPart struct {
	EncPart *EncLocalGradientPart `json:"enc_part"` // 加密参数
	RawPart *RawLocalGradientPart `json:"raw_part"` // 原始参数
}

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

func CalLocalGradientPart 

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

CalLocalGradientPart 非标签方为计算本地模型中，每个特征的参数做准备，计算本地同态加密结果 对每一条数据（ID编号j），计算predictValue(j-A)，predictValue(j-A)^2，并对它们分别使用公钥pubKey-A进行同态加密

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

func CalLocalGradientTagPart 

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

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

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

type RawLocalGradientPart 

type RawLocalGradientPart struct {
	RawGradPart       map[int]*big.Int `json:"raw_grad_part"`        // 对每一条数据（ID编号），计算predictValue(j-A)
	RawGradPartSquare map[int]*big.Int `json:"raw_grad_part_square"` // 对每一条数据（ID编号），计算predictValue(j-A)^2
	RawRegCost        *big.Int         `json:"raw_reg_cost"`         // 正则化损失
}

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.