def predict(self, data_instances):
self._abnormal_detection(data_instances)
self.init_schema(data_instances)
data_instances = self.align_data_header(data_instances, self.header)
LOGGER.info("Start predict is a one_vs_rest task: {}".format(
self.need_one_vs_rest))
if self.need_one_vs_rest:
predict_result = self.one_vs_rest_obj.predict(data_instances)
return predict_result
# predict_wx = self.compute_wx(data_instances, self.model_weights.coef_, self.model_weights.intercept_)
pred_prob = data_instances.mapValues(lambda v: activation.sigmoid(
vec_dot(v.features, self.model_weights.coef_) + self.model_weights.
intercept_))
predict_result = self.predict_score_to_output(
data_instances,
pred_prob,
classes=[0, 1],
threshold=self.model_param.predict_param.threshold)
return predict_result
def predict(self, data=None, predict_param=None):
# synchronize encryption information
if not self.has_sychronized_encryption:
self.__synchronize_encryption()
self.__send_host_mode()
for idx, use_encrypt in enumerate(self.host_use_encryption):
if use_encrypt:
encrypter = self.host_encrypter[idx]
predict_wx_id = self.transfer_variable.generate_transferid(
self.transfer_variable.predict_wx)
predict_wx = federation.get(
name=self.transfer_variable.predict_wx.name,
tag=predict_wx_id,
idx=idx)
decrypted_wx = encrypter.distribute_decrypt(predict_wx)
pred_prob = decrypted_wx.mapValues(
lambda x: activation.sigmoid(x))
pred_label = self.classified(pred_prob,
predict_param.threshold)
predict_result_id = self.transfer_variable.generate_transferid(
self.transfer_variable.predict_result)
federation.remote(
pred_label,
name=self.transfer_variable.predict_result.name,
tag=predict_result_id,
role=consts.HOST,
idx=idx)
LOGGER.info("Finish predicting, result has been sent back")
return
def predict(self, data_instances, predict_param):
LOGGER.info("Start predict ...")
prob_guest = self.compute_wx(data_instances, self.coef_,
self.intercept_)
prob_host = federation.get(
name=self.transfer_variable.host_prob.name,
tag=self.transfer_variable.generate_transferid(
self.transfer_variable.host_prob),
idx=0)
LOGGER.info("Get probability from Host")
# guest probability
pred_prob = prob_guest.join(prob_host,
lambda g, h: activation.sigmoid(g + h))
pred_label = self.classified(pred_prob, predict_param.threshold)
if predict_param.with_proba:
labels = data_instances.mapValues(lambda v: v.label)
predict_result = labels.join(pred_prob, lambda label, prob:
(label, prob))
else:
predict_result = data_instances.mapValues(lambda v:
(v.label, None))
predict_result = predict_result.join(pred_label, lambda r, p:
(r[0], r[1], p))
return predict_result
def predict(self, data_instances, predict_param):
if not self.has_sychronized_encryption:
self.__synchronize_encryption()
self.__load_arbiter_model()
else:
LOGGER.info("in predict, has synchronize encryption information")
wx = self.compute_wx(data_instances, self.coef_, self.intercept_)
if self.use_encrypt:
encrypted_wx_id = self.transfer_variable.generate_transferid(self.transfer_variable.predict_wx)
# LOGGER.debug("predict_wd_id: {}".format(encrypted_wx_id))
federation.remote(wx,
name=self.transfer_variable.predict_wx.name,
tag=encrypted_wx_id,
role=consts.ARBITER,
idx=0)
predict_result_id = self.transfer_variable.generate_transferid(self.transfer_variable.predict_result)
# LOGGER.debug("predict_result_id: {}".format(predict_result_id))
predict_result = federation.get(name=self.transfer_variable.predict_result.name,
tag=predict_result_id,
idx=0)
# local_predict_table = predict_result.collect()
predict_result_table = predict_result.join(data_instances, lambda p, d: (d.label, None, p))
else:
pred_prob = wx.mapValues(lambda x: activation.sigmoid(x))
pred_label = self.classified(pred_prob, predict_param.threshold)
if predict_param.with_proba:
predict_result = data_instances.mapValues(lambda x: x.label)
predict_result = predict_result.join(pred_prob, lambda x, y: (x, y))
else:
predict_result = data_instances.mapValues(lambda x: (x.label, None))
predict_result_table = predict_result.join(pred_label, lambda x, y: (x[0], x[1], y))
return predict_result_table
def predict(self, data_instances, predict_param):
"""
Prediction of lr
Parameters
----------
data_instance:DTable of Instance, input data
predict_param: PredictParam, the setting of prediction.
Returns
----------
DTable
include input data label, predict probably, label
"""
LOGGER.info("Start predict ...")
data_features = self.transform(data_instances)
prob_guest = self.compute_wx(data_features, self.coef_, self.intercept_)
prob_host = federation.get(name=self.transfer_variable.host_prob.name,
tag=self.transfer_variable.generate_transferid(
self.transfer_variable.host_prob),
idx=0)
LOGGER.info("Get probability from Host")
# guest probability
pred_prob = prob_guest.join(prob_host, lambda g, h: activation.sigmoid(g + h))
pred_label = self.classified(pred_prob, predict_param.threshold)
if predict_param.with_proba:
labels = data_instances.mapValues(lambda v: v.label)
predict_result = labels.join(pred_prob, lambda label, prob: (label, prob))
else:
predict_result = data_instances.mapValues(lambda v: (v.label, None))
predict_result = predict_result.join(pred_label, lambda r, p: (r[0], r[1], p))
return predict_result
def predict(self, data_instantces=None):
LOGGER.info(f'Start predict task')
current_suffix = ('predict',)
host_ciphers = self.cipher.paillier_keygen(key_length=self.model_param.encrypt_param.key_length,
suffix=current_suffix)
# LOGGER.debug("Loaded arbiter model: {}".format(self.model_weights.unboxed))
for idx, cipher in host_ciphers.items():
if cipher is None:
continue
encrypted_model_weights = self.model_weights.encrypted(cipher, inplace=False)
self.transfer_variable.aggregated_model.remote(obj=encrypted_model_weights.for_remote(),
role=consts.HOST,
idx=idx,
suffix=current_suffix)
# Receive wx results
for idx, cipher in host_ciphers.items():
if cipher is None:
continue
encrypted_predict_wx = self.transfer_variable.predict_wx.get(idx=idx, suffix=current_suffix)
predict_wx = cipher.distribute_decrypt(encrypted_predict_wx)
prob_table = predict_wx.mapValues(lambda x: activation.sigmoid(x))
predict_table = prob_table.mapValues(lambda x: 1 if x > self.model_param.predict_param.threshold else 0)
self.transfer_variable.predict_result.remote(predict_table,
role=consts.HOST,
idx=idx,
suffix=current_suffix)
self.host_predict_results.append((prob_table, predict_table))
def test_numeric_stability(self):
x_list = np.linspace(-709, 709, 10000)
# Original function
# a = 1. / (1. + np.exp(-x))
for x in x_list:
a1 = 1. / (1. + np.exp(-x))
a2 = activation.sigmoid(x)
self.assertTrue(np.abs(a1 - a2) < 1e-5)
def predict(self, data_instances):
self._abnormal_detection(data_instances)
self.init_schema(data_instances)
data_instances = self.align_data_header(data_instances, self.header)
# predict_wx = self.compute_wx(data_instances, self.model_weights.coef_, self.model_weights.intercept_)
pred_prob = data_instances.mapValues(lambda v: activation.sigmoid(vec_dot(v.features, self.model_weights.coef_)
+ self.model_weights.intercept_))
predict_result = self.predict_score_to_output(data_instances, pred_prob, classes=[0, 1],
threshold=self.model_param.predict_param.threshold)
return predict_result
def predict(self, data_instances):
LOGGER.info(f'Start predict task')
self._abnormal_detection(data_instances)
self.init_schema(data_instances)
data_instances = self.align_data_header(data_instances, self.header)
suffix = ('predict', )
if self.component_properties.has_arbiter:
pubkey = self.cipher.gen_paillier_pubkey(enable=self.use_encrypt,
suffix=suffix)
else:
if self.use_encrypt:
raise ValueError(f"In use_encrypt case, arbiter should be set")
pubkey = None
if self.use_encrypt:
self.cipher_operator.set_public_key(pubkey)
final_model = self.transfer_variable.aggregated_model.get(
idx=0, suffix=suffix)
model_weights = LogisticRegressionWeights(final_model.unboxed,
self.fit_intercept)
wx = self.compute_wx(data_instances, model_weights.coef_,
model_weights.intercept_)
self.transfer_variable.predict_wx.remote(wx,
consts.ARBITER,
0,
suffix=suffix)
predict_result = self.transfer_variable.predict_result.get(
idx=0, suffix=suffix)
# predict_result = predict_result.join(data_instances, lambda p, d: [d.label, p, None,
# {"0": None, "1": None}])
predict_result = predict_result.join(
data_instances, lambda p, d: Instance(
features=[d.label, p, None, {
"0": None,
"1": None
}],
inst_id=d.inst_id))
else:
pred_prob = data_instances.mapValues(lambda v: activation.sigmoid(
vec_dot(v.features, self.model_weights.coef_) + self.
model_weights.intercept_))
predict_result = self.predict_score_to_output(
data_instances,
pred_prob,
classes=[0, 1],
threshold=self.model_param.predict_param.threshold)
return predict_result
def predict(self, data_instances, predict_param):
wx = self.compute_wx(data_instances, self.coef_, self.intercept_)
pred_prob = wx.mapValues(lambda x: activation.sigmoid(x))
pred_label = self.classified(pred_prob, predict_param.threshold)
if predict_param.with_proba:
predict_result = data_instances.mapValues(lambda x: x.label)
predict_result = predict_result.join(pred_prob, lambda x, y:
(x, y))
else:
predict_result = data_instances.mapValues(lambda x:
(x.label, None))
predict_result = predict_result.join(pred_label, lambda x, y:
(x[0], x[1], y))
return predict_result
def predict(value):
"""
Predict method for using sigmoid cross entropy
Formula : probability = 1.0 / (1.0 + exp(-value))
Parameters
----------
value : float, The input value of sigmoid function
Returns
-------
probability : float, the output of sigmoid function
"""
return activation.sigmoid(value)
def predict(self, data_instances):
"""
Prediction of lr
Parameters
----------
data_instances: Table of Instance, input data
Returns
----------
Table
include input data label, predict probably, label
"""
LOGGER.info("Start predict ...")
self._abnormal_detection(data_instances)
data_instances = self.align_data_header(data_instances, self.header)
if self.need_one_vs_rest:
predict_result = self.one_vs_rest_obj.predict(data_instances)
return predict_result
LOGGER.debug(
f"Before_predict_reveal_strategy: {self.model_param.reveal_strategy}, {self.is_respectively_reveal}"
)
def _vec_dot(v, coef, intercept):
return fate_operator.vec_dot(v.features, coef) + intercept
f = functools.partial(_vec_dot,
coef=self.model_weights.coef_,
intercept=self.model_weights.intercept_)
pred_prob = data_instances.mapValues(f)
host_probs = self.transfer_variable.host_prob.get(idx=-1)
LOGGER.info("Get probability from Host")
# guest probability
for host_prob in host_probs:
if not self.is_respectively_reveal:
host_prob = self.cipher.distribute_decrypt(host_prob)
pred_prob = pred_prob.join(host_prob, lambda g, h: g + h)
pred_prob = pred_prob.mapValues(lambda p: activation.sigmoid(p))
threshold = self.model_param.predict_param.threshold
predict_result = self.predict_score_to_output(data_instances,
pred_prob,
classes=[0, 1],
threshold=threshold)
return predict_result
def predict(self, data_instances):
"""
Prediction of lr
Parameters
----------
data_instances: DTable of Instance, input data
Returns
----------
DTable
include input data label, predict probably, label
"""
LOGGER.info("Start predict is a one_vs_rest task: {}".format(
self.need_one_vs_rest))
self._abnormal_detection(data_instances)
data_instances = self.align_data_header(data_instances, self.header)
if self.need_one_vs_rest:
predict_result = self.one_vs_rest_obj.predict(data_instances)
return predict_result
# data_features = self.transform(data_instances)
pred_prob = self.compute_wx(data_instances, self.model_weights.coef_,
self.model_weights.intercept_)
host_probs = self.transfer_variable.host_prob.get(idx=-1)
LOGGER.info("Get probability from Host")
# guest probability
for host_prob in host_probs:
pred_prob = pred_prob.join(host_prob, lambda g, h: g + h)
pred_prob = pred_prob.mapValues(lambda p: activation.sigmoid(p))
threshold = self.model_param.predict_param.threshold
# pred_label = pred_prob.mapValues(lambda x: 1 if x > threshold else 0)
# predict_result = data_instances.mapValues(lambda x: x.label)
# predict_result = predict_result.join(pred_prob, lambda x, y: (x, y))
# predict_result = predict_result.join(pred_label, lambda x, y: [x[0], y, x[1],
# {"0": (1 - x[1]), "1": x[1]}])
predict_result = self.predict_score_to_output(data_instances,
pred_prob,
classes=[0, 1],
threshold=threshold)
return predict_result
def predict(self, data_instances):
"""
Prediction of lr
Parameters
----------
data_instances:DTable of Instance, input data
predict_param: PredictParam, the setting of prediction.
Returns
----------
DTable
include input data label, predict probably, label
"""
LOGGER.info("Start predict is a one_vs_rest task: {}".format(
self.need_one_vs_rest))
if self.need_one_vs_rest:
predict_result = self.one_vs_rest_obj.predict(data_instances)
return predict_result
data_features = self.transform(data_instances)
pred_prob = self.compute_wx(data_features, self.model_weights.coef_,
self.model_weights.intercept_)
host_probs = self.transfer_variable.host_prob.get(idx=-1)
LOGGER.info("Get probability from Host")
# guest probability
for host_prob in host_probs:
pred_prob = pred_prob.join(host_prob, lambda g, h: g + h)
pred_prob = pred_prob.mapValues(lambda p: activation.sigmoid(p))
pred_label = pred_prob.mapValues(
lambda x: 1 if x > self.model_param.predict_param.threshold else 0)
predict_result = data_instances.mapValues(lambda x: x.label)
predict_result = predict_result.join(pred_prob, lambda x, y: (x, y))
predict_result = predict_result.join(
pred_label,
lambda x, y: [x[0], y, x[1], {
"0": (1 - x[1]),
"1": x[1]
}])
return predict_result
def predict(self, data=None):
LOGGER.debug("In arbiter's predict, need run: {}".format(
self.need_run))
if not self.need_run:
return data
# synchronize encryption information
if not self.has_sychronized_encryption:
self.__synchronize_encryption(mode='predict')
self.__send_host_mode()
for idx, use_encrypt in enumerate(self.host_use_encryption):
if use_encrypt:
encrypter = self.host_encrypter[idx]
predict_wx_id = self.transfer_variable.generate_transferid(
self.transfer_variable.predict_wx)
LOGGER.debug(
"Arbiter encrypted wx id: {}".format(predict_wx_id))
predict_wx = federation.get(
name=self.transfer_variable.predict_wx.name,
tag=predict_wx_id,
idx=idx)
decrypted_wx = encrypter.distribute_decrypt(predict_wx)
pred_prob = decrypted_wx.mapValues(
lambda x: activation.sigmoid(x))
pred_label = self.classified(pred_prob,
self.predict_param.threshold)
predict_result_id = self.transfer_variable.generate_transferid(
self.transfer_variable.predict_result)
LOGGER.debug("predict_result_id: {}".format(predict_result_id))
LOGGER.debug(
"Start to remote pred_label: {}, transfer_id: {}".format(
pred_label, predict_result_id))
federation.remote(
pred_label,
name=self.transfer_variable.predict_result.name,
tag=predict_result_id,
role=consts.HOST,
idx=idx)
LOGGER.info("Finish predicting, result has been sent back")
return
def predict(self, data_instances):
if not self.need_run:
return data_instances
LOGGER.debug(
"homo_lr guest need run predict, coef: {}, instercept: {}".format(
len(self.coef_), self.intercept_))
wx = self.compute_wx(data_instances, self.coef_, self.intercept_)
pred_prob = wx.mapValues(lambda x: activation.sigmoid(x))
pred_label = self.classified(pred_prob, self.predict_param.threshold)
predict_result = data_instances.mapValues(lambda x: x.label)
predict_result = predict_result.join(pred_prob, lambda x, y: (x, y))
predict_result = predict_result.join(
pred_label,
lambda x, y: [x[0], y, x[1], {
"1": x[1],
"0": (1 - x[1])
}])
return predict_result
def predict(self, data_instances):
"""
Prediction of lr
Parameters
----------
data_instances:DTable of Instance, input data
predict_param: PredictParam, the setting of prediction.
Returns
----------
DTable
include input data label, predict probably, label
"""
LOGGER.info("Start predict ...")
data_features = self.transform(data_instances)
prob_guest = self.compute_wx(data_features, self.coef_,
self.intercept_)
prob_host = federation.get(
name=self.transfer_variable.host_prob.name,
tag=self.transfer_variable.generate_transferid(
self.transfer_variable.host_prob),
idx=0)
LOGGER.info("Get probability from Host")
# guest probability
pred_prob = prob_guest.join(prob_host,
lambda g, h: activation.sigmoid(g + h))
pred_label = self.classified(pred_prob, self.predict_param.threshold)
predict_result = data_instances.mapValues(lambda x: x.label)
predict_result = predict_result.join(pred_prob, lambda x, y: (x, y))
predict_result = predict_result.join(
pred_label,
lambda x, y: [x[0], y, x[1], {
"0": (1 - x[1]),
"1": x[1]
}])
return predict_result
def predict(self, data_instances):
"""
Prediction of fm
Parameters
----------
data_instances:DTable of Instance, input data
Returns
----------
DTable
include input data label, predict probably, label
"""
LOGGER.info("Start predict is a one_vs_rest task: {}".format(self.need_one_vs_rest))
if self.need_one_vs_rest:
predict_result = self.one_vs_rest_obj.predict(data_instances)
return predict_result
prob_guest = self.compute_fm(data_instances, self.model_weights)
vx_guest = self.compute_vx(data_instances, self.model_weights.embed_)
prob_guest = prob_guest.join(vx_guest, lambda a, b: (a, b))
host_probs = self.transfer_variable.host_prob.get(idx=-1)
LOGGER.info("Get probability from Host")
# guest probability
assert(len(host_probs)==1, "Currently Hetero FM only support single host.")
host_prob = host_probs[0]
pred_prob = prob_guest.join(host_prob, lambda g, h: g[0] + h[0] + np.dot(h[1], g[1]))
pred_prob = pred_prob.mapValues(lambda p: activation.sigmoid(p))
pred_label = pred_prob.mapValues(lambda x: 1 if x > self.model_param.predict_param.threshold else 0)
predict_result = data_instances.mapValues(lambda x: x.label)
predict_result = predict_result.join(pred_prob, lambda x, y: (x, y))
predict_result = predict_result.join(pred_label, lambda x, y: [x[0], y, x[1], {"0": (1 - x[1]), "1": x[1]}])
return predict_result
def predict(x):
prob = activation.sigmoid(x)
pred_label = 1 if prob > threshold else 0
return prob, pred_label
def predict(self, U_B):
if self.y_A_u_A is None:
self.U_A = self.localModel.transform(self.X)
self.y_A_u_A = self.__compute_yA_uA(self.U_A, self.y)
return sigmoid(np.matmul(U_B, self.y_A_u_A.transpose()))
def predict(value):
return activation.sigmoid(value)
def predict(self, data_instances):
if not self.need_run:
return data_instances
if not self.has_sychronized_encryption:
self.__synchronize_encryption(mode='predict')
self.__load_arbiter_model()
else:
LOGGER.info("in predict, has synchronize encryption information")
feature_shape = get_features_shape(data_instances)
LOGGER.debug("Shape of coef_ : {}, feature shape: {}".format(
len(self.coef_), feature_shape))
local_data = data_instances.first()
LOGGER.debug("One data, features: {}".format(local_data[1].features))
wx = self.compute_wx(data_instances, self.coef_, self.intercept_)
if self.use_encrypt:
encrypted_wx_id = self.transfer_variable.generate_transferid(
self.transfer_variable.predict_wx)
LOGGER.debug("Host encrypted wx id: {}".format(encrypted_wx_id))
LOGGER.debug("Start to remote wx: {}, transfer_id: {}".format(
wx, encrypted_wx_id))
federation.remote(wx,
name=self.transfer_variable.predict_wx.name,
tag=encrypted_wx_id,
role=consts.ARBITER,
idx=0)
predict_result_id = self.transfer_variable.generate_transferid(
self.transfer_variable.predict_result)
LOGGER.debug("predict_result_id: {}".format(predict_result_id))
predict_result = federation.get(
name=self.transfer_variable.predict_result.name,
tag=predict_result_id,
idx=0)
# local_predict_table = predict_result.collect()
LOGGER.debug(
"predict_result count: {}, data_instances count: {}".format(
predict_result.count(), data_instances.count()))
predict_result_table = predict_result.join(
data_instances,
lambda p, d: [d.label, None, p, {
"0": None,
"1": None
}])
else:
pred_prob = wx.mapValues(lambda x: activation.sigmoid(x))
pred_label = self.classified(pred_prob,
self.predict_param.threshold)
if self.predict_param.with_proba:
predict_result = data_instances.mapValues(lambda x: x.label)
predict_result = predict_result.join(pred_prob, lambda x, y:
(x, y))
else:
predict_result = data_instances.mapValues(lambda x:
(x.label, None))
predict_result_table = predict_result.join(
pred_label,
lambda x, y: [x[0], y, x[1], {
"0": None,
"1": None
}])
LOGGER.debug("Finish predict")
LOGGER.debug("In host predict, predict_result_table is : {}".format(
predict_result_table.first()))
return predict_result_table
def predict(self, uB):
if self.phi is None:
self.uA = self.localModel.transform(self.X)
self.phi = self.__compute_phi(self.uA, self.y)
return sigmoid(np.matmul(uB, self.phi.transpose()))
