def test_init_shared_label_space(numpy_data, shared_label_space):
x, y = numpy_data
dummy = InMemoryDataset(x, y)
Trsf_0 = []
Trsf_1 = [transforms.RandomAffine(degrees=[40, 50])]
Trsf_2 = [transforms.RandomAffine(degrees=[85, 95])]
dummy_transf = [Trsf_0, Trsf_1, Trsf_2]
scenario = TransformationIncremental(
cl_dataset=dummy,
incremental_transformations=dummy_transf,
shared_label_space=shared_label_space
)
for task_id, taskset in enumerate(scenario):
assert taskset.nb_classes == NB_CLASSES
classes = taskset.get_classes()
if shared_label_space:
assert classes.max() == NB_CLASSES - 1
assert classes.min() == 0
else:
assert classes.max() == (NB_CLASSES * (task_id + 1)) - 1
assert classes.min() == (NB_CLASSES * task_id)
def test_get_task_transformation(numpy_data):
x, y = numpy_data
dummy = InMemoryDataset(x, y)
Trsf_0 = []
Trsf_1 = [transforms.RandomAffine(degrees=[40, 50])]
Trsf_2 = [transforms.RandomAffine(degrees=[85, 95])]
dummy_transf = [Trsf_0, Trsf_1, Trsf_2]
base_transformations = [
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
]
scenario = TransformationIncremental(
cl_dataset=dummy,
incremental_transformations=dummy_transf,
base_transformations=base_transformations)
for task_id, taskset in enumerate(scenario):
# first task specific transformation then base_transformation
tot_transf_task = transforms.Compose(dummy_transf[task_id] +
base_transformations)
# we compare the str representation of the composition
assert tot_transf_task.__repr__() == scenario.get_task_transformation(
task_id).__repr__()
def __init__(self, data_root, effect):
self.data_root = os.path.join(data_root, effect)
self.data_figure_root = os.path.join(data_root, effect + '-figure')
self.effect = effect
self.data_list = sorted(os.listdir(self.data_root), key=lambda x: int(x.replace('.png', '')))
self.data_figure_list = sorted(os.listdir(self.data_figure_root), key=lambda x: int(x.replace('.png', '')))
self.effect_shape = cv2.imread(os.path.join(self.data_root, self.data_list[0])).shape[:2]
self.figure_shape = cv2.imread(os.path.join(self.data_figure_root, self.data_figure_list[0])).shape[:2]
# self.scaled_shape = (int(self.train_shape[0] * 0.5), int(self.train_shape[1] * 0.8))
diff_h = (self.figure_shape[0] - self.effect_shape[0]) // 2
diff_w = (self.figure_shape[1] - self.effect_shape[1]) // 2
self.target_transforms = transforms.Compose([
transforms.ToPILImage(),
transforms.RandomAffine(degrees=(-20, 20), translate=(0.2, 0.3), scale=(0.5, 1.1), ),
])
self.source_transforms = transforms.Compose([
transforms.ToPILImage(),
transforms.Pad((diff_w, diff_h, diff_w, diff_h)), # 左，上，右，下
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
self.final_transforms = transforms.Compose([
transforms.ToPILImage(),
transforms.RandomAffine(degrees=(-20, 20), translate=(0.2, 0.5), scale=(0.5, 1.1), ),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
self.length = len(self.data_list) - 1
def get_transforms(dataset, aug: Union[List, str], cutout: int):
if 'imagenet' in dataset:
return _get_imagenet_transforms()
if dataset == 'cifar10':
MEAN = [0.49139968, 0.48215827, 0.44653124]
STD = [0.24703233, 0.24348505, 0.26158768]
transf = [
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip()
]
elif dataset == 'cifar100':
MEAN = [0.507, 0.487, 0.441]
STD = [0.267, 0.256, 0.276]
transf = [
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip()
]
elif dataset == 'svhn':
MEAN = [0.4914, 0.4822, 0.4465]
STD = [0.2023, 0.1994, 0.20100]
transf = [
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip()
]
elif dataset == 'mnist':
MEAN = [0.13066051707548254]
STD = [0.30810780244715075]
transf = [
transforms.RandomAffine(degrees=15,
translate=(0.1, 0.1),
scale=(0.9, 1.1),
shear=0.1)
]
elif dataset == 'fashionmnist':
MEAN = [0.28604063146254594]
STD = [0.35302426207299326]
transf = [
transforms.RandomAffine(degrees=15,
translate=(0.1, 0.1),
scale=(0.9, 1.1),
shear=0.1),
transforms.RandomVerticalFlip()
]
else:
raise ValueError('dataset not recognized: {}'.format(dataset))
normalize = [transforms.ToTensor(), transforms.Normalize(MEAN, STD)]
train_transform = transforms.Compose(transf + normalize)
test_transform = transforms.Compose(normalize)
# add additional aug and cutout transformations
_add_augs(train_transform, aug, cutout)
return train_transform, test_transform
def test_init_range(numpy_data):
x, y = numpy_data
dummy = InMemoryDataset(x, y)
Trsf_0 = []
Trsf_1 = [transforms.RandomAffine(degrees=[40, 50])]
Trsf_2 = [transforms.RandomAffine(degrees=[85, 95])]
list_transf = [Trsf_0, Trsf_1, Trsf_2]
scenario = TransformationIncremental(
cl_dataset=dummy, incremental_transformations=list_transf)
def get_simclr_pipeline_transform(size, s=1, num_aug=5):
"""Return a set of data augmentation transformations as described in the SimCLR paper."""
color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s,
0.2 * s)
if num_aug == 5:
data_transforms = transforms.Compose([
transforms.RandomResizedCrop(size=size),
transforms.RandomHorizontalFlip(),
transforms.RandomApply([color_jitter], p=0.8),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(kernel_size=int(0.1 * size)),
transforms.ToTensor()
])
elif num_aug == 7:
data_transforms = transforms.Compose([
transforms.RandomResizedCrop(size=size),
transforms.RandomHorizontalFlip(),
transforms.RandomApply([color_jitter], p=0.8),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(kernel_size=int(0.1 * size)),
transforms.RandomRotation(degrees=45),
transforms.RandomAffine(degrees=45),
transforms.ToTensor()
])
return data_transforms
def get_random_region_mask(self, x):
"""
Chooses random masks from `self.segmentation_masks`.
:param (torch.Tensor) x: tensor image
"""
mask = torch.zeros_like(x)
batch_size, img_height, img_width = x.shape[0], x.shape[-2], x.shape[
-1]
# Apply distortions in the form of affine transformations to the masks for diversification
transform = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize((img_height, img_width)),
transforms.RandomAffine(degrees=(-45, 45),
translate=(0.25, 0.25),
shear=(-10, 10),
fillcolor=0),
transforms.ToTensor(),
])
for i in range(batch_size):
segmentation_mask = random.choice(self.segmentation_masks).repeat(
3, 1, 1)
mask[i] = transform(segmentation_mask)
return mask
def create_dataloader(data_path,
target_size,
train_val_split,
batch_size,
verbose: bool = False) -> Dict[str, DataLoader]:
# Data augmentation and normalization for training
# Just normalization for validation
width, height = target_size
data_transforms = {
'train':
transforms.Compose([
transforms.Resize((width, height)),
transforms.ColorJitter(brightness=0.2,
contrast=0.2,
saturation=0.5,
hue=0.5),
transforms.RandomAffine(degrees=10,
translate=(0.05, 0.05),
scale=(0.95, 1.05),
shear=10),
transforms.ToTensor(),
transforms.Normalize([0.6205, 0.6205, 0.6205],
[0.1343, 0.1343, 0.1343])
]),
'test':
transforms.Compose([
transforms.Resize((width, height)),
transforms.ToTensor(),
transforms.Normalize([0.6205, 0.6205, 0.6205],
[0.1343, 0.1343, 0.1343])
]),
}
# Load dataset
if "car" in data_path.lower():
dataset = CAR(data_path,
transform=data_transforms,
train_val_split=train_val_split,
verbose=verbose)
else:
dataset = CVL(data_path,
transform=data_transforms,
train_val_split=train_val_split,
verbose=verbose)
if verbose:
print(dataset)
# Create training and validation dataloaders
loader_names = ['train', 'test']
if train_val_split < 1.0:
loader_names.append('val')
dataloaders_dict = {
x: DataLoader(dataset.subsets[x],
batch_size=batch_size,
shuffle=True,
num_workers=4)
for x in loader_names
}
return dataloaders_dict
def __init__(self, root):
super().__init__(root, download=True)
self.my_transform = transforms.Compose(
[transforms.RandomAffine(degrees=15, translate=(0.1, 0.1), scale=(0.9, 1.1), shear=5),
transforms.ToTensor(),
transforms.Normalize(0, 1),
my_transforms.AddGaussianNoise(0, 0.1)]
)
def __init__(self, resize_to=(224, 224)):
list_of_transforms = [
transforms.RandomAffine(degrees=(-180, 180)),
transforms.CenterCrop(size=resize_to),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
]
self.transform = transforms.Compose(list_of_transforms)
def lfw(stage, configs=None, augment=False, tta=False, tta_size=48):
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
folder_path = os.path.join(configs["data_path"], f"{stage}")
dataset = datasets.ImageFolder(
folder_path,
transforms.Compose([
#transforms.RandomResizedCrop(224),
#transforms.RandomHorizontalFlip(),
transforms.Resize(224),
transforms.ToTensor(),
#normalize,
]),
)
if augment:
dataset2 = datasets.ImageFolder(
folder_path,
transforms.Compose([
transforms.Resize(224),
transforms.RandomHorizontalFlip(),
transforms.RandomRotation((1, 20)),
transforms.ColorJitter(),
transforms.ToTensor(),
]),
)
dataset3 = datasets.ImageFolder(
folder_path,
transforms.Compose([
transforms.Resize(224),
transforms.RandomHorizontalFlip(),
transforms.RandomRotation((-20, -1)),
transforms.ColorJitter(),
transforms.ToTensor(),
]),
)
dataset4 = datasets.ImageFolder(
folder_path,
transforms.Compose([
transforms.Resize(224),
transforms.RandomHorizontalFlip(),
transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),
transforms.ColorJitter(),
transforms.ToTensor(),
AddGaussianNoise(0., 0.05),
]),
)
return torch.utils.data.ConcatDataset(
[dataset4, dataset2, dataset3, dataset])
else:
return dataset
def gen_dataloaders(indir,
val_split=0.05,
shuffle=True,
batch_size=4,
seed=42,
img_size=224,
cuda=True):
data_transforms = {
'train':
transforms.Compose([
# transforms.ColorJitter(0.3, 0.3, 0.3, 0.3),
transforms.RandomResizedCrop(img_size, scale=(0.1, 1.0)),
transforms.RandomAffine(10.),
transforms.RandomRotation(13.),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
]),
'valid':
transforms.Compose([
transforms.Resize((img_size, img_size)),
transforms.ToTensor(),
])
}
mask_train_dataset = MaskDataset(path=indir,
transform=data_transforms['train'])
mask_valid_dataset = MaskDataset(path=indir,
transform=data_transforms['valid'])
# Creating data indices for training and validation splits:
dataset_size = len(mask_train_dataset)
indices = list(range(dataset_size))
split = int(np.floor(val_split * dataset_size))
if shuffle:
np.random.seed(seed)
np.random.shuffle(indices)
train_indices, val_indices = indices[split:], indices[:split]
# Creating data samplers and loaders
train_sampler = SubsetRandomSampler(train_indices)
valid_sampler = SubsetRandomSampler(val_indices)
kwargs = {'num_workers': 4, 'pin_memory': True} if cuda else {}
train_loader = torch.utils.data.DataLoader(mask_train_dataset,
batch_size=batch_size,
sampler=train_sampler,
**kwargs)
valid_loader = torch.utils.data.DataLoader(mask_valid_dataset,
batch_size=batch_size,
sampler=valid_sampler,
**kwargs)
return train_loader, valid_loader
def test_init(numpy_data):
x, y = numpy_data
dummy = InMemoryDataset(x, y, train='train')
Trsf_0 = []
Trsf_1 = [transforms.RandomAffine(degrees=[45, 45])]
Trsf_2 = [transforms.RandomAffine(degrees=[90, 90])]
list_transf = [Trsf_0, Trsf_1, Trsf_2]
scenario = TransformationIncremental(
cl_dataset=dummy, incremental_transformations=list_transf
)
ref_data = None
raw_ref_data = None
for task_id, taskset in enumerate(scenario):
samples, _, _ = taskset.get_random_samples(10)
# we need raw data to apply same transformation as the TransformationIncremental class
raw_samples, _, _ = taskset.get_raw_samples(range(10))
if task_id == 0:
ref_data = samples
raw_ref_data = raw_samples
else:
# we verify that data has changed
assert not torch.all(ref_data.eq(samples))
assert (raw_samples == raw_ref_data
).all() # raw data should be the same in this scenario
# we test transformation on one data point and verify if it is applied
trsf = list_transf[task_id][0]
raw_sample = Image.fromarray(raw_ref_data[0].astype("uint8"))
trsf_data = trsf(raw_sample)
trsf_data = transforms.ToTensor()(trsf_data)
assert torch.all(trsf_data.eq(samples[0]))
def test_list_transforms(fake_data):
nb_tasks = 5
list_trsfs = []
for _ in range(nb_tasks - 1):
list_trsfs.append([transforms.RandomAffine(degrees=[0, 90])])
# should fail since nb_task != len(list_trsfs)
with pytest.raises(ValueError) as e:
scenario = ClassIncremental(
cl_dataset=fake_data,
increment=2,
transformations=list_trsfs
)
def augment_image(img):
# Convert weird half transparent background to completely transparent
arr = np.array(img)
for i in range(arr.shape[0]):
for j in range(arr.shape[1]):
if arr[i, j][3] == 63:
arr[i, j] = (0, 0, 0, 0)
img = Image.fromarray(arr)
# Create and apply transform
transform = transforms.RandomAffine(degrees=[-180, 180], )
transformed_img = transform(img)
return transformed_img
def get_transforms(self) -> tuple:
MEAN = [0.13066051707548254]
STD = [0.30810780244715075]
transf = [
transforms.RandomAffine(degrees=15,
translate=(0.1, 0.1),
scale=(0.9, 1.1),
shear=0.1)
]
normalize = [transforms.ToTensor(), transforms.Normalize(MEAN, STD)]
train_transform = transforms.Compose(transf + normalize)
test_transform = transforms.Compose(normalize)
return train_transform, test_transform
def get_transforms(self) -> tuple:
MEAN = [0.28604063146254594]
STD = [0.35302426207299326]
transf = [
transforms.RandomAffine(degrees=15,
translate=(0.1, 0.1),
scale=(0.9, 1.1),
shear=0.1),
transforms.RandomVerticalFlip()
]
normalize = [transforms.ToTensor(), transforms.Normalize(MEAN, STD)]
train_transform = transforms.Compose(transf + normalize)
test_transform = transforms.Compose(normalize)
return train_transform, test_transform
def get_transforms(opt):
"""
Return Composed torchvision transforms based on specified arguments.
"""
transforms_list = []
if "none" in opt.input_transforms:
return
every = "all" in opt.input_transforms
if every or "vflip" in opt.input_transforms:
transforms_list.append(transforms.RandomVerticalFlip())
if every or "hflip" in opt.input_transforms:
transforms_list.append(transforms.RandomHorizontalFlip())
if every or "affine" in opt.input_transforms:
transforms_list.append(
transforms.RandomAffine(
degrees=10, translate=(0.1, 0.1), scale=(0.8, 1.2), shear=20
)
)
if every or "perspective" in opt.input_transforms:
transforms_list.append(transforms.RandomPerspective())
return transforms.RandomOrder(transforms_list)
def get_transforms(config, image_size=None):
config = config.get_dictionary()
if image_size is not None:
image_size = image_size
elif config['estimator'] not in resize_size_dict:
image_size = 32
else:
image_size = resize_size_dict[config['estimator']]
val_transforms = transforms.Compose([
transforms.Resize(image_size),
transforms.CenterCrop(image_size),
transforms.ToTensor(),
])
if check_for_bool(config['aug']):
if check_for_bool(config['auto_aug']):
# from .transforms import AutoAugment
data_transforms = {
'train':
transforms.Compose([
# AutoAugment(),
transforms.Resize(image_size),
transforms.RandomCrop(image_size,
padding=int(image_size / 8)),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
]),
'val':
val_transforms,
}
else:
transform_list = []
if check_for_bool(config['jitter']):
transform_list.append(
transforms.ColorJitter(brightness=config['brightness'],
saturation=config['saturation'],
hue=config['hue']))
if check_for_bool(config['affine']):
transform_list.append(
transforms.RandomAffine(degrees=config['degree'],
shear=config['shear']))
transform_list.append(transforms.RandomResizedCrop(image_size))
transform_list.append(transforms.RandomCrop(image_size, padding=4))
if check_for_bool(config['random_flip']):
transform_list.append(transforms.RandomHorizontalFlip())
transform_list.append(transforms.ToTensor())
data_transforms = {
'train': transforms.Compose(transform_list),
'val': val_transforms
}
else:
data_transforms = {
'train':
transforms.Compose([
transforms.Resize(image_size),
transforms.CenterCrop(image_size),
transforms.ToTensor(),
]),
'val':
val_transforms,
}
return data_transforms
def create_cmnist_datasets(
*,
root: str,
scale: float,
train_pcnt: float,
download: bool = False,
seed: int = 42,
rotate_data: bool = False,
shift_data: bool = False,
padding: bool = False,
quant_level: int = 8,
input_noise: bool = False,
classes_to_keep: Optional[Sequence[_Classes]] = None,
) -> Tuple[LdTransformedDataset, LdTransformedDataset]:
"""Create and return colourised MNIST train/test pair.
Args:
root: Where the images are downloaded to.
scale: The amount of 'bias' in the colour. Lower is more biased.
train_pcnt: The percentage of data to make the test set.
download: Whether or not to download the data.
seed: Random seed for reproducing results.
rotate_data: Whether or not to rotate the training images.
shift_data: Whether or not to shift the training images.
padding: Whether or not to pad the training images.
quant_level: the number of bins to quantize the data into.
input_noise: Whether or not to add noise to the training images.
classes_to_keep: Which digit classes to keep. If None or empty then all classes will be kept.
Returns:
tuple of train and test data as a Dataset.
"""
np.random.seed(seed)
random.seed(seed)
torch.manual_seed(seed)
base_aug = [transforms.ToTensor()]
data_aug = []
if rotate_data:
data_aug.append(transforms.RandomAffine(degrees=15))
if shift_data:
data_aug.append(
transforms.RandomAffine(degrees=0, translate=(0.11, 0.11)))
if padding > 0:
base_aug.insert(0, transforms.Pad(padding))
if quant_level != 8:
base_aug.append(Quantize(int(quant_level)))
if input_noise:
base_aug.append(NoisyDequantize(int(quant_level)))
mnist_train = MNIST(root=root, train=True, download=download)
mnist_test = MNIST(root=root, train=False, download=download)
if classes_to_keep:
mnist_train = _filter_classes(dataset=mnist_train,
classes_to_keep=classes_to_keep)
mnist_test = _filter_classes(dataset=mnist_test,
classes_to_keep=classes_to_keep)
all_data: ConcatDataset = ConcatDataset([mnist_train, mnist_test])
train_data, test_data = train_test_split(all_data, train_pcnt=train_pcnt)
colorizer = LdColorizer(scale=scale,
background=False,
black=True,
binarize=True,
greyscale=False)
train_data = DatasetWrapper(train_data, transform=base_aug + data_aug)
train_data = LdTransformedDataset(
dataset=train_data,
ld_transform=colorizer,
target_dim=10,
label_independent=False,
discrete_labels=True,
)
test_data = DatasetWrapper(test_data, transform=base_aug)
test_data = LdTransformedDataset(
test_data,
ld_transform=colorizer,
target_dim=10,
label_independent=True,
discrete_labels=True,
)
return train_data, test_data
width = int(data.size[0] / (data.size[1] / height))
data = data.resize((width, height))
if self.transform is not None:
data = self.transform(data)
label = re.search('([0-9_]+)', img_name).group(1)
label = re.sub('\D', '', label)
return data, label
def __len__(self):
return self.fileList.__len__()
myTransform = transforms.Compose([
transforms.RandomAffine(5.0,
translate=None,
scale=(1.05, 0.95),
shear=0.2,
resample=False,
fillcolor=127),
transforms.Grayscale(),
transforms.ToTensor(),
transforms.Lambda(lambda x: do(x)),
#transforms.Normalize((0.1307,), (0.3081,)),
])
if __name__ == '__main__':
import matplotlib.pyplot as plt
import torchvision
manualSeed = random.randint(1, 10000) # fix seed
random.seed(manualSeed)
np.random.seed(manualSeed)
@Time : 2020/10/24 19:40
"""
import torch, os, cv2
from torch.utils.data import Dataset, DataLoader
from torchvision.transforms import transforms
import matplotlib.pyplot as plt
from PIL import Image
import numpy as np
import random
ImgResize = (1024, 1280) # image size
# %% Data augmentation
TrainImgTransform = transforms.Compose([
transforms.RandomAffine(degrees=(-45, 45),
translate=(0.2, 0.2),
scale=(1, 1.),
shear=10),
transforms.RandomHorizontalFlip(),
transforms.RandomVerticalFlip(),
transforms.RandomResizedCrop(ImgResize,
scale=(1., 1.),
interpolation=Image.BILINEAR),
transforms.ToTensor(),
transforms.Normalize(mean=[0.46], std=[0.10]),
])
TrainLabelTransform = transforms.Compose([
transforms.RandomAffine(degrees=(-45, 45),
translate=(0.2, 0.2),
scale=(1, 1.),
shear=10),
transforms.RandomHorizontalFlip(),
device = torch.device("cuda:0")
else:
torch.set_default_tensor_type(torch.FloatTensor)
device = torch.device("cpu")
transform = dict()
mean = [
0.054813755064775954, 0.0808928726780973, 0.08367144133595689,
0.05226083561943362
]
std = [
0.15201123862047256, 0.14087982537762958, 0.139965362113942,
0.10123220339551285
]
transform['train'] = transforms.Compose([
transforms.RandomAffine(20, shear=20, resample=PIL.Image.BILINEAR),
#transforms.RandomRotation(20),
transforms.RandomResizedCrop(512),
transforms.RandomHorizontalFlip(),
transforms.RandomVerticalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean, std)
])
transform['val'] = transforms.Compose([
transforms.Resize(570),
transforms.CenterCrop(512),
transforms.ToTensor(),
transforms.Normalize(mean, std)
])
from torch import classes
from torchvision.transforms import transforms
def imshow(img):
img = img / 2 + 0.5 # unnormalize
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
plt.show()
if __name__ == '__main__':
transform = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.RandomAffine(5,
translate=(2 / 32, 2 / 32),
scale=(0.95, 1.05),
resample=PIL.Image.NEAREST),
transforms.ToTensor(),
transforms.RandomChoice([
transforms.Normalize((0.5, 0.5, 0.5), (0.9, 0.9, 0.9)),
transforms.Normalize((0.5, 0.5, 0.5), (0.7, 0.7, 0.7)),
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',
def RandomAffine(self, **args):
return self._add(transforms.RandomAffine(**args))
r = args.random
train_transforms = transforms.Compose([
transforms.ToTensor(),
#transforms.RandomApply([
# transforms.GaussianBlur(3, sigma=(0.1, 2.0))
#], p=0.2),
transforms.RandomApply(
[transforms.Grayscale(num_output_channels=3)], p=0.2),
transforms.RandomApply([
transforms.ColorJitter(brightness=r,
contrast=r,
saturation=r,
hue=r)
]),
transforms.RandomApply(
[transforms.RandomAffine(r * 10, shear=r * 10)]),
transforms.RandomResizedCrop((32, 32), scale=(1 - r, 1.0)),
transforms.RandomHorizontalFlip(p=0.5),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
])
test_transforms = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
else:
train_transforms = transforms.ToTensor()
test_transforms = transforms.ToTensor()
# LOADING DATA
dataname = args.dataset
if dataname == "mnist":
import cv2
from torchvision.transforms import transforms
from torchvision.transforms.transforms import RandomAffine, RandomPerspective, RandomRotation, RandomVerticalFlip, ToPILImage
CLASSES = ("glass", "paper", "cardboard", "plastic", "metal", "trash")
testTransform = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(mean=(104, 117, 123), std=(57.4, 57.1, 58.4)),
])
augmentTransform = transforms.Compose([
transforms.ToPILImage(),
transforms.RandomAffine(degrees=5, shear=10),
transforms.RandomRotation(degrees=[90, 270]),
transforms.RandomVerticalFlip(),
transforms.RandomHorizontalFlip(),
transforms.RandomPerspective(),
# transforms.RandomCrop((300,300)),
])
trainTransform = transforms.Compose([
*augmentTransform.transforms,
*testTransform.transforms[1:] # Exclude PIL image conversion
# transforms.Resize((224, 224)),
# transforms.ToTensor(),
# transforms.Normalize(mean=(104, 117, 123), std=(57.4, 57.1, 58.4)),
])
@Author : Xiaoqi Cheng
@Time : 2021/1/15 19:40
"""
import torch, os, cv2
from torch.utils.data import Dataset, DataLoader
from torchvision.transforms import transforms
import matplotlib.pyplot as plt
from PIL import Image
import numpy as np
import random
ImgResize = (1024, 1280) # image size
# %% Data augmentation
TrainImgTransform = transforms.Compose([
transforms.RandomAffine(degrees=(-10, 10),
translate=(0.1, 0.1),
scale=(0.5, 2.),
shear=10),
transforms.RandomHorizontalFlip(),
transforms.RandomVerticalFlip(),
transforms.RandomResizedCrop(ImgResize,
scale=(1., 1.),
interpolation=Image.BILINEAR),
transforms.ToTensor(),
transforms.Normalize(mean=[0.46], std=[0.10]),
])
TrainLabelTransform = transforms.Compose([
transforms.RandomAffine(degrees=(-10, 10),
translate=(0.1, 0.1),
scale=(0.5, 2.),
shear=10),
transforms.RandomHorizontalFlip(),
val_dataset = torch.utils.data.Subset(my_dataset, mask)
mask = list(
range(num_training + num_validation,
num_training + num_validation + num_test))
test_dataset = torch.utils.data.Subset(my_dataset, mask)
data_aug_transforms = []
# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
if data_aug == True:
transformsList = [
# transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.RandomRotation(15),
transforms.RandomAffine(degrees=0, translate=(.3, .7)),
# transforms.ColorJitter(
# brightness=float(0.1*np.random.rand(1)),
# contrast=float(0.1*np.random.rand(1)),
# saturation=float(0.1*np.random.rand(1)),
# hue=float(0.1*np.random.rand(1))),
#transforms.RandomGrayscale(p=0.1)
]
data_aug_transforms = transformsList
data_aug_transforms = transforms.RandomApply(transformsList, p=0.5)
# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
# norm_transform = transforms.Compose([data_aug_transforms]+[transforms.ToTensor()])
# test_transform = transforms.Compose([transforms.ToTensor()])
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
