def get_transforms(auto_augment, input_sizes, m, mean, n, std):
if auto_augment:
# AutoAugment + Cutout
train_transforms = Compose([
RandomCrop(size=input_sizes, padding=4, fill=128),
RandomHorizontalFlip(p=0.5),
CIFAR10Policy(),
ToTensor(),
Normalize(mean=mean, std=std),
Cutout(n_holes=1, length=16)
])
else:
# RandAugment + Cutout
train_transforms = Compose([
RandomCrop(size=input_sizes, padding=4, fill=128),
RandomHorizontalFlip(p=0.5),
RandomRandAugment(n=n, m_max=m), # This version includes cutout
ToTensor(),
Normalize(mean=mean, std=std)
])
test_transforms = Compose([
ToTensor(),
Normalize(mean=mean, std=std)
])
return test_transforms, train_transforms
def prepare_data(self):
"Prepare supervised and unsupervised datasets from cifar"
dataset_path = self.hparams.dataset_path
n_labeled = self.hparams.n_labeled
n_overlap = self.hparams.n_overlap
seed = self.hparams.seed
if self.hparams.dataset == "cifar":
n = self.hparams.randaug_n
m = self.hparams.randaug_m
uda_tfm = Compose([RandAugment(n, m), ToTensor(), Normalize(*CIFAR_STATS)])
sup_tfm = Compose([RandomCrop(32, 4, padding_mode="reflect"), RandomHorizontalFlip(), ToTensor(), Normalize(*CIFAR_STATS)])
val_tfm = Compose([ToTensor(), Normalize(*CIFAR_STATS)])
sup_ds, unsup_ds = Cifar.uda_ds(dataset_path, n_labeled, n_overlap, sup_tfm, uda_tfm, seed=seed)
val_ds = Cifar.val_ds(dataset_path, val_tfm)
if self.hparams.dataset == "quickdraw":
uda_tfm = Compose([ExpandChannels, SketchDeformation, RandomHorizontalFlip(), RandomRotation(30), RandomCrop(128, 18), ToTensor()])
sup_tfm = Compose([ExpandChannels, RandomCrop(128, 9), RandomHorizontalFlip(), ToTensor()])
val_tfm = Compose([ExpandChannels, ToTensor()])
sup_ds, unsup_ds = QuickDraw.uda_ds(dataset_path, n_labeled, n_overlap, sup_tfm, uda_tfm, seed=seed)
val_ds = QuickDraw.val_ds(dataset_path, val_tfm)
self.train_ds_sup = sup_ds
self.train_ds_unsup = unsup_ds
self.valid_ds = val_ds
def get_transforms(augment):
valid_t = Compose([Resize(256),
CenterCrop(224),
ToTensor(),
Normalize(**_ImageNet['Normalize'])])
if augment == False:
train_t = valid_t
elif augment == True:
train_t = Compose([RandomResizedCrop(224),
RandomHorizontalFlip(),
ToTensor(),
ColorJitter(),
Lighting(_ImageNet['PCA']),
Normalize(**_ImageNet['Normalize'])])
elif augment == "torchvision":
train_t = Compose([RandomResizedCrop(224),
RandomHorizontalFlip(),
ToTensor(),
Normalize(**_ImageNet['Normalize'])])
elif augment == "torchvision2":
train_t = Compose([Resize(256),
RandomCrop(224),
RandomHorizontalFlip(),
ToTensor(),
Normalize(**_ImageNet['Normalize'])])
else:
assert(False)
transforms = {
'training': train_t,
'validation': valid_t
}
return transforms
def train_hr_transform(crop_size):
return Compose([
RandomCrop(crop_size),
RandomHorizontalFlip(),
RandomHorizontalFlip(),
ColorJitter(0.2, 0.2, 0.1, 0.1),
ToTensor(),
])
def init_datasets(x, y, cfg):
# We assume IMDB, FairFace
print("Loading Datasets...")
transforms_train = transforms.Compose([
Resize(224),
RandomHorizontalFlip(0.5),
RandomCrop(224),
RandomGrayscale(0.5),
ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
transforms_val = transforms.Compose([
Resize(224),
RandomHorizontalFlip(0.5),
CenterCrop(224),
RandomGrayscale(0.5),
ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
datasets = {k: [] for k in ['train', 'val', 'test']}
for i, (x_val, y_val) in enumerate(zip(x, y)):
#print(x_val,y_val)
X_train, X_test, y_train, y_test = train_test_split(
x_val,
y_val,
test_size=(1 - cfg.TRAIN.TRAIN_RATIO),
random_state=42)
X_train, X_val, y_train, y_val = train_test_split(X_train,
y_train,
test_size=0.15,
random_state=42)
datasets['train'].append(
IMDBDataset(X_train,
y_train,
root_dir=cfg.DATASET.DATA_FOLDER[i],
transform=transforms_train))
datasets['val'].append(
IMDBDataset(X_val,
y_val,
root_dir=cfg.DATASET.DATA_FOLDER[i],
transform=transforms_val))
datasets['test'].append(
IMDBDataset(X_test,
y_test,
root_dir=cfg.DATASET.DATA_FOLDER[i],
transform=transforms_val))
for k in ['train', 'val', 'test']:
datasets[k] = ConcatDataset(datasets[k])
return datasets
def get_transform(new_size=None, flip_horizontal=False):
"""
obtain the image transforms required for the input data
:param new_size: size of the resized images
:param flip_horizontal: Whether to randomly mirror input images during training
:return: image_transform => transform object from TorchVision
"""
from torchvision.transforms import ToTensor, Normalize, Compose, Resize, \
RandomHorizontalFlip
if not flip_horizontal:
if new_size is not None:
image_transform = Compose([
Resize(new_size),
ToTensor(),
#TODO: Make this respect 1 or 3 channels
#Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
Normalize(mean=[0.5], std=[0.5])
])
else:
image_transform = Compose([
ToTensor(),
#TODO: Make this respect 1 or 3 channels
#Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
Normalize(mean=[0.5], std=[0.5])
])
else:
if new_size is not None:
image_transform = Compose([
RandomHorizontalFlip(p=0.5),
Resize(new_size),
ToTensor(),
#TODO: Make this respect 1 or 3 channels
#Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
Normalize(mean=[0.5], std=[0.5])
])
else:
image_transform = Compose([
RandomHorizontalFlip(p=0.5),
ToTensor(),
#TODO: Make this respect 1 or 3 channels
#Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
Normalize(mean=[0.5], std=[0.5])
])
return image_transform
def __init__(self,
*args,
num_classes=100,
keep_index=True,
img_size=224,
train=True,
load_features_path=None,
save_features_path=None,
extract_at_layer=None,
feature_extractor=None,
**kwargs):
super(ExtendedDataset, self).__init__(*args, train=train, **kwargs)
self.train = train
self.num_classes = num_classes
self.data_index = None
self.keep_index = keep_index
if keep_index:
self.data_index = np.arange(len(self))
self.mean_image = None
self.resize = Resize(img_size)
self.augment = Compose(
[RandomCrop(img_size, padding=8),
RandomHorizontalFlip()])
self._set_mean_image()
self._set_data()
self.layer = extract_at_layer
self.use_feature_data = False
self.feature_data_set = False
if extract_at_layer:
self.use_feature_data = True
self._set_feature_data(feature_extractor,
extract_at_layer,
load_features_path=load_features_path,
save_features_path=save_features_path)
def get_basic_train_test_loaders(path, batch_size, num_workers, device):
train_set_raw = CIFAR10(root=path, train=True, download=False)
test_set_raw = CIFAR10(root=path, train=False, download=False)
train_transforms = Compose([
RandomHorizontalFlip(),
ToTensor(),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
test_transforms = Compose([
ToTensor(),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
train_set = TransformedDataset(train_set_raw, train_transforms)
test_set = TransformedDataset(test_set_raw, test_transforms)
train_loader = DataLoader(train_set, batch_size=batch_size, num_workers=num_workers,
pin_memory="cuda" in device, drop_last=True)
test_loader = DataLoader(test_set, batch_size=batch_size * 4, num_workers=num_workers,
pin_memory="cuda" in device, drop_last=False)
return train_loader, test_loader
def get_cifar10_loaders(data_root: str, batch_size: int, num_workers: int, augment=True) -> (DataLoader, DataLoader):
""" Function for retrieving CIFAR10 data as data loaders.
Training set is augmented. Note that ToTensor() automatically divides by 255.
Args:
data_root: Path to CIFAR10 data.
batch_size: Batch size of data.
num_workers: Number of workers to pre-process data.
augment: Whether to use data augmentation on the training data.
Returns:
Training and evaluation data loaders for the CIFAR10 dataset.
"""
# Normalize(mean=[0.491, 0.482, 0.447], std=[0.247, 0.243, 0.262])
if augment:
train_transform = Compose([RandomHorizontalFlip(), RandomCrop(size=32, padding=4), ToTensor()])
else:
train_transform = ToTensor()
eval_transform = ToTensor()
train_set = CIFAR10(root=data_root, train=True, transform=train_transform, download=True)
eval_set = CIFAR10(root=data_root, train=False, transform=eval_transform, download=True)
train_loader = DataLoader(train_set, batch_size, shuffle=True, num_workers=num_workers, pin_memory=True)
eval_loader = DataLoader(eval_set, batch_size, shuffle=False, num_workers=num_workers, pin_memory=True)
return train_loader, eval_loader
def get_train_test_loaders(dataset_name, path, batch_size, num_workers):
assert dataset_name in datasets.__dict__, "Unknown dataset name {}".format(dataset_name)
fn = datasets.__dict__[dataset_name]
train_transform = Compose([
Pad(2),
RandomCrop(32),
RandomHorizontalFlip(),
ToTensor(),
Normalize((0.5, 0.5, 0.5), (0.25, 0.25, 0.25)),
])
test_transform = Compose([
ToTensor(),
Normalize((0.5, 0.5, 0.5), (0.25, 0.25, 0.25)),
])
train_ds = fn(root=path, train=True, transform=train_transform, download=True)
test_ds = fn(root=path, train=False, transform=test_transform, download=False)
train_loader = DataLoader(train_ds, batch_size=batch_size, num_workers=num_workers, pin_memory=True)
test_loader = DataLoader(test_ds, batch_size=batch_size * 2, num_workers=num_workers, pin_memory=True)
return train_loader, test_loader
def __init__(self,SourceDatasetPath="../data/dataset/kaggledataset",pathTestDataSource="../test/dataset/kaggledataset"):
self.SourceDatasetPath=SourceDatasetPath
self.pathTestDataSource=pathTestDataSource
self.pathTestDataTarget="../test/testdata/test_tmp/"
self.trainValidDatasetLength=0
self.directory_common = "../data/tmp_kaggle/"
self.directory_original = '../data/'
self.train_prefix = 'train/'
self.val_prefix = 'valid/'
self.datasplit=0.2 # reatio of dataset between test and train+valid
self.load_second_dataset()
# preparing dataset-train dataset/ validation datadset
self.train_transform = Compose([Resize([128,128]),RandomHorizontalFlip(0.5),RandomRotation(0.2),ToTensor(),Normalize(mean=(0.5,0.5,0.5),std=(0.5,0.5,0.5))])
self.simple_transform = Compose([Resize([128,128]),ToTensor(),Normalize(mean=(0.5,0.5,0.5),std=(0.5,0.5,0.5))])
self.train_dataset = ImageFolder(os.path.join(self.directory_original,'train'),transform=self.train_transform)
self.valid_dataset = ImageFolder(os.path.join(self.directory_original,'valid'),transform=self.simple_transform)
self.test_dataset=ImageFolder(self.pathTestDataTarget,transform=self.simple_transform)
# preparing dataloader - train dataloader /validation dataloader
self.train_dataloader = DataLoader(self.train_dataset,batch_size=30)
self.valid_dataloader = DataLoader(self.valid_dataset,batch_size=30)
self.test_dataloader = DataLoader(self.test_dataset,batch_size=30)
################ Removing temporary paths #######################
sh.rmtree(self.directory_common)
def get_frame_and_landmarks_from_folder(path,
num_frames,
generate_landmark=False):
augumentation = Compose([RandomHorizontalFlip(0.5)])
transform = Compose(
[ToTensor(), Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])])
length = len(path)
if len(path) > num_frames:
random_frames = [
random.choice(range(0, length - 1)) for _ in range(num_frames + 1)
]
else:
random_frames = random.sample(range(0, length - 1), num_frames + 1)
res = []
for index in random_frames:
frame = cv2.imread(path[index])
frame = cv2.resize(frame, (256, 256), interpolation=cv2.INTER_LINEAR)
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
frame = augumentation(Image.fromarray(frame, mode='RGB'))
# frame = Image.fromarray(frame, mode='RGB')
if generate_landmark:
landmark = get_landmark(np.array(frame))
res.append([transform(frame), landmark])
else:
res.append(transform(frame))
return res
def default_transforms(self) -> Dict[str, Callable]:
if self.training:
post_tensor_transform = [
RandomShortSideScale(min_size=256, max_size=320),
RandomCrop(244),
RandomHorizontalFlip(p=0.5),
]
else:
post_tensor_transform = [
ShortSideScale(256),
]
return {
"post_tensor_transform": Compose([
ApplyTransformToKey(
key="video",
transform=Compose([UniformTemporalSubsample(8)] + post_tensor_transform),
),
]),
"per_batch_transform_on_device": Compose([
ApplyTransformToKey(
key="video",
transform=K.VideoSequential(
K.Normalize(torch.tensor([0.45, 0.45, 0.45]), torch.tensor([0.225, 0.225, 0.225])),
data_format="BCTHW",
same_on_frame=False
)
),
]),
}
def CropResize(options):
return Compose([
RandomResizedCrop(size=options.image_size),
RandomHorizontalFlip(0.5),
ToTensor(),
Normalize(options.image_mean, options.image_std),
])
def get_data_loaders(train_files, val_files, img_size=224):
train_transform = Compose([
ColorJitter(0.3, 0.3, 0.3, 0.3),
RandomResizedCrop(img_size, scale=(0.8, 1.2)),
RandomAffine(10.),
RandomRotation(13.),
RandomHorizontalFlip(),
ToTensor(),
])
#train_mask_transform = Compose([
# RandomResizedCrop(img_size, scale=(0.8, 1.2)),
# RandomAffine(10.),
# RandomRotation(13.),
# RandomHorizontalFlip(),
# ToTensor(),
#])
val_transform = Compose([
Resize((img_size, img_size)),
ToTensor(),
])
train_loader = DataLoader(MaskDataset(train_files, train_transform),
batch_size=BATCH_SIZE,
shuffle=True,
pin_memory=True,
num_workers=4)
val_loader = DataLoader(MaskDataset(val_files, val_transform),
batch_size=BATCH_SIZE,
shuffle=False,
pin_memory=True,
num_workers=4)
return train_loader, val_loader
def __getitem__(self, index):
transforms = list()
if self.dataset_name == 'facades':
transforms += [Resize((self.load_size, self.load_size), Image.BILINEAR)]
transforms += [RandomHorizontalFlip()] if random.random() > 0.5 else []
transforms += [ToTensor(), Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])]
image_input = Image.open(join(self.dir_input, self.list_paths_input[index])).convert('RGB')
if self.mode == 'train' or self.mode == 'val':
index_random = random.randint(0, len(self.list_paths_real) - 1)
image_real = Image.open(join(self.dir_real, self.list_paths_real[index_random])).convert('RGB')
else:
transforms += [Resize((self.load_size, self.load_size), Image.BILINEAR)]
transforms += [ToTensor(), Normalize(mean=[0.5], std=[0.5])]
image_input = Image.open(join(self.dir_input, self.list_paths_input[index])).convert('L')
if self.mode == 'train' or self.mode == 'val':
index_random = random.randint(0, len(self.list_paths_real) - 1)
image_real = Image.open(join(self.dir_real, self.list_paths_real[index_random])).convert('L')
transforms = Compose(transforms)
input = transforms(image_input)
real = transforms(image_real) if self.mode == 'train' or self.mode == 'val' else 0
return input, real
def get_data_loaders(train_files, val_files, img_size=224):
train_transform = Compose([
#ColorJitter(0.3, 0.3, 0.3, 0.3),
RandomResizedCrop(img_size, scale=(0.8, 1.2)),
RandomAffine(10.),
RandomRotation(13.),
RandomHorizontalFlip(),
ToTensor(),
Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])
val_transform = Compose([
Resize((img_size, img_size)),
ToTensor(),
Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])
train_loader = DataLoader(HairStyleDataset(train_files, train_transform),
batch_size=BATCH_SIZE,
shuffle=True,
pin_memory=True,
num_workers=4)
val_loader = DataLoader(HairStyleDataset(val_files, val_transform),
batch_size=BATCH_SIZE,
shuffle=True,
pin_memory=True,
num_workers=4)
return train_loader, val_loader
def __init__(self, opt, val=False):
super(CustomCIFAR100, self).__init__()
dir_dataset = opt.dir_dataset
if val:
self.dataset = CIFAR100(root=dir_dataset,
train=False,
download=True)
self.transform = Compose([
ToTensor(),
Normalize(mean=[0.507, 0.487, 0.441],
std=[0.267, 0.256, 0.276])
])
else:
self.dataset = CIFAR100(root=dir_dataset,
train=True,
download=True)
self.transform = Compose([
RandomCrop((32, 32),
padding=4,
fill=0,
padding_mode='constant'),
RandomHorizontalFlip(),
ToTensor(),
Normalize(mean=[0.507, 0.487, 0.441],
std=[0.267, 0.256, 0.276])
])
def __init__(self, filepath, split='train', data_augmentation=False, img_size=None):
self.filepath = filepath
self.split = split
# open the dataset file
self.file = h5py.File(self.filepath , "r")
self.data_group = self.file[self.split]
self.n_images = self.data_group['observations'].shape[0]
self.has_labels = 'labels' in self.data_group
if img_size is not None:
self.img_size = img_size
else:
self.img_size = self.data_group['observations'][0].shape
self.data_augmentation = data_augmentation
if self.data_augmentation:
radius = max(self.img_size[0], self.img_size[1]) / 2
padding_size = int(np.sqrt(2 * np.power(radius, 2)) - 128)
self.spheric_pad = SphericPad(padding_size=padding_size) # max rotation needs padding of [sqrt(2*128^2)-128 = 53.01]
self.random_horizontal_flip = RandomHorizontalFlip(0.2)
self.random_vertical_flip = RandomVerticalFlip(0.2)
self.random_resized_crop = RandomResizedCrop(size=self.img_size)
self.random_rotation = RandomRotation(40)
self.center_crop = CenterCrop(self.img_size)
self.roll_y = Roll(shift=0, dim=1)
self.roll_x = Roll(shift=0, dim=2)
def ImageTransform(loadSize, cropSize):
return Compose([
Resize(size=loadSize, interpolation=Image.BICUBIC),
RandomCrop(size=cropSize),
RandomHorizontalFlip(p=0.5),
ToTensor(),
])
def get_frames_and_landmarks_non_random(video_path,
num_frames,
generate_landmark=False):
augumentation = Compose([RandomHorizontalFlip(0.5)])
transform = Compose(
[ToTensor(), Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])])
res = []
cap = cv2.VideoCapture(video_path)
length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
# for
if length < num_frames:
num_frames = length
for frame_number in range(0, num_frames):
cap.set(1, frame_number)
_, frame = cap.read()
frame = cv2.resize(frame, (256, 256), interpolation=cv2.INTER_LINEAR)
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
# frame = augumentation(Image.fromarray(frame, mode='RGB'))
frame = Image.fromarray(frame, mode='RGB')
if generate_landmark:
landmark = get_landmark_save_frames(frame,
frame_number=frame_number)
res.append([transform(frame), landmark])
else:
res.append(transform(frame))
cap.release()
return res
def __init__(self, opts):
self.dataroot = opts.dataroot
self.num_domains = opts.num_domains
self.input_dim = opts.input_dim
self.nz = opts.input_nz
domains = [chr(i) for i in range(ord('A'),ord('Z')+1)]
self.images = [None]*self.num_domains
stats = ''
for i in range(self.num_domains):
img_dir = os.path.join(self.dataroot, opts.phase + domains[i])
ilist = os.listdir(img_dir)
self.images[i] = [os.path.join(img_dir, x) for x in ilist]
stats += '{}: {}'.format(domains[i], len(self.images[i]))
stats += ' images'
self.dataset_size = max([len(self.images[i]) for i in range(self.num_domains)])
# setup image transformation
transforms = [Resize((opts.resize_size, opts.resize_size), Image.BICUBIC)]
if opts.phase == 'train':
transforms.append(RandomCrop(opts.img_size))
else:
transforms.append(CenterCrop(opts.img_size))
if not opts.no_flip:
transforms.append(RandomHorizontalFlip())
transforms.append(ToTensor())
transforms.append(Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]))
self.transforms = Compose(transforms)
return
def load_dataset(batch_size=64):
data_path = 'autism_faces/train/'
valid_path = 'autism_faces/valid/'
test_path = 'autism_faces/test/'
transformed = transforms.Compose([
RandomResizedCrop(224),
RandomHorizontalFlip(),
RandomRotation(10),
ToTensor()
])
train_dataset = torchvision.datasets.ImageFolder(root=data_path,
transform=transformed)
validation_dataset = torchvision.datasets.ImageFolder(
root=valid_path, transform=transformed)
test_dataset = torchvision.datasets.ImageFolder(root=test_path,
transform=transformed)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=batch_size,
num_workers=0,
shuffle=True)
validation_loader = torch.utils.data.DataLoader(validation_dataset,
batch_size=100,
num_workers=0,
shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=batch_size,
num_workers=0,
shuffle=True)
return train_loader, validation_loader, test_loader
def __init__(self, seq_name, vis_threshold, P, K, max_per_person, crop_H, crop_W,
transform, normalize_mean=None, normalize_std=None):
self.data_dir = osp.join(cfg.DATA_DIR, 'Market-1501-v15.09.15')
self.seq_name = seq_name
self.P = P
self.K = K
self.max_per_person = max_per_person
self.crop_H = crop_H
self.crop_W = crop_W
if transform == "random":
self.transform = Compose([RandomCrop((crop_H, crop_W)), RandomHorizontalFlip(), ToTensor(), Normalize(normalize_mean, normalize_std)])
elif transform == "center":
self.transform = Compose([CenterCrop((crop_H, crop_W)), ToTensor(), Normalize(normalize_mean, normalize_std)])
else:
raise NotImplementedError("Tranformation not understood: {}".format(transform))
if seq_name:
assert seq_name in ['bounding_box_test', 'bounding_box_train', 'gt_bbox'], \
'Image set does not exist: {}'.format(seq_name)
self.data = self.load_images()
else:
self.data = []
self.build_samples()
def __init__(self, opts):
self.dataroot = opts.dataroot
# A
images_A = os.listdir(os.path.join(self.dataroot, opts.phase + 'A'))
self.A = [os.path.join(self.dataroot, opts.phase + 'A', x) for x in images_A]
# B
images_B = os.listdir(os.path.join(self.dataroot, opts.phase + 'B'))
self.B = [os.path.join(self.dataroot, opts.phase + 'B', x) for x in images_B]
self.A_size = len(self.A)
self.B_size = len(self.B)
self.dataset_size = max(self.A_size, self.B_size)
self.input_dim_A = opts.input_dim_a
self.input_dim_B = opts.input_dim_b
# setup image transformation
transforms = [Resize((opts.resize_size, opts.resize_size), Image.BICUBIC)]
if opts.phase == 'train':
transforms.append(RandomCrop(opts.crop_size))
else:
transforms.append(CenterCrop(opts.crop_size))
if not opts.no_flip:
transforms.append(RandomHorizontalFlip())
transforms.append(ToTensor())
transforms.append(Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]))
self.transforms = Compose(transforms)
print('A: %d, B: %d images'%(self.A_size, self.B_size))
return
def get_train_transform(cfg):
trfm = Compose([
RandomHorizontalFlip(),
ToTensor(),
Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
])
return trfm
def MedT_preprocess_image_v3(img, train, mean=None, std=None) -> torch.Tensor:
if std is None:
std = [0.5, 0.5, 0.5]
if mean is None:
mean = [0.5, 0.5, 0.5]
if train == True:
augment = Compose([
Image.fromarray,
RandomResizedCrop(224, scale=(0.88, 1.0), ratio=(0.999, 1.001)),
RandomHorizontalFlip(),
RandomVerticalFlip(),
RandomRot90()
])
normilize = Compose([ToTensor(), Normalize(mean=mean, std=std)])
augmented = augment(img)
preprocced = normilize(augmented).unsqueeze(0)
return preprocced, augmented
preprocessing = Compose([
Image.fromarray,
Resize(size=224),
ToTensor(),
Normalize(mean=mean, std=std)
])
return preprocessing(img).unsqueeze(0), None
def build_dataset(source_domain_name,
target_domain_name):
""" Build torch DataSet
Args:
source_domain_name (string): name of source domain dataset.
target_domain_name (string): name of target domain dataset.
Returns:
datasets (dict): dictionary mapping domain_name (string) to torch Dataset.
"""
# Define transforms for training and evaluation
transform_train = Compose([Resize([256, 256]),
RandomCrop([224, 224]),
RandomHorizontalFlip(),
RandomRotation(degrees=30, fill=128),
ToTensor(),
Normalize(IMAGENET_MEAN, IMAGENET_STD)])
transform_eval = Compose([Resize([256, 256]),
CenterCrop([224, 224]),
ToTensor(),
Normalize(IMAGENET_MEAN, IMAGENET_STD)])
datasets = {}
datasets['train_source'] = ImageFolder(root=root_dir[source_domain_name],
transform=transform_train)
datasets['train_target'] = ImageFolder(root=root_dir[target_domain_name],
transform=transform_train)
datasets['test'] = ImageFolder(root=root_dir[target_domain_name],
transform=transform_eval)
return datasets
def transform_train(self, data, targets=None, batch_size=None):
""" Transform the training data, perform random cropping data augmentation and basic random flip augmentation.
Args:
data: Numpy array. The data to be transformed.
batch_size: int batch_size.
targets: the target of training set.
Returns:
A DataLoader class instance.
"""
short_edge_length = min(data.shape[1], data.shape[2])
common_list = [Normalize(torch.Tensor(self.mean), torch.Tensor(self.std))]
if self.augment:
compose_list = [ToPILImage(),
RandomCrop(data.shape[1:3], padding=4),
RandomHorizontalFlip(),
ToTensor()
] + common_list + [Cutout(n_holes=Constant.CUTOUT_HOLES,
length=int(short_edge_length * Constant.CUTOUT_RATIO))]
else:
compose_list = common_list
if len(data.shape) != 4:
compose_list = []
dataset = self._transform(compose_list, data, targets)
if batch_size is None:
batch_size = Constant.MAX_BATCH_SIZE
batch_size = min(len(data), batch_size)
return DataLoader(dataset, batch_size=batch_size, shuffle=True)
def transform_target(crop_size):
"""Ground truth image
"""
return Compose([
RandomCrop(crop_size),
RandomHorizontalFlip(),
])
