def __init__(self, resize, mean, std):
self.data_transform = {
'valid': transforms.Compose([
transforms.RandomOrder([
transforms.RandomRotation(20),
transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.1),
transforms.RandomHorizontalFlip(),
transforms.RandomVerticalFlip(),
transforms.RandomResizedCrop(
resize, scale=(0.8,1.0)),]),
transforms.ToTensor(),
transforms.Normalize(mean, std)
]),
'train': transforms.Compose([
transforms.RandomOrder([
transforms.RandomRotation(20),
transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.1),
transforms.RandomHorizontalFlip(),
transforms.RandomVerticalFlip(),
transforms.RandomResizedCrop(
resize, scale=(0.8,1.0)),]),
transforms.ToTensor(),
transforms.Normalize(mean, std)
]),
'test': transforms.Compose([
transforms.Resize(resize),
transforms.ToTensor(),
transforms.Normalize(mean, std)
])
}
def __init__(self, split, crop_size, scaling_factor, lr_img_type,
hr_img_type):
"""
:param split: one of 'train' or 'test'
:param crop_size: crop size of HR images
:param scaling_factor: LR images will be downsampled from the HR images by this factor
:param lr_img_type: the target format for the LR image; see convert_image() above for available formats
:param hr_img_type: the target format for the HR image; see convert_image() above for available formats
"""
self.split = split.lower()
self.crop_size = crop_size
self.scaling_factor = scaling_factor
self.lr_img_type = lr_img_type
self.hr_img_type = hr_img_type
self.downsample_methods = [
Image.NEAREST, Image.BOX, Image.BILINEAR, Image.HAMMING,
Image.BICUBIC, Image.LANCZOS
]
self.downsample_proba = [0.1, 0.1, 0.2, 0.1, 0.3, 0.2]
self.jpeg_quality_dist = bounded_norm_dist(mean=50,
std=25,
lower=1,
upper=100)
# weights = scipy.io.loadmat(path.join('./processing/jpeg_artifacts/weights/q{}.mat'.format(40)))
# self.denoiser = ARCNN(weights).to("cpu").eval()
assert self.split in {'train', 'test'}
self.augmenter = transforms.RandomOrder([
transforms.ColorJitter(brightness=0.15,
contrast=0.15,
saturation=0.15,
hue=0.1),
transforms.RandomGrayscale(p=0.15),
transforms.RandomHorizontalFlip(0.25)
])
def get_batch_data(image_list, batch_size):
batch_x = []
batch_y = []
while len(batch_x) < batch_size:
index = np.random.randint(args.num_classes)
label = index
image = Image.open('./standard_img/%s' % image_list[index]).convert('RGB')
image = image.resize((128, 128), Image.ANTIALIAS)
compose = [transforms.RandomAffine(180, shear=5, resample=Image.BILINEAR),
transforms.ColorJitter(brightness=0.6, contrast=0.6, saturation=0.6)
]
compose = transforms.Compose([transforms.RandomOrder(compose),
transforms.ToTensor(),
# transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])
image = compose(image)
batch_x.append(image.numpy())
batch_y.append(label)
batch_x = torch.Tensor(batch_x)
batch_y = torch.Tensor(batch_y)
return batch_x, batch_y
def load_datasets():
randomized_transformations = transforms.RandomOrder([
transforms.RandomApply([tr])
for tr in TRANSFORMATIONS
])
all_transform_combinations = []
for n in range(len(TRANSFORMATIONS) + 1): # (from 0 to len)
for comb in itertools.permutations(TRANSFORMATIONS, n):
all_transform_combinations.append(transforms.Compose(comb))
train_dataset = CityscapesDataset(randomized_transformations)
valid_datasets = [CityscapesDataset(translist) for translist in all_transform_combinations]
ids = list(range(len(train_dataset)))
random.shuffle(ids)
train_sampler = torchdata.sampler.SubsetRandomSampler(ids[VALIDATION_SET_SIZE:])
valid_sampler = torchdata.sampler.SubsetRandomSampler(ids[:VALIDATION_SET_SIZE])
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=BATCH_SIZE, sampler=train_sampler, num_workers=NUM_WORKERS)
valid_loaders = [
torch.utils.data.DataLoader(dset, batch_size=BATCH_SIZE, sampler=valid_sampler, num_workers=NUM_WORKERS)
for dset in valid_datasets
]
train_size = len(train_sampler)
valid_size = len(valid_sampler) * len(valid_datasets)
return train_size, valid_size, train_loader, valid_loaders, train_dataset.result_to_image
def build_transform(self):
if self.train_eval_flag == "train":
self.transform = transforms.Compose([
transforms.RandomOrder([
RandomTransWrapper(seq=iaa.GaussianBlur((0, 1.5)), p=0.09),
RandomTransWrapper(seq=iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.05), per_channel=0.5),
p=0.09),
RandomTransWrapper(seq=iaa.Dropout((0.0, 0.10),
per_channel=0.5),
p=0.3),
RandomTransWrapper(seq=iaa.CoarseDropout(
(0.0, 0.10), size_percent=(0.08, 0.2),
per_channel=0.5),
p=0.3),
RandomTransWrapper(seq=iaa.Add((-20, 20), per_channel=0.5),
p=0.3),
RandomTransWrapper(seq=iaa.Multiply((0.9, 1.1),
per_channel=0.2),
p=0.4),
RandomTransWrapper(seq=iaa.ContrastNormalization(
(0.8, 1.2), per_channel=0.5),
p=0.09),
]),
transforms.ToTensor()
])
else:
self.transform = transforms.Compose([
transforms.ToTensor(),
])
def train_data_loader(data_path, img_size, use_augment=False):
if use_augment:
data_transforms = transforms.Compose([
transforms.RandomOrder([
transforms.RandomApply([transforms.ColorJitter(contrast=0.5)], .5),
transforms.Compose([
transforms.RandomApply([transforms.ColorJitter(saturation=0.5)], .5),
transforms.RandomApply([transforms.ColorJitter(hue=0.1)], .5),
])
]),
transforms.RandomApply([transforms.ColorJitter(brightness=0.125)], .5),
transforms.RandomApply([transforms.RandomRotation(15)], .5),
transforms.RandomResizedCrop(img_size),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
else:
data_transforms = transforms.Compose([
transforms.RandomResizedCrop(img_size),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
image_dataset = datasets.ImageFolder(data_path, data_transforms)
return image_dataset
def __init__(self, args):
super(CifarLoader, self).__init__()
transform = transforms.Compose([
# TODO: Add data augmentations here
transforms.RandomOrder([
transforms.RandomVerticalFlip(),
transforms.RandomGrayscale(),
transforms.ColorJitter()
]),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
])
trainset = torchvision.datasets.CIFAR10(root='./data',
train=True,
download=True,
transform=transform)
self.trainloader = torch.utils.data.DataLoader(
trainset, batch_size=args.batchSize, shuffle=True, num_workers=2)
testset = torchvision.datasets.CIFAR10(root='./data',
train=False,
download=True,
transform=transform_test)
self.testloader = torch.utils.data.DataLoader(
testset, batch_size=args.batchSize, shuffle=False, num_workers=2)
self.classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog',
'horse', 'ship', 'truck')
def get_experiment_inception_transformations_composition(device):
"""See base_inception_experiment.
Note: this experiment uses data agumentation methods: horizontal flip, vertical flip,
brightness, contrast and hue transformations and random rotation"""
pcam_train_transform = transforms.Compose(transforms=[
transforms.RandomApply([
transforms.RandomOrder(transforms=[
transforms.RandomHorizontalFlip(p=0.5),
transforms.RandomVerticalFlip(p=0.5),
transforms.ColorJitter(brightness=0.05),
transforms.ColorJitter(contrast=0.05),
transforms.ColorJitter(hue=0.025),
transforms.RandomRotation(degrees=5)
])
],
p=0.5),
transforms.Resize(299),
transforms.ToTensor()
])
pcam_valid_transform = transforms.Compose([transforms.ToTensor()])
pcam_test_transform = transforms.Compose([transforms.ToTensor()])
pcam_data_transform = {
'train': pcam_train_transform,
'valid': pcam_valid_transform,
'test': pcam_test_transform
}
pcam_dataset = dataset.PCamDatasets(data_transforms=pcam_data_transform)
train_set = pcam_dataset.train
valid_set = pcam_dataset.valid
test_set = pcam_dataset.test
data_dict = {
dataset.TRAIN: train_set,
dataset.VALID: valid_set,
dataset.TEST: test_set
}
return base_inception_experiment(
experiment_name="inception_transformation_composition",
learn_rate=1e-3,
batch_size=32,
validation_batch_size=128,
num_epochs=25,
weight_decay=0,
pretrained=True,
fixed_weights=False,
data_dict=data_dict,
device=device)
def load_data():
"""Load the data: The detail folders contain a '1 bee' folder with 78x78 grayscale PNG images
of bees in honeycombs and a '0 notbee' folder with negative examples."""
b_size = 200
sigma = 15
transform_train = transforms.Compose([
transforms.RandomOrder([
transforms.RandomRotation(180),
transforms.RandomHorizontalFlip(),
transforms.RandomVerticalFlip(),
transforms.ColorJitter(brightness=0.5, contrast=0.5)
]),
transforms.CenterCrop(54),
transforms.Resize(32),
transforms.Grayscale(num_output_channels=1),
transforms.ToTensor()
])
transform_test = transforms.Compose([
transforms.CenterCrop(54),
transforms.Resize(32),
transforms.Grayscale(num_output_channels=1),
transforms.ToTensor()
])
trainset = beeimagefolder.BeeImageFolder(
root='../Videos/detail_training', valid_classes=['0 notbee', '1 bee'])
translated_trainset = mydataset.MyDataset(dataset=trainset,
sigma=sigma,
transform=transform_train)
testset = beeimagefolder.BeeImageFolder(
root='../Videos/detail_test',
valid_classes=['0 notbee', '1 bee'],
transform=transform_test)
print('class_to_idx trainset: {}\t class_to_idx testset: {}'.format(
trainset.class_to_idx, testset.class_to_idx))
trainloader = torch.utils.data.DataLoader(translated_trainset,
num_workers=2,
batch_size=b_size,
shuffle=True)
testloader = torch.utils.data.DataLoader(testset)
classes = ('notbee', 'bee')
return trainloader, testloader, classes, b_size, sigma
def get_experiment_densenet_transformation_composition(device):
"""See transformations_densenet_experiment_base"""
train_transform = transforms.Compose(
transforms=[
transforms.RandomApply(
[transforms.RandomOrder(transforms=[
transforms.RandomHorizontalFlip(p=0.5),
transforms.RandomVerticalFlip(p=0.5),
transforms.ColorJitter(brightness=0.05),
transforms.ColorJitter(contrast=0.05),
transforms.ColorJitter(hue=0.025),
transforms.RandomRotation(degrees=5)])], p=0.5),
transforms.ToTensor()])
return transformations_densenet_experiment_base(
train_transformations=train_transform,
experiment_name="densenet_transformation_composition", learn_rate=1e-4,
batch_size=32, validation_batch_size=1024, num_epochs=20, weight_decay=0,
pretrained=True, fixed_weights=False, device=device)
def random_transforms(aug_degree: float) -> t.RandomOrder:
assert 0 <= aug_degree <= 3
aug_list = [
t.functional.hflip,
t.RandomResizedCrop(size=SIZE, scale=(7 / 8, 7 / 8)),
t.RandomAffine(degrees=aug_degree * 10,
translate=(0.1 * aug_degree, 0.1 * aug_degree),
scale=(1 - 0.1 * aug_degree, 1 + 0.1 * aug_degree),
shear=aug_degree * 5,
fillcolor=0),
t.ColorJitter(brightness=0.1 * aug_degree,
contrast=0.1 * aug_degree,
saturation=0.1 * aug_degree)
]
transforms = t.RandomOrder(
[t.RandomApply([aug], p=0.4 + 0.1 * aug_degree) for aug in aug_list])
return transforms
def import_transfrom(data_dir):
train_dir = data_dir + '/train'
valid_dir = data_dir + '/valid'
test_dir = data_dir + '/test'
train_transforms = transforms.Compose([
transforms.RandomOrder([
transforms.RandomRotation(30),
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.RandomVerticalFlip()
]),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
valid_transforms = transforms.Compose([
transforms.Resize(255),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
test_transforms = transforms.Compose([
transforms.Resize(255),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
# TODO: Load the datasets with ImageFolder
train_data = datasets.ImageFolder(train_dir, transform=train_transforms)
valid_data = datasets.ImageFolder(valid_dir, transform=valid_transforms)
test_data = datasets.ImageFolder(test_dir, transform=test_transforms)
# TODO: Using the image datasets and the trainforms, define the dataloaders
trainloader = torch.utils.data.DataLoader(train_data,
batch_size=64,
shuffle=True)
validloader = torch.utils.data.DataLoader(valid_data, batch_size=64)
testloader = torch.utils.data.DataLoader(valid_data, batch_size=64)
return train_data, valid_data, test_data, trainloader, validloader, testloader
def set_transforms(self, p: float) -> None:
if p > 0:
transforms_list = [self._add_random_const_transform,
self._ampl_inversion_transform,
self._sync_impulse_transform,
self._sine_distortion_transform,
self._energy_absorption_transform]
random_transforms = t.RandomOrder([t.RandomApply([transform], p=p) for transform in transforms_list])
self._transforms = t.Compose([random_transforms,
self._add_random_noise_transform,
t.RandomApply([self._ampl_zero_transform,
self._high_noise_trace_transform], p=p),
data_normalize_and_limiting,
t.ToTensor()])
elif p == 0:
self._transforms = t.Compose([data_normalize_and_limiting,
t.ToTensor()])
else:
ValueError('Probability must be non-negative')
def get_cars(augment: bool,
train_dir: str,
project_dir: str,
test_dir: str,
img_size=224):
shape = (3, img_size, img_size)
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
normalize = transforms.Normalize(mean=mean, std=std)
transform_no_augment = transforms.Compose([
transforms.Resize(size=(img_size, img_size)),
transforms.ToTensor(), normalize
])
if augment:
transform = transforms.Compose([
transforms.Resize(size=(img_size + 32,
img_size + 32)), #resize to 256x256
transforms.RandomOrder([
transforms.RandomPerspective(distortion_scale=0.5, p=0.5),
transforms.ColorJitter((0.6, 1.4), (0.6, 1.4), (0.6, 1.4),
(-0.4, 0.4)),
transforms.RandomHorizontalFlip(),
transforms.RandomAffine(degrees=15, shear=(-2, 2)),
]),
transforms.RandomCrop(size=(img_size, img_size)), #crop to 224x224
transforms.ToTensor(),
normalize,
])
else:
transform = transform_no_augment
trainset = torchvision.datasets.ImageFolder(train_dir, transform=transform)
projectset = torchvision.datasets.ImageFolder(
project_dir, transform=transform_no_augment)
testset = torchvision.datasets.ImageFolder(test_dir,
transform=transform_no_augment)
classes = trainset.classes
return trainset, projectset, testset, classes, shape
def test_random_order(self):
random_state = random.getstate()
random.seed(42)
random_order_transform = transforms.RandomOrder(
[transforms.Resize(20),
transforms.CenterCrop(10)])
img = transforms.ToPILImage()(torch.rand(3, 25, 25))
num_samples = 250
num_normal_order = 0
resize_crop_out = transforms.CenterCrop(10)(transforms.Resize(20)(img))
for _ in range(num_samples):
out = random_order_transform(img)
if out == resize_crop_out:
num_normal_order += 1
p_value = stats.binom_test(num_normal_order, num_samples, p=0.5)
random.setstate(random_state)
assert p_value > 0.0001
# Checking if RandomOrder can be printed as string
random_order_transform.__repr__()
def get_birds(augment: bool,
train_dir: str,
project_dir: str,
test_dir: str,
img_size=224):
shape = (3, img_size, img_size)
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
normalize = transforms.Normalize(mean=mean, std=std)
transform_no_augment = transforms.Compose([
transforms.Resize(size=(img_size, img_size)),
transforms.ToTensor(), normalize
])
if augment:
transform = transforms.Compose([
transforms.Resize(size=(img_size, img_size)),
transforms.RandomOrder([
transforms.RandomPerspective(distortion_scale=0.2, p=0.5),
transforms.ColorJitter((0.6, 1.4), (0.6, 1.4), (0.6, 1.4),
(-0.02, 0.02)),
transforms.RandomHorizontalFlip(),
transforms.RandomAffine(degrees=10,
shear=(-2, 2),
translate=[0.05, 0.05]),
]),
transforms.ToTensor(),
normalize,
])
else:
transform = transform_no_augment
trainset = torchvision.datasets.ImageFolder(train_dir, transform=transform)
projectset = torchvision.datasets.ImageFolder(
project_dir, transform=transform_no_augment)
testset = torchvision.datasets.ImageFolder(test_dir,
transform=transform_no_augment)
classes = trainset.classes
for i in range(len(classes)):
classes[i] = classes[i].split('.')[1]
return trainset, projectset, testset, classes, shape
def prepareData(self):
# The output of torchvision datasets are PILImage images of range [0, 1]
# We transform them to Tensor type
# And normalize the data
# Be sure you do same normalization for your train and test data
print('Preparing dataset...')
# The transform function for train data
transform_train = transforms.Compose([
transforms.RandomOrder([
transforms.RandomCrop(128, padding=4),
transforms.RandomHorizontalFlip(),
]),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (1, 1, 1)),
# you can apply more augment function
# [document]: https://pytorch.org/docs/stable/torchvision/transforms.html
])
# The transform function for test data
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (1, 1, 1)),
])
# TODO
self.trainset = torchvision.datasets.ImageFolder(
"dataset", transform=transform_train)
self.testset = torchvision.datasets.ImageFolder(
"testset", transform=transform_train)
self.trainloader = torch.utils.data.DataLoader(
self.trainset, batch_size=self.batch_size, shuffle=True)
self.testloader = torch.utils.data.DataLoader(
self.testset, batch_size=self.batch_size, shuffle=False)
# you can also split validation set
# self.validloader = torch.utils.data.DataLoader(self.validset, batch_size=self.batch_size, shuffle=True)
return
def transform_tr(self, sample):
color_transforms = [
transforms.RandomApply([transforms.ColorJitter(brightness=0.1)
]), # brightness
transforms.RandomApply([transforms.ColorJitter(contrast=0.1)
]), # contrast
transforms.RandomApply([transforms.ColorJitter(saturation=0.1)
]), # saturation
transforms.RandomApply([transforms.ColorJitter(hue=0.05)])
] # hue
joint_transforms = transforms.Compose([
tr.RandomHorizontalFlip(),
tr.RandomScaleCrop(base_size=self.args.base_size,
crop_size=self.args.crop_size,
fill=255),
tr.equalize(),
tr.RandomGaussianBlur(),
tr.RandomRotate(degree=7)
])
image_transforms = transforms.Compose([
transforms.RandomOrder(color_transforms),
transforms.RandomGrayscale(p=0.3)
])
normalize_transforms = transforms.Compose([
tr.Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225)),
tr.ToTensor()
])
tmp_sample = joint_transforms(sample)
tmp_sample['image'] = image_transforms(tmp_sample['image'])
tmp_sample = normalize_transforms(tmp_sample)
return tmp_sample
def aug_image(image, is_infer=False, augment = None):
if is_infer:
flip_code = augment[0]
if flip_code == 1:
image = TF.hflip(image)
elif flip_code == 2:
image = TF.vflip(image)
elif flip_code == 3:
image = TF.vflip(image)
image = TF.hflip(image)
elif flip_code == 0:
return image
else:
dist_scale = random.random() / 10 + 0.01
aug_factor = 1.5
transform = transforms.Compose([
transforms.RandomAffine(degrees=(-15, 15),
shear=(-20, 20)),
transforms.RandomOrder([
transforms.RandomApply([transforms.ColorJitter(brightness=0.1*aug_factor, contrast=0.1*aug_factor)], p=0.2),
transforms.RandomApply([transforms.ColorJitter(saturation=0.1*aug_factor, hue=0.1*aug_factor)], p=0.5),
transforms.RandomPerspective(distortion_scale=dist_scale*aug_factor, p=0.5)#,
#transforms.RandomApply([transforms.Compose([
# transforms.ToTensor(),
# transforms.RandomErasing(p=1.0, scale=(0.02, 0.1), ratio=(0.25, 1)),
# transforms.ToPILImage()
#])], p=0.7),
#transforms.RandomApply([transforms.Compose([
# transforms.ToTensor(),
# AddGaussianNoise(0., 2.),
# transforms.ToPILImage()
#])], p=0.5)
])
])
image = transform(image)
return image
def __init__(self, data_path, train_eval_flag, batch_size):
"""
Args:
data_path (string): Path to the data folder.
train_eval_flag (string): "train" or "eval".
batch_size (int): Recommended to be consistent with the number of processor cores
"""
self.data_path = data_path
self.batch_size = batch_size
if train_eval_flag == "train":
self.tran = transforms.Compose([
transforms.RandomOrder([
#各类数据增强方法,随机顺序，且按一定概率决定是不是使用
sometimes(0.09, iaa.GaussianBlur(sigma=(0, 1.5))),
sometimes(
0.09,
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.0, 0.05),
per_channel=0.5)),
sometimes(
0.09,
iaa.ContrastNormalization((0.8, 1.2),
per_channel=0.5)),
sometimes(0.3, iaa.Dropout((0.0, 0.10), per_channel=0.5)),
sometimes(
0.3,
iaa.CoarseDropout((0.0, 0.10),
size_percent=(0.08, 0.2),
per_channel=0.5)),
sometimes(0.3, iaa.Add((-20, 20), per_channel=0.5)),
sometimes(0.4, iaa.Multiply((0.9, 1.1), per_channel=0.2)),
]),
transforms.ToTensor()
])
else:
self.tran = transforms.Compose([transforms.ToTensor()])
def __init__(self, rootDir=Path('/home/zzr/Data/XinGuan/lung'),
mode='train',
size=(160, 240)):
super().__init__(rootDir, mode, size)
self.mean, self.std = .5536, .2696
if mode == 'train':
self.to_tensorImg = \
transforms.Compose([
transforms.RandomOrder([
transforms.RandomHorizontalFlip(),
transforms.RandomVerticalFlip(),
transforms.RandomApply([
transforms.RandomRotation(45,
resample=Image.BILINEAR)], p=.5),
transforms.RandomApply([
transforms.ColorJitter(.1, .1, .1, .1)], p=.5)]),
transforms.ToTensor(),
transforms.Normalize((self.mean, ), (self.std, ))])
else:
self.to_tensorImg = \
transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((self.mean, ),(self.std, ))])
def set_choice(self):
choice = {
# random_choice 1: Blur, rotaion, Blur + rotation + scale_translate (random_order)
self.augmentation_name[1]: [
Stage2_RandomAffine(degrees=15, translate=(0, 0),
scale=(1, 1)),
transforms.RandomOrder([
Stage2_GaussianNoise(),
Stage2_RandomAffine(degrees=30,
translate=(0.3, 0.3),
scale=(1, 2))
])
],
# random_choice 2: noise, crop, noise + crop + rotation_scale_translate (random_order)
self.augmentation_name[2]: [
Stage2_GaussianNoise(),
Stage2_RandomAffine(degrees=30,
translate=(0.3, 0.3),
scale=(0.8, 1.5)),
transforms.RandomOrder([
Stage2_GaussianNoise(),
Stage2_RandomAffine(degrees=30,
translate=(0.3, 0.3),
scale=(1, 2))
])
],
# random_choice 3: noise + blur , noise + rotation ,noise + blur + rotation_scale_translate
self.augmentation_name[3]: [
transforms.RandomOrder([
Stage2_RandomAffine(degrees=30,
translate=(0.3, 0.3),
scale=(1, 2)),
Stage2_RandomAffine(degrees=30,
translate=(0.3, 0.3),
scale=(1, 2))
]),
transforms.RandomOrder([
Stage2_RandomAffine(degrees=30,
translate=None,
scale=(1, 1)),
Stage2_RandomAffine(degrees=0,
translate=(0.3, 0.3),
scale=(1, 2))
]),
transforms.RandomOrder([
Stage2_GaussianNoise(),
Stage2_RandomAffine(degrees=30,
translate=(0.3, 0.3),
scale=(1, 2))
]),
transforms.RandomOrder([
Stage2_RandomAffine(degrees=30,
translate=None,
scale=(1, 1)),
Stage2_RandomAffine(degrees=0,
translate=(0.3, 0.3),
scale=(1, 2))
])
],
# random_choice 4: noise + crop , blur + crop ,noise + blur + crop + rotation_scale_translate
self.augmentation_name[4]: [
transforms.RandomOrder([
Stage2_RandomAffine(degrees=15,
translate=(0.3, 0.3),
scale=(1, 2)),
Stage2_RandomAffine(degrees=30,
translate=(0.3, 0.3),
scale=(1, 2))
]),
transforms.Compose([
Stage2_GaussianNoise(),
Stage2_RandomAffine(degrees=30,
translate=(0.3, 0.3),
scale=(1, 2)),
]),
transforms.RandomOrder([
Stage2_RandomAffine(degrees=0,
translate=(0.3, 0.3),
scale=(1, 2)),
Stage2_RandomAffine(degrees=30,
translate=(0.3, 0.3),
scale=(1, 2))
])
]
}
self.randomchoice = choice
from torchvision import transforms
to_PIL = transforms.Compose([transforms.ToPILImage()])
data_augmentation = transforms.RandomOrder([
transforms.RandomHorizontalFlip(0.5),
transforms.ColorJitter(brightness=0.3,
contrast=0.3,
saturation=0.3,
hue=0.1),
transforms.RandomRotation(40)
])
random_erasing = transforms.Compose(
[transforms.RandomErasing(p=0.5, scale=(0.02, 0.33), ratio=(0.3, 3.3))])
model_transforms = {
'reseption_v1':
transforms.Compose([
transforms.Resize((299, 299)),
transforms.ToTensor(),
transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
]),
'reseption_v2':
transforms.Compose([
transforms.Resize((299, 299)),
transforms.ToTensor(),
transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
]),
'reseption_ensemble':
transforms.Compose([
def normalize(img): nimg = img.numpy() m, M = np.min(nimg), np.max(nimg) nimg -= m nimg /= (M-m) return torch.tensor(nimg).float() Normalize = transforms.Normalize([0.]*3, [1.]*3) normalize_transforms = [transforms.Lambda(normalize)] feature_build_transforms = []#[transforms.Lambda(feature_build)] #[] ## List of transforms for Data Augmentation RC = lambda ts : transforms.RandomChoice(ts) RA = lambda ts : transforms.RandomApply(ts, p=0.7) RO = lambda ts : transforms.RandomOrder(ts) HFlip = transforms.RandomHorizontalFlip(p=0.7) VFlip = transforms.RandomVerticalFlip(p=0.7) Rotation = transforms.RandomRotation((0, 180), resample=False, expand=False, center=None) ## White noise noise = transforms.Lambda(lambda img : img+0.01*Variable(torch.randn(img.size()))) Resize = transforms.Lambda(lambda img : transforms.functional.resize(img, (shape, shape)) if (shape > 0) else img) CJ = transforms.ColorJitter(brightness=0.4, contrast=0, saturation=0.5, hue=0) ## For custom transformations # transforms.LinearTransformation(transformation_matrix) # transforms.Lambda(lambd) data_augmentation = [RC([HFlip, VFlip, Rotation, RA([CJ])])]*2 data_transform_train = transforms.Compose( [Resize]+ [RO(data_augmentation)]+
# -*- coding: utf_8 -*-
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from auto_augment import AutoAugment, Cutout
import os
from torch.utils.data import Dataset
from torchvision import transforms, datasets
from PIL import Image
"""
transforms.RandomOrder([
transforms.RandomApply([transforms.ColorJitter(contrast=0.5)], .5),
transforms.Compose([
transforms.RandomApply([transforms.ColorJitter(saturation=0.5)], .5),
transforms.RandomApply([transforms.ColorJitter(hue=0.1)], .5),
])
]),
transforms.RandomApply([transforms.ColorJitter(brightness=0.125)], .5),
transforms.RandomApply([transforms.RandomRotation(15)], .5),
transforms.RandomResizedCrop(img_size),
transforms.RandomHorizontalFlip(),
"""
def train_data_loader(data_path, img_size, use_augment=False):
if use_augment:
data_transforms = transforms.Compose([
transforms.RandomResizedCrop(img_size),
AutoAugment(),
Cutout(),
'n02105641': 'Old English sheepdog',
'n02088364': 'Beagle',
'n02111889': 'Samoyed',
'n02093754': 'Border terrier',
'n02089973': 'English foxhound',
'n02096294': 'Australian terrier',
'n02115641': 'Dingo'
}
MODEL_TYPE = 'efficientnet-b0'
NUM_CLASSES = len(CLASS_NAMES)
INPUT_SHAPE = (224, 224, 3)
NORMALIZE_MEAN = [0, 0, 0]
NORMALIZE_STD = [255, 255, 255]
TRAIN_DATA_TRANSFORMS = transforms.Compose([
transforms.ToTensor(),
transforms.RandomResizedCrop(INPUT_SHAPE[:2]),
transforms.RandomOrder([
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(brightness=0.25, contrast=0.25, saturation=0.1, hue=0.05),
transforms.RandomAffine(degrees=5, scale=(0.8, 1.2), fillcolor=None),
transforms.GaussianBlur(kernel_size=3)
]),
transforms.Normalize([0, 0, 0], [255, 255, 255])
])
TEST_DATA_TRANSFORMS = transforms.Compose([
transforms.ToTensor(),
transforms.Resize(INPUT_SHAPE[:2]),
transforms.Normalize(NORMALIZE_MEAN, NORMALIZE_STD)
])
normalize = transforms.Normalize(mean, std)
preprocess = transforms.Compose([rescale, transforms.ToTensor(), normalize])
v_flip = transforms.RandomVerticalFlip()
h_flip = transforms.RandomHorizontalFlip()
s_color = transforms.ColorJitter(saturation=0.1)
c_color = transforms.ColorJitter(contrast=0.1)
h_color = transforms.ColorJitter(hue=0.1)
grayscale = transforms.RandomGrayscale()
augment1 = transforms.RandomApply(
[h_flip, s_color, c_color, h_color, v_flip, grayscale])
augment2 = transforms.RandomChoice(
[h_flip, s_color, c_color, h_color, v_flip, grayscale])
augment3 = transforms.RandomOrder(
[h_flip, s_color, c_color, h_color, v_flip, grayscale])
class TrainDataset(Dataset):
def __init__(self, transform=None):
with open(TRAIN, 'r') as f:
self.train_paths = f.read().splitlines()
self.transform = transform
def __len__(self):
return len(self.train_paths)
def __getitem__(self, idx):
csv_file = self.train_paths[idx]
def set_choice(self):
choice = {
# random_choice 1: Blur, rotaion, Blur + rotation + scale_translate (random_order)
self.augmentation_name[1]: [
GaussianNoise(),
RandomAffine(degrees=15,
translate=(0.1, 0.1),
scale=(0.9, 1.2)),
transforms.RandomOrder([
GaussianNoise(),
RandomAffine(degrees=15,
translate=(0.1, 0.1),
scale=(0.9, 1.2))
])
],
# random_choice 2: noise, crop, noise + crop + rotation_scale_translate (random_order)
self.augmentation_name[2]: [
Blurfilter(),
RandomAffine(degrees=15,
translate=(0.1, 0.1),
scale=(0.9, 1.2)),
transforms.RandomOrder([
Blurfilter(),
RandomAffine(degrees=15,
translate=(0.1, 0.1),
scale=(0.9, 1.2))
])
],
# random_choice 3: noise + blur , noise + rotation ,noise + blur + rotation_scale_translate
self.augmentation_name[3]: [
transforms.RandomOrder([
GaussianNoise(),
RandomAffine(degrees=15,
translate=(0.1, 0.1),
scale=(0.9, 1.2))
]),
transforms.RandomOrder([
GaussianNoise(),
RandomAffine(degrees=15,
translate=(0.1, 0.1),
scale=(0.9, 1.2))
]),
transforms.RandomOrder([
GaussianNoise(),
Blurfilter(),
RandomAffine(degrees=15,
translate=(0.1, 0.1),
scale=(0.9, 1.2))
])
],
# random_choice 4: noise + crop , blur + crop ,noise + blur + crop + rotation_scale_translate
self.augmentation_name[4]: [
transforms.RandomOrder([
GaussianNoise(),
RandomAffine(degrees=15,
translate=(0.1, 0.1),
scale=(0.9, 1.2))
]),
transforms.Compose([
Blurfilter(),
RandomAffine(degrees=15,
translate=(0.1, 0.1),
scale=(0.9, 1.2))
]),
transforms.RandomOrder([
GaussianNoise(),
Blurfilter(),
RandomAffine(degrees=15,
translate=(0.1, 0.1),
scale=(0.9, 1.2))
])
]
}
self.randomchoice = choice
transforms.RandomChoice([
transforms.RandomVerticalFlip(p=1),
transforms.RandomHorizontalFlip(p=1)
]),
# 2 RandomApply
transforms.RandomApply([
transforms.RandomAffine(degrees=0, shear=45, fillcolor=(255, 0, 0)),
transforms.Grayscale(num_output_channels=3)
],
p=0.5),
# 3 RandomOrder
transforms.RandomOrder([
transforms.RandomRotation(15),
transforms.Pad(padding=32),
transforms.RandomAffine(degrees=0,
translate=(0.01, 0.1),
scale=(0.9, 1.1))
]),
# transforms.ToTensor(),
# transforms.Normalize(norm_mean, norm_std),
])
valid_transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(norm_mean, norm_std)
])
# 构建MyDataset实例
import tfrecord_creator
from config import im_size, unknown_code, fg_path, bg_path, a_path, num_valid, valid_ratio, num_fgs, num_bgs
from utils import safe_crop, parse_args, maybe_random_interp
global args
args = parse_args()
# Data augmentation and normalization for training
# Just normalization for validation
if args.data_augumentation:
data_transforms = {
'train': transforms.Compose([
transforms.ColorJitter(brightness=0.125, contrast=0.125, saturation=0.125),
transforms.RandomApply([
transforms.RandomOrder([
transforms.RandomApply([transforms.RandomAffine(degrees=30, scale=[0.8,1.25], shear=10)]),
transforms.RandomApply([transforms.RandomHorizontalFlip(0.5)]),
transforms.RandomApply([transforms.RandomCrop(size=(320, 320), pad_if_needed=True)])])]),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
]),
'valid': transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
}
else:
data_transforms = {
'train': transforms.Compose([
transforms.ColorJitter(brightness=0.125, contrast=0.125, saturation=0.125),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
