text: # data loader
  import torch
  from skimage import io, transform, color
  import numpy as np
  from torch.utils.data import Dataset, DataLoader
  from torchvision import transforms, utils
  
  #==========================dataset load==========================
  class RescaleT(object):
  
  	def __init__(self,output_size):
  		assert isinstance(output_size,(int,tuple))
  		self.output_size = output_size
  
  	def __call__(self,image):
  
  		img = transform.resize(image,(self.output_size,self.output_size),mode='constant')
  
  		return img
  
  class ToTensorLab(object):
  	"""Convert ndarrays in sample to Tensors."""
  	def __init__(self,flag=0):
  		self.flag = flag
  
  	def __call__(self, image):
  
  		# change the color space
  		if self.flag == 2: # with rgb and Lab colors
  			tmpImg = np.zeros((image.shape[0],image.shape[1],6))
  			tmpImgt = np.zeros((image.shape[0],image.shape[1],3))
  			if image.shape[2]==1:
  				tmpImgt[:,:,0] = image[:,:,0]
  				tmpImgt[:,:,1] = image[:,:,0]
  				tmpImgt[:,:,2] = image[:,:,0]
  			else:
  				tmpImgt = image
  			tmpImgtl = color.rgb2lab(tmpImgt)
  
  			# nomalize image to range [0,1]
  			tmpImg[:,:,0] = (tmpImgt[:,:,0]-np.min(tmpImgt[:,:,0]))/(np.max(tmpImgt[:,:,0])-np.min(tmpImgt[:,:,0]))
  			tmpImg[:,:,1] = (tmpImgt[:,:,1]-np.min(tmpImgt[:,:,1]))/(np.max(tmpImgt[:,:,1])-np.min(tmpImgt[:,:,1]))
  			tmpImg[:,:,2] = (tmpImgt[:,:,2]-np.min(tmpImgt[:,:,2]))/(np.max(tmpImgt[:,:,2])-np.min(tmpImgt[:,:,2]))
  			tmpImg[:,:,3] = (tmpImgtl[:,:,0]-np.min(tmpImgtl[:,:,0]))/(np.max(tmpImgtl[:,:,0])-np.min(tmpImgtl[:,:,0]))
  			tmpImg[:,:,4] = (tmpImgtl[:,:,1]-np.min(tmpImgtl[:,:,1]))/(np.max(tmpImgtl[:,:,1])-np.min(tmpImgtl[:,:,1]))
  			tmpImg[:,:,5] = (tmpImgtl[:,:,2]-np.min(tmpImgtl[:,:,2]))/(np.max(tmpImgtl[:,:,2])-np.min(tmpImgtl[:,:,2]))
  
  			# tmpImg = tmpImg/(np.max(tmpImg)-np.min(tmpImg))
  
  			tmpImg[:,:,0] = (tmpImg[:,:,0]-np.mean(tmpImg[:,:,0]))/np.std(tmpImg[:,:,0])
  			tmpImg[:,:,1] = (tmpImg[:,:,1]-np.mean(tmpImg[:,:,1]))/np.std(tmpImg[:,:,1])
  			tmpImg[:,:,2] = (tmpImg[:,:,2]-np.mean(tmpImg[:,:,2]))/np.std(tmpImg[:,:,2])
  			tmpImg[:,:,3] = (tmpImg[:,:,3]-np.mean(tmpImg[:,:,3]))/np.std(tmpImg[:,:,3])
  			tmpImg[:,:,4] = (tmpImg[:,:,4]-np.mean(tmpImg[:,:,4]))/np.std(tmpImg[:,:,4])
  			tmpImg[:,:,5] = (tmpImg[:,:,5]-np.mean(tmpImg[:,:,5]))/np.std(tmpImg[:,:,5])
  
  		elif self.flag == 1: #with Lab color
  			tmpImg = np.zeros((image.shape[0],image.shape[1],3))
  
  			if image.shape[2]==1:
  				tmpImg[:,:,0] = image[:,:,0]
  				tmpImg[:,:,1] = image[:,:,0]
  				tmpImg[:,:,2] = image[:,:,0]
  			else:
  				tmpImg = image
  
  			tmpImg = color.rgb2lab(tmpImg)
  
  			# tmpImg = tmpImg/(np.max(tmpImg)-np.min(tmpImg))
  
  			tmpImg[:,:,0] = (tmpImg[:,:,0]-np.min(tmpImg[:,:,0]))/(np.max(tmpImg[:,:,0])-np.min(tmpImg[:,:,0]))
  			tmpImg[:,:,1] = (tmpImg[:,:,1]-np.min(tmpImg[:,:,1]))/(np.max(tmpImg[:,:,1])-np.min(tmpImg[:,:,1]))
  			tmpImg[:,:,2] = (tmpImg[:,:,2]-np.min(tmpImg[:,:,2]))/(np.max(tmpImg[:,:,2])-np.min(tmpImg[:,:,2]))
  
  			tmpImg[:,:,0] = (tmpImg[:,:,0]-np.mean(tmpImg[:,:,0]))/np.std(tmpImg[:,:,0])
  			tmpImg[:,:,1] = (tmpImg[:,:,1]-np.mean(tmpImg[:,:,1]))/np.std(tmpImg[:,:,1])
  			tmpImg[:,:,2] = (tmpImg[:,:,2]-np.mean(tmpImg[:,:,2]))/np.std(tmpImg[:,:,2])
  
  		else: # with rgb color
  			tmpImg = np.zeros((image.shape[0],image.shape[1],3))
  			image = image/np.max(image)
  			if image.shape[2]==1:
  				tmpImg[:,:,0] = (image[:,:,0]-0.485)/0.229
  				tmpImg[:,:,1] = (image[:,:,0]-0.485)/0.229
  				tmpImg[:,:,2] = (image[:,:,0]-0.485)/0.229
  			else:
  				tmpImg[:,:,0] = (image[:,:,0]-0.485)/0.229
  				tmpImg[:,:,1] = (image[:,:,1]-0.456)/0.224
  				tmpImg[:,:,2] = (image[:,:,2]-0.406)/0.225
  
  		# change the r,g,b to b,r,g from [0,255] to [0,1]
  		tmpImg = tmpImg.transpose((2, 0, 1))
  
  		return torch.from_numpy(tmpImg)
  