                                 self.config.get("clipnorm", False),
                                 self._args).optimizer
          if self._settings.use_mixed_precision:
              optimizer = self._settings.LossScaleOptimizer(optimizer, loss_scale="dynamic")
  
          self._loss.configure(self._model.inputs, self._model.outputs)
          self._model.compile(optimizer=optimizer, loss=self._loss.functions)
          if not self._is_predict:
              self._state.add_session_loss_names(self._loss.names)
          logger.debug("Compiled Model: %s", self._model)
  
 
</s> remove                 loss_funcs.append(mask_loss)
 </s> add                 loss_func = self._loss_dict[self._config["mask_loss_function"]] </s> remove                 loss_funcs.append(losses.PenalizedLoss(selected_loss))
 </s> add                 loss_func = losses.PenalizedLoss(selected_loss)
            else:
                loss_func = selected_loss
            logger.debug("%s: (output_name: '%s', function: %s)", name, output_name, loss_func)
            if get_backend() == "amd":
                self._funcs[output_name] = loss_func </s> remove             retval.extend(["{}_{}{}".format(name, side,
                                            "" if output_types.count(name) == 1
                                            else "_{}".format(idx))
                           for idx, name in enumerate(output_types)])
        logger.debug(retval)
        return retval
 </s> add             self._names.extend(["{}_{}{}".format(name, side,
                                                 "" if output_types.count(name) == 1
                                                 else "_{}".format(idx))
                                for idx, name in enumerate(output_types)])
        logger.debug(self._names) </s> remove         retval = []
 </s> add  </s> remove         mask_loss = self._loss_dict[self._config["mask_loss_function"]]
        loss_funcs = []
        for name in self._names:
 </s> add         for name, output_name in zip(self._names, output_names):
        if get_backend() == "amd":
            self._rewrite_plaid_outputs()
        self._loss.configure(self._model)
                                 self.config.get("clipnorm", False),
                                 self._args).optimizer
          if self._settings.use_mixed_precision:
              optimizer = self._settings.LossScaleOptimizer(optimizer, loss_scale="dynamic")
        if get_backend() == "amd":
            self._rewrite_plaid_outputs()
        self._loss.configure(self._model)
        if get_backend() == "amd":
            self._rewrite_plaid_outputs()
        self._loss.configure(self._model)
          self._model.compile(optimizer=optimizer, loss=self._loss.functions)
          if not self._is_predict:
              self._state.add_session_loss_names(self._loss.names)
          logger.debug("Compiled Model: %s", self._model)
  
keep keep keep keep replace replace keep keep keep keep keep
 training - Use explicit loss dictionaries to map to outputs 
plugins/train/model/_base.py