def input_transform(crop_size):
return Compose([
CenterCrop(crop_size),
Scale(256),
RandomHorizontalFlip(),
ToTensor(), # [0, 255] --> [ 0., 1.]
Lambda(lambda x: 2 * x - 1), # [0., 1.] --> [-1., 1.]
])
def input_transform(crop_size, upscale_factor):
return Compose([
CenterCrop(crop_size),
RandomDiscreteRotation([0, 90, 180, 270]),
RandomHorizontalFlip(),
Resize(crop_size // upscale_factor, interpolation=3),
ToTensor(),
])
def train_hr_transform(crop_size):
return Compose([
RandomCrop(crop_size),
RandomVerticalFlip(),
RandomHorizontalFlip(),
ColorJitter(0.2, 0.2, 0.1, 0.1),
ToTensor(),
])
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, CenterCrop
if not flip_horizontal:
if new_size is not None:
image_transform = Compose([
Resize(new_size),
ToTensor(),
Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
])
else:
image_transform = Compose([
ToTensor(),
Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
])
else:
if new_size is not None:
image_transform = Compose([
RandomHorizontalFlip(p=0.5),
Resize(new_size),
ToTensor(),
Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
])
else:
image_transform = Compose([
RandomHorizontalFlip(p=0.5),
ToTensor(),
Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
])
return Compose([
CenterCrop((370, 370)),
RandomHorizontalFlip(p=0.5),
Resize(new_size),
ToTensor(),
Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
])
def input_transform_augment(crop_size, img_size):
return Compose([
CenterCrop(crop_size),
Resize(img_size),
RandomHorizontalFlip(),
ToTensor(), # [0, 255] --> [ 0., 1.]
Lambda(lambda x: 2 * x - 1), # [0., 1.] --> [-1., 1.]
])
def train_hr_transform(crop_size):
return Compose([
RandomCrop(crop_size),
RandomHorizontalFlip(),
RandomVerticalFlip(),
ToTensor(),
Lambda(lambda img: (2.0 * img) - 1.0),
])
def train_hr_transform(crop_size):
return Compose([
RandomCrop(crop_size),
RandomHorizontalFlip(),
RandomVerticalFlip(),
ToTensor(),
Lambda(imagenet_normalise),
])
def train_hr_transform(crop_size):
return Compose([
RandomCrop(crop_size, pad_if_needed=True),
RandomHorizontalFlip(p=0.5),
RandomVerticalFlip(p=0.5),
RandomRotation(360),
# ToTensor(),
])
def train_hr_transform(crop_size):
return Compose([
RandomCrop(crop_size),
RandomHorizontalFlip(p=0.5),
RandomVerticalFlip(p=0.5),
Grayscale(),
ToTensor(),
])
def __init__(self, scenario="ni", run_id=0):
"""Init.
:param scenario: The desired CoRE50 scenario. Supports 'nc', 'ni', and
'joint', which is the scenario with a single experience.
:param run_id: an integer in [0, 4]. Each run uses a different set of
expert models and data splits.
"""
assert scenario in {
"ni",
"joint",
"nc",
}, "`scenario` argument must be one of {'ni', 'joint', 'nc'}."
core50_normalization = Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
core50_train_transforms = Compose([
RandomHorizontalFlip(p=0.5),
RandomCrop(size=128, padding=1),
RandomRotation(15),
ToTensor(),
core50_normalization,
])
core50_eval_transforms = Compose(
[CenterCrop(size=128),
ToTensor(), core50_normalization])
if scenario == "ni":
benchmark = CORe50(
scenario="ni",
train_transform=core50_train_transforms,
eval_transform=core50_eval_transforms,
run=run_id,
)
elif scenario == "nc":
benchmark = CORe50(
scenario="nc",
train_transform=core50_train_transforms,
eval_transform=core50_eval_transforms,
run=run_id,
)
elif scenario == "joint":
core50nc = CORe50(scenario="nc")
train_cat = AvalancheConcatDataset(
[e.dataset for e in core50nc.train_stream])
test_cat = AvalancheConcatDataset(
[e.dataset for e in core50nc.test_stream])
benchmark = nc_benchmark(train_cat,
test_cat,
n_experiences=1,
task_labels=False)
else:
assert False, "Should never get here."
ll = len(benchmark.train_stream)
experts = _load_expert_models(f"{scenario}_core50", run_id, ll)
super().__init__(benchmark, experts)
def get_train_test_loaders(path,
batch_size,
num_workers,
distributed=False,
pin_memory=True):
train_transform = Compose([
Pad(4),
RandomCrop(32, fill=128),
RandomHorizontalFlip(),
ToTensor(),
Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
])
test_transform = Compose([
ToTensor(),
Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
])
if not os.path.exists(path):
os.makedirs(path)
download = True
else:
download = True if len(os.listdir(path)) < 1 else False
train_ds = datasets.CIFAR10(root=path,
train=True,
download=download,
transform=train_transform)
test_ds = datasets.CIFAR10(root=path,
train=False,
download=False,
transform=test_transform)
train_sampler = None
test_sampler = None
if distributed:
train_sampler = DistributedSampler(train_ds)
test_sampler = DistributedSampler(test_ds, shuffle=False)
train_labelled_loader = DataLoader(
train_ds,
batch_size=batch_size,
sampler=train_sampler,
num_workers=num_workers,
pin_memory=pin_memory,
drop_last=True,
)
test_loader = DataLoader(
test_ds,
batch_size=batch_size * 2,
sampler=test_sampler,
num_workers=num_workers,
pin_memory=pin_memory,
)
return train_labelled_loader, test_loader
def build_transforms(height, width, transforms='random_flip', norm_mean=[0.485, 0.456, 0.406],
norm_std=[0.229, 0.224, 0.225]):
"""Builds train and test transform functions.
Args:
height (int): target image height.
width (int): target image width.
transforms (str or list of str, optional): transformations applied to model training.
Default is 'random_flip'.
norm_mean (list or None, optional): normalization mean values. Default is ImageNet means.
norm_std (list or None, optional): normalization standard deviation values. Default is
ImageNet standard deviation values.
"""
normalize = Normalize(mean=norm_mean, std=norm_std)
print('Building train transforms ...')
transform_tr = []
print('+ resize to {}x{}'.format(height, width))
transform_tr += [Resize((height, width))]
if 'random_flip' in transforms:
print('+ random flip')
transform_tr += [RandomHorizontalFlip()]
if 'random_crop' in transforms:
print('+ random crop (enlarge to {}x{} and ' \
'crop {}x{})'.format(int(round(height * 1.125)), int(round(width * 1.125)), height, width))
transform_tr += [Random2DTranslation(height, width)]
if 'random_patch' in transforms:
print('+ random patch')
transform_tr += [RandomPatch()]
if 'color_jitter' in transforms:
print('+ color jitter')
transform_tr += [ColorJitter(brightness=0.2, contrast=0.15, saturation=0, hue=0)]
print('+ to torch tensor of range [0, 1]')
transform_tr += [ToTensor()]
print('+ normalization (mean={}, std={})'.format(norm_mean, norm_std))
transform_tr += [normalize]
if 'random_erase' in transforms:
print('+ random erase')
transform_tr += [RandomErasing()]
transform_tr = Compose(transform_tr)
print('Building test transforms ...')
print('+ resize to {}x{}'.format(height, width))
print('+ to torch tensor of range [0, 1]')
print('+ normalization (mean={}, std={})'.format(norm_mean, norm_std))
transform_te = Compose([
Resize((height, width)),
ToTensor(),
normalize,
])
return transform_tr, transform_te
def _get_new1data(opt, mean, std, attrs):
root = os.path.join(opt.root_path, 'new_data')
# cropping_transform = get_inference_transform_person_lr
if opt.logits_vac:
cropping_transform = Compose(
[get_inference_transform_person_lr, square_no_elastic])
train_img_transform = Compose([
# [RandomHorizontalFlip(), RandomRotation(10, expand=True),
# Resize((opt.person_size, opt.person_size)),
ToTensor(),
Normalize(mean, std)
])
# [CenterCrop(178), Resize((256, 256)), RandomCrop(224), RandomHorizontalFlip(), ToTensor(), Normalize(mean, std)])
val_img_transform = Compose(
[ # Resize((opt.person_size, opt.person_size)),
ToTensor(),
Normalize(mean, std)
])
else:
cropping_transform = get_inference_transform_person_lr
train_img_transform = Compose([
square_no_elastic,
RandomHorizontalFlip(),
RandomRotation(10, expand=True),
Resize((opt.person_size, opt.person_size)),
ToTensor(),
Normalize(mean, std)
])
# [CenterCrop(178), Resize((256, 256)), RandomCrop(224), RandomHorizontalFlip(), ToTensor(), Normalize(mean, std)])
val_img_transform = Compose([
square_no_elastic,
Resize((opt.person_size, opt.person_size)),
ToTensor(),
Normalize(mean, std)
])
target_transform = ToMaskedTargetTensor(attrs, opt.label_smooth, opt.at,
opt.at_loss)
train_data = NewdataAttr1(attrs,
root,
'train',
opt.mode,
opt.state,
cropping_transform,
img_transform=train_img_transform,
target_transform=target_transform,
logits_vac=opt.logits_vac)
val_data = NewdataAttr1(attrs,
root,
'test',
opt.mode,
opt.state,
cropping_transform,
img_transform=val_img_transform,
target_transform=target_transform,
logits_vac=opt.logits_vac)
return train_data, val_data
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, RandomCrop, RandomHorizontalFlip
if not flip_horizontal:
if new_size is not None:
intermediate_size = (new_size[0] * 2, new_size[1] * 2)
# print(intermediate_size, new_size)
image_transform = Compose([
Resize(intermediate_size), # Resize(new_size),
RandomCrop(new_size), # new_size = 2**(net_depth + 1) = 128
ToTensor(),
Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
])
else:
image_transform = Compose([
ToTensor(),
Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
])
else:
if new_size is not None:
intermediate_size = (new_size[0] * 2, new_size[1] * 2)
# print(intermediate_size, new_size)
image_transform = Compose([
RandomHorizontalFlip(),
Resize(intermediate_size), # Resize(new_size),
RandomCrop(new_size), # new_size = 2**(net_depth + 1) = 128
ToTensor(),
Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
])
else:
image_transform = Compose([
RandomHorizontalFlip(),
ToTensor(),
Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
])
return image_transform
def __init__(self,
root_dir,
split='train',
start_date=1900,
img_size=171,
nclasses=120,
resize=True,
target_type='regression'):
"""
Args:
root_dir: Path to the root directory
split: One of ['train' | 'valid' | 'test']
start_data: Least date in the dataset
img_size: Output size of the cropped image
"""
self.root_dir = os.path.join(root_dir, split)
self.annot_file = os.path.join(root_dir, split + '.txt')
self.split = split
self.annotations = readFile(self.annot_file)
self.start_date = start_date
self.img_size = img_size
self.nclasses = nclasses
self.target_type = target_type
if resize:
if split in ['train', 'valid']:
self.transform = transforms.Compose([
RandomCrop(img_size),
Scale(224),
RandomHorizontalFlip(),
ToTensor()
])
else:
self.transform = transforms.Compose(
[CenterCrop(img_size),
Scale(224), ToTensor()])
else:
if split in ['train', 'valid']:
self.transform = transforms.Compose(
[RandomCrop(img_size),
RandomHorizontalFlip(),
ToTensor()])
else:
self.transform = transforms.Compose(
[CenterCrop(img_size), ToTensor()])
def input_transform():
return Compose([
Resize((224, 224)),
RandomHorizontalFlip(),
RandomRotation(degrees=15),
ToTensor(),
Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
def get_augmentation(augmentation, dataset, data_shape):
c, h, w = data_shape
if augmentation is None:
pil_transforms = []
elif augmentation == 'horizontal_flip':
pil_transforms = [RandomHorizontalFlip(p=0.5)]
elif augmentation == 'neta':
assert h==w
pil_transforms = [Pad(int(math.ceil(h * 0.04)), padding_mode='edge'),
RandomAffine(degrees=0, translate=(0.04, 0.04)),
CenterCrop(h)]
elif augmentation == 'eta':
assert h==w
pil_transforms = [RandomHorizontalFlip(),
Pad(int(math.ceil(h * 0.04)), padding_mode='edge'),
RandomAffine(degrees=0, translate=(0.04, 0.04)),
CenterCrop(h)]
return pil_transforms
def apply_hflip(device, data):
images = []
transform = Compose([RandomHorizontalFlip(p=1)])
for d in data:
image = ToPILImage()(d)
image = transform(image)
image = ToTensor()(image)
images.append(image)
return torch.stack(images)
def __getitem__(self, idx):
if torch.is_tensor(idx):
idx = idx.tolist()
img_name = self.METADATA.iloc[idx, 10]
img = np.load(img_name, allow_pickle=True)
img = img[0]
img = np.reshape(img.astype(np.float32), (64, 27))
img = img / 100
img = np.stack((img, ) * 3, axis=-1)
img = np.swapaxes(img, 0, 2)
img = np.swapaxes(img, 1, 2)
metadata = self.METADATA.iloc[idx, 0:9]
metadata = np.array(metadata)
# if label is supine_plo, hbh, xl, or sl it is also supine
if self.LABELS[idx] in (1, 2, 3, 4):
one_hot_label = np.eye(8)[self.LABELS[idx]] + np.eye(8)[0]
# else if label is lateral_plo it is also lateral
elif self.LABELS[idx] == 7:
one_hot_label = np.eye(8)[self.LABELS[idx]] + np.eye(8)[6]
# else the label is supine, phu, or lateral keep it as it is
else:
one_hot_label = np.eye(8)[self.LABELS[idx]]
one_hot_label = one_hot_label.astype(np.uint8)
augs = transforms.Compose([RandomHorizontalFlip()])
sample = {
'image': torch.from_numpy(img),
'label': torch.from_numpy(one_hot_label)
}
if self.transform:
img = torch.from_numpy(img)
if self.num_classes_dict[np.argmax(
one_hot_label)] < self.aug_thresh:
img = augs(img)
sample = {'image': img, 'label': torch.from_numpy(one_hot_label)}
if self.enable_binary:
if one_hot_label[self.binary_class]:
one_hot_label = np.eye(2)[0]
else:
one_hot_label = np.eye(2)[1]
sample = {
'image': torch.from_numpy(img),
'label': torch.from_numpy(one_hot_label)
}
# if self.transform:
# sample = self.transform(sample)
return sample
def get_train_transform(aug=None):
transforms = []
transforms.append(RandomCrop(320, pad_if_needed=True))
transforms.append(RandomHorizontalFlip())
if 'autoaug' in aug:
print('=> using auto augmentation.')
transforms.append(ImageNetPolicy(fillcolor=(128, 128, 128)))
return Compose(transforms)
def __init__(self, hp: HParams):
s = hp.colour_distortion
self.simclr_augment = Compose([
RandomResizedCrop(hp.image_size),
RandomHorizontalFlip(),
RandomApply([ColorJitter(0.8 * s, 0.8 * s, 0.8 * s, 0.2 * s)],
p=0.8),
RandomGrayscale(p=0.2),
ToTensor(),
])
def MedT_preprocess_image_v4(img,
train,
mask=-1,
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]
augmented_mask = np.zeros(1) + (-1)
if train == True:
augment = Compose([
RandomResizedCrop(224, scale=(0.88, 1.0), ratio=(0.999, 1.001)),
RandomHorizontalFlip(),
RandomRot90()
])
normilize_augment = Compose([
ToTensor(),
AddGaussianNoise(),
])
normilize = Normalize(mean=mean, std=std)
img_mask = img
if mask.numel() > 1:
img_mask = torch.cat((img, mask), dim=0)
augmented_image_mask = augment(img_mask)
augmented_image = augmented_image_mask
if mask.numel() > 1:
augmented_image = augmented_image_mask[0:3, :, :]
augmented_mask = np.array(augmented_image_mask.permute([1, 2,
0]))[:, :,
3]
augmented_image = augmented_image.permute([1, 2, 0])
normilized_and_augmented = normilize_augment(np.array(augmented_image))
preprocced = normilize(normilized_and_augmented).unsqueeze(0)
#aug = normilized_and_augmented.clone()
#mn = aug.min()
#mx = aug.max()
#aug -= mn.view(1,1,1)
#aug /= mx.view(1,1,1)
#aug = (aug*255).ceil().int().permute([1,2,0])
return preprocced, augmented_image, augmented_mask
preprocessing = Compose([
Image.fromarray,
Resize(size=224),
ToTensor(),
Normalize(mean=mean, std=std)
])
return preprocessing(img).unsqueeze(0), None, augmented_mask
def fetch_subset_dataloader(types, params):
"""
Use only a subset of dataset for KD training, depending on params.subset_percent
"""
mean = [0.5071, 0.4865, 0.4409]
std_dev = [0.2673, 0.2564, 0.2762]
# using random crops and horizontal flip for train set
if params.augmentation == "yes":
train_transformer = transforms.Compose([
RandomResizedCrop((64, 64), scale = (0.7, 1.0)),
RandomRotation(30),
RandomHorizontalFlip(),
ColorJitter(0.2, 0.2, 0.2, 0.05),
ToTensor(),
Normalize(mean, std_dev)
])
# data augmentation can be turned off
else:
train_transformer = transforms.Compose([Resize((64, 64)),
ToTensor(),
Normalize(mean, std_dev)])
# transformer for dev set
dev_transformer = transforms.Compose([Resize((64, 64)),
ToTensor(),
Normalize(mean, std_dev)])
trainset = torchvision.datasets.CIFAR100(root='./data-cifar10', train=True,
download=True, transform=train_transformer)
devset = torchvision.datasets.CIFAR100(root='./data-cifar10', train=False,
download=True, transform=dev_transformer)
trainset_size = len(trainset)
indices = list(range(trainset_size))
split = int(np.floor(params.subset_percent * trainset_size))
np.random.seed(230)
np.random.shuffle(indices)
train_sampler = SubsetRandomSampler(indices[:split])
trainloader = torch.utils.data.DataLoader(trainset, batch_size=params.batch_size,
sampler=train_sampler, num_workers=params.num_workers, pin_memory=params.cuda)
devloader = torch.utils.data.DataLoader(devset, batch_size=params.batch_size,
shuffle=False, num_workers=params.num_workers, pin_memory=params.cuda)
if types == 'train':
dl = trainloader
else:
dl = devloader
return dl
def __init__(self, root, df):
super().__init__()
self._root = root
self._df = df
self.transform = Compose([
Resize((256, 256)),
RandomHorizontalFlip(),
ToTensor(),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
def __init__(self, root, train=True, download=False, *args, **kwargs):
if train:
transforms = Compose([
Pad(padding=4),
RandomCrop(size=32),
RandomHorizontalFlip(p=0.5),
ToTensor(),
Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225))
])
else:
transforms = Compose([
RandomHorizontalFlip(p=0.5),
ToTensor(),
Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225))
])
super(WrappedCIFAR100, self).__init__(
root=root, train=train, transform=transforms,
download=download, *args, **kwargs)
def load_transforms(self):
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 __init__(self, data_dir, batch_size, num_workers):
super().__init__()
transforms = Compose([
ToTensor(),
RandomHorizontalFlip(),
RandomAffine(degrees=5, translate=(0.05, 0.05), scale=(1., 1.5))
])
self.dataset = UTKFaceDataset(data_dir, transforms)
self.batch_size = batch_size
self.num_workers = num_workers
def __init__(self, datafolder):
classFolders = ['free', 'blocked_left', 'blocked_right', 'blocked_all']
print(f'Found classes: {classFolders}')
self.len = 0
self.dataset = []
self.normalize = Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])
self.topil = ToPILImage()
self.totensor = ToTensor()
self.resize = Resize((224, 224))
self.randomflip = RandomHorizontalFlip(0.5)
self.flip = RandomHorizontalFlip(1.0)
for i in range(len(classFolders)):
path = os.path.join(datafolder, classFolders[i])
folder = os.listdir(path)
for file in folder:
file_path = os.path.join(path, file)
if os.path.isfile(file_path):
self.dataset.append([file_path, i])
self.len += 1
def __init__(self, opts):
self.dataroot = opts.dataroot
self.data_flair = os.path.join(self.dataroot, 'Flair')
self.data_t1 = os.path.join(self.dataroot, 'T1')
# A
images_A_flair = sorted(
os.listdir(os.path.join(self.data_flair, opts.phase + 'A')))
images_A_t1 = sorted(
os.listdir(os.path.join(self.data_t1, opts.phase + 'A')))
self.A_flair = [
os.path.join(self.data_flair, opts.phase + 'A', x)
for x in images_A_flair
]
self.A_t1 = [
os.path.join(self.data_t1, opts.phase + 'A', x)
for x in images_A_t1
]
# B
images_B_flair = sorted(
os.listdir(os.path.join(self.data_flair, opts.phase + 'B')))
images_B_t1 = sorted(
os.listdir(os.path.join(self.data_t1, opts.phase + 'B')))
self.B_flair = [
os.path.join(self.data_flair, opts.phase + 'B', x)
for x in images_B_flair
]
self.B_t1 = [
os.path.join(self.data_t1, opts.phase + 'B', x)
for x in images_B_t1
]
self.A_size = len(self.A_flair)
self.B_size = len(self.B_flair)
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 make_transform(input_size, mode='train', flag=0):
if flag == 2:
train_transform = Compose([
ToPILImage(),
# RandomResizedCrop(input_size),
Resize(input_size, BICUBIC),
# RandomCrop(input_size),
RandomHorizontalFlip(),
RandomVerticalFlip(),
ToTensor(),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
elif flag == 0:
train_transform = Compose([
ToPILImage(),
Resize(input_size, BICUBIC),
RandomHorizontalFlip(),
ToTensor(),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
elif flag == 1:
train_transform = Compose([
ToPILImage(),
Resize(input_size, BICUBIC),
RandomHorizontalFlip(),
RandomVerticalFlip(),
ToTensor(),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
test_transform = Compose([
ToPILImage(),
Resize(input_size, BICUBIC),
ToTensor(),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
if mode == 'train':
return train_transform
return test_transform
