class_docstr: A custom dataloader to preprocessing observations (including images)
  and feed them to the network.
  
  Original code for the dataloader from https://github.com/araffin/robotics-rl-srl
  (MIT licence)
  Authors: Antonin Raffin, René Traoré, Ashley Hill
  
  :param indices: ([int]) list of observations indices
  :param observations: (np.ndarray) observations or images path
  :param actions: (np.ndarray) actions
  :param batch_size: (int) Number of samples per minibatch
  :param n_workers: (int) number of preprocessing worker (for loading the images)
  :param infinite_loop: (bool) whether to have an iterator that can be reset
  :param max_queue_len: (int) Max number of minibatches that can be preprocessed at the same time
  :param shuffle: (bool) Shuffle the minibatch after each epoch
  :param start_process: (bool) Start the preprocessing process (default: True)
  :param backend: (str) joblib backend (one of 'multiprocessing', 'sequential', 'threading'
      or 'loky' in newest versions)
  :param sequential: (bool) Do not use subprocess to preprocess the data
      (slower but use less memory for the CI)
  :param partial_minibatch: (bool) Allow partial minibatches (minibatches with a number of element
      lesser than the batch_size)
code: def __init__(
      self,
      indices,
      observations,
      actions,
      batch_size,
      n_workers=1,
      infinite_loop=True,
      max_queue_len=1,
      shuffle=False,
      start_process=True,
      backend="threading",
      sequential=False,
      partial_minibatch=True,
  ):
      super(DataLoader, self).__init__()
      self.n_workers = n_workers
      self.infinite_loop = infinite_loop
      self.indices = indices
      self.original_indices = indices.copy()
      self.n_minibatches = len(indices) // batch_size
      # Add a partial minibatch, for instance
      # when there is not enough samples
      if partial_minibatch and len(indices) % batch_size > 0:
          self.n_minibatches += 1
      self.batch_size = batch_size
      self.observations = observations
      self.actions = actions
      self.shuffle = shuffle
      self.queue = Queue(max_queue_len)
      self.process = None
      self.load_images = isinstance(observations[0], str)
      self.backend = backend
      self.sequential = sequential
      self.start_idx = 0
      if start_process:
          self.start_process()
  
imports: import queue
  import time
  from multiprocessing import Queue, Process
  import cv2
  import numpy
  from joblib import Parallel, delayed
  from stable_baselines import logger
label_desc: Use image node_id 1 to create a new DataLoader object from inherited base classes: object with example: obj = DataLoader(indices, observations, actions, batch_size, n_workers, infinite_loop, max_queue_len, shuffle, start_process, backend, sequential, partial_minibatch)