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_simclr_data_transforms_train(dataset_name):
if dataset_name == "stl10":
input_shape = (96, 96, 3)
s = 1
# get 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)
return transforms.Compose([
transforms.RandomResizedCrop(size=input_shape[0]),
transforms.RandomHorizontalFlip(),
transforms.RandomApply([color_jitter], p=0.8),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(kernel_size=int(0.1 * input_shape[0])),
transforms.ToTensor()
])
elif dataset_name == "cifar10":
return transforms.Compose([
transforms.RandomResizedCrop(32),
transforms.RandomHorizontalFlip(p=0.5),
transforms.RandomApply(
[transforms.ColorJitter(0.4, 0.4, 0.4, 0.1)], p=0.8),
transforms.RandomGrayscale(p=0.2),
transforms.ToTensor(),
transforms.Normalize([0.4914, 0.4822, 0.4465],
[0.2023, 0.1994, 0.2010])
])
else:
raise RuntimeError(f"unknown dataset: {dataset_name}")
def __init__(self):
self.transform = transforms.Compose([
transforms.RandomResizedCrop(224, interpolation=Image.BICUBIC),
transforms.RandomHorizontalFlip(p=0.5),
transforms.RandomApply([
transforms.ColorJitter(
brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1)
],
p=0.8),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(p=1.0),
Solarization(p=0.0),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
self.transform_prime = transforms.Compose([
transforms.RandomResizedCrop(224, interpolation=Image.BICUBIC),
transforms.RandomHorizontalFlip(p=0.5),
transforms.RandomApply([
transforms.ColorJitter(
brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1)
],
p=0.8),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(p=0.1),
Solarization(p=0.2),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
def train_dataloader(self):
train_transforms = transforms.Compose([
transforms.RandomResizedCrop(size=(36, 60), scale=(0.5, 1.3)),
transforms.RandomPerspective(distortion_scale=0.2),
transforms.RandomGrayscale(p=0.1),
transforms.ColorJitter(brightness=0.5,
hue=0.2,
contrast=0.5,
saturation=0.5), lambda x: x
if np.random.random_sample() <= 0.1 else x.filter(
ImageFilter.GaussianBlur(radius=2)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
data_train = RTBENEH5Dataset(h5_pth=self.hparams.dataset,
subject_list=self._train_subjects,
transform=train_transforms,
loader_desc="train")
return DataLoader(data_train,
batch_size=self.hparams.batch_size,
shuffle=True,
num_workers=self.hparams.num_io_workers,
pin_memory=True)
def get_query_transforms(image_set):
if image_set == 'train':
# SimCLR style augmentation
return transforms.Compose([
transforms.Resize((128, 128)),
transforms.RandomApply(
[
transforms.ColorJitter(0.4, 0.4, 0.4,
0.1) # not strengthened
],
p=0.8),
transforms.RandomGrayscale(p=0.2),
transforms.RandomApply([GaussianBlur([.1, 2.])], p=0.5),
transforms.ToTensor(),
# transforms.RandomHorizontalFlip(), HorizontalFlip may cause the pretext too difficult, so we remove it
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
if image_set == 'val':
return transforms.Compose([
transforms.Resize((128, 128)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
raise ValueError(f'unknown {image_set}')
def train_dataloader(self):
_train_transforms = None
if self.hparams.augment:
_train_transforms = transforms.Compose([
transforms.RandomResizedCrop(size=(36, 60), scale=(0.5, 1.3)),
transforms.RandomGrayscale(p=0.1),
transforms.ColorJitter(brightness=0.5,
hue=0.2,
contrast=0.5,
saturation=0.5), lambda x: x
if np.random.random_sample() <= 0.1 else x.filter(
ImageFilter.GaussianBlur(radius=3)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
_data_train = RTGENEH5Dataset(h5_file=h5py.File(self.hparams.hdf5_file,
mode="r"),
subject_list=self._train_subjects,
transform=_train_transforms)
return DataLoader(_data_train,
batch_size=self.hparams.batch_size,
shuffle=True,
num_workers=self.hparams.num_io_workers,
pin_memory=False)
def train_dataloader(self):
_train_transforms: None = None
if self.hparams.augment:
_train_transforms = transforms.Compose([
transforms.RandomResizedCrop(size=(224, 224),
scale=(0.85, 1.0)),
transforms.RandomGrayscale(p=0.08),
# lambda x: x if np.random.random_sample() > 0.08 else x.filter(ImageFilter.GaussianBlur(radius=1)),
# lambda x: x if np.random.random_sample() > 0.08 else x.filter(ImageFilter.GaussianBlur(radius=3)),
self.gaussianBlur1,
self.gaussianBlur3,
transforms.Resize((224, 224), Image.BICUBIC),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
_data_train = RTGENEH5Dataset(h5_file=h5pickle.File(
self.hparams.hdf5_file, mode="r"),
subject_list=self._train_subjects,
transform=_train_transforms)
return DataLoader(_data_train,
batch_size=self.hparams.batch_size,
shuffle=True,
num_workers=self.hparams.num_io_workers,
pin_memory=False)
def Transforms(Input_Dim, S=1):
Color_Jitter = transforms.ColorJitter(0.8 * S, 0.8 * S, 0.8 * S, 0.2 * S)
Data_Transforms = transforms.Compose([
transforms.RandomResizedCrop(size=Input_Dim[0]),
transforms.RandomHorizontalFlip(),
transforms.RandomApply([Color_Jitter], p=0.75),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(int(0.1 * Input_Dim[0])),
transforms.ToTensor(),
])
return Data_Transforms
def get_simclr_transform(size, s=1):
"""Return a set of data augmentation transformations as described in the SimCLR paper."""
color_jitter = transforms.ColorJitter(0.1 * s, 0.8 * s, 0.2 * s, 0 * s)
data_transforms = transforms.Compose(
[ #transforms.RandomResizedCrop(size=size),
transforms.RandomHorizontalFlip(),
transforms.RandomApply([color_jitter], p=1),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(kernel_size=int(0.1 * size)),
transforms.ToTensor()
])
return data_transforms
def get_simclr_data_transforms(input_shape, s=1):
# get 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)
data_transforms = transforms.Compose([
transforms.RandomResizedCrop(size=eval(input_shape)[0]),
transforms.RandomHorizontalFlip(),
transforms.RandomApply([color_jitter], p=0.8),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(kernel_size=int(0.1 * eval(input_shape)[0])),
transforms.ToTensor()
])
return data_transforms
def get_simclr_pipeline_transform(size, s=1):
"""transforms can be improved to match well with SimCLR paper. this doesnt seem to be exactly what paper says. can try more transforms as well"""
color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s,
0.2 * s) #
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()
])
return data_transforms
def get_simclr_transform(size, s=1):
"""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)
data_transforms = transforms.Compose([
transforms.Resize(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(),
transforms.Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225))
])
return data_transforms
def get_simclr_data_transforms(input_shape, s=1):
# get a set of data augmentation transformations as described in the SimCLR paper.
normalize = transforms.Normalize(mean=(0.4914, 0.4822, 0.4465),
std=(0.2023, 0.1994, 0.2010))
color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s, 0.2 * s)
data_transforms = transforms.Compose([
transforms.RandomResizedCrop(size=eval(input_shape)[0],
scale=(0.2, 1.)),
transforms.RandomHorizontalFlip(),
transforms.RandomApply([color_jitter], p=0.8),
transforms.RandomGrayscale(p=0.2),
#GaussianBlur(kernel_size=int(0.1 * eval(input_shape)[0])),
transforms.ToTensor(),
normalize
])
return data_transforms
def get_simclr_pipeline_transform(size, s=1):
"""
Returns a set of data augmentation transformations
"""
color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s,
0.2 * s)
data_transforms = transforms.Compose([
transforms.RandomResizedCrop(size),
transforms.RandomHorizontalFlip(),
transforms.RandomApply([color_jitter], p=0.8),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(kernel_size=int(0.1 * size)),
transforms.ToTensor(),
])
return data_transforms
def __init__(self, data_dir, batch_size, labeled_percents=20):
self.mean = [0.485, 0.456, 0.406]
self.std = [0.229, 0.224, 0.225]
self.train_path = os.path.join(data_dir, "train")
self.classes = []
for d in os.listdir(self.train_path):
if ".txt" not in d:
self.classes.append(d)
self.transform = T.Compose([
T.Resize((128, 128), interpolation=2),
T.RandomRotation(45),
T.RandomVerticalFlip(),
T.RandomGrayscale(),
T.RandomSizedCrop((112, 112)),
T.ToTensor(),
T.Normalize(self.mean, self.std)
])
self.paths = []
self.true_labels = []
self.true_idxs = []
self.relabeled = []
self.labeled_idxs = []
self.unlabeled_idxs = []
ck = 0
last_cls = None
for i, c in enumerate(self.classes):
for file in list(
glob.glob(
os.path.join(self.train_path, os.path.join(c,
"*.*")))):
self.paths.append(file)
self.true_labels.append(c)
self.true_idxs.append(i)
self.relabeled.append(i)
unlabeled_limit = int(
(len(self.true_idxs) - ck) * labeled_percents)
for idx in range(ck, ck + unlabeled_limit):
self.relabeled[idx] = NO_LABEL
# collect indexes of labels both labeled and unlabeled
for i, l in enumerate(self.relabeled):
if l == -1:
self.unlabeled_idxs.append(i)
else:
self.labeled_idxs.append(i)
def get_image_dataloader(path_to_data, batch_size=16):
my_transforms = transforms.Compose([
transforms.ToTensor(),
transforms.ToPILImage(),
transforms.RandomHorizontalFlip(),
transforms.RandomGrayscale(),
transforms.RandomRotation([-30, 30]),
# transforms.Normalize([],[]) # get mean and std
transforms.ToTensor(),
])
dataset = ImageFolder(root=path_to_data,
transform=my_transforms,
is_valid_file=check_valid)
print(len(dataset.classes))
dataloader = DataLoader(dataset=dataset,
batch_size=batch_size,
shuffle=True)
return dataloader, dataset
def get_simclr_pipeline_transform(size, s=1, channels=3):
"""Return a set of data augmentation transformations as described in the SimCLR paper."""
#Original
color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s, 0.2 * s)
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), channels=channels),
transforms.ToTensor()])
# data_transforms = transforms.Compose([iaa.Sequential([iaa.SomeOf((1, 5),
# [iaa.LinearContrast((0.5, 1.0)),
# iaa.GaussianBlur((0.5, 1.5)),
# iaa.Crop(percent=((0, 0.4),(0, 0),(0, 0.4),(0, 0.0)), keep_size=True),
# iaa.Crop(percent=((0, 0.0),(0, 0.02),(0, 0),(0, 0.02)), keep_size=True),
# iaa.Sharpen(alpha=(0.0, 0.5), lightness=(0.0, 0.5)),
# iaa.PiecewiseAffine(scale=(0.02, 0.03), mode='edge'),
# iaa.PerspectiveTransform(scale=(0.01, 0.02))],
# random_order=True)]).augment_image,
# transforms.ToTensor()])
return data_transforms
def DataModule(batch_size, ks, imagenet_stats):
# https://github.com/fastai/imagenette
# Define parameters for dataset construction:
dataset_url = 'https://s3.amazonaws.com/fast-ai-imageclas/imagenette2.tgz'
dataset_filename = dataset_url.split('/')[-1]
dataset_foldername = dataset_filename.split('.')[0]
data_path = './data'
dataset_filepath = os.path.join(data_path, dataset_filename)
dataset_folderpath = os.path.join(data_path, dataset_foldername)
os.makedirs(data_path,
exist_ok=True) # Create a data folder (@ project folder)
# If data does not exist, download it from specified URL:
download = False
if not os.path.exists(dataset_filepath):
download = True
else:
md5_hash = hashlib.md5()
file = open(dataset_filepath, "rb")
content = file.read()
md5_hash.update(content)
digest = md5_hash.hexdigest()
if digest != 'fe2fc210e6bb7c5664d602c3cd71e612':
download = True
if download:
download_url(dataset_url, data_path)
# Extract tar file containing dataset examples
with tarfile.open(dataset_filepath, 'r:gz') as tar:
tar.extractall(path=data_path)
# Define model-input transforms for data augmentation:
train_transform = TwoCropsTransform(
transforms.Compose([
transforms.RandomResizedCrop(scale=(0.2, 1), size=224),
transforms.RandomHorizontalFlip(),
transforms.RandomApply(
[transforms.ColorJitter(0.8, 0.8, 0.8, 0.2)], p=0.8),
transforms.RandomGrayscale(p=0.2),
# transforms.GaussianBlur(kernel_size=ks),
transforms.ToTensor(),
transforms.Normalize(**imagenet_stats)
]))
# Define train and val dataset wrappers:
dataset_train = torchvision.datasets.ImageFolder(
os.path.join(dataset_folderpath, 'train'), train_transform)
dataset_validation = torchvision.datasets.ImageFolder(
os.path.join(dataset_folderpath, 'val'), train_transform)
# Define train and val dataloaders:
train_dataloader = torch.utils.data.DataLoader(
dataset_train,
batch_size=batch_size,
num_workers=8,
drop_last=True,
shuffle=True,
)
validation_dataloader = torch.utils.data.DataLoader(
dataset_validation,
batch_size=batch_size,
num_workers=8,
drop_last=True,
shuffle=True,
)
return train_dataloader, validation_dataloader, transforms
transforms.RandomResizedCrop((384, 768), scale=(0.5, 2.), interpolation=0),
transforms.RandomHorizontalFlip(),
Relabel(run_cc=False),
transforms.ToTensor()
])
TEST_LABEL_TRANSFORM = transforms.Compose([
transforms.Resize(size=(384, 768), interpolation=Image.NEAREST),
Relabel(run_cc=False),
transforms.ToTensor()
])
EXTENDED_TRANSFORM = transforms.Compose([
transforms.RandomApply([transforms.ColorJitter(0.4, 0.4, 0.4, 0.1)],
p=0.8),
transforms.RandomGrayscale(p=0.2),
GaussianBlur([.1, 2.]),
transforms.ToTensor(),
ImgNormalize()
])
class CityscapesDataset:
def __init__(self,
root_dir,
phase,
class_name,
instance_ratio=None,
spoco=False):
assert phase in ['train', 'val', 'test']
self.root_dir = root_dir
def RandomGrayscale(self, **args):
return self._add(transforms.RandomGrayscale(**args))
def __init__(self,
p: float = 0.5,
target_type: Optional[TargetType] = None):
super().__init__(target_type)
self._impl = VT.RandomGrayscale(p)
