def get_transform(train, augmentation_ver=None, imageclassidentifier=None):
if augmentation_ver is None or augmentation_ver == 0:
data_transforms = albumentations.Compose([
albumentations.Flip(),
#albumentations.RandomBrightness(0.2),
albumentations.ShiftScaleRotate(rotate_limit=90, scale_limit=0.10),
#ToTensorV2()
], bbox_params=albumentations.BboxParams(format='pascal_voc', label_fields=['class_labels'])) # min_visibility=0.2
elif augmentation_ver == 1:
if imageclassidentifier is None:
imageclassidentifier = preprocess.ImageClassIdentifier()
def ifpred(**kwargs):
img = kwargs['image']
predicted_class = imageclassidentifier.detect(np.array(img))
if predicted_class == 2:
return True
return False
data_transforms = albumentations.Compose([
IfThenElse(ifpred, albumentations.Compose([
albumentations.RandomSizedCrop((256, 1024), 1024, 1024)
#albumentations.RandomSizedBBoxSafeCrop(height=1024, width=1024)
]),
albumentations.Compose([
# do nothing
])),
albumentations.Flip(),
albumentations.VerticalFlip(),
albumentations.RandomRotate90(p=0.5),
albumentations.ShiftScaleRotate(rotate_limit=15, scale_limit=0.10),
#ToTensorV2()
], bbox_params=albumentations.BboxParams(format='pascal_voc', label_fields=['class_labels'])) # min_visibility=0.2
return data_transforms
def create_tsfm(args, mean, std, normalize=True, tsfms=None):
"""
Create transform based on configuration
:param args: the argument parameters defined in config.py
:param mean: mean of the dataset
:param std: std of the dataset
:param normalize: if True, will normalize the dataset
:param tsfms: transforms used to augment the data, if None, will use the default ones
:return: corresponding train and validation transforms
"""
input_size = eval(args['dataset']['input_size'])
crop_size = eval(args['dataset']['crop_size'])
if tsfms is None:
if normalize:
tsfms = [
A.Flip(),
A.RandomRotate90(),
A.Normalize(mean=mean, std=std),
ToTensorV2()
]
else:
tsfms = [A.Flip(), A.RandomRotate90(), ToTensorV2()]
if input_size[0] > crop_size[0] and input_size[1] > crop_size[1]:
tsfm_train = A.Compose([A.RandomCrop(*crop_size)] + tsfms)
tsfm_valid = A.Compose([A.RandomCrop(*crop_size)] + tsfms[2:])
elif input_size[0] < crop_size[0] or input_size[1] < crop_size[1]:
tsfm_train = A.Compose([A.RandomResizedCrop(*crop_size)] + tsfms)
tsfm_valid = A.Compose([A.RandomResizedCrop(*crop_size)] + tsfms[2:])
else:
tsfm_train = A.Compose(tsfms)
tsfm_valid = A.Compose(tsfms[-2:])
return tsfm_train, tsfm_valid
def get_aug(aug_type="val", size=512):
"""Return augmentations by type
Args:
aug_type (str): one of `val`, `test`, `light`, `medium`
size (int): final size of the crop
"""
NORM_TO_TENSOR = albu.Compose(
[albu.Normalize(mean=MEAN, std=STD),
albu_pt.ToTensorV2()])
# CROP_AUG = albu.Compose([albu.RandomCrop(size, size)])
VAL_AUG = albu.Compose([
# albu.CenterCrop(size, size),
NORM_TO_TENSOR
])
LIGHT_AUG = albu.Compose(
[
albu.Flip(),
albu.Cutout(num_holes=12,
max_h_size=size // 16,
max_w_size=size // 16,
fill_value=0,
p=0.5), NORM_TO_TENSOR
],
p=1.0,
)
# aug from github.com/lyakaap/Landmark2019-1st-and-3rd-Place-Solution/
HARD_AUG = albu.Compose(
[
albu.Flip(p=0.5),
albu.IAAAffine(rotate=0.2, shear=0.2, mode='constant', p=0.5),
albu.RandomBrightnessContrast(
brightness_limit=0.3, contrast_limit=0.3, p=0.5),
albu.MotionBlur(p=0.5),
albu.CLAHE(p=0.5),
albu.Cutout(num_holes=16,
max_h_size=size // 16,
max_w_size=size // 16,
fill_value=0,
p=0.5),
RandomCropThenScaleToOriginalSize(limit=0.3, p=1.0),
NORM_TO_TENSOR,
],
p=1.0,
)
types = {
"val": VAL_AUG,
"test": VAL_AUG,
"light": LIGHT_AUG,
"hard": HARD_AUG,
}
return types[aug_type]
def get_tta_transform(tta_idx):
if tta_idx == 0: # original
tta_test_transform = A.Compose([
ColorConstancy(p=1),
A.Normalize(),
ToTensor(),
])
elif tta_idx == 1: # horizontal flip
tta_test_transform = A.Compose([
ColorConstancy(p=1),
A.HorizontalFlip(p=1),
A.Normalize(),
ToTensor(),
])
elif tta_idx == 2: # vertical flip
tta_test_transform = A.Compose([
ColorConstancy(p=1),
A.VerticalFlip(p=1),
A.Normalize(),
ToTensor(),
])
elif tta_idx == 3: # random rotate 90 degree
tta_test_transform = A.Compose([
ColorConstancy(p=1),
A.RandomRotate90(p=1),
A.Normalize(),
ToTensor(),
])
elif tta_idx == 4: # flip and transpose
tta_test_transform = A.Compose([
ColorConstancy(p=1),
A.Flip(p=0.5),
A.Transpose(p=1),
A.Normalize(),
ToTensor(),
])
else: # train transform
tta_test_transform = A.Compose([
ColorConstancy(p=1),
A.OneOf([
A.Flip(p=0.5),
A.IAAFliplr(p=0.5),
A.Transpose(p=0.5),
A.IAAFlipud(p=0.5),
],
p=0.5),
A.OneOf([
A.Rotate(limit=365, p=0.75),
A.ShiftScaleRotate(p=0.75),
],
p=0.75),
A.Blur(blur_limit=3, p=0.5),
A.Normalize(),
ToTensor(),
])
return tta_test_transform
def __call__(self, img):
self.img = img
min_val = torch.min(torch.flatten(self.img))
if self.img.shape[0] == 1: # 2D images
self.img = torch.squeeze(self.img)
pipeline = A.Compose([
A.Flip(p=0.5),
A.Rotate(self.params["rot"],
interpolation=1,
border_mode=0,
value=min_val.item(),
p=0.5),
A.RandomBrightnessContrast(
brightness_limit=self.params["bright"],
contrast_limit=self.params["contrast"],
p=0.5)
],
p=0.5)
data = {"image": np.float32(self.img)}
out = pipeline(**data)
out = np.expand_dims(out["image"], 0)
elif self.img.shape[0] > 1: # 2.5D images
pipeline = A.Compose([
A.Flip(p=0.5),
A.RandomBrightnessContrast(
brightness_limit=self.params["bright"],
contrast_limit=self.params["contrast"],
p=0.5)
],
p=0.75)
data = {"image": np.float32(self.img)}
out = pipeline(**data)
out = out["image"]
# Elastic deformations with library elasticdeform
if random.uniform(0, 1) < 0.5:
elasticdeform.deform_random_grid(
out,
self.params["sigma"],
self.params["points"],
order=self.params["resample_order"])
return torch.from_numpy(out).float()
def get_aug(mode="train"):
if mode=="Nor":
aug=A.Compose([
ToTensor(),
])
elif mode =="train":
print("train aug")
mean = (0.485,0.456,0.406)
std = (0.229,0.224,0.225)
aug=A.Compose([
A.Flip(),
A.ShiftScaleRotate(rotate_limit=1.0, p=0.8),
# Pixels
A.OneOf([
A.IAAEmboss(p=1.0),
A.IAASharpen(p=1.0),
A.Blur(p=1.0),
], p=0.5),
# Affine
A.OneOf([
A.ElasticTransform(p=1.0),
A.IAAPiecewiseAffine(p=1.0)
], p=0.5),
A.Normalize(mean=mean,std=std,max_pixel_value=255.0,always_apply=True),
])
else:
print("valid/test aug")
mean = (0.485,0.456,0.406)
std = (0.229,0.224,0.225)
aug=A.Compose([
A.Normalize(mean=mean,std=std,max_pixel_value=255.0,always_apply=True),
])
return aug
def prepare_data(self):
train_df = pd.read_csv(os.path.join(self.hparams.data_dir,
'train.csv'))
train_df, val_df = train_test_split(train_df,
stratify=train_df['isup_grade'])
transform = A.Compose([
A.Resize(height=self.hparams.image_size,
width=self.hparams.image_size,
interpolation=1,
always_apply=False,
p=1.0),
A.Flip(always_apply=False, p=0.5),
A.Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225),
max_pixel_value=255.0,
always_apply=False,
p=1.0)
])
self.train_dataset = PANDADataset(train_df,
self.hparams.data_dir,
self.hparams.image_format,
transform=transform)
self.val_dataset = PANDADataset(val_df,
self.hparams.data_dir,
self.hparams.image_format,
transform=transform)
def __init__(self, outputs=6):
super().__init__()
self.net = models.resnet34(True)
self.linear = Sequential(ReLU(), Dropout(), 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_128_100"
self.train_transforms = A.Compose([
A.InvertImg(p=1),
A.RandomGridShuffle(grid=(10, 10)),
A.RandomScale(0.1),
A.PadIfNeeded(1280, 1280),
A.RandomSizedCrop([1000, 1280], 1280, 1280),
A.Flip(),
A.Rotate(90),
A.RandomBrightnessContrast(0.02, 0.02),
A.HueSaturationValue(0, 10, 10),
A.Normalize(mean, std, 1),
])
self.valid_transforms = A.Compose([
A.InvertImg(p=1),
A.Normalize(mean, std, 1),
])
def __init__(self,
metadata: DataFrame,
params: dict,
transform,
data_filter,
frame_num=8):
self.metadata_df = metadata
self.real_filename = list(data_filter(metadata).index)
self.transform = transform
self.frame_num = frame_num
self.same_transform = params['same_transform']
self.smooth = params['label_smoothing']
self.trans = aug.OneOf([
aug.Downscale(0.5, 0.5, p=0.666),
aug.JpegCompression(quality_lower=20, quality_upper=20, p=0.666),
aug.Flip(p=0)
])
self.video_path = pathlib.Path(params['data_path'])
self.cached_path = pathlib.Path(params['cache_path'])
self.cached_path.mkdir(exist_ok=True)
self.data_dropout = params['data_dropout']
self.input_mix = params['input_mix']
np.random.shuffle(self.real_filename)
self.real_filename = self.real_filename[:int(
len(self.real_filename) * (1 - self.data_dropout))]
self.real2fakes = {fn: [] for fn in self.real_filename}
filename_set = set(self.real_filename)
for fn, row in metadata.iterrows():
if row['label'] == 'FAKE' and row['original'] in filename_set:
self.real2fakes[row['original']].append(fn)
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 det_train_augs(height: int, width: int) -> albu.Compose:
return albu.Compose([
albu.Resize(height=height, width=width),
albu.ShiftScaleRotate(shift_limit=0.025,
scale_limit=0.1,
rotate_limit=10),
albu.Flip(),
albu.RandomRotate90(),
albu.OneOf(
[
albu.HueSaturationValue(p=1.0),
albu.IAAAdditiveGaussianNoise(p=1.0),
albu.IAASharpen(p=1.0),
albu.RandomBrightnessContrast(
brightness_limit=0.1, contrast_limit=0.1, p=1.0),
albu.RandomGamma(p=1.0),
],
p=1.0,
),
albu.OneOf(
[
albu.Blur(blur_limit=3, p=1.0),
albu.MotionBlur(blur_limit=3, p=1.0)
],
p=1.0,
),
albu.Normalize(),
])
def preprocess_image(cls, images_path, image_file):
preprocessed_dir = os.path.join('../../images/dogscats500/preprocessed', cls)
image_filepath = os.path.join(images_path, image_file)
print(" ", image_filepath)
image = cv.imread(image_filepath)
if not os.path.exists(preprocessed_dir):
os.makedirs(preprocessed_dir)
aug = A.Compose(
transforms=[
A.RandomRotate90(),
A.Flip()],
p=0.5)
image_file_name, image_file_ext = os.path.splitext(image_file)[:2]
print(image_file_name, image_file_ext)
preprocessed_name = image_file_name + '.aug' + image_file_ext
preprocessed_image_file = os.path.join(preprocessed_dir, preprocessed_name)
print(preprocessed_name)
print(preprocessed_image_file)
preprocessed_image = aug(image=image)['image']
cv.imwrite(preprocessed_image_file, preprocessed_image)
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))
def affine_transform(
self): # Affine Transforms: Scale & Translation & Rotation
return A.Compose(
[
# Transpose the input by swapping rows and columns.
A.Transpose(p=self.p),
A.OneOf(
[
# Randomly rotate the input by 90 degrees zero or more times.
A.RandomRotate90(p=self.p),
# Rotate the input by an angle selected randomly from the uniform distribution.
A.Rotate(limit=90, p=self.p),
# Randomly apply affine transforms: translate, scale and rotate the input.
A.ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.1,
rotate_limit=45,
p=self.p)
],
p=1),
A.OneOf(
[
A.HorizontalFlip(
p=self.p
), # Flip the input vertically around the x-axis.
A.VerticalFlip(
p=self.p
), # Flip the input horizontally around the y-axis.
A.Flip(
p=self.p
) # Flip the input either horizontally, vertically or both horizontally and vertically.
],
p=1)
],
p=1)
def get_transforms(phase, crop_type=0, size=512):
list_transforms = []
if phase == "train":
list_transforms.extend([
aug.Flip(),
aug.Cutout(num_holes=4, p=0.5),
aug.OneOf([
aug.RandomContrast(),
aug.RandomGamma(),
aug.RandomBrightness(),
],
p=1),
aug.ShiftScaleRotate(rotate_limit=90),
aug.OneOf([
aug.GaussNoise(p=.35),
], p=.5),
])
if crop_type == 0:
list_transforms.extend([
CropNonEmptyMaskIfExists(size, size),
])
elif crop_type == 1:
list_transforms.extend([
RandomCrop(size, size, p=1.0),
])
list_transforms.extend([
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 __init__(self, metadata: DataFrame, bbox: DataFrame, params: dict,
transform, data_filter, diff):
self.metadata_df = metadata
self.real_filename = list(data_filter(metadata).index)
self.bbox_df = bbox
self.bbox_index_fn = set(bbox.index.get_level_values(0))
self.transform = transform
self.same_transform = params['same_transform']
self.diff = diff
self.video_path = pathlib.Path(params['data_path'])
self.cached_path = pathlib.Path(params['cache_path'])
self.cached_path.mkdir(exist_ok=True)
self.real2fakes = {fn: [] for fn in self.real_filename}
filename_set = set(self.real_filename)
for fn, row in metadata.iterrows():
if row['label'] == 'FAKE' and row['original'] in filename_set:
self.real2fakes[row['original']].append(fn)
import albumentations as aug
self.trans = aug.OneOf([
aug.Downscale(0.5, 0.5, p=0.66),
aug.JpegCompression(quality_lower=20, quality_upper=20, p=0.66),
aug.Flip(p=0)
])
def on_epoch_start(self, trainer, pl_module):
if pl_module.hparams.progressive:
ind = int(trainer.current_epoch / 3) if trainer.current_epoch < 3*7 else 7
prog = [256, 512, 768, 1024, 1280, 1536, 1792, 2048]
batch = [32, 32, 32, 16, 8, 8, 4, 4]
# For Progressive Resizing
train_transform = A.Compose([
A.RandomResizedCrop(height=prog[ind], width=prog[ind], scale=(0.8, 1.0), ratio=(0.75, 1.3333333333333333), interpolation=1, always_apply=False, p=1.0),
A.Flip(always_apply=False, p=0.5),
A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, brightness_by_max=True, always_apply=False, p=0.5),
A.GaussNoise(var_limit=(10.0, 50.0), mean=0, always_apply=False, p=0.5),
#A.Rotate(limit=90, interpolation=1, border_mode=4, value=None, mask_value=None, always_apply=False, p=0.5),
A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=45, interpolation=1, border_mode=4, value=None, mask_value=None, always_apply=False, p=0.5),
A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, always_apply=False, p=1.0)
])
valid_transform = A.Compose([A.Resize(height=prog[ind], width=prog[ind], interpolation=1, always_apply=False, p=1.0),
A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, always_apply=False, p=1.0)
])
pl_module.train_dataset = PANDADataset(pl_module.train_df, pl_module.hparams.data_dir, pl_module.hparams.image_format, transform=train_transform, tile=pl_module.hparams.tile, layer=pl_module.hparams.image_layer)
pl_module.val_dataset = PANDADataset(pl_module.val_df, pl_module.hparams.data_dir, pl_module.hparams.image_format, transform=valid_transform, tile=pl_module.hparams.tile, layer=pl_module.hparams.image_layer)
trainer.train_dataloader = DataLoader(pl_module.train_dataset, batch_size=batch[ind],
shuffle=True, num_workers=4, drop_last=True)
trainer.val_dataloaders = [DataLoader(pl_module.val_dataset, batch_size=batch[ind],
shuffle=True, num_workers=4, drop_last=True)]
trainer.num_training_batches = len(trainer.train_dataloader)#float('inf')
trainer.num_val_batches = len(trainer.val_dataloaders[0])#float('inf')
trainer.val_check_batch = trainer.num_training_batches
def __init__(self, outputs=5):
super().__init__()
self.net = EfficientNet.from_pretrained('efficientnet-b0')
self.linear = Sequential(ReLU(), Dropout(), Linear(1000, outputs))
df = pd.read_csv("../input/prostate-cancer-grade-assessment/train.csv")
self.train_df, self.valid_df = train_test_split(df, test_size=0.2)
self.data_dir = "../input/prostate-cancer-grade-assessment/train_images"
self.train_transforms = A.Compose(
[
A.InvertImg(p=1),
A.RandomSizedCrop([int(IMAGE_SIZE * 0.9), IMAGE_SIZE], IMAGE_SIZE, IMAGE_SIZE),
A.Transpose(),
A.Flip(),
A.Rotate(90, border_mode=cv.BORDER_CONSTANT, value=(0, 0, 0)),
A.RandomBrightnessContrast(0.02, 0.02),
A.HueSaturationValue(0, 10, 10),
A.Normalize(mean, std, 1),
]
)
self.valid_transforms = A.Compose([A.InvertImg(p=1), A.Normalize(mean, std, 1),])
self.criterion = BCEWithLogitsLoss()
if False and BATCH_SIZE == 1:
for m in self.modules():
if isinstance(m, nn.BatchNorm2d):
m.weight.requires_grad = False
m.bias.requires_grad = False
def get_train_augm(size=Tuple[int, int],
p=0.5):
return albu.Compose([
albu.Flip(p=p),
albu.ToFloat(255),
ToTensorV2() # albu.Lambda(image=to_tensor)
])
def __init__(self, outputs=5):
super().__init__()
self.net = EfficientNet.from_pretrained('efficientnet-b0')
self.linear = Sequential(ReLU(), Dropout(), Linear(1000, outputs))
df = pd.read_csv("../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_128_100"
self.train_transforms = A.Compose([
A.InvertImg(p=1),
A.RandomSizedCrop([100, 128], 128, 128),
A.Transpose(),
A.Flip(),
A.Rotate(90),
# A.RandomBrightnessContrast(0.02, 0.02),
# A.HueSaturationValue(0, 10, 10),
A.Normalize(mean, std, 1),
])
self.valid_transforms = A.Compose([
A.InvertImg(p=1),
A.Normalize(mean, std, 1),
])
self.criterion = BCEWithLogitsLoss()
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 strong_aug(p=1):
return A.Compose([
A.RandomRotate90(p=0.5),
A.Flip(p=0.5),
A.CLAHE(p=0.5),
],
p=p)
def classification_augmentations(height: int,
width: int) -> albumentations.Compose:
return albumentations.Compose([
albumentations.Resize(height=height, width=width),
albumentations.Flip(),
albumentations.Normalize(),
])
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_aug(mode="train"):
if mode == "Nor":
aug = A.Compose([
ToTensor(),
])
elif mode == "train":
aug = A.Compose([
A.Flip(),
A.ShiftScaleRotate(rotate_limit=1.0, p=0.8),
# Pixels
A.OneOf([
A.IAAEmboss(p=1.0),
A.IAASharpen(p=1.0),
A.Blur(p=1.0),
],
p=0.5),
# Affine
A.OneOf(
[A.ElasticTransform(p=1.0),
A.IAAPiecewiseAffine(p=1.0)],
p=0.5),
A.Normalize(p=1.0),
ToTensor(),
])
else:
aug = A.Compose([
A.Normalize(p=1.0),
ToTensor(),
])
return aug
def strong_aug(p=.5):
return A.Compose([
A.RandomRotate90(),
A.Flip(),
A.Transpose(),
A.OneOf([
A.IAAAdditiveGaussianNoise(),
A.GaussNoise(),
], p=0.2),
A.OneOf([
A.MotionBlur(p=.2),
A.MedianBlur(blur_limit=3, p=.1),
A.Blur(blur_limit=3, p=.1),
],
p=0.2),
A.ShiftScaleRotate(
shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=.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.RandomContrast(),
A.RandomBrightness(),
],
p=0.3),
A.HueSaturationValue(p=0.3),
],
p=p)
def get_train_transform():
return A.Compose([
A.Flip(p=0.5),
A.Rotate(20, p=0.9),
A.RandomSizedBBoxSafeCrop(1024, 1024, 0.2),
ToTensorV2(p=1.0)
], bbox_params={'format': 'pascal_voc', 'label_fields': ['labels']})
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 hard_transforms():
result = [
# random flip
albu.Flip(),
# add random brightness and contrast, 70% prob
albu.RandomBrightnessContrast(brightness_limit=0.2,
contrast_limit=0.2,
p=0.7),
# Random gamma changes with a 30% probability
albu.RandomGamma(gamma_limit=(85, 115), p=0.3),
# Randomly changes the hue, saturation, and color value of the input image
albu.HueSaturationValue(p=0.3),
# apply compression to lower the image quality
albu.JpegCompression(quality_lower=80),
# add cutout with 0.5 prob on the image
albu.Cutout(num_holes=15,
max_h_size=20,
max_w_size=20,
fill_value=5,
p=0.5),
# randomly select of these operations
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),
]
return result
def get_default_augmentor():
list_ops = [
aug.Flip(always_apply=True),
aug.RandomRotate90(always_apply=True)
]
augmentor = aug.Compose(list_ops)
return augmentor
