def __init__(self, root, input_transform=None, target_transform=None, _train=False): self.images_root = os.path.join(root, 'Images') self.labels_root = os.path.join(root, 'Labels') self._train = _train self.filenames = [ image_basename(f) for f in os.listdir(self.labels_root) if is_image(f) ] random.shuffle(self.filenames) self.input_transform = input_transform self.target_transform = target_transform self.A_transform = A.Compose([ A.Rotate(limit=40, p=0.9), A.HorizontalFlip(p=0.5), A.RGBShift(r_shift_limit=25, g_shift_limit=25, b_shift_limit=25, p=0.9), A.OneOf([A.Blur(blur_limit=2, p=0.5), A.ColorJitter(p=0.5)], p=1.0) ])
def common_aug(mode, params): ''' :param mode: 'train', 'test', 'inference' :param params: ''' #aug_params = params.get('augm_params', dict()) augs_list = [] assert mode in {'train', 'debug', 'inference'} if mode == 'train': augs_list.append(albumentations.PadIfNeeded(min_height=params.data.net_hw[0], min_width=params.data.net_hw[1], border_mode=cv2.BORDER_REPLICATE, always_apply=True)) augs_list.append(albumentations.RandomCrop(height=params.data.net_hw[0], width=params.data.net_hw[1], always_apply=True)) if params.augmentation.rotate_limit: augs_list.append(T.Rotate(limit=params.augmentation.rotate_limit, border_mode=cv2.BORDER_CONSTANT, always_apply=True)) # augs_list.append(T.OpticalDistortion(border_mode=cv2.BORDER_CONSTANT)) - can't handle boundboxes elif mode == 'debug': augs_list.append(albumentations.CenterCrop(height=params.data.net_hw[0], width=params.data.net_hw[1], always_apply=True)) if mode != 'inference': if params.augmentation.get('blur_limit', 4): augs_list.append(T.Blur(blur_limit=params.augmentation.get('blur_limit', 4))) if params.augmentation.get('RandomBrightnessContrast', True): augs_list.append(T.RandomBrightnessContrast()) #augs_list.append(T.MotionBlur()) if params.augmentation.get('JpegCompression', True): augs_list.append(T.JpegCompression(quality_lower=30, quality_upper=100)) #augs_list.append(T.VerticalFlip()) if params.augmentation.get('HorizontalFlip', True): augs_list.append(T.HorizontalFlip()) return albumentations.ReplayCompose(augs_list, p=1., bbox_params = {'format':'albumentations', 'min_visibility':0.5})
def augmentation(mode, target_size, prob=0.5, aug_m=2): ''' description: augmentation mode: 'train' 'test' target_size: int or list, the shape of image , aug_m: Strength of transform ''' high_p = prob low_p = high_p / 2.0 M = aug_m first_size = [int(x / 0.7) for x in target_size] if mode == 'train': return composition.Compose([ transforms.Resize(first_size[0], first_size[1], interpolation=3), transforms.Flip(p=0.5), composition.OneOf([ RandomCenterCut(scale=0.1 * M), transforms.ShiftScaleRotate(shift_limit=0.05 * M, scale_limit=0.1 * M, rotate_limit=180, border_mode=cv2.BORDER_CONSTANT, value=0), albumentations.imgaug.transforms.IAAAffine( shear=(-10 * M, 10 * M), mode='constant') ], p=high_p), transforms.RandomBrightnessContrast( brightness_limit=0.1 * M, contrast_limit=0.03 * M, p=high_p), transforms.HueSaturationValue(hue_shift_limit=5 * M, sat_shift_limit=15 * M, val_shift_limit=10 * M, p=high_p), transforms.OpticalDistortion(distort_limit=0.03 * M, shift_limit=0, border_mode=cv2.BORDER_CONSTANT, value=0, p=low_p), composition.OneOf([ transforms.Blur(blur_limit=7), albumentations.imgaug.transforms.IAASharpen(), transforms.GaussNoise(var_limit=(2.0, 10.0), mean=0), transforms.ISONoise() ], p=low_p), transforms.Resize(target_size[0], target_size[1], interpolation=3), transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5), max_pixel_value=255.0) ], p=1) else: return composition.Compose([ transforms.Resize(target_size[0], target_size[1], interpolation=3), transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5), max_pixel_value=255.0) ], p=1)
def augment(im, params=None): """ Perform data augmentation on some image using the albumentations package. Parameters ---------- im : Numpy array params : dict or None Contains the data augmentation parameters Mandatory keys: - h_flip ([0,1] float): probability of performing an horizontal left-right mirroring. - v_flip ([0,1] float): probability of performing an vertical up-down mirroring. - rot ([0,1] float): probability of performing a rotation to the image. - rot_lim (int): max degrees of rotation. - stretch ([0,1] float): probability of randomly stretching an image. - crop ([0,1] float): randomly take an image crop. - zoom ([0,1] float): random zoom applied to crop_size. --> Therefore the effective crop size at each iteration will be a random number between 1 and crop*(1-zoom). For example: * crop=1, zoom=0: no crop of the image * crop=1, zoom=0.1: random crop of random size between 100% image and 90% of the image * crop=0.9, zoom=0.1: random crop of random size between 90% image and 80% of the image * crop=0.9, zoom=0: random crop of always 90% of the image Image size refers to the size of the shortest side. - blur ([0,1] float): probability of randomly blurring an image. - pixel_noise ([0,1] float): probability of randomly adding pixel noise to an image. - pixel_sat ([0,1] float): probability of randomly using HueSaturationValue in the image. - cutout ([0,1] float): probability of using cutout in the image. Returns ------- Numpy array """ ## 1) Crop the image effective_zoom = np.random.rand() * params['zoom'] crop = params['crop'] - effective_zoom ly, lx, channels = im.shape crop_size = int(crop * min([ly, lx])) rand_x = np.random.randint(low=0, high=lx - crop_size + 1) rand_y = np.random.randint(low=0, high=ly - crop_size + 1) crop = transforms.Crop(x_min=rand_x, y_min=rand_y, x_max=rand_x + crop_size, y_max=rand_y + crop_size) im = crop(image=im)['image'] ## 2) Now add the transformations for augmenting the image pixels transform_list = [] # Add random stretching if params['stretch']: transform_list.append( imgaug_transforms.IAAPerspective(scale=0.1, p=params['stretch'])) # Add random rotation if params['rot']: transform_list.append( transforms.Rotate(limit=params['rot_lim'], p=params['rot'])) # Add horizontal flip if params['h_flip']: transform_list.append(transforms.HorizontalFlip(p=params['h_flip'])) # Add vertical flip if params['v_flip']: transform_list.append(transforms.VerticalFlip(p=params['v_flip'])) # Add some blur to the image if params['blur']: transform_list.append( albumentations.OneOf([ transforms.MotionBlur(blur_limit=7, p=1.), transforms.MedianBlur(blur_limit=7, p=1.), transforms.Blur(blur_limit=7, p=1.), ], p=params['blur'])) # Add pixel noise if params['pixel_noise']: transform_list.append( albumentations.OneOf( [ transforms.CLAHE(clip_limit=2, p=1.), imgaug_transforms.IAASharpen(p=1.), imgaug_transforms.IAAEmboss(p=1.), transforms.RandomBrightnessContrast(contrast_limit=0, p=1.), transforms.RandomBrightnessContrast(brightness_limit=0, p=1.), transforms.RGBShift(p=1.), transforms.RandomGamma(p=1.) #, # transforms.JpegCompression(), # transforms.ChannelShuffle(), # transforms.ToGray() ], p=params['pixel_noise'])) # Add pixel saturation if params['pixel_sat']: transform_list.append( transforms.HueSaturationValue(p=params['pixel_sat'])) # Remove randomly remove some regions from the image if params['cutout']: ly, lx, channels = im.shape scale_low, scale_high = 0.05, 0.25 # min and max size of the squares wrt the full image scale = np.random.uniform(scale_low, scale_high) transform_list.append( transforms.Cutout(num_holes=8, max_h_size=int(scale * ly), max_w_size=int(scale * lx), p=params['cutout'])) # Compose all image transformations and augment the image augmentation_fn = albumentations.Compose(transform_list) im = augmentation_fn(image=im)['image'] return im
def augment(im, params=None): """ Perform data augmentation on some image using the albumentations package. Parameters ---------- im : Numpy array params : dict or None Contains the data augmentation parameters Mandatory keys: - h_flip ([0,1] float): probability of performing an horizontal left-right mirroring. - v_flip ([0,1] float): probability of performing an vertical up-down mirroring. - rot ([0,1] float): probability of performing a rotation to the image. - rot_lim (int): max degrees of rotation. - stretch ([0,1] float): probability of randomly stretching an image. - expand ([True, False] bool): whether to pad the image to a square shape with background color canvas. - crop ([0,1] float): randomly take an image crop. - invert_col ([0, 1] float): randomly invert the colors of the image. p=1 -> invert colors (VPR) - zoom ([0,1] float): random zoom applied to crop_size. --> Therefore the effective crop size at each iteration will be a random number between 1 and crop*(1-zoom). For example: * crop=1, zoom=0: no crop of the image * crop=1, zoom=0.1: random crop of random size between 100% image and 90% of the image * crop=0.9, zoom=0.1: random crop of random size between 90% image and 80% of the image * crop=0.9, zoom=0: random crop of always 90% of the image Image size refers to the size of the shortest side. - blur ([0,1] float): probability of randomly blurring an image. - pixel_noise ([0,1] float): probability of randomly adding pixel noise to an image. - pixel_sat ([0,1] float): probability of randomly using HueSaturationValue in the image. - cutout ([0,1] float): probability of using cutout in the image. Returns ------- Numpy array """ ## 1) Expand the image by padding it with bg-color canvas if params["expand"]: desired_size = max(im.shape) # check bg if np.argmax(im.shape) > 0: bgcol = tuple(np.repeat(int(np.mean(im[[0, -1], :, :])), 3)) else: bgcol = tuple(np.repeat(int(np.mean(im[:, [0, -1], :])), 3)) im = Image.fromarray(im) old_size = im.size # old_size[0] is in (width, height) format ratio = float(desired_size) / max(old_size) new_size = tuple([int(x * ratio) for x in old_size]) im = im.resize(new_size, Image.ANTIALIAS) # create a new image and paste the resized on it new_im = Image.new("RGB", (desired_size, desired_size), color=bgcol) new_im.paste(im, ((desired_size - new_size[0]) // 2, (desired_size - new_size[1]) // 2)) im = np.array(new_im) ## 2) Crop the image if params["crop"] and params["crop"] != 1: effective_zoom = np.random.rand() * params['zoom'] crop = params['crop'] - effective_zoom ly, lx, channels = im.shape crop_size = int(crop * min([ly, lx])) rand_x = np.random.randint(low=0, high=lx - crop_size + 1) rand_y = np.random.randint(low=0, high=ly - crop_size + 1) crop = transforms.Crop(x_min=rand_x, y_min=rand_y, x_max=rand_x + crop_size, y_max=rand_y + crop_size) im = crop(image=im)['image'] if params["enhance"]: im = Image.fromarray(im) enhancer = ImageEnhance.Contrast(im) im = np.array(enhancer.enhance(params["enhance"])) ## 3) Now add the transformations for augmenting the image pixels transform_list = [] if params['invert_col']: transform_list.append(transforms.InvertImg(p=params['invert_col'])) # Add random stretching if params['stretch']: transform_list.append( imgaug_transforms.IAAPerspective(scale=0.1, p=params['stretch'])) # Add random rotation if params['rot']: transform_list.append( transforms.Rotate(limit=params['rot_lim'], p=params['rot'])) # Add horizontal flip if params['h_flip']: transform_list.append(transforms.HorizontalFlip(p=params['h_flip'])) # Add vertical flip if params['v_flip']: transform_list.append(transforms.VerticalFlip(p=params['v_flip'])) # Add some blur to the image if params['blur']: transform_list.append( albumentations.OneOf([ transforms.MotionBlur(blur_limit=7, p=1.), transforms.MedianBlur(blur_limit=7, p=1.), transforms.Blur(blur_limit=7, p=1.), ], p=params['blur'])) # Add pixel noise if params['pixel_noise']: transform_list.append( albumentations.OneOf( [ transforms.CLAHE(clip_limit=2, p=1.), imgaug_transforms.IAASharpen(p=1.), imgaug_transforms.IAAEmboss(p=1.), transforms.RandomBrightnessContrast(contrast_limit=0, p=1.), transforms.RandomBrightnessContrast(brightness_limit=0, p=1.), transforms.RGBShift(p=1.), transforms.RandomGamma(p=1.) #, # transforms.JpegCompression(), # transforms.ChannelShuffle(), # transforms.ToGray() ], p=params['pixel_noise'])) # Add pixel saturation if params['pixel_sat']: transform_list.append( transforms.HueSaturationValue(p=params['pixel_sat'])) # Remove randomly remove some regions from the image if params['cutout']: ly, lx, channels = im.shape scale_low, scale_high = 0.05, 0.25 # min and max size of the squares wrt the full image scale = np.random.uniform(scale_low, scale_high) transform_list.append( transforms.Cutout(num_holes=8, max_h_size=int(scale * ly), max_w_size=int(scale * lx), p=params['cutout'])) # Compose all image transformations and augment the image augmentation_fn = albumentations.Compose(transform_list) im = augmentation_fn(image=im)['image'] return im