def get_loss_functions(self, mask): """ Set the loss function """ loss_funcs = [] largest_face = self.largest_output loss_dict = { 'mae': losses.mean_absolute_error, 'mse': losses.mean_squared_error, 'logcosh': losses.logcosh, 'smooth_l1': generalized_loss, 'l_inf_norm': l_inf_norm, 'ssim': DSSIMObjective(), 'gmsd': gmsd_loss, 'pixel_gradient_diff': gradient_loss } img_loss_config = self.config.get("loss_function", "mae") mask_loss_config = "mse" for idx, loss_name in enumerate(self.names): if loss_name.startswith("mask"): loss_funcs.append(loss_dict[mask_loss_config]) logger.debug("mask loss: %s", mask_loss_config) elif mask and idx == largest_face and self.config.get( "penalized_mask_loss", False): loss_funcs.append( PenalizedLoss(mask[0], loss_dict[img_loss_config])) logger.debug("final face loss: %s", img_loss_config) else: loss_funcs.append(loss_dict[img_loss_config]) logger.debug("face loss func: %s", img_loss_config) logger.debug(loss_funcs) return loss_funcs
def get_loss_functions(self, side, predict, mask): """ Set the loss function """ loss_funcs = list() largest_face = self.largest_output if self.config.get("dssim_loss", False): if not predict and side.lower() == "a": logger.verbose("Using DSSIM Loss") loss_func = DSSIMObjective() else: loss_func = losses.mean_absolute_error if not predict and side.lower() == "a": logger.verbose("Using Mean Absolute Error Loss") for idx, loss_name in enumerate(self.names): if loss_name.startswith("mask"): mask_func = losses.mean_squared_error loss_funcs.append(mask_func) logger.debug("mask loss: %s", mask_func) elif mask and idx == largest_face and self.config.get( "penalized_mask_loss", False): face_func = PenalizedLoss(mask[0], loss_func) logger.debug("final face loss: %s", face_func) loss_funcs.append(face_func) if not predict and side.lower() == "a": logger.verbose("Penalizing mask for Loss") else: logger.debug("face loss func: %s", loss_func) loss_funcs.append(loss_func) logger.debug(loss_funcs) return loss_funcs
def mask_loss_function(self, mask, side, initialize): """ Set the loss function for masks Side is input so we only log once """ if side == "a" and not self.predict: logger.verbose("Using Mean Absolute Error Loss for mask") mask_loss_func = losses.mean_absolute_error if self.config.get("penalized_mask_loss", False): if side == "a" and not self.predict and initialize: logger.verbose("Using Penalized Loss for mask") mask_loss_func = PenalizedLoss(mask, mask_loss_func) logger.debug(mask_loss_func) return mask_loss_func
def loss_function(self, mask, side, initialize): """ Set the loss function Side is input so we only log once """ if side == '1': logger.verbose( "Loss function for the model is mean_absolute_error") loss_func = losses.mean_absolute_error if mask and self.config.get("penalized_mask_loss", False): loss_mask = mask[0] if side == "1" and not self.predict and initialize: logger.verbose("Penalizing mask for Loss") loss_func = PenalizedLoss(loss_mask, loss_func) return loss_func
def loss_function(self, mask, side, initialize): """ Set the loss function Side is input so we only log once """ if self.config.get("dssim_loss", False): if side == "a" and not self.predict and initialize: logger.verbose("Using DSSIM Loss") loss_func = DSSIMObjective() else: if side == "a" and not self.predict and initialize: logger.verbose("Using Mean Absolute Error Loss") loss_func = losses.mean_absolute_error if mask and self.config.get("penalized_mask_loss", False): loss_mask = mask[0] if side == "a" and not self.predict and initialize: logger.verbose("Penalizing mask for Loss") loss_func = PenalizedLoss(loss_mask, loss_func) return loss_func
def get_loss_functions(self): """ Set the loss function """ loss_funcs = [] for idx, loss_name in enumerate(self.names): if loss_name.startswith("mask"): loss_funcs.append(self.selected_mask_loss) elif self.mask_input is not None and self.config.get("penalized_mask_loss", False): face_size = self.output_shapes[idx][1] mask_size = self.mask_shape[1] scaling = face_size / mask_size logger.debug("face_size: %s mask_size: %s, mask_scaling: %s", face_size, mask_size, scaling) loss_funcs.append(PenalizedLoss(self.mask_input, self.selected_loss, mask_scaling=scaling, preprocessing_func=self.mask_preprocessing_func)) else: loss_funcs.append(self.selected_loss) logger.debug("%s: %s", loss_name, loss_funcs[-1]) logger.debug(loss_funcs) return loss_funcs