def get_augments(image_height, image_width): train_transform = A.Compose([ A.PadIfNeeded(min_height=image_height, min_width=image_width, always_apply=True, border_mode=0), A.CropNonEmptyMaskIfExists( image_height, image_width, always_apply=True, ), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), ToTensorV2(transpose_mask=True) ]) val_transform = A.Compose([ A.PadIfNeeded(min_height=image_height, min_width=image_width, always_apply=True, border_mode=0), A.CropNonEmptyMaskIfExists(image_height, image_width), ToTensorV2(transpose_mask=True) ]) test_transform = A.Compose([ToTensorV2(transpose_mask=True)]) return (train_transform, val_transform, test_transform)
def __init__(self, path, _, autoaugment): self.imgs_pre, self.lbls_pre = load_data(path, "pre") self.imgs_post, self.lbls_post = load_data(path, "post") assert len(self.imgs_pre) == len(self.imgs_post) assert len(self.imgs_post) == len(self.lbls_post) data_frame = pd.read_csv("/workspace/xview2/utils/index.csv") self.idx = [] self.idx.extend( data_frame[data_frame["1"] == 1]["idx"].values.tolist()) self.idx.extend( data_frame[data_frame["2"] == 1]["idx"].values.tolist()) self.idx.extend( data_frame[data_frame["3"] == 1]["idx"].values.tolist()) self.idx.extend( data_frame[data_frame["4"] == 1]["idx"].values.tolist()) self.idx = sorted(list(set(self.idx))) self.crop = A.CropNonEmptyMaskIfExists(p=1, width=512, height=512) self.zoom = A.RandomScale(p=0.2, scale_limit=(0, 0.3), interpolation=cv2.INTER_CUBIC) self.hflip = A.HorizontalFlip(p=0.33) self.vflip = A.VerticalFlip(p=0.33) self.noise = A.GaussNoise(p=0.1) self.brctr = A.RandomBrightnessContrast(p=0.2) self.normalize = A.Normalize() self.use_autoaugment = autoaugment if self.use_autoaugment: self.autoaugment = ImageNetPolicy()
def get_transform(mode='train', H=384, W=576): if mode == 'train': transform = A.Compose([ A.Flip(p=.5), A.OneOf([ A.CLAHE(clip_limit=2, p=.5), A.IAASharpen(p=.25), ], p=.35), A.OneOf( [A.RandomBrightness(), A.RandomContrast(), A.RandomGamma()], p=.3), A.OneOf([ A.ElasticTransform( alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), A.GridDistortion(), A.OpticalDistortion(distort_limit=2, shift_limit=0.5), ], p=.3), A.ShiftScaleRotate(scale_limit=0.2, rotate_limit=0, shift_limit=0, border_mode=0, p=.5), A.CropNonEmptyMaskIfExists(height=int(1400 * .9), width=int(2100 * .9), p=.5), A.Resize(H, W), ToTensor() ]) else: transform = A.Compose([A.Resize(352, 544), ToTensor()]) return transform
def __build_augmentator(self): return albu.Compose([ albu.CropNonEmptyMaskIfExists(height=self.height, width=self.width, p=1.0), albu.OneOf([ albu.VerticalFlip(p=0.5), albu.HorizontalFlip(p=0.5), ], p=0.5), ], p=self.p)
def data_mask_crop1(): return A.Compose([ A.HorizontalFlip(p=0.5), A.RandomBrightnessContrast(brightness_limit=0.15, contrast_limit=0.2, p=0.5), A.CropNonEmptyMaskIfExists(height=200, width=200), A.Resize(256, 256), ToTensorV2() ])
def crop_transform(image_size: Tuple[int, int], min_scale=0.75, max_scale=1.25, input_size=5000): return A.OneOrOther( A.RandomSizedCrop( (int(image_size[0] * min_scale), int(min(input_size, image_size[0] * max_scale))), image_size[0], image_size[1], ), A.CropNonEmptyMaskIfExists(image_size[0], image_size[1]), )
def data_mask_crop3(): return A.Compose([ A.HorizontalFlip(p=0.5), A.ShiftScaleRotate(), A.RandomBrightnessContrast(brightness_limit=0.15, contrast_limit=0.2, p=0.5), A.CropNonEmptyMaskIfExists(height=256, width=256), A.Resize(512, 512), A.VerticalFlip(p=0.5), ToTensorV2() ])
def crop_transform_xview2(image_size: Tuple[int, int], min_scale=0.4, max_scale=0.75, input_size=1024): return A.OneOrOther( A.RandomSizedCrop( (int(image_size[0] * min_scale), int(min(input_size, image_size[0] * max_scale))), image_size[0], image_size[1], ), A.Compose( [A.Resize(input_size * 2, input_size * 2), A.CropNonEmptyMaskIfExists(image_size[0], image_size[1])] ), )
def __build_augmentator(self): return albu.Compose([ albu.CropNonEmptyMaskIfExists(height=self.height, width=self.width, p=1.0), albu.ShiftScaleRotate(shift_limit=0.15, scale_limit=0.15, p=0.6), albu.PadIfNeeded(256, 256), albu.OneOf([ albu.VerticalFlip(p=0.5), albu.HorizontalFlip(p=0.5), ], p=0.5), albu.RandomBrightnessContrast(0.1, 0.1), # albu.RandomGamma() ], p=self.p)
def get_cc_training_augmentation(): train_transform = [ A.CropNonEmptyMaskIfExists(height=640, width=640, always_apply=True), A.Resize(height=256, width=256), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.PadIfNeeded(min_height=256, min_width=256, always_apply=True, border_mode=0), ] return A.Compose(train_transform)
def data_mask_crop4(): return A.Compose([ A.HorizontalFlip(p=0.5), A.ShiftScaleRotate(), A.RandomBrightnessContrast(brightness_limit=0.15, contrast_limit=0.2, p=0.5), A.OneOf([ A.RandomResizedCrop(512,512,scale = (0.5,0.8),p=0.8), A.CropNonEmptyMaskIfExists(height=300, width=300, p=0.2), ], p=0.5), A.Resize(512, 512), A.VerticalFlip(p=0.5), ToTensorV2() ])
def data_clahe(): return A.Compose([ A.CLAHE(), A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), A.HorizontalFlip(p=0.5), A.ShiftScaleRotate(), A.RandomBrightnessContrast(brightness_limit=0.15, contrast_limit=0.2, p=0.5), A.OneOf([ A.RandomResizedCrop(512,512,scale = (0.5,0.8),p=0.8), A.CropNonEmptyMaskIfExists(height=300, width=300, p=0.2), ], p=0.5), A.Resize(512, 512), A.VerticalFlip(p=0.5), ToTensorV2() ])
def val(): transform = A.Compose([ A.SmallestMaxSize(520), A.CropNonEmptyMaskIfExists( 360, 360, ignore_values=[ 0, ], ), A.HorizontalFlip(), ToTensorV2(), ]) return ADE20K("val", transform=transform)
def hard_transforms(crop_size=512): return albu.Compose([ albu.ShiftScaleRotate(shift_limit=0, scale_limit=0.1, rotate_limit=180, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0), albu.CropNonEmptyMaskIfExists(crop_size, crop_size, p=1), albu.RandomShadow(shadow_roi=(0, 0, 1, 1), num_shadows_lower=1, num_shadows_upper=4, shadow_dimension=7, always_apply=False, p=0.5), albu.HueSaturationValue(p=0.3), albu.OneOf([ albu.IAAAdditiveGaussianNoise(), albu.GaussNoise(), albu.MultiplicativeNoise( multiplier=[0.5, 1.5], per_channel=True, p=1) ], p=0.3), albu.OneOf([ albu.MotionBlur(p=0.2), albu.MedianBlur(blur_limit=3, p=0.1), albu.Blur(blur_limit=3, p=0.1), ], p=0.2), albu.OneOf([ albu.CLAHE(clip_limit=2), albu.IAASharpen(), albu.IAAEmboss(), albu.RandomBrightnessContrast( brightness_limit=0.2, contrast_limit=0.2, p=0.3), albu.RandomGamma(gamma_limit=(85, 115), p=0.3), ], p=0.3), albu.JpegCompression(quality_lower=40, quality_upper=100, p=0.5), albu.Cutout( num_holes=25, max_h_size=5, max_w_size=5, fill_value=0, p=0.3), ], p=1)
def test_crop_non_empty_mask(): def _test_crop(mask, crop, aug, n=1): for _ in range(n): augmented = aug(image=mask, mask=mask) np.testing.assert_array_equal(augmented["image"], crop) np.testing.assert_array_equal(augmented["mask"], crop) # test general case mask_1 = np.zeros([10, 10]) mask_1[0, 0] = 1 crop_1 = np.array([[1]]) aug_1 = A.CropNonEmptyMaskIfExists(1, 1) # test empty mask mask_2 = np.zeros([10, 10]) crop_2 = np.array([[0]]) aug_2 = A.CropNonEmptyMaskIfExists(1, 1) # test ignore values mask_3 = np.ones([2, 2]) mask_3[0, 0] = 2 crop_3 = np.array([[2]]) aug_3 = A.CropNonEmptyMaskIfExists(1, 1, ignore_values=[1]) # test ignore channels mask_4 = np.zeros([2, 2, 2]) mask_4[0, 0, 0] = 1 mask_4[1, 1, 1] = 2 crop_4 = np.array([[[1, 0]]]) aug_4 = A.CropNonEmptyMaskIfExists(1, 1, ignore_channels=[1]) # test full size crop mask_5 = np.random.random([10, 10, 3]) crop_5 = mask_5 aug_5 = A.CropNonEmptyMaskIfExists(10, 10) mask_6 = np.zeros([10, 10, 3]) mask_6[0, 0, 0] = 0 crop_6 = mask_6 aug_6 = A.CropNonEmptyMaskIfExists(10, 10, ignore_values=[1]) _test_crop(mask_1, crop_1, aug_1, n=1) _test_crop(mask_2, crop_2, aug_2, n=1) _test_crop(mask_3, crop_3, aug_3, n=5) _test_crop(mask_4, crop_4, aug_4, n=5) _test_crop(mask_5, crop_5, aug_5, n=1) _test_crop(mask_6, crop_6, aug_6, n=10)
def prepare_data(self): # Read DataFrame df = pd.read_csv(os.path.join(self.hparams.data_dir, 'train.csv')) df = df[df['data_provider'] == 'radboud'].reset_index(drop=True) #Delete rows (mask dont exist) for idx in range(len(df)): image_id = df.loc[idx, 'image_id'] if not os.path.exists( os.path.join( os.path.join(self.hparams.data_dir, 'train_label_masks/'), image_id + '_mask.' + self.hparams.image_format)): df = df.drop(idx, axis=0) df = df.reset_index(drop=True) skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=2020) for fold, (train_index, val_index) in enumerate( skf.split(df.values, df['isup_grade'])): df.loc[val_index, 'fold'] = int(fold) df['fold'] = df['fold'].astype(int) #print(df) train_df = df[df['fold'] != self.hparams.fold] val_df = df[df['fold'] == self.hparams.fold] #train_df, val_df = train_test_split(train_df, stratify=train_df['isup_grade']) train_transform = A.Compose([ A.PadIfNeeded(min_height=self.hparams.image_size, min_width=self.hparams.image_size, border_mode=4, value=255, mask_value=0, always_apply=False, p=1.0), A.CropNonEmptyMaskIfExists(height=self.hparams.image_size, width=self.hparams.image_size, ignore_values=None, ignore_channels=None, always_apply=False, p=1.0), A.RandomResizedCrop(height=self.hparams.image_size, width=self.hparams.image_size, scale=(0.8, 1.2), ratio=(0.75, 1.3333333333333333), interpolation=1, always_apply=False, p=1.0), A.Flip(always_apply=False, p=0.5), A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, brightness_by_max=True, always_apply=False, p=0.5), A.GaussNoise(var_limit=(10.0, 50.0), mean=0, always_apply=False, p=0.5), #A.Rotate(limit=90, interpolation=1, border_mode=4, value=None, mask_value=None, always_apply=False, p=0.5), A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=45, interpolation=1, border_mode=4, value=None, mask_value=None, always_apply=False, p=0.5), A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, always_apply=False, p=1.0) ]) valid_transform = A.Compose([ A.PadIfNeeded(min_height=self.hparams.image_size, min_width=self.hparams.image_size, border_mode=4, value=255, mask_value=0, always_apply=False, p=1.0), A.CropNonEmptyMaskIfExists(height=self.hparams.image_size, width=self.hparams.image_size, ignore_values=None, ignore_channels=None, always_apply=False, p=1.0), A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, always_apply=False, p=1.0) ]) self.train_dataset = PANDASegDataset(train_df, self.hparams.data_dir, self.hparams.image_format, transform=train_transform) self.val_dataset = PANDASegDataset(val_df, self.hparams.data_dir, self.hparams.image_format, transform=valid_transform)
def get_augmentation(version): if version == "v1": return { "train": A.Compose([ A.Flip(p=0.5), A.Rotate(p=0.5), A.Resize(height=256, width=256, p=1.0), A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), "valid": A.Compose([ A.Resize(height=256, width=256, p=1.0), A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), } elif version == "v2": return { "train": A.Compose([ A.Flip(p=0.5), A.Rotate(p=0.5), A.OneOf([ A.RandomCrop(height=256, width=256, p=1), A.RandomCrop(height=384, width=384, p=1), A.RandomCrop(height=512, width=512, p=1), A.RandomCrop(height=640, width=640, p=1), ], p=0.5), A.Resize(height=256, width=256, p=1.0), A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), "valid": A.Compose([ A.Resize(height=256, width=256, p=1.0), A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), } elif version == "v3": return { "train": A.Compose([ A.RandomCrop(height=1024, width=1024, p=1), A.Flip(p=0.5), A.Rotate(p=0.5), A.Resize(height=256, width=256, p=1.0), A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), "valid": A.Compose([ A.Resize(height=256, width=256, p=1.0), A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), } elif version == "v4": # for 3x-scaled dataset | 256x256 return { "train": A.Compose([ A.RandomCrop(height=512, width=512, p=1), A.Flip(p=0.5), A.Rotate(p=0.5), A.Resize(height=256, width=256, p=1.0), A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), "valid": A.Compose([ A.Resize(height=256, width=256, p=1.0), A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), } elif version == "v5": # for 3x-scaled dataset | 512x512 return { "train": A.Compose([ A.RandomCrop(height=512, width=512, p=1), A.Flip(p=0.5), A.Rotate(p=0.5), A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), "valid": A.Compose([ A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), } elif version == "v6": # for 3x-scaled dataset | 512x512 return { "train": A.Compose([ A.Flip(p=0.5), A.Rotate(p=0.5), A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, always_apply=False, p=0.25), A.RandomBrightness(limit=0.4, always_apply=False, p=0.25), A.RandomContrast(limit=0.2, always_apply=False, p=0.25), A.RandomShadow(shadow_roi=(0, 0, 1, 1), num_shadows_lower=1, num_shadows_upper=50, shadow_dimension=5, always_apply=False, p=0.25), A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), "valid": A.Compose([ A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), } elif version == "v7": # for 3x-scaled dataset | 512x512 return { "train": A.Compose([ A.Flip(p=0.5), A.Rotate(p=0.5), A.RandomCrop(height=768, width=768, p=1), A.Resize(height=256, width=256, p=1.0), A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, always_apply=False, p=0.25), A.RandomBrightness(limit=0.4, always_apply=False, p=0.25), A.RandomContrast(limit=0.2, always_apply=False, p=0.25), A.RandomShadow(shadow_roi=(0, 0, 1, 1), num_shadows_lower=1, num_shadows_upper=50, shadow_dimension=5, always_apply=False, p=0.25), A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), "valid": A.Compose([ A.Resize(height=256, width=256, p=1.0), A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), } elif version == "v8": # for 3x-scaled dataset | 512x512 return { "train": A.Compose([ A.Rotate(p=0.5), A.RandomCrop(height=512, width=512, p=1), A.Flip(p=0.5), # color A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, always_apply=False, p=0.25), A.RandomBrightness(limit=0.4, always_apply=False, p=0.25), A.RandomContrast(limit=0.2, always_apply=False, p=0.25), A.RandomShadow(shadow_roi=(0, 0, 1, 1), num_shadows_lower=1, num_shadows_upper=50, shadow_dimension=5, always_apply=False, p=0.25), # transform A.ElasticTransform(p=1, alpha=120, sigma=6, alpha_affine=0.25), A.GridDistortion(p=0.25), A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=0.25), A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), "valid": A.Compose([ A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), } elif version == "v9": # for 3x-scaled dataset | 512x512 return { "train": A.Compose([ A.Flip(p=0.5), A.Rotate(p=0.5), A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, always_apply=False, p=0.25), A.RandomBrightness(limit=0.4, always_apply=False, p=0.25), A.RandomContrast(limit=0.2, always_apply=False, p=0.25), A.RandomShadow(shadow_roi=(0, 0, 1, 1), num_shadows_lower=1, num_shadows_upper=50, shadow_dimension=5, always_apply=False, p=0.25), # transform A.OneOf([ A.ElasticTransform( alpha=120, sigma=6, alpha_affine=0.25, p=0.25), A.GridDistortion(p=0.25), A.OpticalDistortion( distort_limit=2, shift_limit=0.5, p=0.25) ], p=0.75), A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), "valid": A.Compose([ A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), } elif version == "v10": # for 3x-scaled dataset | 512x512 return { "train": A.Compose([ A.Flip(p=0.5), A.Rotate(p=0.5), # size A.OneOf([ A.CropNonEmptyMaskIfExists(height=128, width=128, p=1.0), A.CropNonEmptyMaskIfExists(height=256, width=256, p=1.0), A.CropNonEmptyMaskIfExists(height=384, width=384, p=1.0) ], p=0.25), A.PadIfNeeded(min_height=512, min_width=512, border_mode=4, p=1), # array shuffle A.OneOf([A.MaskDropout(p=1), A.RandomGridShuffle(p=1)], p=0.5), # quality A.Downscale(scale_min=0.25, scale_max=0.75, interpolation=0, always_apply=False, p=0.5), A.GaussNoise(p=0.5), A.OneOf([ A.GlassBlur(p=1), A.GaussianBlur(p=1), ], p=0.5), # colors A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, always_apply=False, p=0.5), A.RandomBrightness(limit=0.4, always_apply=False, p=0.5), A.RandomContrast(limit=0.2, always_apply=False, p=0.5), A.RandomShadow(shadow_roi=(0, 0, 1, 1), num_shadows_lower=1, num_shadows_upper=50, shadow_dimension=5, always_apply=False, p=0.5), A.CLAHE(p=0.5), A.Equalize(p=0.5), A.ChannelShuffle(p=0.5), # transform A.OneOf([ A.ElasticTransform( alpha=120, sigma=6, alpha_affine=0.25, p=1), A.GridDistortion(p=1), A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1) ], p=0.5), A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), "valid": A.Compose([ A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), } elif version == "v11": # custom normalization (see other/img_normalization.py) return { "train": A.Compose([ A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), "valid": A.Compose([ A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), } elif version == "v12": # for 3x-scaled dataset | 512x512 return { "train": A.Compose([ A.Flip(p=0.5), A.Rotate(p=0.5), # size / quality A.OneOf([ A.CropNonEmptyMaskIfExists(height=128, width=128, p=1.0), A.CropNonEmptyMaskIfExists(height=256, width=256, p=1.0), A.CropNonEmptyMaskIfExists(height=384, width=384, p=1.0), A.Downscale(scale_min=0.25, scale_max=0.75, interpolation=0, always_apply=False, p=1.0), ], p=0.25), A.PadIfNeeded(min_height=512, min_width=512, border_mode=4, p=1), # array shuffle A.OneOf([A.MaskDropout(p=1), A.RandomGridShuffle(p=1)], p=0.15), # noise A.OneOf([ A.GaussNoise(p=1), A.GlassBlur(p=1), A.GaussianBlur(p=1), ], p=0.15), # colors A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, always_apply=False, p=0.15), A.RandomBrightness(limit=0.4, always_apply=False, p=0.15), A.RandomContrast(limit=0.2, always_apply=False, p=0.15), A.RandomShadow(shadow_roi=(0, 0, 1, 1), num_shadows_lower=1, num_shadows_upper=50, shadow_dimension=5, always_apply=False, p=0.15), A.OneOf([ A.CLAHE(p=1), A.Equalize(p=1), A.ChannelShuffle(p=1), ], p=0.15), # transform A.OneOf([ A.ElasticTransform( alpha=120, sigma=6, alpha_affine=0.25, p=1), A.GridDistortion(p=1), A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1) ], p=0.15), A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), "valid": A.Compose([ A.Normalize(mean=(0.623, 0.520, 0.650), std=(0.278, 0.305, 0.274), max_pixel_value=255.0, p=1.0) ]), } else: raise Exception(f"Augmentation version '{version}' is UNKNOWN!")
A.RandomBrightness(), ], p=0.3), # A.OneOf([ # A.ElasticTransform(alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), # A.GridDistortion(), # A.OpticalDistortion(distort_limit=2, shift_limit=0.5), # ], p=0.3), A.ToFloat(max_value=1) ], p=1) AUGMENTATIONS_TRAIN_CROP = A.Compose( [ A.OneOf([ A.CropNonEmptyMaskIfExists(256, 416, ignore_channels=[4], p=0.7), A.RandomCrop(256, 416, p=0.3), ], p=1.0), A.HorizontalFlip(p=0.5), # A.VerticalFlip(p=0.5), # A.OneOf([ # A.RandomContrast(), # A.RandomGamma(), # A.RandomBrightness(), # ], p=0.3), A.ToFloat(max_value=1), ], p=1) AUGMENTATIONS_TEST = A.Compose([A.ToFloat(max_value=1)], p=1)
def get_loaders(preprocessing_fn, batch_size=12, num_workers=4): preprocessing = get_preprocessing(preprocessing_fn) SDD_train_PATH = r'Z:\test tasks\Sber_robo\SDD_images\imgs\train' SDD_val_PATH = r'Z:\test tasks\Sber_robo\SDD_images\imgs\test' train_transforms = albu.Compose( [pre_transforms(image_size=512), hard_transforms(crop_size=512)]) valid_transforms = pre_transforms(image_size=512) SDD_train = SDD_dataset(SDD_train_PATH, augmentations=train_transforms, preprocessing=preprocessing) SDD_val = SDD_dataset(SDD_val_PATH, augmentations=valid_transforms, preprocessing=preprocessing) ############# UAVid_train_PATH = r'Z:\test tasks\Sber_robo\uavid_v1.5_official_release_image\uavid_train' UAVid_val_PATH = r'Z:\test tasks\Sber_robo\uavid_v1.5_official_release_image\uavid_val' train_transforms = albu.Compose( [pre_transforms(image_size=1024), hard_transforms(crop_size=512)]) valid_transforms = albu.Compose([ pre_transforms(image_size=1024), albu.CropNonEmptyMaskIfExists(512, 512, p=1) ]) UAVid_train = UAVid_dataset(UAVid_train_PATH, augmentations=train_transforms, preprocessing=preprocessing) UAVid_val = UAVid_dataset(UAVid_val_PATH, augmentations=valid_transforms, preprocessing=preprocessing) train_dataset = SDD_train + UAVid_train val_dataset = SDD_val + UAVid_val print(f"found {len(SDD_train)} images for SDD") print(f"found {len(UAVid_train)} images for UAVid") SDD_weight = 1 / len(SDD_train) UAVid_weight = 1 / len(UAVid_train) samples_weight = np.array([SDD_weight] * len(SDD_train) + [UAVid_weight] * len(UAVid_train)) sampler = WeightedRandomSampler(torch.from_numpy(samples_weight), len(samples_weight)) train_loader = DataLoader(train_dataset, batch_size=batch_size, sampler=sampler, num_workers=num_workers, pin_memory=True, drop_last=True) valid_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers, pin_memory=True, drop_last=False) loaders = {"train": train_loader, "valid": valid_loader} return loaders
import albumentations as A import torch import numpy as np from utils import read_img_ski p = 0.5 albu_train = A.Compose([ A.CropNonEmptyMaskIfExists(512, 512), A.HorizontalFlip(p=p), A.VerticalFlip(p=p), A.RandomRotate90(p=p), A.OneOf([ A.RandomBrightnessContrast(p=1), A.RandomGamma(p=1), ], p=p), A.OneOf([ A.GaussianBlur(p=1), A.GaussNoise(p=1), A.IAAAdditiveGaussianNoise(p=1), A.Blur(p=1), ], p=p), ]) albu_dev = A.Compose([ A.PadIfNeeded(1024, 1024, border_mode=0), ]) def train_transform(img, mask):
def set_transforms(self) -> dict: d4_tansforms = [ A.SmallestMaxSize(self.img_size[0], interpolation=0, p=1.), # D4 Group augmentations A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.RandomRotate90(p=0.5), A.Transpose(p=0.5), ] tensor_norm = [ ToTensor(), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ] geometric = [ A.SmallestMaxSize(self.img_size[0], interpolation=0, p=1.), A.ShiftScaleRotate(shift_limit=self.shift_limit, self.scale_limit, rotate_limit=self.rotate_limit, interpolation=cv2.INTER_LINEAR, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=0.5), # crop and resize A.RandomSizedCrop( (self.crop_size[0], min(self.crop_size[1], self.img_size[0], self.img_size[1])), self.img_size[0], self.img_size[1], w2h_ratio=1.0, interpolation=cv2.INTER_LINEAR, always_apply=False, p=0.2), ] resize_crop = [ A.SmallestMaxSize(max(self.img_size[0], self.img_size[1]), interpolation=0, p=1.), A.RandomCrop(self.img_size[0], self.img_size[1], p=1.), ] train_light = [ A.SmallestMaxSize(self.img_size[0], interpolation=0, p=1.), A.RandomCrop(self.img_size[0], self.img_size[1], p=1.), A.HorizontalFlip(p=0.5), A.RandomBrightnessContrast(p=0.5), ] train_medium = train_light.append([ A.ShiftScaleRotate(shift_limit=self.shift_limit, self.scale_limit, rotate_limit=self.rotate_limit, p=0.5), A.OneOf([ A.RandomBrightnessContrast(p=0.7), A.Equalize(p=0.3), A.HueSaturationValue(p=0.5), A.RGBShift(p=0.5), A.RandomGamma(p=0.4), A.ChannelShuffle(p=0.05), ], p=0.9), A.OneOf([ A.GaussNoise(p=0.5), A.ISONoise(p=0.5), A.MultiplicativeNoise(0.5), ], p=0.2), ]) valid_ade = [ A.SmallestMaxSize(self.img_size, p=1.), A.Lambda(name="Pad32", image=pad_x32, mask=pad_x32), ] # from bloodaxe # https://github.com/BloodAxe/Catalyst-Inria-Segmentation-Example/blob/master/inria/augmentations.py crop = [ #(image_size: Tuple[int, int], min_scale=0.75, max_scale=1.25, input_size=5000): A.OneOrOther( A.RandomSizedCrop((self.crop_size[0], min(self.crop_size[1], self.img_size[0], self.img_size[1])), self.img_size[0], self.img_size[1]), A.CropNonEmptyMaskIfExists(self.img_size[0], self.img_size[1]), ) ] safe_augmentations = [A.HorizontalFlip(), A.RandomBrightnessContrast()] light_augmentations = [ A.HorizontalFlip(), A.RandomBrightnessContrast(), A.OneOf([ A.ShiftScaleRotate(scale_limit=self.scale_limit, rotate_limit=self.rotate_limit, border_mode=cv2.BORDER_CONSTANT), A.IAAAffine(), A.IAAPerspective(), A.NoOp() ]), A.HueSaturationValue(), ] medium_augmentations = [ A.HorizontalFlip(), A.ShiftScaleRotate(scale_limit=self.scale_limit, rotate_limit=self.rotate_limit, border_mode=cv2.BORDER_CONSTANT), # Add occasion blur/sharpening A.OneOf([A.GaussianBlur(), A.IAASharpen(), A.NoOp()]), # Spatial-preserving augmentations: A.OneOf( [A.CoarseDropout(), A.MaskDropout(max_objects=5), A.NoOp()]), A.GaussNoise(), A.OneOf([ A.RandomBrightnessContrast(), A.CLAHE(), A.HueSaturationValue(), A.RGBShift(), A.RandomGamma() ]), # Weather effects A.RandomFog(fog_coef_lower=0.01, fog_coef_upper=0.3, p=0.1), ] hard_augmentations = [ A.RandomRotate90(), A.Transpose(), A.RandomGridShuffle(), A.ShiftScaleRotate(scale_limit=self.scale_limit, rotate_limit=self.rotate_limit, border_mode=cv2.BORDER_CONSTANT, mask_value=0, value=0), A.ElasticTransform(border_mode=cv2.BORDER_CONSTANT, alpha_affine=5, mask_value=0, value=0), # Add occasion blur A.OneOf([ A.GaussianBlur(), A.GaussNoise(), A.IAAAdditiveGaussianNoise(), A.NoOp() ]), # D4 Augmentations A.OneOf( [A.CoarseDropout(), A.MaskDropout(max_objects=10), A.NoOp()]), # Spatial-preserving augmentations: A.OneOf([ A.RandomBrightnessContrast(brightness_by_max=True), A.HueSaturationValue(), A.RGBShift(), A.RandomGamma(), A.NoOp(), ]), # Weather effects A.OneOf([ A.RandomFog(fog_coef_lower=0.01, fog_coef_upper=0.3, p=0.1), A.NoOp() ]), ] TRANSFORMS = { "d4": d4_tansforms, "resize_crop": resize_crop, "geometric": geometric, "light": train_light, "medium": train_medium, "ade_valid": valid_ade, "flip_bright": safe_augmentations, "crop": crop, "inria_light": light_augmentations, "inria_medium": medium_augmentations, "inria_hard": hard_augmentations, "inria_valid": safe_augmentations, } return TRANSFORMS def get_transforms(self): augs = [] if self.augs_name: augs = self.set_transforms[self.augs_name] augs.append( A.Resize(height=self.img_size[0], width=self.img_size[1], p=1.0)) if self.use_d4: augs.append(self.set_transforms["d4"]) if self.vflip: augs.append(A.VerticalFlip(p=0.5)) if self.hflip: augs.append(A.HorizontalFlip(p=0.5)) if self.normalise: augs.append(A.Normalize()) return A.Compose(augs)