code: """
  __author__: Abhishek Thakur
  """
  
  import torch
  
  import numpy as np
  
  from PIL import Image
  from PIL import ImageFile
  
  try:
      import torch_xla.core.xla_model as xm
  
      _xla_available = True
  except ImportError:
      _xla_available = False
  
  ImageFile.LOAD_TRUNCATED_IMAGES = True
  
  
  class ClassificationDataset:
      def __init__(self, image_paths, targets, resize, augmentations=None):
          """
          :param image_paths: list of paths to images
          :param targets: numpy array
          :param resize: tuple or None
          :param augmentations: albumentations augmentations
          """
          self.image_paths = image_paths
          self.targets = targets
          self.resize = resize
          self.augmentations = augmentations
  
      def __len__(self):
          return len(self.image_paths)
  
      def __getitem__(self, item):
          image = Image.open(self.image_paths[item])
          targets = self.targets[item]
          if self.resize is not None:
              image = image.resize(
                  (self.resize[1], self.resize[0]), resample=Image.BILINEAR
              )
          image = np.array(image)
          if self.augmentations is not None:
              augmented = self.augmentations(image=image)
              image = augmented["image"]
          image = np.transpose(image, (2, 0, 1)).astype(np.float32)
          return {
              "image": torch.tensor(image),
              "targets": torch.tensor(targets),
          }
  
  
  class ClassificationDataLoader:
      def __init__(self, image_paths, targets, resize, augmentations=None):
          """
          :param image_paths: list of paths to images
          :param targets: numpy array
          :param resize: tuple or None
          :param augmentations: albumentations augmentations
          """
          self.image_paths = image_paths
          self.targets = targets
          self.resize = resize
          self.augmentations = augmentations
          self.dataset = ClassificationDataset(
              image_paths=self.image_paths,
              targets=self.targets,
              resize=self.resize,
              augmentations=self.augmentations,
          )
  
      def fetch(self, batch_size, num_workers, drop_last=False, shuffle=True, tpu=False):
          """
          :param batch_size: batch size
          :param num_workers: number of processes to use
          :param drop_last: drop the last batch?
          :param shuffle: True/False
          :param tpu: True/False, to use tpu or not
          """
          sampler = None
          if tpu:
              sampler = torch.utils.data.distributed.DistributedSampler(
                  self.dataset,
                  num_replicas=xm.xrt_world_size(),
                  rank=xm.get_ordinal(),
                  shuffle=shuffle,
              )
  
          data_loader = torch.utils.data.DataLoader(
              self.dataset,
              batch_size=batch_size,
              sampler=sampler,
              drop_last=drop_last,
              num_workers=num_workers,
          )
          return data_loader
  
apis: numpy.array torch.utils.data.DataLoader torch.tensor numpy.transpose