def __test(self, matrix):
paillierEncrypt = PaillierEncrypt()
paillierEncrypt.generate_key()
publickey = paillierEncrypt.get_public_key()
privatekey = paillierEncrypt.get_privacy_key()
result = distribute_encrypt_matrix(publickey, matrix)
decrypted_result = distribute_decrypt_matrix(privatekey, result)
assert_matrix(matrix, decrypted_result)
def __test_matrix(self, matrix):
paillierEncrypt = PaillierEncrypt()
paillierEncrypt.generate_key()
publickey = paillierEncrypt.get_public_key()
privatekey = paillierEncrypt.get_privacy_key()
enc_matrix = encrypt_matrix(publickey, matrix)
masked_enc_matrix, mask = add_random_mask(enc_matrix)
cleared_enc_matrix = remove_random_mask(masked_enc_matrix, mask)
cleared_matrix = decrypt_matrix(privatekey, cleared_enc_matrix)
assert_matrix(matrix, cleared_matrix)
def __test_scalar(self, value):
paillierEncrypt = PaillierEncrypt()
paillierEncrypt.generate_key()
publickey = paillierEncrypt.get_public_key()
privatekey = paillierEncrypt.get_privacy_key()
enc_value = publickey.encrypt(value)
masked_enc_value, mask = add_random_mask(enc_value)
cleared_enc_value = remove_random_mask(masked_enc_value, mask)
cleared_value = privatekey.decrypt(cleared_enc_value)
print("original matrix", value)
print("cleared_matrix", cleared_value)
self.assertEqual(value, cleared_value)
def setUp(self):
paillierEncrypt = PaillierEncrypt()
paillierEncrypt.generate_key()
self.publickey = paillierEncrypt.get_public_key()
self.privatekey = paillierEncrypt.get_privacy_key()
def fit(self):
LOGGER.info("@ start arbiter fit")
paillierEncrypt = PaillierEncrypt()
paillierEncrypt.generate_key()
public_key = paillierEncrypt.get_public_key()
private_key = paillierEncrypt.get_privacy_key()
self.private_key = private_key
# distribute public key to guest and host
self._do_remote(public_key,
name=self.transfer_variable.paillier_pubkey.name,
tag=self.transfer_variable.generate_transferid(
self.transfer_variable.paillier_pubkey),
role=consts.HOST,
idx=-1)
self._do_remote(public_key,
name=self.transfer_variable.paillier_pubkey.name,
tag=self.transfer_variable.generate_transferid(
self.transfer_variable.paillier_pubkey),
role=consts.GUEST,
idx=-1)
is_stop = False
start_time = time.time()
while self.n_iter_ < self.max_iter:
# LOGGER.debug("@ iteration: " + str(self.n_iter_))
# decrypt gradient from host
encrypt_host_gradient = self._do_get(
name=self.transfer_variable.encrypt_host_gradient.name,
tag=self.transfer_variable.generate_transferid(
self.transfer_variable.encrypt_host_gradient,
self.n_iter_),
idx=-1)[0]
decrypt_host_gradient = self.__decrypt_gradients(
encrypt_host_gradient)
self._do_remote(
decrypt_host_gradient,
name=self.transfer_variable.decrypt_host_gradient.name,
tag=self.transfer_variable.generate_transferid(
self.transfer_variable.decrypt_host_gradient,
self.n_iter_),
role=consts.HOST,
idx=-1)
# decrypt gradient from guest
encrypt_guest_gradient = self._do_get(
name=self.transfer_variable.encrypt_guest_gradient.name,
tag=self.transfer_variable.generate_transferid(
self.transfer_variable.encrypt_guest_gradient,
self.n_iter_),
idx=-1)[0]
decrypt_guest_gradient = self.__decrypt_gradients(
encrypt_guest_gradient)
self._do_remote(
decrypt_guest_gradient,
name=self.transfer_variable.decrypt_guest_gradient.name,
tag=self.transfer_variable.generate_transferid(
self.transfer_variable.decrypt_guest_gradient,
self.n_iter_),
role=consts.GUEST,
idx=-1)
# decrypt loss from guest
encrypt_loss = self._do_get(
name=self.transfer_variable.encrypt_loss.name,
tag=self.transfer_variable.generate_transferid(
self.transfer_variable.encrypt_loss, self.n_iter_),
idx=-1)[0]
loss = self.__decrypt_loss(encrypt_loss)
if self.converge_func.is_converge(loss):
is_stop = True
# send is_stop indicator to host and guest
self._do_remote(
is_stop,
name=self.transfer_variable.is_encrypted_ftl_stopped.name,
tag=self.transfer_variable.generate_transferid(
self.transfer_variable.is_encrypted_ftl_stopped,
self.n_iter_),
role=consts.HOST,
idx=-1)
self._do_remote(
is_stop,
name=self.transfer_variable.is_encrypted_ftl_stopped.name,
tag=self.transfer_variable.generate_transferid(
self.transfer_variable.is_encrypted_ftl_stopped,
self.n_iter_),
role=consts.GUEST,
idx=-1)
LOGGER.info("@ time: " + str(time.time()) + ", ep: " +
str(self.n_iter_) + ", loss: " + str(loss))
LOGGER.info("@ converged: " + str(is_stop))
self.n_iter_ += 1
if is_stop:
break
end_time = time.time()
LOGGER.info("@ running time: " + str(end_time - start_time))
print(
"################################ Build Federated Models ############################"
)
tf.reset_default_graph()
autoencoder_A = Autoencoder(1)
autoencoder_B = Autoencoder(2)
autoencoder_A.build(X_A.shape[-1], 10, learning_rate=0.01)
autoencoder_B.build(X_B.shape[-1], 10, learning_rate=0.01)
paillierEncrypt = PaillierEncrypt()
paillierEncrypt.generate_key()
publickey = paillierEncrypt.get_public_key()
privatekey = paillierEncrypt.get_privacy_key()
# alpha = 100
fake_model_param = FakeFTLModelParam()
partyA = EncryptedFTLGuestModel(autoencoder_A,
fake_model_param,
public_key=publickey)
partyB = EncryptedFTLHostModel(autoencoder_B,
fake_model_param,
public_key=publickey)
federatedLearning = LocalEncryptedFederatedTransferLearning(
partyA, partyB, privatekey)
print(
"################################ Train Federated Models ############################"
def generate_encryption_key_pair():
paillierEncrypt = PaillierEncrypt()
paillierEncrypt.generate_key()
public_key = paillierEncrypt.get_public_key()
private_key = paillierEncrypt.get_privacy_key()
return public_key, private_key