def gettraintransforms(self, mean, std, p=1): # Train Phase transformations albumentations_transform = Compose([ # RandomRotate90(), PadIfNeeded(72, 72, border_mode=cv2.BORDER_REFLECT, always_apply=True), RandomCrop(64, 64, True), Flip(), GaussNoise(p=0.8, mean=mean), OneOf([ MotionBlur(p=0.4), MedianBlur(blur_limit=3, p=0.2), Blur(blur_limit=3, p=0.2), ], p=0.4), ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.6), OneOf([ OpticalDistortion(p=0.8), GridDistortion(p=0.4), ], p=0.6), HueSaturationValue(hue_shift_limit=20, sat_shift_limit=0.1, val_shift_limit=0.1, p=0.6), CoarseDropout(always_apply=True, max_holes=1, min_holes=1, max_height=16, max_width=16, fill_value=(255 * .6), min_height=16, min_width=16), Normalize(mean=mean, std=std, always_apply=True), pytorch.ToTensorV2(always_apply=True), ], p=p) return albumentations_transform;
def __init__(self, root="data/interim", transform=None, train=True, size=512): df = pd.read_csv(os.path.join(root, "train_val.csv")) df = df[df["is_train"].astype(np.bool) == train] self.filenames = [ os.path.join(root, f"train_data_{size}", path) for path in df["file_path"].values.tolist()] # Сheck that all images exist assert map(lambda x: pathlib.Path(x).exists(), self.filenames), "Found missing images!" self.targets = df["label"].values.tolist() self.ar = df["aspect_ratio"].values # For each aspect ration in `ar` find closest value from the # `_aspect_ratios` and return it's index (group) self.group_ids = np.argmin( np.abs(self._aspect_ratios.reshape(1, -1) - self.ar.reshape(-1, 1)), axis=1 ) self.sizes = [] for group in self.group_ids: ar = self._aspect_ratios[group] # Resize image to have `size` shape on smaller side and be devidable by 16 on another if ar <= 1: H = size W = int(size / ar) // 8 * 8 else: W = size H = int(size * ar) // 8 * 8 self.sizes.append((H, W)) logger.info(f"Using sizes {set(self.sizes)} for {'train'if train else 'validation'}") self.transform = albu.Compose([albu_pt.ToTensorV2()]) if transform is None else transform
def __init__(self, root="data/interim", transform=None, size=512, test_type="B"): df = pd.read_csv(os.path.join(root, "test_B.csv")) self.filenames = [ os.path.join(root, f"test_data_B_{size}", path) for path in df["file_path"].values.tolist()] # Сheck that all images exist assert map(lambda x: pathlib.Path(x).exists(), self.filenames), "Found missing images!" self.ar = df["aspect_ratio"].values self.size = size # For each aspect ration in `ar` find closest value from the # `_aspect_ratios` and return it's index (group) self.group_ids = np.argmin( np.abs(self._aspect_ratios.reshape(1, -1) - self.ar.reshape(-1, 1)), axis=1 ) self.sizes = [] for group in self.group_ids: ar = self._aspect_ratios[group] # Resize image to have `size` shape on smaller side and be devidable by 8 on another if ar <= 1: H = size W = int(size / ar) // 8 * 8 else: W = size H = int(size / ar) // 8 * 8 self.sizes.append((H, W)) self.transform = albu.Compose([albu_pt.ToTensorV2()]) if transform is None else transform
def get_transform(conf_augmentation): # For multi-channel mask additional_targets = { "mask0": "mask", "mask1": "mask", "mask2": "mask", "mask3": "mask", "mask4": "mask", } def get_object(trans): if trans.name in {"Compose", "OneOf"}: augs_tmp = [get_object(aug) for aug in trans.member] return getattr(alb, trans.name)(augs_tmp, **trans.params) if hasattr(alb, trans.name): return getattr(alb, trans.name)(**trans.params) else: return eval(trans.name)(**trans.params) if conf_augmentation is None: augs = list() else: augs = [get_object(aug) for aug in conf_augmentation] augs.append(albp.ToTensorV2()) return alb.Compose(augs, additional_targets=additional_targets)
def gettraintransforms(self, mean, std, p=1): # Train Phase transformations albumentations_transform = Compose([ RandomRotate90(), Flip(), GaussNoise(p=0.6, mean=mean), OneOf([ MotionBlur(p=0.2), MedianBlur(blur_limit=3, p=0.1), Blur(blur_limit=3, p=0.1), ], p=0.2), ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.3), OneOf([ OpticalDistortion(p=0.4), GridDistortion(p=0.2), ], p=0.3), HueSaturationValue(hue_shift_limit=20, sat_shift_limit=0.1, val_shift_limit=0.1, p=0.3), Cutout(always_apply=True, num_holes=2, max_h_size=10, max_w_size=10, fill_value=(255 * .6)), Normalize(mean=mean, std=std, always_apply=True), pytorch.ToTensorV2(always_apply=True), ], p=p) return albumentations_transform
def __init__(self, dataset_path, phase ): self.imgs, self.labels = load_dataset(dataset_path) if phase == "train": self.transform = A.Compose([A.RandomResizedCrop(224, 224, always_apply=True, p=1), A.HorizontalFlip(p=0.5), A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), Atorch.ToTensorV2()]) elif phase == "validation": self.transform = A.Compose([A.Resize(256, 256), A.CenterCrop(224, 224), A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), Atorch.ToTensorV2()])
def get_aug(aug_type="val", size=512): """Return augmentations by type Args: aug_type (str): one of `val`, `test`, `light`, `medium` size (int): final size of the crop """ NORM_TO_TENSOR = albu.Compose( [albu.Normalize(mean=MEAN, std=STD), albu_pt.ToTensorV2()]) # CROP_AUG = albu.Compose([albu.RandomCrop(size, size)]) VAL_AUG = albu.Compose([ # albu.CenterCrop(size, size), NORM_TO_TENSOR ]) LIGHT_AUG = albu.Compose( [ albu.Flip(), albu.Cutout(num_holes=12, max_h_size=size // 16, max_w_size=size // 16, fill_value=0, p=0.5), NORM_TO_TENSOR ], p=1.0, ) # aug from github.com/lyakaap/Landmark2019-1st-and-3rd-Place-Solution/ HARD_AUG = albu.Compose( [ albu.Flip(p=0.5), albu.IAAAffine(rotate=0.2, shear=0.2, mode='constant', p=0.5), albu.RandomBrightnessContrast( brightness_limit=0.3, contrast_limit=0.3, p=0.5), albu.MotionBlur(p=0.5), albu.CLAHE(p=0.5), albu.Cutout(num_holes=16, max_h_size=size // 16, max_w_size=size // 16, fill_value=0, p=0.5), RandomCropThenScaleToOriginalSize(limit=0.3, p=1.0), NORM_TO_TENSOR, ], p=1.0, ) types = { "val": VAL_AUG, "test": VAL_AUG, "light": LIGHT_AUG, "hard": HARD_AUG, } return types[aug_type]
def to_tensor_normalize() -> Transform: """ :return: Albumentations transform [imagenet normalization, to tensor] """ base_transform = albu.Compose([ albu.Normalize([0.4802, 0.4481, 0.3975], [0.2302, 0.2265, 0.2262], max_pixel_value=255), albu_pytorch.ToTensorV2(), ]) return base_transform
def transform_test(self, sample): """No random operation so that test set always keeps the same.""" composed_transform = albu.Compose([ # albu.resize(512, 1024, p=1), albu.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), albupt.ToTensorV2() ]) transformed = composed_transform(image=sample['image'], mask=sample['mask']) return transformed['image'], transformed['mask']
def transform_train(self, sample): composed_transform = albu.Compose([ albu.VerticalFlip(), albu.HorizontalFlip(), albu.Normalize( ), # different form torchvision.transforms, dtype shoud be uint8, /255 -mean /std albupt.ToTensorV2() ]) augmented = composed_transform(image=sample['image'], mask=sample['mask']) return augmented['image'], augmented['mask']
def __init__(self, root="data/raw", transform=None): self.images_root = os.path.join(root, self._folder, "images") # Read file mith DMOS and names self.df = pd.read_csv(os.path.join(root, self._folder, self._filename)) self.df.rename(columns={"dmos": "score"}, inplace=True) self.scores = self.df["score"].to_numpy() self.df['dist_type'] = self.df['dist_img'].apply(lambda x: x[4:-4]) if transform is None: self.transform = albu_pt.ToTensorV2() else: self.transform = transform
def build_transforms(second_stage): if second_stage: train_transforms = A.Compose([ #A.Flip(), #A.Rotate(), A.Resize(224, 224), A.Normalize(), AT.ToTensorV2() ]) valid_transforms = A.Compose( [A.Resize(224, 224), A.Normalize(), AT.ToTensorV2()]) transforms_dict = { "train_transforms": train_transforms, "valid_transforms": valid_transforms, } else: train_transforms = A.Compose([ A.RandomResizedCrop(height=224, width=224, scale=(0.15, 1.)), A.Rotate(), A.ColorJitter(0.4, 0.4, 0.4, 0.1, p=0.9), A.ToGray(p=0.2), A.Normalize(), AT.ToTensorV2(), ]) valid_transforms = A.Compose( [A.Resize(224, 224), A.Normalize(), AT.ToTensorV2()]) transforms_dict = { "train_transforms": train_transforms, 'valid_transforms': valid_transforms, } return transforms_dict
def __init__(self, root="data/raw/tid2013", transform=None): self.df = pd.read_csv(os.path.join(root, self._filename), sep=' ', names=['score', 'dist_img'], header=None) self.df["ref_img"] = self.df["dist_img"].apply( lambda x: (x[:3] + x[-4:]).upper()) self.df['dist_type'] = self.df['dist_img'].apply(lambda x: x[4:-4]) self.scores = self.df['score'].to_numpy() self.root = root if transform is None: self.transform = albu_pt.ToTensorV2() else: self.transform = transform
def get_transform(conf_augmentation, img_height, img_width): def get_object(trans): if trans.name in {'Compose', 'OneOf'}: augs_tmp = [get_object(aug) for aug in trans.member] return getattr(alb, trans.name)(augs_tmp, **trans.params) if hasattr(alb, trans.name): return getattr(alb, trans.name)(**trans.params) else: return eval(trans.name)(**trans.params) if conf_augmentation is None: augs = list() else: augs = [get_object(aug) for aug in conf_augmentation] augs.extend([ alb.Resize(height=img_height, width=img_width), albp.ToTensorV2() ]) return alb.Compose(augs)
IMAGE_SIZE = 512 train_transform_randaug = albumentations.Compose([ albumentations.Resize(IMAGE_SIZE, IMAGE_SIZE), albumentations.RandomRotate90( p=0.5), # albumentations.SafeRotate(border_mode=1, p=0.5), albumentations.Transpose(p=0.5), albumentations.Flip(p=0.5), randAugment(), albumentations.Normalize(), albumentations.Cutout(num_holes=8, max_h_size=IMAGE_SIZE // 8, max_w_size=IMAGE_SIZE // 8, fill_value=0, p=0.25), AT.ToTensorV2(), ]) train_transform = albumentations.Compose([ albumentations.Resize(IMAGE_SIZE, IMAGE_SIZE), albumentations.RandomRotate90(p=0.5), albumentations.Transpose(p=0.5), albumentations.Flip(p=0.5), albumentations.OneOf([ albumentations.RandomBrightness(0.2, p=1), albumentations.RandomContrast(0.2, p=1), albumentations.HueSaturationValue( hue_shift_limit=15, sat_shift_limit=20, val_shift_limit=15, p=1), ], p=0.5), albumentations.OneOf([
configs = read_parameters() device = get_device() transform = A.Compose([ A.Resize(256, 256, p = 1), A.OneOf([ A.Blur(p = 1), A.RandomGamma(p = 1), A.RandomBrightness(p = 1), A.RandomContrast(p = 1), ]), A.OneOf([ A.VerticalFlip(p = 1), ]), A.CoarseDropout(p = 0.5), A.Normalize(p = 1), pytorch.ToTensorV2() ]) transform_val_test = A.Compose([ A.Resize(height = 256, width = 256, p = 1.0), A.Normalize(p = 1.0), pytorch.ToTensorV2(), ]) KF = StratifiedKFold() for train, val in KF.split(df["labels"].values, df["classes"].values): x_train, x_val = np.array(df["labels"].values)[train], np.array(df["labels"].values)[val] y_train, y_val = np.array(df["classes"].values)[train], np.array(df["classes"].values)[val], train_loader, val_loader = generate_train_validation_dataloader(x_train, y_train, transform, x_val, y_val,
def transform(self, image, mask): if self.color_aug: transforms = A.Compose([ A.Resize(self.img_size, self.img_size), A.OneOf( [ A.IAAAdditiveGaussianNoise(), A.GaussNoise(var_limit=(100, 200)), A.JpegCompression(quality_lower=75, p=0.2), ], p=0.3, ), A.OneOf( [ A.MotionBlur(blur_limit=10, p=0.2), A.MedianBlur(blur_limit=11, p=0.1), A.Blur(blur_limit=11, p=0.1), ], p=0.3, ), A.ShiftScaleRotate(shift_limit=0, scale_limit=(-0.1, 0.4), rotate_limit=5, p=0.6), A.Cutout(num_holes=8, max_h_size=48, max_w_size=48, p=0.3), A.OneOf( [ A.CLAHE(clip_limit=4), A.IAASharpen(), A.IAAEmboss(), A.RandomBrightnessContrast(), ], p=0.5, ), A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=50, val_shift_limit=50, p=0.5), ]) else: transforms = A.Compose([ A.Resize(self.img_size, self.img_size), ]) image_norm_and_to_tensor = A.Compose([ A.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]), AT.ToTensorV2(transpose_mask=True), ]) mask_norm_and_to_tensor = A.Compose([ A.Normalize(mean=[0.0, 0.0, 0.0], std=[1, 1, 1]), AT.ToTensorV2(transpose_mask=True), ]) transform_pair = transforms(image=image, mask=mask) transform_image = transform_pair["image"] transform_mask = transform_pair["mask"] transform_image = image_norm_and_to_tensor( image=transform_image)["image"] transform_mask = mask_norm_and_to_tensor(image=transform_mask)["image"] return transform_image, transform_mask
def gettesttransforms(self, mean, std): # Test Phase transformations return Compose([ Normalize(mean=mean, std=std, always_apply=True), pytorch.ToTensorV2(always_apply=True), ])
def __init__(self): self.params = { "entity": "ugurgudelek", "project": "sample-project", "experiment": "mnist", "seed": 42, "device": torch.device("cpu") if not torch.cuda.is_available() else torch.device(type="cuda", index=cuda_ops.get_free_gpu()), "resume": False, "pretrained": False, "checkpoint": { "metric": metrics.Accuracy.__name__.lower(), "trigger": lambda new, old: new > old }, "log": { "on_epoch": 1, }, "stdout": { "verbose": True, "on_epoch": 1, "on_batch": 10 }, "validate_epoch_0": True, "root": Path("./"), } self.hyperparams = { "lr": 0.001, "batch_size": 1000, "validation_batch_size": 1000, "epoch": 50, } self.dataset = MNIST( root="./input/", transform=A.Compose([ # A.ShiftScaleRotate(shift_limit=0.05, # scale_limit=0.05, # rotate_limit=15, # p=0.5), # A.HorizontalFlip(p=0.5), # A.RandomBrightnessContrast(p=0.2), A.Normalize(mean=(0.1307, ), std=(0.3081, )), Ap.ToTensorV2(), ]), ) # self.dataset.trainset = self.dataset.trainset.get_first_n_sample(200) # self.dataset.testset = self.dataset.testset.get_first_n_sample(100) self.model = CNN(in_channels=1, out_channels=10, input_dim=(1, 28, 28)) self.logger = logger( project=self.params["project"], entity=self.params["entity"], config=self.params | self.hyperparams, ) self.logger.watch(self.model) self.optimizer = Adam( params=self.model.parameters(), lr=self.hyperparams.get("lr", 0.001), weight_decay=self.hyperparams.get("weight_decay", 0), ) # Decay LR by a factor of 0.1 every 7 epochs self.exp_lr_scheduler = lr_scheduler.StepLR(self.optimizer, step_size=7, gamma=0.1, verbose=True) self.trainer = CNNTrainer( model=self.model, criterion=nn.CrossEntropyLoss(reduction="none"), optimizer=self.optimizer, scheduler=self.exp_lr_scheduler, metrics=[torchmetrics.Accuracy()], hyperparams=self.hyperparams, params=self.params, logger=self.logger, )
def get_aug(aug_type: str = "val", task: str = "denoise", dataset: str = "cifar100", size: int = 64): """ Args: aug_type: {`val`, `test`, `light`, `medium`} task: {"denoise", "deblur", "sr"} dataset: Name of dataset to get MEAN and STD size: final size of the crop """ assert aug_type in ["val", "test", "light", "medium"] # Add the same noise for all channels for single-channel images mean, std, max_value = MEAN_STD_BY_NAME[dataset] if dataset == "medicaldecathlon": singlechannel = True normalization = albu.NoOp() noise = GaussNoiseNoClipping( singlechannel, var_limit=0.1, ) else: singlechannel = False normalization = albu.Normalize(mean=mean, std=std, max_pixel_value=max_value) noise = albu.MultiplicativeNoise(multiplier=(0.75, 1.25), per_channel=True, elementwise=True) NORM_TO_TENSOR = albu.Compose( [normalization, albu_pt.ToTensorV2()], additional_targets={"mask": "image"}) CROP_AUG = albu.Compose([ albu.PadIfNeeded(size, size), albu.RandomResizedCrop(size, size, scale=(0.5, 1.)), ]) if task == "deblur": TASK_AUG = albu.OneOf( [ albu.Blur(blur_limit=(3, 5)), albu.GaussianBlur(blur_limit=(3, 5)), # albu.MotionBlur(), # albu.MedianBlur(), # albu.GlassBlur(), ], p=1.0) elif task == "denoise": # TASK_AUG = noise TASK_AUG = albu.OneOf( [ noise, # albu.GaussNoise(), # GaussNoiseNoClipping(singlechannel, var_limit=0.1 if singlechannel else (20., 50.)), # albu.GlassBlur(), # albu.ISONoise(), # albu.MultiplicativeNoise(), ], p=1.0) elif task == "sr": TASK_AUG = albu.Downscale(scale_min=0.5, scale_max=0.5, interpolation=cv2.INTER_CUBIC, always_apply=True) else: raise ValueError("Name of task must be in {'deblur', 'denosie', 'sr'}") VAL_AUG = albu.Compose([ albu.PadIfNeeded(size, size), albu.CenterCrop(size, size), TASK_AUG, NORM_TO_TENSOR, ]) LIGHT_AUG = albu.Compose([ CROP_AUG, TASK_AUG, NORM_TO_TENSOR, ]) MEDIUM_AUG = albu.Compose([ albu.Flip(), albu.RandomRotate90(), CROP_AUG, TASK_AUG, NORM_TO_TENSOR ]) types = { "val": VAL_AUG, "light": LIGHT_AUG, "medium": MEDIUM_AUG, } return types[aug_type]