              self.names.insert(0, "total_loss")
          logger.debug("Initialized: %s", self.__class__.__name__)
  
      @property
      def config(self):
          """ Return the global _CONFIG variable """
          return _CONFIG
  
      @property
 
</s> remove     def loss_shapes(self):
 </s> add     def selected_loss(self):
        """ Return the selected loss function """
        retval = self.loss_dict[self.config.get("loss_function", "mae")]
        logger.debug(retval)
        return retval

    @property
    def selected_mask_loss(self):
        """ Return the selected mask loss function. Currently returns mse """
        retval = self.loss_dict["mse"]
        logger.debug(retval)
        return retval

    @property
    def output_shapes(self): </s> remove         self.funcs = self.get_loss_functions(mask_input)
 </s> add         self.funcs = self.get_loss_functions() </s> remove     def largest_output(self):
        """ Return the index of the largest face output """
        max_size = max(shape[0] for shape in self.loss_shapes if shape[2] == 3)
        largest_idx = [idx for idx, shape in enumerate(self.loss_shapes)
                       if shape[0] == max_size and shape[2] == 3][0]
        return largest_idx
 </s> add     def mask_input(self):
        """ Return the mask input or None """
        mask_inputs = [inp for inp in self.inputs if inp.name.startswith("mask")]
        if not mask_inputs:
            return None
        return mask_inputs[0]

    @property
    def mask_shape(self):
        """ Return the mask shape """
        if self.mask_input is None:
            return None
        return K.int_shape(self.mask_input)[1:] </s> remove     def __init__(self, outputs, mask_input):
        logger.debug("Initializing %s: (outputs: '%s', mask_input: '%s')",
                     self.__class__.__name__, outputs, mask_input)
 </s> add     def __init__(self, inputs, outputs):
        logger.debug("Initializing %s: (inputs: %s, outputs: %s)",
                     self.__class__.__name__, inputs, outputs)
        self.inputs = inputs </s> remove         # Only return the output shape of the face
 </s> add 
    @property
    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_l=generalized_loss,
                         l_inf_norm=l_inf_norm,
                         ssim=DSSIMObjective(),
                         gmsd=gmsd_loss,
                         pixel_gradient_diff=gradient_loss)
        return loss_dict

              self.names.insert(0, "total_loss")
          logger.debug("Initialized: %s", self.__class__.__name__)
  
    @property
    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_l=generalized_loss,
                         l_inf_norm=l_inf_norm,
                         ssim=DSSIMObjective(),
                         gmsd=gmsd_loss,
                         pixel_gradient_diff=gradient_loss)
        return loss_dict

      @property
      def config(self):
          """ Return the global _CONFIG variable """
          return _CONFIG
  
      @property
keep keep add keep keep keep keep keep keep
 Fix penalized loss for multiscale decoders 
plugins/train/model/_base.py