def get_training_augmentation(grayscale=False, height=320, width=640, crop_mode=0): mea = mean st = std if grayscale: mea = (mean[0] + mean[1] + mean[2]) / 3 st = (std[0] + std[1] + std[2]) / 3 if crop_mode == 0: train_transform = [ albu.PadIfNeeded(height * 3 // 2, width * 3 // 2), albu.RandomCrop(height * 3 // 2, width * 3 // 2), albu.HorizontalFlip(p=0.5), albu.VerticalFlip(p=0.5), albu.CoarseDropout(p=0.1), albu.ShiftScaleRotate(scale_limit=0.4, rotate_limit=45, shift_limit=0.1, p=0.5, border_mode=0), albu.GridDistortion(p=0.3), albu.OpticalDistortion(p=0.3, distort_limit=2, shift_limit=0.5), albu.RGBShift(p=0.3), albu.Blur(p=0.3), albu.MotionBlur(p=0.3), albu.PadIfNeeded(height, width), albu.RandomCrop(height, width) ] else: train_transform = [ albu.HorizontalFlip(p=0.5), albu.VerticalFlip(p=0.5), albu.ShiftScaleRotate(scale_limit=0.4, rotate_limit=45, shift_limit=0.1, p=0.5, border_mode=0), albu.GridDistortion(p=0.5), albu.OpticalDistortion(p=0.5, distort_limit=2, shift_limit=0.5), albu.RGBShift(p=0.5), albu.ToGray(p=0.5), albu.Resize(height, width) ] train_transform.extend([ #Equalize(p=1.0, by_channels=False), albu.Normalize(mean=mea, std=st, p=1), ToTensor(), ]) return albu.Compose(train_transform)
def acase2_augs(name, **kwargs): return [ A.Compose( [A.Posterize(), A.GridDistortion(num_steps=4), A.Normalize()], p=1.0), A.Compose( [A.Downscale(), A.GridDistortion(num_steps=4), A.Normalize()], p=1.0), ]
def get_train_transforms(): return A.Compose([ A.JpegCompression(p=0.5), A.Rotate(limit=80, p=1.0), A.OneOf([ A.OpticalDistortion(), A.GridDistortion(), A.IAAPiecewiseAffine(), ]), A.RandomSizedCrop(min_max_height=(int(resolution * 0.7), input_res), height=resolution, width=resolution, p=1.0), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.GaussianBlur(p=0.3), A.OneOf([ A.RandomBrightnessContrast(), A.HueSaturationValue(), ]), A.Cutout(num_holes=8, max_h_size=resolution // 8, max_w_size=resolution // 8, fill_value=0, p=0.3), A.Normalize(), ToTensorV2(), ], p=1.0)
def hard_spatial_augmentations(image_size: Tuple[int, int], rot_angle=45): return A.Compose([ A.OneOf([ A.NoOp(), A.RandomGridShuffle(grid=(4, 4)), A.RandomGridShuffle(grid=(3, 3)), A.RandomGridShuffle(grid=(2, 2)), ]), A.MaskDropout(max_objects=10), A.OneOf([ A.ShiftScaleRotate(scale_limit=0.1, rotate_limit=rot_angle, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0), A.NoOp(), ]), A.OneOf([ A.ElasticTransform(border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0), A.GridDistortion(border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0), A.NoOp(), ]), # D4 A.Compose([A.Transpose(), A.RandomRotate90()]), ])
def test_grid_distortion_interpolation(interpolation): image = np.random.randint(low=0, high=256, size=(100, 100, 3), dtype=np.uint8) mask = np.random.randint(low=0, high=2, size=(100, 100), dtype=np.uint8) aug = A.GridDistortion(num_steps=1, distort_limit=(0.3, 0.3), interpolation=interpolation, p=1) data = aug(image=image, mask=mask) expected_image = F.grid_distortion(image, num_steps=1, xsteps=[1.3], ysteps=[1.3], interpolation=interpolation, border_mode=cv2.BORDER_REFLECT_101) expected_mask = F.grid_distortion(mask, num_steps=1, xsteps=[1.3], ysteps=[1.3], interpolation=cv2.INTER_NEAREST, border_mode=cv2.BORDER_REFLECT_101) assert np.array_equal(data['image'], expected_image) assert np.array_equal(data['mask'], expected_mask)
def compose_albumentations(gamma_limit_lower=0, gamma_limit_upper=0, CLAHE_clip_limit=0., brightness_limit=0, contrast_limit=0., distort_limit=0.): 'Compose albumentations augmentations' augs = [] if sum([gamma_limit_lower, gamma_limit_upper]) > 0: augs.append( A.RandomGamma(gamma_limit=(gamma_limit_lower, gamma_limit_upper), p=0.5)) if CLAHE_clip_limit > 0: augs.append(A.CLAHE(clip_limit=CLAHE_clip_limit)) if sum([brightness_limit, contrast_limit]) > 0: augs.append( A.RandomBrightnessContrast(brightness_limit=brightness_limit, contrast_limit=contrast_limit)) if distort_limit > 0: augs.append( A.GridDistortion(num_steps=5, distort_limit=distort_limit, interpolation=1, border_mode=4, p=0.5)) return augs
def augment_image(self, image, annotations): new_annotations = annotations if annotations['bboxes'].any(): annotation = { 'image': image, 'bboxes': annotations['bboxes'], 'category_id': annotations['labels'] } aug = self.get_aug([ A.VerticalFlip(), A.HorizontalFlip(), A.RGBShift(), A.Blur(blur_limit=7), A.GaussNoise(), A.OpticalDistortion(distort_limit=0.2), A.GridDistortion(), A.ShiftScaleRotate( p=0.75, shift_limit=0.1, rotate_limit=45, scale_limit=0.2), ], min_area=(1024 * 0.05)**2) augmented = aug(**annotation) image = augmented['image'] annotations['bboxes'] = np.array(augmented['bboxes']) annotations['labels'] = np.array(augmented['category_id']) return image, annotations
def da_policy_combination_old(img_size): print("Using Data Augmentation Combinations Old") train_aug = [ albumentations.ElasticTransform(p=0.72, alpha=177, sigma=177 * 0.05, alpha_affine=176 * 0.03), albumentations.GridDistortion(p=0.675, distort_limit=0.3), albumentations.OpticalDistortion(p=0.2, distort_limit=0.2, shift_limit=0.2), albumentations.ShiftScaleRotate(p=0.56, shift_limit=0.2, scale_limit=0.0, rotate_limit=0), # shift albumentations.ShiftScaleRotate(p=0.25, shift_limit=0.0, scale_limit=0.2, rotate_limit=0), # scale albumentations.VerticalFlip(p=0.325), albumentations.HorizontalFlip(p=0.3), albumentations.Rotate(p=0.625, limit=45, interpolation=1, border_mode=0), ] train_aug = common_test_augmentation(img_size) + train_aug train_aug_img = [] val_aug = common_test_augmentation(img_size) return train_aug, train_aug_img, val_aug
def __data_generation(self, training_temp, label_temp): 'Generates data containing batch_size samples' # X : (n_samples, *dim, n_channels) # Initialization X = np.empty((self.batch_size, *self.dim, self.n_channels)) y = np.empty((self.batch_size), dtype=int) # Generate data for i, img_label in enumerate (zip(training_temp, label_temp)): # Store sample training_img, training_label = img_label # If for training, add AUGMENTATION if self.augmentation: transform = A.Compose([ A.GaussianBlur(p=0.2), # gaussian blur A.RandomBrightnessContrast(p=0.5), # brightness contrast change A.GaussNoise(p=0.5), # inject gaussian noise A.GridDistortion(p=0.2), # grid distortion A.ShiftScaleRotate(shift_limit=0.1, rotate_limit=5, p=0.5), ]) training_img = transform(image=training_img)['image'] self.add_line(training_img, p=0.5) training_img = training_img.astype("float32") / 255.0 training_img = np.expand_dims(training_img, axis=2) X[i,] = training_img # Store class y[i] = training_label return X, tf.keras.utils.to_categorical(y, num_classes=self.n_classes)
def aug_medium(prob=1): return aug.Compose([ aug.Flip(), aug.OneOf([ aug.CLAHE(clip_limit=2, p=.5), aug.IAASharpen(p=.25), ], p=0.35), aug.OneOf([ aug.RandomContrast(), aug.RandomGamma(), aug.RandomBrightness(), ], p=0.3), aug.OneOf([ aug.ElasticTransform( alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), aug.GridDistortion(), aug.OpticalDistortion(distort_limit=2, shift_limit=0.5), ], p=0.3), aug.ShiftScaleRotate(rotate_limit=12), aug.OneOf([ aug.GaussNoise(p=.35), SaltPepperNoise(level_limit=0.0002, p=.7), aug.ISONoise(p=.7), ], p=.5), aug.Cutout(num_holes=3, p=.25), ], p=prob)
def __init__(self, imgs_dir, masks_dir, labels_dir=None): self.imgs_dir = imgs_dir self.masks_dir = masks_dir self.images_filesnames = sorted(os.listdir(imgs_dir)) self.labels_dir = labels_dir self.labels, self.negative_samples_idx = None, [] if labels_dir is not None: self.labels = pd.read_csv(labels_dir)['labels'].to_numpy() # For now: use 1 for benign/malignant, 0 for normal self.labels[self.labels != 2] = 1 self.labels[self.labels == 2] = 0 self.negative_samples_idx = (self.labels == 0) # Specify data augmentations here self.transformations = A.Compose([ A.Resize(256, 256), A.OneOf([ A.RandomRotate90(p=0.5), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, shift_limit=0.1, p=0.5, border_mode=0), A.RandomBrightnessContrast(p=0.2), A.GridDistortion(p=0.2), A.ElasticTransform(p=0.2) ]), ])
def get_training_augmentation(): train_transform = [ # albu.Resize(320, 640, always_apply=True), # albu.VerticalFlip(), # albu.HorizontalFlip(), # albu.Rotate(limit=20), # albu.GridDistortion(), albu.Resize(320, 640, always_apply=True), albu.HorizontalFlip(), albu.VerticalFlip(), albu.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, shift_limit=0.1, p=0.5, border_mode=0), albu.GridDistortion(), albu.Rotate(limit=20) # albu.OneOf([ # albu.RandomBrightnessContrast(), # albu.RandomGamma(), # ], p=0.3), # albu.OneOf([ # # albu.ElasticTransform(alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), # albu.GridDistortion(), # albu.OpticalDistortion(distort_limit=2, shift_limit=0.5), # ], p=0.3), # albu.ShiftScaleRotate(), ] return albu.Compose(train_transform)
def get_transforms(phase, size, mean, std): list_transforms = [] if phase == "train": list_transforms.extend( [ albu.HorizontalFlip(), albu.OneOf([ albu.RandomContrast(), albu.RandomGamma(), albu.RandomBrightness(), ], p=0.3), albu.OneOf([ albu.ElasticTransform(alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), albu.GridDistortion(), albu.OpticalDistortion(distort_limit=2, shift_limit=0.5), ], p=0.3), albu.ShiftScaleRotate(), ] ) list_transforms.extend( [ albu.Normalize(mean=mean, std=std, p=1), albu.Resize(size, size), ToTensorV2(), ] ) list_trfms = albu.Compose(list_transforms) return list_trfms
def get_transforms(type="albumentations"): if type == "albumentations": train_transforms = albumentations.Compose([ albumentations.Transpose(p=0.5), albumentations.OneOf([ albumentations.VerticalFlip(p=0.5), albumentations.HorizontalFlip(p=0.5), ]), albumentations.OneOf([ albumentations.RandomBrightness(limit=0.2, p=0.75), albumentations.RandomContrast(limit=0.2, p=0.75), ]), albumentations.OneOf([ albumentations.MotionBlur(blur_limit=5), albumentations.MedianBlur(blur_limit=5), albumentations.GaussianBlur(blur_limit=5), albumentations.GaussNoise(var_limit=(5.0, 30.0)), ], p=0.7), albumentations.OneOf([ albumentations.OpticalDistortion(distort_limit=1.0), albumentations.GridDistortion(num_steps=5, distort_limit=1.), albumentations.ElasticTransform(alpha=3), ], p=0.7), # albumentations.OneOf([ # albumentations.CLAHE(clip_limit=4.0, p=0.7), # albumentations.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=20, val_shift_limit=10, p=0.5), # albumentations.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=15, border_mode=0, # p=0.85), # ]), albumentations.Resize(256, 256), # albumentations.Cutout(max_h_size=int(256 * 0.375), max_w_size=int(256 * 0.375), num_holes=1, p=0.7), # albumentations.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) test_transforms = albumentations.Compose([ albumentations.Resize(256, 256), # albumentations.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) else: train_transforms = transforms.Compose([ # AdvancedHairAugmentation(hairs_folder='/kaggle/input/melanoma-hairs'), transforms.RandomResizedCrop(size=256, scale=(0.9, 1.0)), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), Microscope(p=0.5), transforms.Resize((256, 256)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) test_transforms = transforms.Compose([ transforms.Resize((256, 256)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) return train_transforms, test_transforms
def get_augmentations(p=0.5, image_size=224): imagenet_stats = { "mean": [0.485, 0.456, 0.406], "std": [0.229, 0.224, 0.225] } train_tfms = A.Compose([ # A.Resize(image_size, image_size), A.RandomResizedCrop(image_size, image_size), A.ShiftScaleRotate(shift_limit=0.15, scale_limit=0.4, rotate_limit=45, p=p), A.Cutout(p=p), A.RandomRotate90(p=p), A.Flip(p=p), A.OneOf( [ A.RandomBrightnessContrast( brightness_limit=0.2, contrast_limit=0.2, ), A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=50, val_shift_limit=50), ], p=p, ), A.OneOf( [ A.IAAAdditiveGaussianNoise(), A.GaussNoise(), ], p=p, ), A.CoarseDropout(max_holes=10, p=p), A.OneOf( [ A.MotionBlur(p=0.2), A.MedianBlur(blur_limit=3, p=0.1), A.Blur(blur_limit=3, p=0.1), ], p=p, ), A.OneOf( [ A.OpticalDistortion(p=0.3), A.GridDistortion(p=0.1), A.IAAPiecewiseAffine(p=0.3), ], p=p, ), ToTensor(normalize=imagenet_stats), ]) valid_tfms = A.Compose([ A.CenterCrop(image_size, image_size), ToTensor(normalize=imagenet_stats) ]) return train_tfms, valid_tfms
def cifar10_albumentations(mean, std): train_transforms = A.Compose([ # A.OneOf([ # A.GridDistortion(distort_limit=(-0.3, 0.3), p=0.5), # A.Rotate(limit=(-10, 10), p=0.5) # ]), A.GridDistortion(distort_limit=(-0.3, 0.3), p=0.5), A.Rotate(limit=(-10, 10), p=0.5), A.HorizontalFlip(p=0.25), A.Cutout(num_holes=1, max_h_size=12, max_w_size=12), A.Normalize( mean=mean, std=std ), # Here, the order of normalization and ToTensor() methods matters. Same goes for test_transforms APT.ToTensor() # APT.ToTensorV2() ]) test_transforms = A.Compose([ A.Normalize(mean=mean, std=std), APT.ToTensor() # APT.ToTensorV2() ]) return Albumentation_Transforms( train_transforms), Albumentation_Transforms(test_transforms)
def transform(train=True, mean=None, std=None): normalize = alb.Compose([ alb.Normalize(mean=mean or _mean, std=std or _std), ToTensorV2(), ]) if not train: return normalize return alb.Compose([ alb.HorizontalFlip(), alb.VerticalFlip(), alb.RandomRotate90(), alb.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=15, p=0.9, border_mode=cv2.BORDER_REFLECT), alb.OneOf([ alb.OpticalDistortion(p=0.3), alb.GridDistortion(p=.1), alb.IAAPiecewiseAffine(p=0.3), ], p=0.3), alb.OneOf([ alb.HueSaturationValue(10, 15, 10), alb.CLAHE(clip_limit=2), alb.RandomBrightnessContrast(), ], p=0.3), normalize, ])
def __init__(self, image_size): self.data_transform = { 'train_transform':A.Compose([ A.Transpose(p=0.5), A.VerticalFlip(p=0.5), A.HorizontalFlip(p=0.5), A.RandomBrightness(limit=0.2, p=0.75), A.RandomContrast(limit=0.2, p=0.75), A.OneOf([ A.MotionBlur(blur_limit=5), A.MedianBlur(blur_limit=5), A.GaussianBlur(blur_limit=5), A.GaussNoise(var_limit=(5.0, 30.0)),], p=0.7), A.OneOf([ A.OpticalDistortion(distort_limit=1.0), A.GridDistortion(num_steps=5, distort_limit=1.), A.ElasticTransform(alpha=3),], p=0.7), A.CLAHE(clip_limit=4.0, p=0.7), A.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=20, val_shift_limit=10, p=0.5), A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=15, border_mode=0, p=0.85), A.Resize(image_size, image_size), A.Cutout(max_h_size=int(image_size * 0.375), max_w_size=int(image_size * 0.375), num_holes=1, p=0.7), A.Normalize() ]), 'test_transform': A.Compose([ A.Resize(image_size, image_size), A.Normalize(), A.Resize(image_size, image_size) ])}
def get_transforms(image_size): transforms_train = albumentations.Compose([ albumentations.Transpose(p=0.5), albumentations.VerticalFlip(p=0.5), albumentations.HorizontalFlip(p=0.5), albumentations.RandomBrightness(limit=0.2, p=0.75), albumentations.RandomContrast(limit=0.2, p=0.75), albumentations.OneOf([ albumentations.MotionBlur(blur_limit=5), albumentations.MedianBlur(blur_limit=5), albumentations.GaussianBlur(blur_limit=5), albumentations.GaussNoise(var_limit=(5.0, 30.0)), ], p=0.7), albumentations.OneOf([ albumentations.OpticalDistortion(distort_limit=1.0), albumentations.GridDistortion(num_steps=5, distort_limit=1.), albumentations.ElasticTransform(alpha=3), ], p=0.7), albumentations.CLAHE(clip_limit=4.0, p=0.7), albumentations.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=20, val_shift_limit=10, p=0.5), albumentations.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=15, border_mode=0, p=0.85), albumentations.Resize(image_size, image_size), albumentations.Cutout(max_h_size=int(image_size * 0.375), max_w_size=int(image_size * 0.375), num_holes=1, p=0.7), albumentations.Normalize() ]) transforms_val = albumentations.Compose([ albumentations.Resize(image_size, image_size), albumentations.Normalize() ]) return transforms_train, transforms_val
def transformer(self): """TRANSFORMATION DE NOTRE IMAGE AFIN DE REDUIRE LE BIAIS""" if self.is_train: transform = A.Compose([ A.CLAHE(), A.RandomRotate90(), A.DualTransform(), # adding A.Transpose(), A.Resize(height=self.img_size, width=self.img_size, interpolation=cv2.INTER_AREA), # RESIZE A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.50, rotate_limit=45, p=.75), A.Blur(blur_limit=3), A.OpticalDistortion(), A.GridDistortion(), A.HueSaturationValue(), ]) else: transform = A.Compose([ A.Resize(height=self.img_size, width=self.img_size, interpolation=cv2.INTER_AREA), # RESIZE ]) return transform
def get_transforms(phase, width=1600, height=256): list_transforms = [] if phase == "train": list_transforms.extend([ albu.HorizontalFlip(), albu.OneOf([ albu.RandomContrast(), albu.RandomGamma(), albu.RandomBrightness(), ], p=0.3), albu.OneOf([ albu.ElasticTransform( alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), albu.GridDistortion(), albu.OpticalDistortion(distort_limit=2, shift_limit=0.5), ], p=0.3), albu.ShiftScaleRotate(), ]) list_transforms.extend([ albu.Resize(width, height, always_apply=True), albu.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1), ToTensor(), ]) list_trfms = albu.Compose(list_transforms) return list_trfms
def _strong_aug(p=0.5): import albumentations return albumentations.Compose([ albumentations.HorizontalFlip(p=0.5), albumentations.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=0, p=0.5, border_mode=cv2.BORDER_CONSTANT), albumentations.OneOf([ albumentations.OpticalDistortion(p=0.5, border_mode=cv2.BORDER_CONSTANT), albumentations.GridDistortion(p=0.5, border_mode=cv2.BORDER_CONSTANT), albumentations.IAAPiecewiseAffine(p=0.5), albumentations.ElasticTransform(p=0.5, border_mode=cv2.BORDER_CONSTANT), ], p=0.5), albumentations.OneOf([ albumentations.CLAHE(clip_limit=2), albumentations.IAASharpen(), albumentations.IAAEmboss(), ], p=0.5), albumentations.OneOf([ albumentations.RandomBrightnessContrast(p=0.5), ], p=0.4), albumentations.HueSaturationValue(p=0.5), ], p=p)
def get_train_transform(): crop_height = 256 crop_width = 256 return albu.Compose([ albu.PadIfNeeded(min_height=crop_height, min_width=crop_width, p=1), albu.RandomSizedCrop((int(0.3 * crop_height), 288), crop_height, crop_width, p=1), albu.HorizontalFlip(p=0.5), albu.OneOf([ albu.IAAAdditiveGaussianNoise(p=0.5), albu.GaussNoise(p=0.5), ], p=0.2), 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.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0, rotate_limit=20, p=0.1), albu.OneOf([ albu.OpticalDistortion(p=0.3), albu.GridDistortion(p=0.1), albu.IAAPiecewiseAffine(p=0.3), ], p=0.2), albu.OneOf([ albu.CLAHE(clip_limit=2, p=0.5), albu.IAASharpen(p=0.5), albu.IAAEmboss(p=0.5), albu.RandomBrightnessContrast(p=0.5), ], p=0.3), albu.HueSaturationValue(p=0.3), albu.JpegCompression(p=0.2, quality_lower=20, quality_upper=99), albu.ElasticTransform(p=0.1), albu.Normalize(p=1) ], p=1)
def train_image_augmentation(image, img_size): image = np.array(image) augmentation = A.Compose( [ A.Resize(img_size, img_size), A.CenterCrop(img_size, img_size, p=1.0), A.Transpose(p=0.5), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.ShiftScaleRotate(p=0.5), A.Blur(blur_limit=3), A.OpticalDistortion(p=0.5), A.GridDistortion(p=0.5), A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5), A.CoarseDropout(p=0.5), A.Cutout(p=0.5), A.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], max_pixel_value=255.0, p=1.0, ) ], p=1.0, ) augmented_image = augmentation(image=image) return augmented_image['image']
def _get_static_augmentations(self, config): augmentations = [] if config["horizontal_flip"]: augmentations.append(albu.HorizontalFlip(p=0.5)) else: augmentations.append(None) if config["grid_distortion"]: augmentations.append(albu.GridDistortion(distort_limit=0.5, border_mode=cv2.BORDER_REPLICATE, p=1.0)) else: augmentations.append(None) if config["hsv_color_shift"]: augmentations.append(albu.HueSaturationValue(p=1.0)) else: augmentations.append(None) if config["random_brightness_contrast"]: augmentations.append(albu.RandomBrightnessContrast(p=1)) else: augmentations.append(None) if config["random_shadow"]: augmentations.append(albu.RandomShadow(shadow_roi=(0, 0, 1, 1), p=0.2)) else: augmentations.append(None) return augmentations
def get_transforms(*, data_type): if data_type == "light_train": return Compose([ Resize(CFG.size, CFG.size), Transpose(p=0.5), HorizontalFlip(p=0.5), VerticalFlip(p=0.5), ShiftScaleRotate(scale_limit=(0, 0), p=0.5), ToTensorV2(), ]) if data_type == "train": return Compose([ Resize(CFG.size, CFG.size), Transpose(p=0.5), HorizontalFlip(p=0.5), VerticalFlip(p=0.5), albumentations.OneOf([ albumentations.ElasticTransform( alpha=1, sigma=20, alpha_affine=10), albumentations.GridDistortion(num_steps=6, distort_limit=0.1), albumentations.OpticalDistortion(distort_limit=0.05, shift_limit=0.05), ], p=0.2), albumentations.core.composition.PerChannel(albumentations.OneOf([ albumentations.MotionBlur(p=.05), albumentations.MedianBlur(blur_limit=3, p=.05), albumentations.Blur(blur_limit=3, p=.05), ]), p=1.0), albumentations.OneOf([ albumentations.CoarseDropout(max_holes=16, max_height=CFG.size // 16, max_width=CFG.size // 16, fill_value=0, p=0.5), albumentations.GridDropout(ratio=0.09, p=0.5), albumentations.Cutout(num_holes=8, max_h_size=CFG.size // 16, max_w_size=CFG.size // 16, p=0.2), ], p=0.5), albumentations.ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.5), ToTensorV2(), ], additional_targets={ 'r': 'image', 'g': 'image', 'b': 'image', 'y': 'image', }) elif data_type == 'valid': return Compose([ Resize(CFG.size, CFG.size), ToTensorV2(), ])
def get_individual_transforms(): transforms = A.Compose([ A.OneOf( [ A.Transpose(p=1.0), A.VerticalFlip(p=1.0), A.HorizontalFlip(p=1.0), A.RandomRotate90(p=1.0), A.NoOp(), ], p=1.0, ), A.OneOf( [ A.ElasticTransform(p=1.0), A.GridDistortion(p=1.0), A.OpticalDistortion(p=1.0), A.NoOp(), ], p=1.0, ), A.OneOf( [ A.GaussNoise(p=1.0), A.GaussianBlur(p=1.0), A.ISONoise(p=1.0), A.CoarseDropout( p=1.0, max_holes=16, max_height=16, max_width=16), A.NoOp(), ], p=1.0, ), ]) return transforms
def __init__(self, outputs=6): super().__init__() self.net = models.resnet34(True) self.linear = Linear(1000, outputs) df = pd.read_csv("/home/dipet/kaggle/prostate/input/prostate-cancer-grade-assessment/train.csv") self.train_df, self.valid_df = train_test_split(df, test_size=0.2) self.data_dir = "/datasets/panda/train_64_100" self.train_transforms = A.Compose( [ A.Compose( [ A.OneOf([A.GaussNoise(), A.MultiplicativeNoise(elementwise=True)]), A.RandomBrightnessContrast(0.02, 0.02), A.HueSaturationValue(0, 10, 10), A.Flip(), A.RandomGridShuffle(grid=(10, 10)), A.GridDistortion(), A.Rotate() ], p=0.5, ), A.ToFloat(), ] ) self.valid_transforms = A.Compose([A.ToFloat()])
def albumentation(): transform = albumentations.Compose([ albumentations.OneOf([ albumentations.GaussNoise(), albumentations.IAAAdditiveGaussianNoise() ]), albumentations.OneOf([ albumentations.MotionBlur(blur_limit=3, p=0.2), albumentations.MedianBlur(blur_limit=3, p=0.1), albumentations.Blur(blur_limit=2, p=0.1) ]), albumentations.OneOf([ albumentations.RandomBrightness(limit=(0.1, 0.4)), albumentations.HueSaturationValue(hue_shift_limit=(0, 128), sat_shift_limit=(0, 60), val_shift_limit=(0, 20)), albumentations.RGBShift(r_shift_limit=30, g_shift_limit=30, b_shift_limit=30) ]), albumentations.OneOf([ albumentations.CLAHE(), albumentations.ChannelShuffle(), albumentations.IAASharpen(), albumentations.IAAEmboss(), albumentations.RandomBrightnessContrast(), ]), albumentations.OneOf([ albumentations.RandomGamma(gamma_limit=(35,255)), albumentations.OpticalDistortion(), albumentations.GridDistortion(), albumentations.IAAPiecewiseAffine() ]), A_torch.ToTensor(normalize={ "mean": [0.485, 0.456, 0.406], "std" : [0.229, 0.224, 0.225]}) ]) return transform
def _strong_aug(p=0.5): return albumentations.Compose([ albumentations.HorizontalFlip(), albumentations.VerticalFlip(), albumentations.ShiftScaleRotate( shift_limit=0, scale_limit=0, rotate_limit=15, p=0.3), albumentations.OneOf([ albumentations.OpticalDistortion(p=0.3), albumentations.GridDistortion(p=0.1), albumentations.IAAPiecewiseAffine(p=0.3), ], p=0.2), albumentations.OneOf([ albumentations.CLAHE(clip_limit=2), albumentations.IAASharpen(), albumentations.IAAEmboss(), ], p=0.3), albumentations.OneOf([ albumentations.RandomBrightnessContrast(p=0.3), ], p=0.4), albumentations.HueSaturationValue(p=0.3), ], p=p)