text: import numpy as np
  import keras
  import cv2
  import os
  from scipy import misc
  
  class DataGenerator(keras.utils.Sequence):
      'Generates data for Keras'
      def __init__(self, list_IDs, labels, batch_size=32, dim=(32,32,23), n_channels=1,
                   n_classes=10, shuffle=True):
          'Initialization'
          self.dim = dim
          self.batch_size = batch_size
          self.labels = labels
          self.list_IDs = list_IDs
          self.n_channels = n_channels
          self.n_classes = n_classes
          self.shuffle = shuffle
          self.on_epoch_end()
          self.n = len(list_IDs) 
  
      def __len__(self):
          'Denotes the number of batches per epoch'
          return int(np.floor(len(self.list_IDs) / self.batch_size))
  
      def __getitem__(self, index):
          'Generate one batch of data'
          # Generate indexes of the batch
          indexes = self.indexes[index*self.batch_size:(index+1)*self.batch_size]
          # Find list of IDs
          list_IDs_temp = [self.list_IDs[k] for k in indexes]
          # Generate data
          X, y = self.__data_generation(list_IDs_temp)
          return X, y
  
      def on_epoch_end(self):
          'Updates indexes after each epoch'
          self.indexes = np.arange(len(self.list_IDs))
          if self.shuffle == True:
              np.random.shuffle(self.indexes)
  
      def __data_generation(self, list_IDs_temp):
          'Generates data containing batch_size samples' # X : (n_samples, *dim, n_channels)
          # Initialization
          X = np.empty((self.batch_size, *self.dim, self.n_channels))
          y = np.empty((self.batch_size), dtype=int)
          # Generate data
          for i, ID in enumerate(list_IDs_temp):
              images=[]
              # Store sample
              for img_name in os.listdir(ID):
                  img=misc.imread(os.path.join(ID,img_name),mode='RGB')
                  img=misc.imresize(img,(self.dim[1],self.dim[2]))
                  images.append(img)
              images=np.array(images)[0:self.dim[0]]
              # pre process image
              images = images.astype('float32')
              images = images / 255.0
              X[i,] = images 
  
              # Store class
              y[i] = self.labels[ID]
          return X, keras.utils.to_categorical(y, num_classes=self.n_classes)