          preds["a_a"] = self.model.predictors["a"].predict(feed_a)
          preds["b_a"] = self.model.predictors["b"].predict(feed_a)
          preds["a_b"] = self.model.predictors["a"].predict(feed_b)
          preds["b_b"] = self.model.predictors["b"].predict(feed_b)
  
          # Get the returned image from predictors that emit multiple items
          if not isinstance(preds["a_a"], np.ndarray):
              for key, val in preds.items():
                  preds[key] = val[0]
          logger.debug("Returning predictions: %s", {key: val.shape for key, val in preds.items()})
          return preds
 
</s> remove                 preds[key] = val[0]
 </s> add                 preds[key] = val[self.model.largest_face_index] </s> remove         self.model_output_size = model_output_size
 </s> add         self.model_output_shapes = model_output_shapes </s> remove                      self.__class__.__name__, model_input_size, model_output_size,
 </s> add                      self.__class__.__name__, model_input_size, model_output_shapes, </s> remove     def __init__(self, model_input_size, model_output_size, training_opts, config):
        logger.debug("Initializing %s: (model_input_size: %s, model_output_shape: %s, "
 </s> add     def __init__(self, model_input_size, model_output_shapes, training_opts, config):
        logger.debug("Initializing %s: (model_input_size: %s, model_output_shapes: %s, " </s> remove         target_image = cv2.resize(  # pylint:disable=no-member
            target_image[slices, slices, :], (self.output_size, self.output_size),
            cv2.INTER_AREA)  # pylint:disable=no-member
        logger.trace("Target image shape: %s", target_image.shape)

        warped_image, warped_mask = self.separate_mask(warped_image)
        target_image, target_mask = self.separate_mask(target_image)

        if target_mask is None:
            logger.trace("Randomly warped image")
            return [warped_image, target_image]

        logger.trace("Target mask shape: %s", target_mask.shape)
        logger.trace("Randomly warped image and mask")
        return [warped_image, target_image, target_mask]
 </s> add         target_images = [cv2.resize(target_image[slices, slices, :],  # pylint:disable=no-member
                                    (size, size),
                                    cv2.INTER_AREA)  # pylint:disable=no-member
                         for size in self.output_sizes]

        logger.trace("Target image shapea: %s", [img.shape for img in target_images])
        return self.compile_images(warped_image, target_images)

    def compile_images(self, warped_image, target_images):
        """ Compile the warped images, target images and mask for feed """
        warped_image, _ = self.separate_mask(warped_image)
        final_target_images = list()
        target_mask = None
        for target_image in target_images:
            image, mask = self.separate_mask(target_image)
            final_target_images.append(image)
            # Add the mask if it exists and is the same size as our largest output
            if mask is not None and mask.shape[1] == max(self.output_sizes):
                target_mask = mask

        retval = [warped_image] + final_target_images
        if target_mask is not None:
            logger.trace("Target mask shape: %s", target_mask.shape)
            retval.append(target_mask)

        logger.trace("Final shapes: %s", [img.shape for img in retval])
        return retval
        # Get the returned largest image from predictors that emit multiple items
          preds["a_a"] = self.model.predictors["a"].predict(feed_a)
          preds["b_a"] = self.model.predictors["b"].predict(feed_a)
          preds["a_b"] = self.model.predictors["a"].predict(feed_b)
          preds["b_b"] = self.model.predictors["b"].predict(feed_b)
        # Get the returned largest image from predictors that emit multiple items
        # Get the returned largest image from predictors that emit multiple items
          if not isinstance(preds["a_a"], np.ndarray):
              for key, val in preds.items():
                  preds[key] = val[0]
          logger.debug("Returning predictions: %s", {key: val.shape for key, val in preds.items()})
          return preds
keep keep keep keep replace 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 
plugins/train/trainer/_base.py