def get_train_transform(mu, sigma): """ Args: tensor (Tensor): Tensor image of size (C, H, W) to be normalized. Returns: Tensor: Normalized image. """ train_transform = A.Compose([ A.HorizontalFlip(p=0.4), A.ShiftScaleRotate(), A.Normalize(mean=(mu), std=(sigma)), A.CoarseDropout(max_holes=1, max_height=16, max_width=16, min_holes=1, min_height=16, min_width=16, fill_value=(mu)), A.ToGray(), ToTensorV2(), ]) return(train_transform)
def get_train_transforms(): return A.Compose([ A.HueSaturationValue(hue_shift_limit=0.4, sat_shift_limit=0.4, val_shift_limit=0.4, p=0.5), A.OneOf([ A.RandomGamma(p=0.5), A.RandomBrightnessContrast( brightness_limit=0.4, contrast_limit=0.85, p=0.5) ], p=0.5), A.Blur(p=0.5), A.ToGray(p=0.1), A.RandomRotate90(p=0.5), A.Resize(height=1024, width=1024, p=1), A.Cutout( num_holes=10, max_h_size=64, max_w_size=64, fill_value=0, p=0.5), ToTensorV2(p=1.0), ], p=1.0, bbox_params=A.BboxParams(format='pascal_voc', min_area=0, min_visibility=0, label_fields=['labels']))
def get_train_transforms(): return A.Compose( [ A.RandomSizedCrop(min_max_height=(800, 800), height=1024, width=1024, p=0.5), A.OneOf([ A.HueSaturationValue(hue_shift_limit=0.1, sat_shift_limit= 0.3, val_shift_limit=0.3, p=0.9), A.RandomBrightnessContrast(brightness_limit=0.4, contrast_limit=0.3, p=0.9), ],p=0.9), A.ToGray(p=0.01), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.Resize(height=512, width=512, p=1), A.Cutout(num_holes=8, max_h_size=64, max_w_size=64, fill_value=0, p=0.5), ToTensorV2(p=1.0), ], p=1.0, bbox_params=A.BboxParams( format='pascal_voc', min_area=0, min_visibility=0, label_fields=['labels'] ) )
def get_train_transforms(): return A.Compose( [ A.RandomSizedCrop( min_max_height=(650, 1024), height=1024, width=1024, p=0.5), A.OneOf([ A.HueSaturationValue(hue_shift_limit=0.68, sat_shift_limit=0.68, val_shift_limit=0.1, p=0.9), A.RandomGamma(p=0.9), A.RandomBrightnessContrast( brightness_limit=0.1, contrast_limit=0.1, p=0.9), ], p=0.9), # A.CLAHE(p=1.0), A.ToGray(p=0.01), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.RandomRotate90(p=0.5), A.Resize(height=512, width=512, p=1), A.CoarseDropout(max_holes=20, max_height=32, max_width=32, fill_value=0, p=0.25), ToTensorV2(p=1.0), ], p=1.0, bbox_params=A.BboxParams(format='pascal_voc', min_area=0, min_visibility=0, label_fields=['labels']))
def apply_transforms(mean, std): train_transforms = A.Compose([ A.HorizontalFlip(p=0.2), A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=10, p=0.2), A.CoarseDropout( max_holes=1, max_height=16, max_width=16, min_holes=1, min_height=16, min_width=16, fill_value=tuple((x * 255.0 for x in mean)), p=0.2, ), A.ToGray(p=0.15), A.Normalize(mean=mean, std=std, always_apply=True), ToTensorV2(), ]) test_transforms = A.Compose([ A.Normalize(mean=mean, std=std, always_apply=True), ToTensorV2(), ]) return lambda img: train_transforms(image=np.array(img))[ "image"], lambda img: test_transforms(image=np.array(img))["image"] # if __name__ == "__main__": # pass
def __init__(self, images_path, labels_path, input_size, transform=None, multiscale=False, normalized_bboxes=True, balance_classes=False, class_names=None, single_channel=True): self.img_files = [] self.label_files = [] self.input_size = input_size self.transform = transform self.normalized_bboxes = normalized_bboxes self.multiscale = multiscale self.min_input_size = self.input_size - 3 * 32 # Network stride self.max_input_size = self.input_size + 3 * 32 self.balance_classes = balance_classes self.class_counter = np.zeros(len(class_names)) self.ignored, self.total = 0, 0 self.single_channel = single_channel self.batch_count = 0 # Data format self.data_format = A.Compose([ A.ToGray(p=1.0), A.LongestMaxSize(max_size=self.input_size, interpolation=cv2.INTER_AREA), A.PadIfNeeded(min_height=self.input_size, min_width=self.input_size, border_mode=cv2.BORDER_CONSTANT, value=(128, 128, 128)), ], p=1) # Get files self.img_files = [] self.label_files = [] for filename in os.listdir(images_path): img_path = os.path.join(images_path, filename) label_path = os.path.join(labels_path, filename.replace(".jpg", ".txt").replace(".png", ".txt")) # Check if label file exists if os.path.exists(label_path): self.img_files.append(img_path) self.label_files.append(label_path)
def get_preprocess(input_size, use_crop=False, use_center_crop=False, center_crop_ratio=0.9, use_gray=False): if isinstance(input_size, int): input_size = (input_size, input_size) if use_crop: resize = [ al.Resize(int(input_size[0] * 1.1), int(input_size[1] * 1.1)), al.RandomSizedCrop(min_max_height=(int(input_size[0] * 0.7), int(input_size[0] * 1.1)), height=input_size[0], width=input_size[1]) ] elif use_center_crop: resize = [ al.Resize(int(input_size[0] * (2. - center_crop_ratio)), int(input_size[1] * (2. - center_crop_ratio))), al.CenterCrop(input_size[0], input_size[1]) ] else: resize = [al.Resize(input_size[0], input_size[1])] return al.Compose( resize + [al.ToGray(p=1. if use_gray else 0.), al.Normalize(), ToTensorV2()])
def get_training_augmentation(type='basic'): if type == 'basic': train_transform = [ album.RandomCrop(height=1024, width=1024, always_apply=True), album.HorizontalFlip(p=0.5), album.VerticalFlip(p=0.5), ] elif type == 'advance': train_transform = [ album.RandomCrop(height=1024, width=1024, always_apply=True), album.HorizontalFlip(p=0.5), album.VerticalFlip(p=0.5), album.RandomBrightnessContrast(brightness_limit=0.25, contrast_limit=0.25), album.HueSaturationValue(p=0.5), album.Blur(blur_limit=7, p=0.5), album.ToGray(p=0.5), album.IAASharpen(p=0.5), ] elif type == 'intermediate': train_transform = [ album.RandomCrop(height=1024, width=1024, always_apply=True), album.HorizontalFlip(p=0.5), album.VerticalFlip(p=0.5), album.Rotate(limit=90, p=0.5), album.RandomBrightnessContrast(brightness_limit=0.25, contrast_limit=0.25), album.HueSaturationValue(p=0.5), ] else: raise ValueError(f'type {type} is not supported') return album.Compose(train_transform)
def aug_train(): ''' augmentation for training a FR-system ''' aug = alt.Compose([ alt.Resize(height=112, width=112), alt.HorizontalFlip(p=0.5), alt.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=20, val_shift_limit=10, p=0.2), alt.RGBShift(r_shift_limit=20, g_shift_limit=20, b_shift_limit=20, p=0.2), alt.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.3), alt.ToGray(p=0.01), alt.MotionBlur(blur_limit=7, p=0.2), # default=11 alt.GaussianBlur(blur_limit=7, p=0.2), # default=11 alt.GaussNoise(var_limit=(5.0, 20.0), mean=0, p=0.1), # defalt var_limit=(10.0, 30.0) alt.ISONoise(p=0.2), alt.Normalize(), ToTensor() ]) return aug
def get_train_transforms(cfg): image_size = cfg["image_size"] return A.Compose([ A.RandomSizedCrop(min_max_height=(image_size - 200, image_size - 200), height=image_size, width=image_size, p=0.5), 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), A.GaussNoise( var_limit=(0.01, .005), mean=0, always_apply=False, p=0.6), ], p=0.9), A.ToGray(p=0.01), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.Resize(height=image_size, width=image_size, p=1), A.CoarseDropout( max_holes=8, max_height=32, max_width=128, fill_value=0, p=0.3), A.CoarseDropout( max_holes=8, max_height=128, max_width=32, fill_value=0, p=0.3), ToTensorV2(p=1.0), ], p=1.0, bbox_params=A.BboxParams(format='pascal_voc', min_area=0, min_visibility=0, label_fields=['labels']))
def __init__(self, root_dir, is_train): super(FaceDataset, self).__init__() #self.local_rank = local_rank self.is_train = is_train self.input_size = 256 self.num_kps = 68 transform_list = [] if is_train: transform_list += \ [ A.ColorJitter(brightness=0.8, contrast=0.5, p=0.5), A.ToGray(p=0.1), A.ISONoise(p=0.1), A.MedianBlur(blur_limit=(1,7), p=0.1), A.GaussianBlur(blur_limit=(1,7), p=0.1), A.MotionBlur(blur_limit=(5,12), p=0.1), A.ImageCompression(quality_lower=50, quality_upper=90, p=0.05), A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.2, rotate_limit=40, interpolation=cv2.INTER_LINEAR, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=0.8), A.HorizontalFlip(p=0.5), RectangleBorderAugmentation(limit=0.33, fill_value=0, p=0.2), ] transform_list += \ [ A.geometric.resize.Resize(self.input_size, self.input_size, interpolation=cv2.INTER_LINEAR, always_apply=True), A.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]), ToTensorV2(), ] self.transform = A.ReplayCompose(transform_list, keypoint_params=A.KeypointParams( format='xy', remove_invisible=False)) self.root_dir = root_dir with open(osp.join(root_dir, 'annot.pkl'), 'rb') as f: annot = pickle.load(f) self.X, self.Y = annot train_size = int(len(self.X) * 0.99) if is_train: self.X = self.X[:train_size] self.Y = self.Y[:train_size] else: self.X = self.X[train_size:] self.Y = self.Y[train_size:] #if local_rank==0: # logging.info('data_transform_list:%s'%transform_list) flip_parts = ([1, 17], [2, 16], [3, 15], [4, 14], [5, 13], [6, 12], [7, 11], [8, 10], [18, 27], [19, 26], [20, 25], [21, 24], [22, 23], [32, 36], [33, 35], [37, 46], [38, 45], [39, 44], [40, 43], [41, 48], [42, 47], [49, 55], [50, 54], [51, 53], [62, 64], [61, 65], [68, 66], [59, 57], [60, 56]) self.flip_order = np.arange(self.num_kps) for pair in flip_parts: self.flip_order[pair[1] - 1] = pair[0] - 1 self.flip_order[pair[0] - 1] = pair[1] - 1 logging.info('len:%d' % len(self.X)) print('!!!len:%d' % len(self.X))
def get_transform(stage, gb_prob=1.0, solarize_prob=0.): t_list = [] normalize = A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) if stage in ('train', 'val'): t_list = [ A.RandomResizedCrop(224, 224), A.HorizontalFlip(p=0.5), A.RandomBrightnessContrast(brightness_limit=0.4, contrast_limit=0.4, p=0.8), A.HueSaturationValue(hue_shift_limit=int(0.1 * 255), sat_shift_limit=int(0.2 * 255), val_shift_limit=0, p=0.8), A.ToGray(p=0.2), A.GaussianBlur(blur_limit=[23, 23], sigma_limit=[0.1, 0.2], p=gb_prob), A.Solarize(p=solarize_prob), normalize, ToTensorV2() ] elif stage == 'ft': t_list = [ A.RandomResizedCrop(224, 224), A.HorizontalFlip(p=0.5), normalize, ToTensorV2() ] elif stage == 'test': t_list = [ A.Resize(256, 256), A.CenterCrop(224, 224), normalize, ToTensorV2() ] transform = A.Compose(t_list) return transform
def get_train_transform(): return A.Compose([ A.RandomSizedCrop( min_max_height=(800, 800), height=1024, width=1024, p=0.5), 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.ToGray(p=0.01), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.Resize(height=our_image_size, width=our_image_size, p=1), A.Cutout(num_holes=8, max_h_size=our_image_size // 8, max_w_size=our_image_size // 8, fill_value=0, p=0.5) ], bbox_params={ 'format': 'pascal_voc', 'label_fields': ['labels'] })
def __init__(self): self.transform = None try: import albumentations as A check_version(A.__version__, '1.0.3', hard=True) # version requirement self.transform = A.Compose([ A.Blur(p=0.01), A.MedianBlur(p=0.01), A.ToGray(p=0.01), A.CLAHE(p=0.01), A.RandomBrightnessContrast(p=0.0), A.RandomGamma(p=0.0), A.ImageCompression(quality_lower=75, p=0.0) ], bbox_params=A.BboxParams( format='yolo', label_fields=['class_labels'])) LOGGER.info( colorstr('albumentations: ') + ', '.join(f'{x}' for x in self.transform.transforms if x.p)) except ImportError: # package not installed, skip pass except Exception as e: LOGGER.info(colorstr('albumentations: ') + f'{e}')
def __init__(self, scale_range: float = (0.35, 0.65), input_size: int = (416, 416), augmentation: bool = False) -> None: if augmentation: self.crop_func = RandomCropAndResize(scale_range, input_size) self.aug_func = alb.Compose([ alb.OneOf([ alb.RGBShift(), alb.ToGray(), alb.NoOp(), ]), alb.RandomBrightnessContrast(), alb.OneOf([ alb.GaussNoise(), alb.IAAAdditiveGaussianNoise(), alb.CoarseDropout(fill_value=100), ]) ]) else: scale = (scale_range[0] + scale_range[1]) / 2. self.crop_func = CenterCropAndResize(scale, input_size) self.aug_func = None self.heatmap_stride = 4 self.heatmap_size = (input_size[0] // self.heatmap_stride, input_size[1] // self.heatmap_stride)
def get_train_transforms(): return A.Compose( [ # A.RandomSizedCrop(min_max_height=(380, 676), height=1024, width=1024, p=0.5), A.RandomSizedBBoxSafeCrop(512, 512, erosion_rate=0.0, interpolation=1, p=0.5), # 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.ToGray(p=0.01), A.HorizontalFlip(p=0.5), # A.VerticalFlip(p=0.5), A.Resize(height=512, width=512, p=1), A.Cutout(num_holes=4, max_h_size=64, max_w_size=64, fill_value=0, p=0.5), A.Normalize(p=1), ToTensorV2(p=1.0), ], p=1.0, bbox_params=A.BboxParams( format='pascal_voc', min_area=0, min_visibility=0, label_fields=['labels'] ) )
def get_train_transforms(cfg): return A.Compose( [ A.RandomSizedCrop(min_max_height=cfg.INPUT.RSC_MIN_MAX_HEIGHT, height=cfg.INPUT.RSC_HEIGHT, width=cfg.INPUT.RSC_WIDTH, p=cfg.INPUT.RSC_PROB), A.OneOf([ A.HueSaturationValue(hue_shift_limit=cfg.INPUT.HSV_H, sat_shift_limit=cfg.INPUT.HSV_S, val_shift_limit=cfg.INPUT.HSV_V, p=cfg.INPUT.HSV_PROB), A.RandomBrightnessContrast(brightness_limit=cfg.INPUT.BC_B, contrast_limit=cfg.INPUT.BC_C, p=cfg.INPUT.BC_PROB), ], p=cfg.INPUT.COLOR_PROB), A.ToGray(p=cfg.INPUT.TOFGRAY_PROB), A.HorizontalFlip(p=cfg.INPUT.HFLIP_PROB), A.VerticalFlip(p=cfg.INPUT.VFLIP_PROB), # A.Resize(height=512, width=512, p=1), A.Cutout(num_holes=cfg.INPUT.COTOUT_NUM_HOLES, max_h_size=cfg.INPUT.COTOUT_MAX_H_SIZE, max_w_size=cfg.INPUT.COTOUT_MAX_W_SIZE, fill_value=cfg.INPUT.COTOUT_FILL_VALUE, p=cfg.INPUT.COTOUT_PROB), ToTensorV2(p=1.0), ], p=1.0, bbox_params=A.BboxParams(format='pascal_voc', min_area=0, min_visibility=0, label_fields=['labels']))
def get_train_transforms(): return A.Compose( [ 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.ToGray(p=0.01), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.Resize(height=512, width=512, p=1), A.Cutout(num_holes=8, max_h_size=64, max_w_size=64, fill_value=0, p=0.5), ToTensorV2(p=1.0), ], p=1.0, bbox_params=A.BboxParams( format="coco", min_area=0, min_visibility=0, label_fields=["labels"] ), )
def get_train_transforms(): return A.Compose([ A.RandomSizedCrop( min_max_height=(800, 1024), height=1024, width=1024, p=0.5), 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.ToGray(p=0.01), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.RandomRotate90(p=0.5), A.Transpose(p=0.5), A.JpegCompression(quality_lower=85, quality_upper=95, p=0.2), A.OneOf( [A.Blur(blur_limit=3, p=1.0), A.MedianBlur(blur_limit=3, p=1.0)], p=0.1), A.Resize(height=1024, width=1024, p=1), A.Cutout( num_holes=8, max_h_size=64, max_w_size=64, fill_value=0, p=0.5), ToTensorV2(p=1.0), ], p=1.0, bbox_params=A.BboxParams(format='pascal_voc', min_area=0, min_visibility=0, label_fields=['labels']))
def get_train_transforms(): # noinspection PyTypeChecker return A.Compose([ A.RandomSizedCrop( min_max_height=(850, 850), height=1024, width=1024, p=0.3), A.OneOf([ A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.8), A.RandomBrightnessContrast( brightness_limit=0.2, contrast_limit=0.2, p=0.9) ], p=0.5), A.OneOf([ A.RandomRain(rain_type='drizzle', p=0.2), A.GaussianBlur(blur_limit=7, p=0.5), A.GaussNoise((0.2, 0.25), p=0.3), A.RandomShadow(p=0.2) ], p=0.4), A.ToGray(p=0.01), A.Flip(p=0.5), A.CoarseDropout(max_height=64, max_width=64, min_holes=3, min_height=32, min_width=32, p=0.5), A.Resize(Config.Train.img_size, Config.Train.img_size, p=1.0), ToTensorV2(p=1.0), ], bbox_params=BboxParams('pascal_voc', label_fields=['labels'], min_visibility=0.0))
class Apollo(object): data_format = 'VOC' voc_root = 'datasets/apollo' train_split = 'train.txt' val_split = 'val.txt' class_names = [ 'bicycle', 'bicycle_group', 'bus', 'car', 'car_groups', 'motorbicycle', 'motorbicycle_group', 'person', 'person_group', 'rider', 'rider_group', 'tricycle', 'truck' ] class_names = [ 'bus', 'car', 'motorbicycle_group', 'person', 'tricycle', 'truck' ] img_format = 'jpg' width = 512 height = 416 train_transform = A.Compose( [ A.RandomSizedCrop(min_max_height=(640, 640), height=800, width=1000, w2h_ratio=1.25, p=0.5), 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.ToGray(p=0.01), A.HorizontalFlip(p=0.5), # A.VerticalFlip(p=0.5), A.Resize(height=height, width=width, p=1), # A.Cutout(num_holes=5, max_h_size=64, max_w_size=64, fill_value=0, p=0.5), ToTensorV2(p=1.0), ], p=1.0, bbox_params=A.BboxParams(format='pascal_voc', min_area=0, min_visibility=0, label_fields=['labels']), ) val_transform = A.Compose([ A.Resize(height=height, width=width, p=1.0), ToTensorV2(p=1.0), ], p=1.0, bbox_params=A.BboxParams(format='pascal_voc', min_area=0, min_visibility=0, label_fields=['labels' ]))
def make_albu_augs(img_size: int, crop_size: Optional[int], mode: str): assert mode in ["train", "val", "test"] if crop_size is None: crop_size = img_size if mode == "train": return A.Compose([ A.RandomResizedCrop( crop_size, crop_size, scale=(0.9, 1), p=1, ), A.HorizontalFlip(p=0.5), A.ShiftScaleRotate(p=0.7), A.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=10, val_shift_limit=10, p=0.7), A.RandomBrightnessContrast(brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2), p=0.7), A.CLAHE(clip_limit=(1, 4), p=0.5), A.OneOf( [ A.OpticalDistortion(distort_limit=1.0), A.GridDistortion(num_steps=5, distort_limit=1.0), A.ElasticTransform(alpha=3), ], p=0.4, ), A.OneOf( [ A.GaussNoise(var_limit=[10, 50]), A.GaussianBlur(), A.MotionBlur(), A.MedianBlur(), ], p=0.4, ), A.ToGray(p=0.5), A.ToSepia(p=0.5), A.Cutout( max_h_size=int(crop_size * 0.075), max_w_size=int(crop_size * 0.075), num_holes=10, p=0.5, ), A.Normalize(mean=IMAGENET_DEFAULT_MEAN, std=IMAGENET_DEFAULT_STD), ToTensorV2(), ], ) if mode in ["val", "test"]: return A.Compose([ A.Resize(img_size, img_size), A.CenterCrop( crop_size, crop_size, p=1 if crop_size != img_size else 0), A.Normalize(mean=IMAGENET_DEFAULT_MEAN, std=IMAGENET_DEFAULT_STD), ToTensorV2(), ], )
def train_aug(height=224, width=224): return alb.Compose( [ alb.RandomResizedCrop(height=height, width=width, always_apply=True, interpolation=cv2.INTER_LANCZOS4), alb.CLAHE(p=0.1), alb.ToGray(p=0.2), alb.RandomBrightnessContrast(p=0.6), ] )
def get_hard_augmentations(image_size): return A.Compose([ A.OneOf([ A.ShiftScaleRotate(shift_limit=0.05, scale_limit=0.1, rotate_limit=45, border_mode=cv2.BORDER_CONSTANT, value=0), A.ElasticTransform(alpha_affine=0, alpha=35, sigma=5, border_mode=cv2.BORDER_CONSTANT, value=0), A.OpticalDistortion(distort_limit=0.11, shift_limit=0.15, border_mode=cv2.BORDER_CONSTANT, value=0), A.GridDistortion(border_mode=cv2.BORDER_CONSTANT, value=0), A.NoOp() ]), A.OneOf([ A.RandomSizedCrop(min_max_height=(int(image_size[0] * 0.75), image_size[0]), height=image_size[0], width=image_size[1], p=0.3), A.NoOp() ]), A.ISONoise(p=0.5), # Brightness/contrast augmentations A.OneOf([ A.RandomBrightnessContrast(brightness_limit=0.5, contrast_limit=0.4), IndependentRandomBrightnessContrast(brightness_limit=0.25, contrast_limit=0.24), A.RandomGamma(gamma_limit=(50, 150)), A.NoOp() ]), A.OneOf([ A.RGBShift(r_shift_limit=40, b_shift_limit=30, g_shift_limit=30), A.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=10), A.ToGray(p=0.2), A.NoOp() ]), A.ChannelDropout(), A.RandomGridShuffle(p=0.3), # D4 A.Compose([ A.RandomRotate90(), A.Transpose() ]) ])
def pet_augmentation(): transform_list = [ albu.Resize(100, 100), albu.HorizontalFlip(p=0.5), albu.ToSepia(p=0.2), albu.ToGray(p=0.3), albu.RandomRotate90(p=0.5), albu.VerticalFlip(p=0.2) ] return albu.Compose(transform_list)
class Rtts(object): data_format = 'VOC' voc_root = 'datasets/RTTS' train_split = 'train.txt' val_split = 'all.txt' class_names = [ "aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike", "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor" ] img_format = 'png' width = 480 height = 480 train_transform = A.Compose( [ A.Resize(height=1024, width=1024, p=1), # 896 A.RandomSizedCrop( min_max_height=(600, 800), height=1024, width=1024, p=0.5), 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.ToGray(p=0.01), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.Resize(height=height, width=width, p=1), # A.Cutout(num_holes=5, max_h_size=64, max_w_size=64, fill_value=0, p=0.5), ToTensorV2(p=1.0), ], p=1.0, bbox_params=A.BboxParams(format='pascal_voc', min_area=0, min_visibility=0, label_fields=['labels']), ) val_transform = A.Compose( [ A.Resize(height=height, width=width, p=1.0), # A.LongestMaxSize(416, p=1.0), # A.PadIfNeeded(min_height=416, min_width=416, border_mode=0, value=(0.5,0.5,0.5), p=1.0), ToTensorV2(p=1.0), ], p=1.0, bbox_params=A.BboxParams(format='pascal_voc', min_area=0, min_visibility=0, label_fields=['labels']))
def get_train_transforms(): return A.Compose([ # A.Resize(height=384, width=384, p=1), # A.RandomSizedCrop(min_max_height=(350, 350), height=384, width=384, p=0.5), # A.RandomRotate90(p=0.5), # A.HorizontalFlip(p=0.5), # A.VerticalFlip(p=0.5), A.ToGray() #A.Cutout(num_holes=8, max_h_size=64, max_w_size=64, fill_value=0, p=0.5), ToTensorV2(p=1.0), ], p=1.0)
def base_line_transform(): result = [ albu.HorizontalFlip(), albu.RandomGamma(), albu.RandomBrightnessContrast(), albu.OneOf([ albu.ToGray(), albu.CLAHE()]), albu.RandomScale(), ] return result
def pet_augmentation(): transform_list = [ albu.Resize(100, 100), albu.HorizontalFlip(p=0.5), albu.ToSepia(p=0.2), albu.ToGray(p=0.3), albu.RandomRotate90(p=0.5), albu.VerticalFlip(p=0.2), albu.GaussianBlur(blur_limit=10,p=0.5,always_apply=False) ] return albu.Compose(transform_list)
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)