          cv2.imwrite(filename, image)
          logger.debug("Created time-lapse: '%s'", filename)
  
  
  def _stack_images(images):
      """ Stack images evenly for preview.
  
      Parameters
      ----------
      images: :class:`numpy.ndarray`
 
</s> remove         images: list
            The list of full paths to the images for creating the time-lapse for this
            :class:`_Feeder`
 </s> add         images: dict
            The list of full paths to the images for creating the time-lapse for each side </s> remove             logger.trace("Reloading image: '%s'", filename)
 </s> add             logger.trace("Reloading image: '%s'", filename)  # type: ignore </s> remove     def _process_full(self, side, images, prediction_size, color):
 </s> add     def _process_full(self,
                      side: Literal["a", "b"],
                      images: np.ndarray,
                      prediction_size: int,
                      color: Tuple[int, int, int]) -> np.ndarray: </s> remove         batch_size: int
            The requested batch size for each training iterations
        samples: dict, optional
            Dictionary for side "a", "b" of :class:`numpy.ndarray`. The sample images that should
            be used for creating the preview. If ``None`` then the samples will be generated from
            the internal random image generator. Default: ``None``
        images: dict, optional
            Dictionary for side "a", "b" of :class:`numpy.ndarray`. The target images that should
            be used for creating the preview. If ``None`` then the targets will be generated from
            the internal random image generator. Default: ``None``
        masks: dict, optional
 </s> add         image_count: int
            The number of images to limit the sample output to.
        feed: dict
            Dictionary for side "a", "b" of :class:`numpy.ndarray`. The images that should be fed
            into the model for obtaining a prediction
        samples: dict
            Dictionary for side "a", "b" of :class:`numpy.ndarray`. The 100% coverage target images
            that should be used for creating the preview.
        masks: dict </s> remove     def _add_mask(self, filename, detected_face):
        """ Load the mask to the cache if a mask is required for training.
 </s> add     def process_batch(self,
                      filenames: List[str],
                      images: np.ndarray,
                      detected_faces: List[DetectedFace],
                      batch: np.ndarray) -> BatchType:
        """ Override for processing the batch for the current generator.
def _stack_images(images: np.ndarray) -> np.ndarray:
          cv2.imwrite(filename, image)
          logger.debug("Created time-lapse: '%s'", filename)
  
  
def _stack_images(images: np.ndarray) -> np.ndarray:
      """ Stack images evenly for preview.
  
      Parameters
      ----------
      images: :class:`numpy.ndarray`
keep keep keep keep replace keep keep keep keep keep
 Data Augmentation update (#1263)

- lib.detected_face
    - Subclass Masks for Landmark based masks
    - Add training mask propery + methods to DetectedFace
  - lib.training_training
    - subclass TrainingDataGenerator for training and preview data
    - Split cache into own module
    - Reduce thread count to 1 to prevent image corruption + data re-use
    - Process on largest model input/output size rather than stored image size
    - Size and crop masks during caching stage
    - Implement ring buffer for data flow
    - Fix preview reload bug
  - augmentation
    - typing
    - switch color aug order
    - better initialization
    - Fix warp + landmark warp to correctly apply at different image scales
    - Slightly improved warp caching
    - Don't store whether image is_preview. Handle all data as training images implicitly
  - plugins.trainer: Typing and fixes to work with trainingdata refactor 
plugins/train/trainer/_base.py