def load_single_model(self, single_model_obj):
LOGGER.info("start to load single model")
if self.is_respectively_reveal:
self.load_single_model_weight(single_model_obj)
else:
feature_shape = len(self.header)
tmp_vars = [None] * feature_shape
weight_dict = dict(single_model_obj.encrypted_weight)
for idx, header_name in enumerate(self.header):
cipher_weight = weight_dict.get(header_name)
public_key = PaillierPublicKey(int(cipher_weight.public_key.n))
cipher_text = int(cipher_weight.cipher_text)
exponent = int(cipher_weight.exponent)
is_obfuscator = cipher_weight.is_obfuscator
coef_i = PaillierEncryptedNumber(public_key, cipher_text, exponent)
if is_obfuscator:
coef_i.apply_obfuscator()
tmp_vars[idx] = coef_i
self.model_weights = LinearModelWeights(tmp_vars, fit_intercept=self.fit_intercept)
self.n_iter_ = single_model_obj.iters
return self
def encrypt_matrix(public_key: PaillierPublicKey, A):
if len(A.shape) == 1:
A = np.expand_dims(A, axis=0)
encrypt_A = []
for i in range(len(A)):
row = []
for j in range(len(A[i])):
if len(A.shape) == 3:
row.append([
public_key.encrypt(float(A[i, j, k]))
for k in range(len(A[i][j]))
])
else:
row.append(public_key.encrypt(float(A[i, j])))
encrypt_A.append(row)
return np.array(encrypt_A)
def load_single_model(self, single_model_obj):
super(HeteroLRGuest, self).load_single_model(single_model_obj)
if not self.is_respectively_reveal:
cipher_info = single_model_obj.cipher
self.cipher = PaillierEncrypt()
public_key = PaillierPublicKey(int(cipher_info.public_key.n))
privacy_key = PaillierPrivateKey(public_key,
int(cipher_info.private_key.p),
int(cipher_info.private_key.q))
self.cipher.set_public_key(public_key=public_key)
self.cipher.set_privacy_key(privacy_key=privacy_key)
def load_single_model(self, single_model_obj):
LOGGER.info("start to load single model")
self.load_single_model_weight(single_model_obj)
self.n_iter_ = single_model_obj.iters
if not self.is_respectively_reveal:
cipher_info = single_model_obj.cipher
self.cipher = PaillierEncrypt()
public_key = PaillierPublicKey(int(cipher_info.public_key.n))
privacy_key = PaillierPrivateKey(public_key, int(cipher_info.private_key.p), int(cipher_info.private_key.q))
self.cipher.set_public_key(public_key=public_key)
self.cipher.set_privacy_key(privacy_key=privacy_key)
return self
def encrypt_matmul(public_key: PaillierPublicKey, A, encrypted_B):
"""
matrix multiplication between a plain matrix and an encrypted matrix
:param public_key:
:param A:
:param encrypted_B:
:return:
"""
if A.shape[-1] != encrypted_B.shape[0]:
LOGGER.debug("A and encrypted_B shape are not consistent")
exit(1)
# TODO: need a efficient way to do this?
res = [[public_key.encrypt(0) for _ in range(encrypted_B.shape[1])] for _ in range(len(A))]
for i in range(len(A)):
for j in range(encrypted_B.shape[1]):
for m in range(len(A[i])):
res[i][j] += A[i][m] * encrypted_B[m][j]
return np.array(res)
def load_single_model(self, single_model_obj):
super(HeteroLRHost, self).load_single_model(single_model_obj)
if not self.is_respectively_reveal:
feature_shape = len(self.header)
tmp_vars = [None] * feature_shape
weight_dict = dict(single_model_obj.encrypted_weight)
for idx, header_name in enumerate(self.header):
cipher_weight = weight_dict.get(header_name)
public_key = PaillierPublicKey(int(cipher_weight.public_key.n))
cipher_text = int(cipher_weight.cipher_text)
exponent = int(cipher_weight.exponent)
is_obfuscator = cipher_weight.is_obfuscator
coef_i = PaillierEncryptedNumber(public_key, cipher_text,
exponent)
if is_obfuscator:
coef_i.apply_obfuscator()
tmp_vars[idx] = coef_i
self.model_weights = LinearModelWeights(
tmp_vars, fit_intercept=self.fit_intercept)
def encrypt_array(public_key: PaillierPublicKey, A):
encrypt_A = []
for i in range(len(A)):
encrypt_A.append(public_key.encrypt(float(A[i])))
return np.array(encrypt_A)
def encrypt(public_key: PaillierPublicKey, x):
return public_key.encrypt(x)