def get_transform(train: bool, im_size: int = 400): if train: transforms = A.Compose([ A.Resize( height=im_size, width=im_size, interpolation=cv2.INTER_CUBIC), A.ChannelShuffle(p=0.5), A.HorizontalFlip(p=0.5), A.ColorJitter(p=0.5), A.VerticalFlip(p=0.5), A.Blur(p=0.5), A.Normalize(), ToTensorV2(), ], bbox_params=A.BboxParams( format='pascal_voc', label_fields=['category_ids'])) else: transforms = A.Compose([ A.Resize( height=im_size, width=im_size, interpolation=cv2.INTER_CUBIC), A.Normalize(), ToTensorV2(), ], bbox_params=A.BboxParams( format='pascal_voc', label_fields=['category_ids'])) return transforms
def cifar_alb_trainData(): '''Apply Albumentations data transforms to the dataset and returns iterable''' train_transform = [ A.HorizontalFlip(p=0.15), A.ShiftScaleRotate(shift_limit=0.05, scale_limit=0.05, rotate_limit=15, p=0.25), A.RGBShift(r_shift_limit=15, g_shift_limit=15, b_shift_limit=15, p=0.5), A.RandomBrightnessContrast(p=0.25), A.RandomGamma(p=0.25), A.CLAHE(p=0.25), A.ChannelShuffle(p=0.1), A.ElasticTransform(p=0.1), A.MotionBlur(blur_limit=17, p=0.1), A.Cutout(num_holes=1, max_h_size=16, max_w_size=16, fill_value=mean, always_apply=False, p=0.5), A.Normalize(mean=mean, std=std), ToTensor() ] transforms_result = A.Compose(train_transform) return lambda img: transforms_result(image=np.array(img))["image"]
def album(self): #이미지 변환 transform = A.Compose([ #A.RandomRotate90(), A.Flip(p=0.2), #A.Transpose(), A.ChannelShuffle(p=0.3), A.ElasticTransform(p=0.3,border_mode=cv2.BORDER_REFLECT_101,alpha_affine=40), A.OneOf([ A.IAAAdditiveGaussianNoise(), A.GaussNoise(), ], p=0.2), A.OneOf([ A.MotionBlur(p=.2), A.MedianBlur(blur_limit=3, p=0.1), A.Blur(blur_limit=3, p=0.1), ], p=0.2), A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2), A.OneOf([ A.OpticalDistortion(p=0.3), A.GridDistortion(p=.1), A.IAAPiecewiseAffine(p=0.3), ], p=0.2), A.OneOf([ A.CLAHE(clip_limit=2), A.IAASharpen(), A.IAAEmboss(), A.RandomBrightnessContrast(), ], p=0.3), A.HueSaturationValue(p=0.3), ]) image = cv2.cvtColor(self.srcResize, cv2.COLOR_BGR2RGB) transformed = transform(image=image)['image'] self.update(transformed)
def get_transform(is_train): if is_train: return albumentations.Compose( [ albumentations.Resize(224,224), albumentations.OneOf([ albumentations.JpegCompression(quality_lower=20, quality_upper=70, p=0.5), albumentations.Downscale(scale_min=0.25, scale_max=0.50, interpolation=1, p=0.5), ], p=0.6), albumentations.HorizontalFlip(p=0.5), albumentations.VerticalFlip(p=0.5), # albumentations.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=45), albumentations.GaussNoise(p=0.2), albumentations.RandomBrightnessContrast(0.3,0.3, p=0.7), albumentations.RandomGamma(p=0.2), albumentations.CLAHE(p=0.2), albumentations.ChannelShuffle(p=0.2), albumentations.MultiplicativeNoise(multiplier=[0.5, 1.5], elementwise=True, p=0.3), albumentations.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=10, val_shift_limit=10, p=0.7), albumentations.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0) ]) else: return albumentations.Compose( [ albumentations.Resize(224,224), albumentations.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0) ])
def get_transform(train: bool, im_size: int = 400): if train: aug = A.Compose([ A.OneOf([ A.RandomSizedCrop(min_max_height=(224, 720), height=im_size, width=im_size, p=0.5), A.Resize(height=im_size, width=im_size, interpolation=cv2.INTER_CUBIC, p=0.5) ], p=1), A.ChannelShuffle(p=0.5), A.HorizontalFlip(p=0.5), A.ColorJitter(p=0.5), A.Blur(p=0.5), A.Normalize(), ToTensorV2(), ]) else: aug = A.Compose([ A.Resize(height=im_size, width=im_size, interpolation=cv2.INTER_CUBIC), A.Normalize(), ToTensorV2(), ]) return aug
def get_train_transforms(): return A.Compose([ A.RandomSizedCrop((140, 140), width=160, height=160, p=0.25), A.OneOf([ A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.9), A.RandomBrightnessContrast( brightness_limit=0.2, contrast_limit=0.2, p=0.9), ], p=0.9), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.Rotate(limit=45, p=1), A.ChannelShuffle(p=0.05), A.FancyPCA(), A.GaussNoise(p=0.25), A.Blur(blur_limit=4, p=0.1), A.Cutout(num_holes=8, max_h_size=4, max_w_size=4, fill_value=0, p=0.1), A.Resize( 160, 160, ), A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), ToTensorV2(p=1.0), ], p=1.0)
def augmentations(image_size: int): channel_augs = [ A.HueSaturationValue(p=0.5), A.ChannelShuffle(p=0.5), ] result = [ # *pre_transform(image_size), A.OneOf([ A.IAAAdditiveGaussianNoise(), A.GaussNoise(), ], p=0.5), A.OneOf([ A.MotionBlur(blur_limit=3, p=0.7), A.MedianBlur(blur_limit=3, p=1.0), A.Blur(blur_limit=3, p=0.7), ], p=0.5), A.OneOf(channel_augs), A.OneOf([ A.CLAHE(clip_limit=2), A.IAASharpen(), A.IAAEmboss(), ], p=0.5), A.RandomBrightnessContrast(brightness_limit=0.5, contrast_limit=0.5, p=0.5), A.RandomGamma(p=0.5), A.OneOf([A.MedianBlur(p=0.5), A.MotionBlur(p=0.5)]), A.RandomGamma(gamma_limit=(85, 115), p=0.5), ] return A.Compose(result, bbox_params=BBOX_PARAMS)
def __init__(self, input_shape, train): self.transform = None try: import albumentations as A check_version(A.__version__, '1.0.3', hard=True) # version requirement if train: # lane mark used self.transform = A.Compose([ A.Resize(height=input_shape[0], width=input_shape[0], interpolation=cv2.INTER_AREA), A.RandomRotate90(p=0.5), A.VerticalFlip(p=0.5), A.HorizontalFlip(p=0.5), A.ChannelShuffle(p=0.5), A.OpticalDistortion(p=0.5), A.GridDistortion(p=0.5), A.HueSaturationValue(p=0.5), A.RandomBrightnessContrast(0.5), A.Transpose(p=0.5) ]) else: self.transform = A.Compose( [A.Resize(input_shape[0], input_shape[1])], ) except ImportError: # package not installed, skip pass
def rgd_shuffle_mo_blur(p=1.0): return albumentations.Compose([ albumentations.ChannelShuffle(p=p), albumentations.MotionBlur(p=p), albumentations.RandomBrightness(p=1) ], p=p)
def get_next_augmentation(): train_transform = [ albu.ChannelShuffle(p=0.1), albu.IAAAdditiveGaussianNoise(p=0.2), albu.OneOf( [ albu.CLAHE(p=1), albu.RandomBrightness(p=1), albu.RandomGamma(p=1), ], p=0.9, ), albu.OneOf( [ albu.IAASharpen(p=1), albu.Blur(blur_limit=3, p=1), albu.MotionBlur(blur_limit=3, p=1), ], p=0.9, ), albu.OneOf( [ albu.RandomContrast(p=1), albu.HueSaturationValue(p=1), ], p=0.9, ), ] return albu.Compose(train_transform)
def __init__(self, used_img_size, final_img_size, transform_params): self._ratio = max( float(final_img_size[0]) / used_img_size[0], float(final_img_size[1]) / used_img_size[1]) self._final_img_size = final_img_size self._scale_compose = [ albumentations.Resize(height=int(used_img_size[0] * self._ratio), width=int(used_img_size[1] * self._ratio), always_apply=True), albumentations.CenterCrop(height=self._final_img_size[0], width=self._final_img_size[1], always_apply=True, p=1), ] self._normalize_transform = albumentations.Normalize() self._normalize_no_transform = albumentations.Normalize(mean=(0, 0, 0), std=(1, 1, 1)) self._train_compose = self._scale_compose if transform_params["filters"]: self._train_compose = [ albumentations.RandomBrightnessContrast( brightness_limit=(-0.1, 0.1), contrast_limit=(-0.1, 0.1), p=0.2), albumentations.RandomGamma(gamma_limit=(90, 110), p=0.2), albumentations.ChannelShuffle(p=0.2), ] + self._scale_compose if transform_params["normalize"]: self._train_compose.append(albumentations.Normalize()) else: self._train_compose.append( albumentations.Normalize(mean=(0, 0, 0), std=(1, 1, 1)))
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 get_transform(train: bool, im_size: int = 400): if train: aug = A.Compose([ A.OneOf([ A.RandomSizedCrop(min_max_height=(224, 720), height=im_size, width=im_size, p=0.5), A.Resize(height=im_size, width=im_size, interpolation=cv2.INTER_CUBIC, p=0.5) ], p=1), A.ChannelShuffle(p=0.5), A.HorizontalFlip(p=0.5), A.ColorJitter(p=0.5), # A.OneOf([ # A.ElasticTransform(alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03, p=0.5), # A.GridDistortion(p=0.5), # A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1) # ], p=0.8), A.Blur(p=0.5), A.Normalize(), ToTensorV2(), ]) else: aug = A.Compose([ A.Resize(height=im_size, width=im_size, interpolation=cv2.INTER_CUBIC), A.Normalize(), ToTensorV2(), ]) return aug
def get_training_augmentation(min_area=0., min_visibility=0.): train_transform = [ albu.OneOf([ albu.ISONoise(p=.5), albu.GaussNoise(p=0.4), albu.Blur(blur_limit=3, p=0.1), ]), albu.OneOf([ albu.CLAHE(clip_limit=2), ], p=0.2), albu.OneOf([ albu.RandomSnow(snow_point_lower=0., snow_point_upper=0.2, brightness_coeff=2., p=0.5), albu.RandomSunFlare(p=0.5), ]), albu.OneOf([ albu.RGBShift(p=0.1), albu.ChannelShuffle(p=0.2), ]) ] return albu.Compose(train_transform, bbox_params={ 'format': 'coco', 'min_area': min_area, 'min_visibility': min_visibility, 'label_fields': ['category_id'] })
def get_train_transform(): transforms = [] if args.hflip: transforms.append(A.VerticalFlip(p=args.hflip)) if args.vflip: transforms.append(A.HorizontalFlip(p=args.vflip)) if args.sharpen: transforms.append(A.IAASharpen(p=args.sharpen)) if args.ssr: transforms.append(A.ShiftScaleRotate(p=args.ssr)) if args.channelshuffle: transforms.append(A.ChannelShuffle(p=args.channelshuffle)) # if args.clahe: # transforms.append(A.CLAHE(p=args.clahe)) if args.oneofcgb: transforms.append( A.OneOf([ A.RandomContrast(), A.RandomGamma(), A.RandomBrightness(), ], p=args.oneofcgb)) transforms.append(A.Resize(256, 256)) transforms.append(A.Normalize()) transforms.append(ToTensorV2(p=1)) return A.Compose(transforms)
def tr_normalization(self, img): norm = A.Compose([ A.RGBShift(p=0.6), A.ChannelShuffle(p=0.6), A.RandomBrightnessContrast(p=0.6), A.Normalize(mean=self.mean, std=self.std, p=1) ]) return norm(image=img)['image']
def test_channel_shuffle(): aug = A.Compose( [A.ChannelShuffle(always_apply=True)], additional_targets={'image2': 'image'}) for i in range(10): image1 = np.random.randint(low=0, high=256, size=(100, 100, 3), dtype=np.uint8) image2 = image1.copy() res = aug(image=image1, image2=image2) aug1 = res['image'] aug2 = res['image2'] assert np.array_equal(aug1, aug2)
def __init__( self, dataset, flip_probs=(0.1, 0.1, 0.2), jitter_prob=0, random_crop=True, random_rescale_prob=0, rescale_distr=(.8, 1.2), crop_size=(128, 128), # channels_first=True, normalize=True, hard_alternative_ds=None, hard_prob=0): if isinstance(flip_probs, float) or isinstance(flip_probs, int): flip_probs = tuple(np.ones(3) * flip_probs) self.flip_probs = flip_probs self.jitter_prob = jitter_prob self.random_crop = random_crop self.crop_size = crop_size self.dataset = dataset # self.channels_first = channels_first self.normalize = normalize self.rescale_distr = rescale_distr self.random_rescale_prob = random_rescale_prob self.hard_alternative_ds = hard_alternative_ds self.hard_prob = hard_prob if hasattr(self.dataset, 'quadratic'): self.quadratic = dataset.quadratic else: self.quadratic = dataset.dataset.quadratic if self.quadratic: additional_targets = { 'imager': 'image', 'y': 'image', 'imagell': 'image', 'imagerr': 'image' } else: additional_targets = {'imager': 'image', 'y': 'image'} self.jitter = A.Compose([ A.CLAHE(p=0.5), A.RandomBrightnessContrast(p=.5), A.HueSaturationValue(hue_shift_limit=40, sat_shift_limit=50, val_shift_limit=50, p=1), A.ChannelShuffle(p=.5) ], p=1, additional_targets=additional_targets)
def __init__(self, used_img_size, final_img_size, transform_params, custom_additional_targets=None): if custom_additional_targets is None: custom_additional_targets = { "image2": "image", "image3": "image", "image4": "image" } self._custom_additional_targets = custom_additional_targets self._ratio = max( float(final_img_size[0]) / used_img_size[0], float(final_img_size[1]) / used_img_size[1]) self._final_img_size = final_img_size self._scale_compose = [ albumentations.Resize(height=int(used_img_size[0] * self._ratio), width=int(used_img_size[1] * self._ratio), always_apply=True), albumentations.CenterCrop(height=self._final_img_size[0], width=self._final_img_size[1], always_apply=True, p=1) ] self._normalize_transform = albumentations.Normalize() self._normalize_no_transform = albumentations.Normalize(mean=(0, 0, 0), std=(1, 1, 1)) self._train_compose = self._scale_compose if "flip" in transform_params and transform_params["flip"]: flip_compose = [albumentations.HorizontalFlip()] self._train_compose = flip_compose + self._train_compose if "filters" in transform_params and transform_params["filters"]: random_compose = [ albumentations.RandomBrightnessContrast(brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2), p=0.5), albumentations.RandomGamma(gamma_limit=(90, 110), p=0.5), albumentations.ChannelShuffle(p=0.5), ] self._train_compose = random_compose + self._train_compose if "normalize" in transform_params and transform_params["normalize"]: self._train_compose.append(albumentations.Normalize()) else: self._train_compose.append( albumentations.Normalize(mean=(0, 0, 0), std=(1, 1, 1)))
def train_augs(self): augs = [] if self.image_size is not None: augs.append(A.Resize(self.image_size, self.image_size)) if self.normalize: # imagenet normalization augs.append( A.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], max_pixel_value=255.0, p=1.0, ) ) if self.apply_augs: img_augs = [ A.HorizontalFlip(p=0.5), A.ChannelShuffle(p=0.1), A.OneOf( [ A.HueSaturationValue( hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5, ), A.RandomBrightnessContrast( brightness_limit=0.2, contrast_limit=0.2, p=0.5 ), ], p=0.5, ), A.ToGray(p=0.01), A.RandomGamma(p=0.1), A.Sharpen(p=0.1), A.Cutout( num_holes=8, max_h_size=64, max_w_size=64, fill_value=0, p=0.2 ), ] augs = augs + img_augs if self.bbox_format is not None: return A.Compose( augs, bbox_params=A.BboxParams( format=self.bbox_format, min_area=0, min_visibility=0, label_fields=["labels"], ), ) return A.Compose(augs)
def augment_image_by_image(path_to_image, path_to_destiny='Dataset/augmented_logo', path_to_logo='Dataset/main_logo.png', logo=True, amount=1): random.seed() if logo: input1 = cv2.imread(path_to_logo, cv2.IMREAD_UNCHANGED) input2 = cv2.imread(path_to_image) for _ in range(amount): image = input2 if logo: logo = input1 blue, green, red = random.randint(0, 255), random.randint( 0, 255), random.randint(0, 255) logo[np.where((logo == [0, 0, 0, 255]).all(axis=2))] = blue, green, red, 255 h_bg, w_bg = image.shape[:2] final_size_logo = random.randrange(100, min(h_bg, w_bg)) h_offset, w_offset = random.randrange(0, h_bg - final_size_logo), \ random.randrange(0, w_bg - final_size_logo) image = overlay_transparent(image, logo, w_offset, h_offset, (final_size_logo, final_size_logo)) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) augment = A.Compose([ A.ShiftScaleRotate( p=1, shift_limit=0.02, rotate_limit=35, scale_limit=0.07), A.OneOf([ A.ChannelShuffle(p=0.45), A.HueSaturationValue( hue_shift_limit=20, sat_shift_limit=50, val_shift_limit=50) ]), A.Blur(p=0.4), A.GaussNoise(p=0.6, var_limit=30), A.GridDistortion(), A.RandomRotate90(), A.ElasticTransform(approximate=True, alpha=3, p=1), ], p=1) res = augment(image=image) # plt.imshow(res['image']) # plt.show() filename = datetime.now().strftime("%Y%m%d-%H%M%S-%f") + '.jpg' file = os.path.join(path_to_destiny, filename) cv2.imwrite(file, res['image'])
def __call__(self, sample): frames, targets = sample color_twister = A.Compose([ A.ChannelShuffle(p=0.5), A.RGBShift( r_shift_limit=50, g_shift_limit=50, b_shift_limit=50, p=0.5), ], p=1) frames = [color_twister(image=frame)["image"] for frame in frames] frames = np.array(frames).astype('uint8') return frames, targets
def blur_and_distortion(self, kernel_size=(3, 3)): # Blur & Distortion aug = A.Compose( [ A.OneOf( [ A.Blur( blur_limit=kernel_size, p=self.p ), # Blur the input image using a random-sized kernel. A.MotionBlur( blur_limit=kernel_size, p=self.p ), # Apply motion blur to the input image using a random-sized kernel. A.MedianBlur( blur_limit=kernel_size, p=self.p ), # Blur the input image using using a median filter with a random aperture linear size. A.GaussianBlur( blur_limit=kernel_size, p=self.p ) # Blur the input image using using a Gaussian filter with a random kernel size. ], p=1), A.OneOf( [ A.RandomGamma(gamma_limit=(80, 120), p=self.p), A.OpticalDistortion( distort_limit=0.05, shift_limit=0.05, p=self.p), A.ElasticTransform(p=self.p), A.HueSaturationValue( p=self.p ), # Randomly change hue, saturation and value of the input image. A.RGBShift( p=self.p ), # Randomly shift values for each channel of the input RGB image. A.ChannelShuffle( p=self.p ), # Randomly rearrange channels of the input RGB image. A.CLAHE( p=self.p ), # Apply Contrast Limited Adaptive Histogram Equalization to the input image. A.InvertImg( p=self.p ), # Invert the input image by subtracting pixel values from 255. ], p=1), A.GaussNoise( var_limit=(10.0, 50.0), mean=0, p=self.p), # Apply gaussian noise to the input image. A.RandomShadow(p=self.p) # Simulates shadows for the image ], p=1) return aug
def color_augment_pool(): augs = [ A.RGBShift(), A.ToGray(), A.ChannelShuffle(), A.CLAHE(), A.HueSaturationValue(), A.RandomContrast(), A.RandomGamma(), A.Blur(), A.MedianBlur(), A.JpegCompression() ] return augs
def get_transform(name='default', resize=512): if name == 'default': transform = A.Compose([ A.Resize(resize, resize), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.OneOf([ A.RandomContrast(), A.RandomGamma(), A.RandomBrightness(), A.ColorJitter(brightness=0.07, contrast=0.07, saturation=0.1, hue=0.1, always_apply=False, p=0.3), ], 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.0), A.ShiftScaleRotate(), ]) elif name == 'train1': transform = A.Compose([ A.RandomCrop(resize, resize, True), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.ColorJitter(brightness=0.07, contrast=0.07, saturation=0.1, hue=0.1, always_apply=False, p=0.3), A.ElasticTransform(alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), A.ChannelShuffle(p=0.6) ]) elif name == 'val' or name == 'test': transform = A.Compose([A.Resize(resize, resize)]) else: return None return transform
def run_train(data_path: Path): cfg = BasicConfig( seed=444, name='test_center_vgg_retrain2', num_workers=4, gpus=(0,), batch_size=24, num_epochs=15, steps=(4, 9, np.inf), warmup_epoch=1, cooldown_epoch=2, train_augmentations=alb.Compose([ alb.Resize(128, 128), alb.OneOf([ alb.MotionBlur(blur_limit=5, p=0.2), alb.MedianBlur(blur_limit=3, p=0.1), alb.Blur(blur_limit=5, p=0.1) ], p=0.2), alb.OneOf([ alb.ImageCompression(70, compression_type=alb.ImageCompression.ImageCompressionType.JPEG), alb.ImageCompression(70, compression_type=alb.ImageCompression.ImageCompressionType.WEBP) ], p=0.2), alb.OneOf([ alb.CLAHE(clip_limit=2), alb.IAASharpen(), alb.IAAEmboss(), alb.RandomBrightnessContrast(), ], p=0.1), alb.Rotate(5, border_mode=cv2.BORDER_REFLECT, p=0.2), alb.OneOf([ alb.RandomResizedCrop(112, 112, scale=(0.9, 1.0), ratio=(0.8, 1.1), p=0.5), alb.Resize(112, 112, p=0.5), ], p=1.0), alb.HorizontalFlip(p=0.5), alb.HueSaturationValue(p=0.7), alb.ChannelShuffle(p=0.5) ]), normalize=True, weight_normalize=True, uniform_subjects=True, classifier_mult=3, lr_factor=0.1, initial_lr=1e-2, # extra_rec=(Path('/run/media/andrey/Fast/FairFace/faces_emore/train.rec'),) ) np.random.seed(cfg.seed) mx.random.seed(cfg.seed) train_df = load_info(data_path, Path('data/train_df.csv')) lib.train.train(cfg, train_df)
def __init__(self, p=0.5): self.zhiguang = True if self.zhiguang: self.blur = albu.Blur(blur_limit=3, p=0.5) self.chanelshuffle = albu.ChannelShuffle(p=0.5) self.hueSaturation = albu.HueSaturationValue(p=0.5) #albu.InvertImg(p=0.2), self.togray = albu.ToGray(p=0.2) else: self.p = p self.scr = albu.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.0, rotate_limit=15, p=self.p) self.ig = albu.IAAAdditiveGaussianNoise(p=self.p) self.ipa = albu.IAAPiecewiseAffine(p=self.p)
def get_training_augmentation(): train_transform = [ albu.HorizontalFlip(p=0.5), albu.VerticalFlip(p=0.2), albu.ShiftScaleRotate(scale_limit=0.5, rotate_limit=50, shift_limit=0.1, p=1, border_mode=0), #320 384 448 512 640 # albu.GridDistortion(num_steps=2, distort_limit=0.2, interpolation=1, border_mode=0, value=None, always_apply=False, p=0.5), albu.PadIfNeeded(min_height=padheight, min_width=padwidth, always_apply=True, border_mode=0), albu.Resize(height=padheight, width=padwidth), albu.RandomCrop(height=inputheight, width=inputwidth, always_apply=True), #the last size albu.ChannelShuffle(p=0.1), albu.IAAAdditiveGaussianNoise(p=0.2), albu.IAAPerspective(p=0.5), albu.OneOf( [ albu.CLAHE(p=1), albu.RandomBrightness(p=1), albu.RandomGamma(p=1), ], p=0.9, ), albu.OneOf( [ albu.IAASharpen(p=1), albu.Blur(blur_limit=3, p=1), albu.MotionBlur(blur_limit=3, p=1), ], p=0.9, ), albu.OneOf( [ albu.RandomContrast(p=1), albu.HueSaturationValue(p=1), ], p=0.9, ), ] return albu.Compose(train_transform)
def get_train_transform(self): if self.fullsizeimage: resize_height = 640 resize_width = 1280 else: resize_height = 512 resize_width = 512 return A.Compose( [ A.OneOf( [ A.RandomBrightnessContrast(p=0.5), A.RGBShift(p=0.5), A.HueSaturationValue(p=0.5), A.ToGray(p=0.5), A.ChannelDropout(p=0.5), A.ChannelShuffle(p=0.5), ], p=0.5, ), A.OneOf( [ A.Blur(p=0.5), A.GaussNoise(p=0.5), A.IAASharpen(p=0.5), ], p=0.5, ), A.OneOf( [ A.Rotate(limit=20, p=0.5), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), ], p=0.5, ), A.Resize(height=resize_height, width=resize_width, p=1.0), ToTensorV2(p=1.0), ], bbox_params=A.BboxParams( format="pascal_voc", min_area=0, min_visibility=0, label_fields=["labels"], ), )
def bboxes_augmentation(cfg): ''' ''' transforms = [] if cfg['smallest'] > 0: transforms += [ albumentations.SmallestMaxSize(max_size=cfg['smallest'], p=1.0) ] if cfg.get('random_crop', 0): # transforms += [OneOf([albumentations.RandomCrop(height=1024, width=1024, p=0.8), # albumentations.RandomCrop(height=720, width=720, p=0.8),], p=1.),] if cfg.get('safe_crop', 0): transforms += [ albumentations.RandomSizedBBoxSafeCrop(height=cfg['height'], width=cfg['width'], p=1.) ] else: transforms += [ albumentations.RandomSizedCrop(cfg['min_max_height'], height=cfg['height'], width=cfg['width'], p=1.0) ] if cfg.get('flip', 0): transforms += [albumentations.HorizontalFlip(p=0.5)] transforms += [ albumentations.RandomBrightness(limit=0.2, p=0.3), albumentations.RandomContrast(limit=0.2, p=0.3), albumentations.Blur(blur_limit=5, p=0.2), albumentations.GaussNoise(var_limit=(5, 20), p=0.2), albumentations.ChannelShuffle(p=0.2), ] bbox_params = { 'format': 'pascal_voc', 'min_visibility': cfg['min_visibility'], 'label_fields': ['labels'], 'min_area': cfg['min_area'] } if cfg['bbox'] else {} return Compose(transforms, bbox_params=bbox_params, p=1.)