code: from __future__ import print_function
  from PIL import Image
  import os
  import os.path
  import numpy as np
  import sys
  
  import pickle
  import torch
  import torch.utils.data as data
  
  from itertools import permutations
  
  class VisionDataset(data.Dataset):
      _repr_indent = 4
  
      def __init__(self, root, transforms=None, transform=None, target_transform=None):
          if isinstance(root, torch._six.string_classes):
              root = os.path.expanduser(root)
          self.root = root
  
          has_transforms = transforms is not None
          has_separate_transform = transform is not None or target_transform is not None
          if has_transforms and has_separate_transform:
              raise ValueError("Only transforms or transform/target_transform can "
                               "be passed as argument")
  
          # for backwards-compatibility
          self.transform = transform
          self.target_transform = target_transform
  
          if has_separate_transform:
              transforms = StandardTransform(transform, target_transform)
          self.transforms = transforms
  
      def __getitem__(self, index):
          raise NotImplementedError
  
      def __len__(self):
          raise NotImplementedError
  
      def __repr__(self):
          head = "Dataset " + self.__class__.__name__
          body = ["Number of datapoints: {}".format(self.__len__())]
          if self.root is not None:
              body.append("Root location: {}".format(self.root))
          body += self.extra_repr().splitlines()
          if self.transforms is not None:
              body += [repr(self.transforms)]
          lines = [head] + [" " * self._repr_indent + line for line in body]
          return '\n'.join(lines)
  
      def _format_transform_repr(self, transform, head):
          lines = transform.__repr__().splitlines()
          return (["{}{}".format(head, lines[0])] +
                  ["{}{}".format(" " * len(head), line) for line in lines[1:]])
  
      def extra_repr(self):
          return ""
  
  class CIFAR10(VisionDataset):
      base_folder = 'cifar-10-batches-py'
      url = "https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz"
      filename = "cifar-10-python.tar.gz"
      tgz_md5 = 'c58f30108f718f92721af3b95e74349a'
      train_list = [
          ['data_batch_1', 'c99cafc152244af753f735de768cd75f'],
          ['data_batch_2', 'd4bba439e000b95fd0a9bffe97cbabec'],
          ['data_batch_3', '54ebc095f3ab1f0389bbae665268c751'],
          ['data_batch_4', '634d18415352ddfa80567beed471001a'],
          ['data_batch_5', '482c414d41f54cd18b22e5b47cb7c3cb'],
      ]
  
      test_list = [
          ['test_batch', '40351d587109b95175f43aff81a1287e'],
      ]
      meta = {
          'filename': 'batches.meta',
          'key': 'label_names',
          'md5': '5ff9c542aee3614f3951f8cda6e48888',
      }
  
      def __init__(self, root, train=True,
                   transform=None, download=False):
  
          super(CIFAR10, self).__init__(root)
          self.transform = transform
  
          self.train = train  # training set or test set
  
          if download:
              raise ValueError('cannot download.')
              exit()
              #self.download()
  
          #if not self._check_integrity():
          #    raise RuntimeError('Dataset not found or corrupted.' +
          #                       ' You can use download=True to download it')
  
          if self.train:
              downloaded_list = self.train_list
          else:
              downloaded_list = self.test_list
  
          self.data = []
          self.targets = []
  
          # now load the picked numpy arrays
          for file_name, checksum in downloaded_list:
              file_path = os.path.join(self.root, self.base_folder, file_name)
              with open(file_path, 'rb') as f:
                  if sys.version_info[0] == 2:
                      entry = pickle.load(f)
                  else:
                      entry = pickle.load(f, encoding='latin1')
                  self.data.append(entry['data'])
                  if 'labels' in entry:
                      self.targets.extend(entry['labels'])
                  else:
                      self.targets.extend(entry['fine_labels'])
  
          self.data = np.vstack(self.data).reshape(-1, 3, 32, 32)
          self.data = self.data.transpose((0, 2, 3, 1))  # convert to HWC
  
          self._load_meta()
  
      def _load_meta(self):
          path = os.path.join(self.root, self.base_folder, self.meta['filename'])
          #if not check_integrity(path, self.meta['md5']):
          #    raise RuntimeError('Dataset metadata file not found or corrupted.' +
          #                       ' You can use download=True to download it')
          with open(path, 'rb') as infile:
              if sys.version_info[0] == 2:
                  data = pickle.load(infile)
              else:
                  data = pickle.load(infile, encoding='latin1')
              self.classes = data[self.meta['key']]
          self.class_to_idx = {_class: i for i, _class in enumerate(self.classes)}
  
      def __getitem__(self, index):
  
          img, target = self.data[index], self.targets[index]
          if self.train:
              if np.random.rand() < 0.5:
                  img = img[:,::-1,:]
  
          img0 = np.rot90(img, 0).copy()
          img0 = Image.fromarray(img0)
          img0 = self.transform(img0)
  
          img1 = np.rot90(img, 1).copy()
          img1 = Image.fromarray(img1)
          img1 = self.transform(img1)
  
          img2 = np.rot90(img, 2).copy()
          img2 = Image.fromarray(img2)
          img2 = self.transform(img2)
  
          img3 = np.rot90(img, 3).copy()
          img3 = Image.fromarray(img3)
          img3 = self.transform(img3)
  
          img = torch.stack([img0,img1,img2,img3])
  
          return img, target
  
  
      def __len__(self):
          return len(self.data)
  
      def _check_integrity(self):
          root = self.root
          for fentry in (self.train_list + self.test_list):
              filename, md5 = fentry[0], fentry[1]
              fpath = os.path.join(root, self.base_folder, filename)
              if not check_integrity(fpath, md5):
                  return False
          return True
  
      def download(self):
          import tarfile
  
          if self._check_integrity():
              print('Files already downloaded and verified')
              return
  
          download_url(self.url, self.root, self.filename, self.tgz_md5)
  
          # extract file
          with tarfile.open(os.path.join(self.root, self.filename), "r:gz") as tar:
              tar.extractall(path=self.root)
  
      def extra_repr(self):
          return "Split: {}".format("Train" if self.train is True else "Test")
  
  
  class CIFAR100(CIFAR10):
      """`CIFAR100 <https://www.cs.toronto.edu/~kriz/cifar.html>`_ Dataset.
  
      This is a subclass of the `CIFAR10` Dataset.
      """
      base_folder = 'cifar-100-python'
      url = "https://www.cs.toronto.edu/~kriz/cifar-100-python.tar.gz"
      filename = "cifar-100-python.tar.gz"
      tgz_md5 = 'eb9058c3a382ffc7106e4002c42a8d85'
      train_list = [
          ['train', '16019d7e3df5f24257cddd939b257f8d'],
      ]
  
      test_list = [
          ['test', 'f0ef6b0ae62326f3e7ffdfab6717acfc'],
      ]
      meta = {
          'filename': 'meta',
          'key': 'fine_label_names',
          'md5': '7973b15100ade9c7d40fb424638fde48',
      }
  
apis: numpy.vstack numpy.rot90 torch.stack numpy.random.rand