              logger.trace("Not loss message. Returning False")
              return False
  
          loss = self.consoleregex["loss"].findall(string)
          if len(loss) < 2:
              logger.trace("Not loss message. Returning False")
              return False
  
          message = ""
          for item in loss:
 
</s> remove         message = ""
        for item in loss:
            message += "{}: {}  ".format(item[0], item[1])
 </s> add         message = "Total Iterations: {} | ".format(int(loss[0][0]))
        message += "  ".join(["{}: {}".format(itm[1], itm[2]) for itm in loss]) </s> remove     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 mask_loss_function(self, side, initialize):
        """ Set the mask loss function
            Side is input so we only log once """
        if side == "a" and not self.predict and initialize:
            logger.verbose("Using Mean Squared Error Loss for mask")
        mask_loss_func = losses.mean_squared_error
        return mask_loss_func

 </s> add  </s> remove             mask = [inp for inp in model.inputs if inp.name.startswith("mask")]
            loss_names = ["loss"]
            loss_funcs = [self.loss_function(mask, side, initialize)]
            if mask:
                loss_names.append("mask_loss")
                loss_funcs.append(self.mask_loss_function(side, initialize))
            model.compile(optimizer=optimizer, loss=loss_funcs)

            if len(loss_names) > 1:
                loss_names.insert(0, "total_loss")
 </s> add             mask_input = [inp for inp in model.inputs if inp.name.startswith("mask")]
            loss = Loss(side, model.outputs, mask_input, self.predict)
            model.compile(optimizer=optimizer, loss=loss.funcs) </s> remove         output = [", ".join(["{}_{}: {:.5f}".format(self.model.state.loss_names[side][idx],
                                                    side.capitalize(),
                                                    this_loss)
                             for idx, this_loss in enumerate(loss[side])])
 </s> add         output = ["Loss {}: {:.5f}".format(side.capitalize(), loss[side][0]) </s> remove         message = "Elapsed: {}  Iteration: {}  {}".format(elapsed,
                                                          self.train_stats["iterations"], message)
 </s> add         message = "Elapsed: {} | Session Iterations: {}  {}".format(
            elapsed,
            self.train_stats["iterations"], message)
        if len(loss) != 2 or not all(len(itm) == 3 for itm in loss):
              logger.trace("Not loss message. Returning False")
              return False
  
          loss = self.consoleregex["loss"].findall(string)
        if len(loss) != 2 or not all(len(itm) == 3 for itm in loss):
              logger.trace("Not loss message. Returning False")
              return False
  
          message = ""
          for item in loss:
keep keep keep keep replace keep keep keep keep keep
 Training: Add Multi-Output Support

- Name output nodes of models
- Add support for multiple outputs in models and in training
- Update loss output format for cli and gui
- Sort graphs tabs on training
- Fix analysis graph for new loss names
- Multi output support in convert 
lib/gui/wrapper.py