def TTA(image, model): #get average of multi version of test image augmentation #batch size must be 1 #imput: img:[256,1600,3],torch.Tensor #output: pred_result:[4,256,1600],np.array h, w, c = image.shape horizon_trans = Compose([HorizontalFlip(p=1)]) vertical_trans = Compose([VerticalFlip(p=1)]) rotate_trans = Compose([HorizontalFlip(p=1), VerticalFlip(p=1)]) none_trans = Compose([]) trans_zoo = [horizon_trans, vertical_trans, rotate_trans, none_trans] pred_total = np.empty((len(trans_zoo), h, w, 4)) for i, tran in enumerate(trans_zoo): #img->norm+trans->predict->pred_mask->re-trans #numpy.array img_aug = tran(image=image.numpy())['image'].squeeze() #[256,1600,3] #img_aug = normal_trans(image=img_aug)['image'].squeeze() img_aug = torch.from_numpy(img_aug).permute( (2, 0, 1)).unsqueeze(0).cuda() #[1,3,256,1600] pred_aug = model(img_aug) pred_aug = F.sigmoid(pred_aug).detach().cpu().numpy() #[1,4,256,1600] pred_aug = pred_aug.squeeze().transpose((1, 2, 0)) #[256,1600,4] pred_recover = tran(image=pred_aug)['image'].squeeze() #[256,1600,4] pred_total[i] = pred_recover pred_result = np.mean(pred_total, axis=0) #[256,1600,4] return pred_result.transpose((2, 0, 1)) #[4,256,1600]
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_tta_aug(tta_index=0): tta_augs = { 1: [HorizontalFlip(always_apply=True)], 2: [VerticalFlip(always_apply=True)], 3: [HorizontalFlip(always_apply=True), VerticalFlip(always_apply=True)], 4: [Rotate90(always_apply=True)], 5: [Rotate90(always_apply=True), HorizontalFlip(always_apply=True)], 6: [VerticalFlip(always_apply=True), Rotate90(always_apply=True)], 7: [ HorizontalFlip(always_apply=True), VerticalFlip(always_apply=True), Rotate90(always_apply=True) ], } if tta_index == 0: return Compose([Resize(img_sz, img_sz)], p=1.) else: return Compose(tta_augs[tta_index], preprocessing_transforms=[ Resize(img_sz, img_sz, always_apply=True) ], p=1.0)
def get_transforms(phase, mean, std): list_transforms = [] if phase == "train": if crop_image_size is not None: list_transforms.extend( [CropNonEmptyMaskIfExists(crop_image_size[0], crop_image_size[1], p=0.85), HorizontalFlip(p=0.5), VerticalFlip(p=0.5), RandomBrightnessContrast(p=0.1, brightness_limit=0.1, contrast_limit=0.1) ]) else: list_transforms.extend( [HorizontalFlip(p=0.5), VerticalFlip(p=0.5), RandomBrightnessContrast(p=0.1, brightness_limit=0.1, contrast_limit=0.1) ] ) list_transforms.extend( [ Normalize(mean=mean, std=std, p=1), ToTensor() ] ) list_trfms = Compose(list_transforms) return list_trfms
def get_transforms(*, data): if data == 'train': return Compose([ HorizontalFlip(p=0.5), VerticalFlip(p=0.5), RandomRotate90(p=0.5), Transpose(p=0.5), ShiftScaleRotate(scale_limit=0.2, rotate_limit=0, shift_limit=0.2, p=0.2, border_mode=0), IAAAdditiveGaussianNoise(p=0.2), IAAPerspective(p=0.5), OneOf( [ CLAHE(p=1), RandomBrightness(p=1), RandomGamma(p=1), ], p=0.9, ), OneOf( [ IAASharpen(p=1), Blur(blur_limit=3, p=1), MotionBlur(blur_limit=3, p=1), ], p=0.9, ), OneOf( [ RandomContrast(p=1), HueSaturationValue(p=1), ], p=0.9, ), Compose([VerticalFlip(p=0.5), RandomRotate90(p=0.5)]), Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensorV2(), #ToTensor(num_classes=2), ]) elif data == 'valid': return Compose([ Resize(256, 256), Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensorV2(), ])
def get_tta_aug(tta_index=None): tta_augs = { 1: [HorizontalFlip(always_apply=True)], 2: [VerticalFlip(always_apply=True)], 3: [HorizontalFlip(always_apply=True),VerticalFlip(always_apply=True)], 4: [Rotate90(always_apply=True)], 5: [Rotate90(always_apply=True), HorizontalFlip(always_apply=True)], 6: [VerticalFlip(always_apply=True), Rotate90(always_apply=True)], 7: [HorizontalFlip(always_apply=True),VerticalFlip(always_apply=True), Rotate90(always_apply=True)], } return Compose(tta_augs[tta_index], p=1.0)
def get_transforms1(*, data, CFG): if data == 'train': return Compose([ #RandomCrop(512,512,p=1), HorizontalFlip(p=CFG.augmentation.augmix_p), VerticalFlip(p=CFG.augmentation.augmix_p), RandomContrast(p=CFG.augmentation.contrast_p), #GaussNoise(p=0.5), RandomRotate90(p=CFG.augmentation.rotate_90_p), #RandomGamma(p=0.5), RandomBrightnessContrast(p=CFG.augmentation.bright_contrast_p), RandomAugMix(severity=CFG.augmentation.augmix_s, width=3, alpha=1., p=CFG.augmentation.augmix_p), #GaussianBlur(p=0.5), GridMask(num_grid=CFG.augmentation.grdimask_n, p=CFG.augmentation.grdimask_p), Cutout(p=CFG.augmentation.cutout_p, max_h_size=CFG.augmentation.cutout_h, max_w_size=CFG.augmentation.cutout_w), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) elif data == 'valid': return Compose([ Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ) ])
def Auger(self): List_Transforms = [] if self.is_train: List_Transforms.extend([ HueSaturationValue(10, 10, 10, p=0.3), HorizontalFlip(0.3), VerticalFlip(p=0.3), # May be it not work,will rescale [0,255] -> [0.0,1.0] ToFloat(always_apply=True), ShiftScaleRotate( shift_limit=0.1, # no resizing scale_limit=0.1, rotate_limit=3, # rotate p=0.5, border_mode=cv2.BORDER_REFLECT), PadIfNeeded(self.padshape, self.padshape), ]) List_Transforms.extend([ # [0.12110683835022196, 0.1308642819666743, 0.14265566800591103] #Normalize(mean=(0.397657144,0.351649219,0.305031406),std=(0.12110683835022196, 0.1308642819666743, 0.14265566800591103)), RandomCrop(self.shape, self.shape), ToTensor(), ]) TR = Compose(List_Transforms) return TR
def __build_augmentator(self): return Compose( [ ShiftScaleRotate( shift_limit=0.0625, scale_limit=0.0, rotate_limit=0, p=0.3), OneOf([ RandomScale(scale_limit=0.05, interpolation=1, p=0.5), Rotate(limit=7, interpolation=1, border_mode=cv2.BORDER_CONSTANT, value=0, p=0.5) ], p=0.5), PadIfNeeded(always_apply=True, min_width=self.width, min_height=self.height), RandomCrop(width=self.width, height=self.height), OneOf( [ VerticalFlip(), # HorizontalFlip(p=0.2), ], p=0.5), # OneOf([ # RandomBrightness(limit=0.2, always_apply=False, p=0.5), # RandomContrast(), # RandomGamma() # ], p=0.7), ], p=self.p)
def __init__(self, root_dir, partition, augment=True): self.root_dir = root_dir self.list_IDs = os.listdir( os.path.join(self.root_dir, 'x_{}'.format(partition))) self.partition = partition self.augment = augment self.augmentator = Compose([ # Non destructive transformations VerticalFlip(p=0.6), HorizontalFlip(p=0.6), RandomRotate90(), Transpose(p=0.6), ShiftScaleRotate(p=0.45, scale_limit=(0.1, 0.3)), # # Non-rigid transformations ElasticTransform(p=0.25, alpha=160, sigma=180 * 0.05, alpha_affine=120 * 0.03), Blur(blur_limit=3, p=0.2), # Color augmentation RandomBrightness(p=0.5), RandomContrast(p=0.5), RandomGamma(p=0.5), CLAHE(p=0.5) ])
def get_transforms(config, mode): if (mode == "val") or (mode =="test"): transform = [ Resize(config["model"]["image_size"], config["model"]["image_size"]), # Normalize(mean=phase_config.mean, std=phase_config.std, p=1), ToTensor(), ] return transform elif mode == "train": list_transforms = [] config_tarnsform = config[mode]["transform"] if config_tarnsform["HorizontalFlip"]: list_transforms.append(HorizontalFlip()) if config_tarnsform["VerticalFlip"]: list_transforms.append(VerticalFlip()) if config_tarnsform["Contrast"]: list_transforms.append( OneOf([ RandomContrast(0.5), RandomBrightness(), ], p=0.5), ) if config_tarnsform["ShiftScaleRotate"]: list_transforms.append(ShiftScaleRotate(shift_limit=(-0.05, 0.05), scale_limit=(-0.05, 0.05), rotate_limit=(-30,30), p=0.5)) list_transforms.extend( [ Resize(config["model"]["image_size"], config["model"]["image_size"]), # Normalize(mean=phase_config.mean, std=phase_config.std, p=1), ToTensor(), ] ) return list_transforms
def udf_transformer(phase): list_transforms = [] # if target in [1,3,4]: # pc_min, pc_max = 150, 50000 # else: # pc_min, pc_max = 5, 50000 # list_transforms.extend([CropNonEmptyMaskIfExists(height = 256, # width = 400, # modify this # # ignore_values = [pc_min,pc_max], # [min, max], # p=1) # # Resize(height = 256, # # width = 1600) # ] # ) # list_transforms.append(ElasticTransform(p=0.6)) # list_transforms.append(OpticalDistortion(p=0.6)) if phase == 'train': list_transforms.append(HorizontalFlip(p=0.5)) list_transforms.append(VerticalFlip(p=0.5)) list_transforms.append(Rotate(limit=20, p=0.5)) # list_transforms.append(GaussNoise()) list_transforms.append(GridDistortion(distort_limit=(-0.2, 0.2), p =0.6)) list_transforms.append(Normalize([0.5], [0.5])) # important step list_transforms.append(ToTensor()) # using albumentations transformers, must use ToTensor from albumentations too return Compose(list_transforms)
def __init__(self, root_dir, annotation_lines, class_number, transform=None, loader=default_loader): self.annotation_lines = annotation_lines self.class_number = class_number self.transform = transform self.loader = loader self.root_dir = root_dir curr_size = 512 min_max_height = (curr_size - curr_size // 2, curr_size - 1) self.transform_strong = Compose([ RandomSizedCrop(min_max_height=min_max_height, height=curr_size, width=curr_size, p=1.0), OneOf([ Transpose(p=0.5), HorizontalFlip(p=0.5), VerticalFlip(p=0.5), Rotate(p=0.5), ], p=1.0), ElasticTransform(alpha=curr_size, sigma=curr_size * 0.05, alpha_affine=10, p=1.0) ])
class ImgAugTTATransform(AugmentationFactoryBase): TRANSFORM_LIST = ( NoOp(p=1), HorizontalFlip(p=1), VerticalFlip(p=1), Rotate(limit=(180, 180), p=1), # Lambda(RollingY(shift=(-20, 20)).transform), # Lambda(RollingY(shift=(-20, 20)).transform), ) CURR_TRANSFORM = TRANSFORM_LIST[0] def __init__(self, image_size=(126, 32)): self.image_size = image_size def build_train(self): pass def build_test(self): print("Using {}".format(self.CURR_TRANSFORM)) return Compose([ Lambda(minmax_norm), self.CURR_TRANSFORM, Resize( self.image_size[0], self.image_size[1], interpolation=cv2.INTER_CUBIC, ), Lambda(normalize), ToTensor(), ])
def train_transform(p=1): return Compose([ VerticalFlip(p=0.5), HorizontalFlip(p=0.5), Normalize(p=1, mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) ], p=p)
def set_defalut(self): self.config.update( dict(image_dir='', label_dir='', mode='segm', include=('pre', 'post'), CV=dict( on=True, cur_k=0, k_fold=5, ), transforms=Compose([ OneOf([ HorizontalFlip(True), VerticalFlip(True), RandomRotate90(True) ], p=0.5), RandomDiscreteScale([0.75, 1.25, 1.5], p=0.5), RandomCrop(640, 640, True), Normalize(mean=(0.485, 0.456, 0.406, 0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225, 0.229, 0.224, 0.225), max_pixel_value=255), ToTensorV2(True), ]), batch_size=1, num_workers=0, training=True))
def get_train_transforms(): return Compose( [ #Resize(args.img_size, args.img_size), RandomResizedCrop(args.img_size, args.img_size), Transpose(p=0.5), HorizontalFlip(p=0.5), VerticalFlip(p=0.25), ShiftScaleRotate(p=0.25), HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.25), RandomBrightnessContrast(brightness_limit=(-0.1, 0.1), contrast_limit=(-0.1, 0.1), p=0.5), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], max_pixel_value=255.0, p=1.0), CoarseDropout(p=0.5), # Cutout(p=0.5), ToTensorV2(p=1.0), ], p=1.)
def train_transform(sz, downscale=1, p=1): augmentation = Compose( [ VerticalFlip(p=0.5), HorizontalFlip(p=0.5), RandomRotate90(p=0.5), # GridDistortion(p=0.5, border_mode=cv2.BORDER_CONSTANT), # RandomGamma(p=0.9, gamma_limit=(80, 150)), HueSaturationValue(p=0.9, hue_shift_limit=10, sat_shift_limit=20, val_shift_limit=10), ], p=p) def transform_fun(img_path): img, mask = read_img_mask(img_path, sz, downscale=downscale) data = {"image": img, "mask": mask} augmented = augmentation(**data) img, mask = augmented["image"], augmented["mask"] img = norm_fun(img) mask = mask_from_rgb(mask) return img, mask return transform_fun
def __getitem__(self, index): path = os.path.join(self.data_dir, self.filename[index] + self.suffix) label = None if self.ids is None else self.ids[index] img = Image.open(path) img = img.convert("RGB") if self.transform is not None: img = self.transform(img) else: if self.augumentation: img = np.asarray(img) task = [ HorizontalFlip(p=0.5), VerticalFlip(p=0.5), RandomGamma(), RandomBrightnessContrast(p=0.5), PadIfNeeded(self.img_size, self.img_size), ShiftScaleRotate(scale_limit=0.5, p=0.5) ] aug = Compose(task) aug_data = aug(image=img) img = aug_data["image"] #img = cv2.resize(img,(self.img_size,self.img_size)) img = Image.fromarray(img) img = self.transform(img) if label is not None: return img, label else: return img
def __getitem__(self, index): img_path = self.image_paths[index] mask_path = self.label_paths[index] if img_path.endswith(".npy"): img = np.load(img_path) else: img = cv2.imread(img_path) if mask_path.endswith(".npy"): mask = np.load(mask_path) else: mask = cv2.imread(mask_path, 0) if self.augmentation: task = [ HorizontalFlip(p=0.5), VerticalFlip(p=0.5), RandomGamma(), RandomBrightnessContrast(p=0.5), PadIfNeeded(self.img_size, self.img_size), ShiftScaleRotate(scale_limit=0.5, p=0.5), #Normalize(mean=[0.210, 0.210, 0.210], std=[0.196, 0.196, 0.196], always_apply=True) ] aug = Compose(task) aug_data = aug(image=img, mask=mask) img, mask = aug_data["image"], aug_data["mask"] img = self._normalize(img) img = cv2.resize(img, (self.img_size, self.img_size)) mask = cv2.resize(mask, (self.img_size, self.img_size)) mask = mask // 255.0 if img.ndim < 3: img = np.expand_dims(img, 0) else: img = np.transpose(img, axes=[2, 0, 1]) return torch.from_numpy(img), torch.from_numpy(mask)
def get_transform(model_name): if 'TAPNet' in model_name: # transform for sequences of images is very tricky # TODO: more transforms should be adopted for better results train_transform_ops = [ PadIfNeeded(min_height=args.input_height, min_width=args.input_width, p=1), Normalize(p=1), # optional transforms Resize(height=args.input_height, width=args.input_width, p=1), # CenterCrop(height=args.input_height, width=args.input_width, p=1) ] else: train_transform_ops = [ VerticalFlip(p=0.5), HorizontalFlip(p=0.5), PadIfNeeded(min_height=args.input_height, min_width=args.input_width, p=1), Normalize(p=1), # optional transforms # Resize(height=args.input_height, width=args.input_width, p=1), # CenterCrop(height=args.input_height, width=args.input_width, p=1) RandomCrop(height=args.input_height, width=args.input_width, p=1), ] valid_transform_ops = [ Normalize(p=1), PadIfNeeded(min_height=args.input_height, min_width=args.input_width, p=1), # optional transforms Resize(height=args.input_height, width=args.input_width, p=1), # CenterCrop(height=args.input_height, width=args.input_width, p=1) ] return Compose(train_transform_ops, p=1), Compose(valid_transform_ops, p=1)
def get_transforms(*, data): if data == 'train': return Compose([ RandomResizedCrop(CFG.size, CFG.size), Transpose(p=0.5), HorizontalFlip(p=0.5), VerticalFlip(p=0.5), ShiftScaleRotate(p=0.5), HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5), RandomBrightnessContrast(brightness_limit=(-0.1, 0.1), contrast_limit=(-0.1, 0.1), p=0.5), Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensorV2(), ]) elif data == 'valid': return Compose([ Resize(CFG.size, CFG.size), Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensorV2(), ])
def __getitem__(self, idx): file = self.files[idx] file_path = os.path.join(os.path.join(PATH, self.mode + '_images'), file) image = cv2.imread(file_path) mean = (0.485, 0.456, 0.406) std = (0.229, 0.224, 0.225) train_aug = Compose([ OneOf([ VerticalFlip(), HorizontalFlip(), ], p=0.5), OneOf([ MotionBlur(p=0.4), MedianBlur(p=0.4, blur_limit=3), Blur(p=0.5, blur_limit=3) ], p=0.4), OneOf([IAAAdditiveGaussianNoise(), GaussNoise()], p=0.4), Normalize(mean=mean, std=std, p=1), # CLAHE(p=0.5), ToTensor() ]) augmented = train_aug(image=image) image = augmented['image'] label = np.array(self.labels[idx]) label = torch.tensor(label, dtype=torch.float32) return (image, label)
def seg_transforms(phase, resize=(512, 512), mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)): """ Get segmentation albumentation tansforms Args: phase: train or valid resize: input image shape into model Returns: albu compose transforms Raises: IOError: An error occurred accessing ablumentation object. """ assert (phase in ['train', 'valid', 'test']) transforms_list = [] if phase == 'train': transforms_list.extend([ # Rotate VerticalFlip(p=0.5), HorizontalFlip(p=0.5), ShiftScaleRotate(rotate_limit=20, border_mode=0, p=0.2), RandomBrightnessContrast(brightness_limit=0.1, contrast_limit=0.1, p=0.2), Resize(resize[0] + 64, resize[1] + 64, interpolation=Image.BILINEAR), Normalize(mean=mean, std=std, p=1), RandomCrop(resize[0], resize[1]), ToTensor(), ]) else: transforms_list.extend([ Resize(resize[0], resize[1], interpolation=Image.BILINEAR), Normalize(mean=mean, std=std, p=1), ToTensor(), ]) transforms = Compose(transforms_list) return transforms
def get_transforms(phase): list_transforms = [] if phase == "train": list_transforms.extend( [ OneOf([ RandomSizedCrop(min_max_height=(50, 101), height=original_height, width=original_width, p=0.5), PadIfNeeded(min_height=original_height, min_width=original_width, p=0.5)], p=1), VerticalFlip(p=0.5), # RandomRotate90(p=0.5), OneOf([ ElasticTransform(p=0.5, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), GridDistortion(p=0.5), OpticalDistortion(p=1, distort_limit=2, shift_limit=0.5) ], p=0.8), CLAHE(p=0.8), RandomBrightnessContrast(p=0.8), RandomGamma(p=0.8), ] ) list_transforms.extend( [ Resize(height=int(original_height/4), width=int(original_width/4), interpolation=cv2.INTER_NEAREST), Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1), ToTensor(), ] ) list_trfms = Compose(list_transforms) return list_trfms
def get_raw_tta(): transform_test_raw = Compose( [Resize(RAW_CROP_SIZE, RAW_CROP_SIZE), ToTensor()]) transform_test_hf = Compose([ Resize(RAW_CROP_SIZE, RAW_CROP_SIZE), HorizontalFlip(p=1, always_apply=True), ToTensor() ]) transform_test_vf = Compose([ Resize(RAW_CROP_SIZE, RAW_CROP_SIZE), VerticalFlip(p=1, always_apply=True), ToTensor() ]) transform_test_tr = Compose( [Resize(RAW_CROP_SIZE, RAW_CROP_SIZE), Transpose(), ToTensor()]) return [ transform_test_raw, transform_test_hf, transform_test_vf, transform_test_tr ]
def __init__(self): self.albumentations_transform = Compose({ Cutout(max_h_size=12, max_w_size=12, num_holes=1, p=0.5), HorizontalFlip(p=0.5), VerticalFlip(p=0.5), Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) })
def hard_aug(original_height=128, original_width=128, k=4): aug = Compose([ OneOf([ RandomSizedCrop( min_max_height=(original_height // k, original_height), height=original_height, width=original_width, p=0.5), PadIfNeeded( min_height=original_height, min_width=original_width, p=0.5) ], p=1), VerticalFlip(p=0.5), HorizontalFlip(p=0.5), RandomRotate90(p=0.5), Transpose(p=0.5), OneOf([ ElasticTransform( p=0.5, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), GridDistortion(p=0.5), OpticalDistortion(p=1, distort_limit=2, shift_limit=0.5) ], p=0.8), CLAHE(p=0.8), RandomBrightnessContrast(p=0.8), RandomGamma(p=0.8) ]) return aug
def transform_v2(config): """ default transforms Args: config: CFG Returns: train_tranforms, test_transforms """ train_transforms = Compose([ RandomResizedCrop(224, 224, scale=(0.7, 1.0)), HorizontalFlip(), VerticalFlip(), Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensor() ], p=1) test_transforms = Compose([ Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensor() ], p=1) return train_transforms, test_transforms
def albumentations_transform(self, img): # 训练集的增强 trans_train = Compose([ # 随机更改输入图像的色相,饱和度和值 # HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, always_apply=False, p=0.5), # 通过用255减去像素值来反转输入图像。 # InvertImg(always_apply=False, p=1), # 随机改变RGB三个通道的顺序 # ChannelShuffle(always_apply=False, p=0.5), # 随机出现小黑点 # Cutout(num_holes=8, max_h_size=8, max_w_size=8, fill_value=0, always_apply=False, p=0.5), # RandomCrop(224, 224), OneOf([ RandomBrightness(limit=0.1, p=1), RandomContrast(limit=0.1, p=1) ]), # OneOf([MotionBlur(blur_limit=3),MedianBlur(blur_limit=3), GaussianBlur(blur_limit=3),], p=0.5,), VerticalFlip(p=0.5), HorizontalFlip(p=0.5), # ShiftScaleRotate( # shift_limit=0.2, # scale_limit=0.2, # rotate_limit=20, # interpolation=cv2.INTER_LINEAR, # border_mode=cv2.BORDER_REFLECT_101, # p=1, # ), ]) augmented = trans_train(image=img) return augmented['image']