text: import torch.utils.data as data
  from torchvision.datasets.folder import has_file_allowed_extension, find_classes, make_dataset, pil_loader, \
      default_loader, accimage_loader, IMG_EXTENSIONS
  
  from PIL import Image
  
  import os
  import os.path
  
  import pickle
  
  
  class FastDatasetFolder(data.Dataset):
      """A generic data loader where the samples are arranged in this way: ::
  
          root/class_x/xxx.ext
          root/class_x/xxy.ext
          root/class_x/xxz.ext
  
          root/class_y/123.ext
          root/class_y/nsdf3.ext
          root/class_y/asd932_.ext
  
      Args:
          root (string): Root directory path.
          loader (callable): A function to load a sample given its path.
          extensions (list[string]): A list of allowed extensions.
          transform (callable, optional): A function/transform that takes in
              a sample and returns a transformed version.
              E.g, ``transforms.RandomCrop`` for images.
          target_transform (callable, optional): A function/transform that takes
              in the target and transforms it.
  
       Attributes:
          classes (list): List of the class names.
          class_to_idx (dict): Dict with items (class_name, class_index).
          samples (list): List of (sample path, class_index) tuples
      """
  
      def __init__(self, root, loader, extensions, transform=None, target_transform=None):
          classes, class_to_idx = find_classes(root)
          samples_cache_path = os.path.join(root, 'samples.pickle')
          if os.path.exists(samples_cache_path):
              with open(samples_cache_path, 'rb') as rf:
                  samples = pickle.load(rf)
              print('=> read {} samples from cache: {}'.format(len(samples), samples_cache_path))
          else:
              samples = make_dataset(root, class_to_idx, extensions)
              if os.access(root, os.W_OK):
                  print('=> caching {} samples to: {}'.format(len(samples), samples_cache_path))
                  with open(samples_cache_path, 'wb') as wf:
                      pickle.dump(samples, wf)
          if len(samples) == 0:
              raise (RuntimeError("Found 0 files in subfolders of: " + root + "\n"
                                                                              "Supported extensions are: " + ",".join(
                  extensions)))
  
          self.root = root
          self.loader = loader
          self.extensions = extensions
  
          self.classes = classes
          self.class_to_idx = class_to_idx
          self.samples = samples
  
          self.transform = transform
          self.target_transform = target_transform
  
      def __getitem__(self, index):
          """
          Args:
              index (int): Index
  
          Returns:
              tuple: (sample, target) where target is class_index of the target class.
          """
          path, target = self.samples[index]
          sample = self.loader(path)
          if self.transform is not None:
              sample = self.transform(sample)
          if self.target_transform is not None:
              target = self.target_transform(target)
  
          return sample, target
  
      def __len__(self):
          return len(self.samples)
  
      def __repr__(self):
          fmt_str = 'Dataset ' + self.__class__.__name__ + '\n'
          fmt_str += '    Number of datapoints: {}\n'.format(self.__len__())
          fmt_str += '    Root Location: {}\n'.format(self.root)
          tmp = '    Transforms (if any): '
          fmt_str += '{0}{1}\n'.format(tmp, self.transform.__repr__().replace('\n', '\n' + ' ' * len(tmp)))
          tmp = '    Target Transforms (if any): '
          fmt_str += '{0}{1}'.format(tmp, self.target_transform.__repr__().replace('\n', '\n' + ' ' * len(tmp)))
          return fmt_str
  
  
  class FastImageFolder(FastDatasetFolder):
      """A generic data loader where the images are arranged in this way: ::
  
          root/dog/xxx.png
          root/dog/xxy.png
          root/dog/xxz.png
  
          root/cat/123.png
          root/cat/nsdf3.png
          root/cat/asd932_.png
  
      Args:
          root (string): Root directory path.
          transform (callable, optional): A function/transform that  takes in an PIL image
              and returns a transformed version. E.g, ``transforms.RandomCrop``
          target_transform (callable, optional): A function/transform that takes in the
              target and transforms it.
          loader (callable, optional): A function to load an image given its path.
  
       Attributes:
          classes (list): List of the class names.
          class_to_idx (dict): Dict with items (class_name, class_index).
          imgs (list): List of (image path, class_index) tuples
      """
  
      def __init__(self, root, transform=None, target_transform=None,
                   loader=default_loader):
          super(FastImageFolder, self).__init__(root, loader, IMG_EXTENSIONS,
                                                transform=transform,
                                                target_transform=target_transform)
          self.imgs = self.samples
  