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)