          """ The shapes of the output nodes """
          return [K.int_shape(output)[1:] for output in self.outputs]
  
      @property
      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
  
      def get_loss_names(self):
          """ Return the loss names based on model output """
          output_names = [output.name for output in self.outputs]
          logger.debug("Model output names: %s", output_names)
 
</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         # Only return the output shape of the face
 </s> add  </s> remove         output_types = ["mask" if shape[-1] == 1 else "face" for shape in self.loss_shapes]
 </s> add         output_types = ["mask" if shape[-1] == 1 else "face" for shape in self.output_shapes] </s> remove     def get_loss_functions(self, mask):
 </s> add     def get_loss_functions(self):
    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:]
          """ The shapes of the output nodes """
          return [K.int_shape(output)[1:] for output in self.outputs]
  
      @property
    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:]
    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:]
    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:]
    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:]
    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:]
    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:]
  
      def get_loss_names(self):
          """ Return the loss names based on model output """
          output_names = [output.name for output in self.outputs]
          logger.debug("Model output names: %s", output_names)
keep keep keep keep replace replace replace replace replace replace keep keep keep keep keep
 Fix penalized loss for multiscale decoders 
plugins/train/model/_base.py