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 loss_function(self, side, initialize):
""" Set the loss function """
# TODO: Try use various loss functions.
loss_func = DSSIMObjective()
# loss_func = losses.mean_absolute_error
return loss_func
def loss_dict(self):
""" Return the loss dict """
loss_dict = dict(mae=losses.mean_absolute_error,
mse=losses.mean_squared_error,
logcosh=losses.logcosh,
smooth_loss=generalized_loss,
l_inf_norm=l_inf_norm,
ssim=DSSIMObjective(),
gmsd=gmsd_loss,
pixel_gradient_diff=gradient_loss)
return loss_dict
def loss_function(self, side):
""" Set the loss function """
if self.config.get("dssim_loss", False):
if side == "a" and not self.predict:
logger.verbose("Using DSSIM Loss")
loss_func = DSSIMObjective()
else:
if side == "a" and not self.predict:
logger.verbose("Using Mean Absolute Error Loss")
loss_func = losses.mean_absolute_error
logger.debug(loss_func)
return loss_func
def mask_loss_function(self, mask, side):
""" Set the loss function for masks
Side is input so we only log once """
if self.config.get("dssim_mask_loss", False):
if side == "a" and not self.predict:
logger.verbose("Using DSSIM Loss for mask")
mask_loss_func = DSSIMObjective()
else:
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:
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 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
