def load_model(self, model_dict):
LOGGER.debug("Start Loading model")
result_obj = list(model_dict.get('model').values())[0].get(
self.model_param_name)
meta_obj = list(model_dict.get('model').values())[0].get(
self.model_meta_name)
# self.fit_intercept = meta_obj.fit_intercept
if self.init_param_obj is None:
self.init_param_obj = InitParam()
self.init_param_obj.fit_intercept = meta_obj.fit_intercept
self.header = list(result_obj.header)
# For hetero-lr arbiter predict function
if self.header is None:
return
need_one_vs_rest = result_obj.need_one_vs_rest
LOGGER.debug(
"in _load_model need_one_vs_rest: {}".format(need_one_vs_rest))
if need_one_vs_rest:
one_vs_rest_result = result_obj.one_vs_rest_result
self.one_vs_rest_obj = one_vs_rest_factory(classifier=self,
role=self.role,
mode=self.mode,
has_arbiter=True)
self.one_vs_rest_obj.load_model(one_vs_rest_result)
self.need_one_vs_rest = True
else:
self.load_single_model(result_obj)
self.need_one_vs_rest = False
def _init_model(self, params: LogisticRegressionParam):
super()._init_model(params)
self.encrypted_mode_calculator_param = params.encrypted_mode_calculator_param
if self.role == consts.HOST:
self.init_param_obj.fit_intercept = False
self.cipher = PaillierEncrypt()
self.cipher.generate_key(self.model_param.encrypt_param.key_length)
self.transfer_variable = SSHEModelTransferVariable()
self.one_vs_rest_obj = one_vs_rest_factory(self,
role=self.role,
mode=self.mode,
has_arbiter=False)
self.converge_func_name = params.early_stop
self.reveal_every_iter = params.reveal_every_iter
self.q_field = self._transfer_q_field()
LOGGER.debug(f"q_field: {self.q_field}")
if not self.reveal_every_iter:
self.self_optimizer = copy.deepcopy(self.optimizer)
self.remote_optimizer = copy.deepcopy(self.optimizer)
self.batch_generator = batch_generator.Guest(
) if self.role == consts.GUEST else batch_generator.Host()
self.batch_generator.register_batch_generator(
BatchGeneratorTransferVariable(), has_arbiter=False)
self.fixedpoint_encoder = FixedPointEndec(n=self.q_field)
self.converge_transfer_variable = ConvergeCheckerTransferVariable()
self.secure_matrix_obj = SecureMatrix(party=self.local_party,
q_field=self.q_field,
other_party=self.other_party)
def load_model(self, model_dict):
LOGGER.debug("Start Loading model")
result_obj = list(model_dict.get('model').values())[0].get(
self.model_param_name)
meta_obj = list(model_dict.get('model').values())[0].get(
self.model_meta_name)
if self.init_param_obj is None:
self.init_param_obj = InitParam()
self.init_param_obj.fit_intercept = meta_obj.fit_intercept
self.model_param.reveal_strategy = meta_obj.reveal_strategy
LOGGER.debug(
f"reveal_strategy: {self.model_param.reveal_strategy}, {self.is_respectively_reveal}"
)
self.header = list(result_obj.header)
need_one_vs_rest = result_obj.need_one_vs_rest
LOGGER.info(
"in _load_model need_one_vs_rest: {}".format(need_one_vs_rest))
if need_one_vs_rest:
one_vs_rest_result = result_obj.one_vs_rest_result
self.one_vs_rest_obj = one_vs_rest_factory(classifier=self,
role=self.role,
mode=self.mode,
has_arbiter=False)
self.one_vs_rest_obj.load_model(one_vs_rest_result)
self.need_one_vs_rest = True
else:
self.load_single_model(result_obj)
self.need_one_vs_rest = False
def _init_model(self, params):
super()._init_model(params)
self.model_weights = LinearModelWeights(
[], fit_intercept=self.fit_intercept)
self.one_vs_rest_obj = one_vs_rest_factory(self,
role=self.role,
mode=self.mode,
has_arbiter=True)
def _init_model(self, params):
self.model_param = params
self.alpha = params.alpha
self.init_param_obj = params.init_param
self.fit_intercept = self.init_param_obj.fit_intercept
self.batch_size = params.batch_size
self.max_iter = params.max_iter
self.optimizer = optimizer_factory(params)
self.converge_func = converge_func_factory(params.early_stop,
params.tol)
self.encrypted_calculator = None
self.validation_freqs = params.validation_freqs
self.one_vs_rest_obj = one_vs_rest_factory(self,
role=self.role,
mode=self.mode,
has_arbiter=True)
def load_model(self, model_dict):
result_obj, _ = super().load_model(model_dict)
need_one_vs_rest = result_obj.need_one_vs_rest
LOGGER.info(
"in _load_model need_one_vs_rest: {}".format(need_one_vs_rest))
if need_one_vs_rest:
one_vs_rest_result = result_obj.one_vs_rest_result
self.one_vs_rest_obj = one_vs_rest_factory(classifier=self,
role=consts.HOST,
mode=self.mode,
has_arbiter=False)
self.one_vs_rest_obj.load_model(one_vs_rest_result)
self.need_one_vs_rest = True
else:
self.load_single_model(result_obj)
self.need_one_vs_rest = False
def _init_model(self, params):
super()._init_model(params)
self.one_vs_rest_obj = one_vs_rest_factory(self,
role=self.role,
mode=self.mode,
has_arbiter=True)
