def __init__(self, phase, train_file, image_file_path, image_height, image_width, mean, std):
self.image_file_path = image_file_path
df = pd.read_csv(train_file)
class_map = {'A':0,'B':1,'C':2}
self.img_id = df['image_id'].apply(lambda x: x.split('.')[0]).values # just take id of image_id
self.labels = df['label'].apply(lambda x: x[-1]).map(class_map).values # encoding labels
if phase == 'valid':
# validation set
self.aug = albumentations.Compose([
albumentations.Resize(image_height,image_width,always_apply=True),
albumentations.Normalize(mean,std,always_apply=True),
])
elif phase == 'train':
# training set
self.aug = albumentations.Compose([
albumentations.Resize(image_height, image_width, always_apply=True),
albumentations.RandomShadow(shadow_roi=(0, 0.85, 1, 1), p=0.5),
albumentations.RandomBrightnessContrast(brightness_limit=0.10, contrast_limit=0.10, p=0.5),
albumentations.ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.1,
rotate_limit=5,
p=0.9),
albumentations.Normalize(mean, std, always_apply=True)
])
def augment(self, img0, img1):
transform = A.Compose([
A.IAAAdditiveGaussianNoise(p=0.05),
A.OneOf([
A.IAASharpen(p=1.0),
A.Blur(blur_limit=3, p=1.0),
],
p=0.5),
A.OneOf([
A.RandomBrightnessContrast(p=1.0),
A.HueSaturationValue(p=1.0),
A.RandomGamma(p=1.0),
],
p=0.5),
A.OneOf([
A.RandomFog(p=1.0),
A.RandomRain(p=1.0),
A.RandomShadow(p=1.0),
A.RandomSnow(p=1.0),
A.RandomSunFlare(p=1.0)
],
p=0.05),
],
additional_targets={'img1': 'image'})
transformed = transform(image=img0, img1=img1)
img0 = transformed["image"]
img1 = transformed["img1"]
return img0, img1
def __init__(self,fold_file, image_file_path, folds, image_height, image_width, mean, std):
self.image_file_path = image_file_path
self.fold_file = fold_file
df = pd.read_csv(self.fold_file)
df = df[['image_id','labels','kfold']]
df = df[df['kfold'].isin(folds)].reset_index(drop= True)
class_map = {'A':0,'B':1,'C':2}
self.img_id = df['image_id'].apply(lambda x: x.split('.')[0]).values # just take id of image_id
self.labels = df['labels'].apply(lambda x: x[-1]).map(class_map).values # encoding labels
if len(folds)==1:
# validation set
self.aug = albumentations.Compose([
albumentations.Resize(image_height,image_width,always_apply=True),
albumentations.Normalize(mean,std,always_apply=True),
])
else:
# training set
self.aug = albumentations.Compose([
albumentations.Resize(image_height, image_width, always_apply=True),
albumentations.HorizontalFlip(p=0.5),
albumentations.VerticalFlip(p=0.5),
albumentations.RandomShadow(shadow_roi=(0, 0.85, 1, 1), p=0.5),
albumentations.RandomBrightnessContrast(brightness_limit=0.10, contrast_limit=0.10, p=0.5),
albumentations.ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.1,
rotate_limit=5,
p=0.5),
albumentations.Normalize(mean, std, always_apply=True)
])
def __init__(self,fold_file, pkl_file_path, folds, image_height, image_width, mean, std):
self.pkl_file_path = pkl_file_path
self.fold_file = fold_file
df = pd.read_csv(self.fold_file)
df = df[['image_id','labels','kfold']]
df = df[df['kfold'].isin(folds)].reset_index(drop= True)
class_map = {'A':0,'B':1,'C':2}
self.img_id = df['image_id'].apply(lambda x: x.split('.')[0]).values
self.labels = df['labels'].apply(lambda x: x[-1]).map(class_map).values
# training set
self.aug = albumentations.Compose([
albumentations.Resize(image_height, image_width, always_apply=True),
albumentations.Cutout(num_holes=8,max_h_size=30,max_w_size=60,always_apply=False,p=0.9),
albumentations.Equalize(always_apply=False, p=0.9),
albumentations.RandomShadow(shadow_roi=(0, 0.85, 1, 1), p=0.9),
albumentations.RandomBrightnessContrast(brightness_limit=0.1, contrast_limit=0.1, p=0.9),
albumentations.ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.1,
rotate_limit=5,
p=0.9),
albumentations.Normalize(mean, std, always_apply=True)
])
def _get_static_augmentations(self, config):
augmentations = []
if config["horizontal_flip"]:
augmentations.append(albu.HorizontalFlip(p=0.5))
else:
augmentations.append(None)
if config["grid_distortion"]:
augmentations.append(albu.GridDistortion(distort_limit=0.5, border_mode=cv2.BORDER_REPLICATE, p=1.0))
else:
augmentations.append(None)
if config["hsv_color_shift"]:
augmentations.append(albu.HueSaturationValue(p=1.0))
else:
augmentations.append(None)
if config["random_brightness_contrast"]:
augmentations.append(albu.RandomBrightnessContrast(p=1))
else:
augmentations.append(None)
if config["random_shadow"]:
augmentations.append(albu.RandomShadow(shadow_roi=(0, 0, 1, 1), p=0.2))
else:
augmentations.append(None)
return augmentations
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 get_training_augmentation(min_area=0., min_visibility=0.):
train_transform = [
albu.OneOf([
albu.MotionBlur(p=.2),
albu.MedianBlur(blur_limit=3, p=0.1),
albu.Blur(blur_limit=3, p=0.1),
],
p=0.2),
albu.ShiftScaleRotate(shift_limit=0,
scale_limit=0,
rotate_limit=15,
p=0.5),
albu.OneOf([
albu.CLAHE(clip_limit=2),
albu.IAASharpen(),
albu.IAAEmboss(),
],
p=0.3),
albu.OneOf([
albu.RandomFog(fog_coef_lower=0.1, fog_coef_upper=0.15, p=0.1),
albu.RandomShadow(p=0.1),
albu.RandomBrightness(limit=0.3, p=0.2),
albu.RandomRain(slant_lower=0,
slant_upper=8,
drop_length=0,
blur_value=4,
brightness_coefficient=0.8,
rain_type='heavy',
p=0.1),
albu.RandomSunFlare(p=0.2),
]),
albu.OneOf([
albu.RGBShift(p=0.1),
albu.HueSaturationValue(p=0.3),
]),
albu.OneOf([
albu.HorizontalFlip(p=0.5),
albu.RandomSizedCrop(min_max_height=(720, 1380),
height=1380,
width=720,
interpolation=cv2.INTER_AREA)
],
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 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 setup_pipeline(self, dict_transform):
tranform_list = []
if 'shadow' in dict_transform:
tranform_list.append(
A.RandomShadow(shadow_roi=(0, 0.5, 1, 1),
num_shadows_upper=1,
p=0.2))
if 'scale' in dict_transform:
tranform_list.append(
A.RandomScale(scale_limit=float(dict_transform['scale'])))
if 'rotate' in dict_transform:
tranform_list.append(
A.Rotate(limit=float(dict_transform['rotate']), p=0.8))
if 'shift' in dict_transform:
tranform_list.append(
A.ShiftScaleRotate(shift_limit=float(dict_transform['shift']),
scale_limit=0.0,
rotate_limit=0,
interpolation=1,
border_mode=4,
p=0.8))
if 'brightness' in dict_transform:
tranform_list.append(
A.RandomBrightness(limit=float(dict_transform['brightness']),
p=0.8))
if 'contrast' in dict_transform:
tranform_list.append(
A.RandomContrast(limit=float(dict_transform['contrast']),
p=0.8))
if 'motion_blur' in dict_transform:
tranform_list.append(A.MotionBlur(p=0.5, blur_limit=7))
if 'fog' in dict_transform:
tranform_list.append(
A.RandomFog(fog_coef_lower=0.0,
fog_coef_upper=float(dict_transform['fog']),
alpha_coef=0.05,
p=0.7))
if 'rain' in dict_transform:
tranform_list.append(
A.RandomRain(brightness_coefficient=0.95,
drop_width=1,
blur_value=1,
p=0.7))
if 'occlusion' in dict_transform:
tranform_list.append(
A.CoarseDropout(max_holes=5, max_height=8, max_width=8, p=0.5))
self.transform = A.Compose(tranform_list)
def hard_transforms(crop_size=512):
return albu.Compose([
albu.ShiftScaleRotate(shift_limit=0,
scale_limit=0.1,
rotate_limit=180,
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0),
albu.CropNonEmptyMaskIfExists(crop_size, crop_size, p=1),
albu.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=4,
shadow_dimension=7,
always_apply=False,
p=0.5),
albu.HueSaturationValue(p=0.3),
albu.OneOf([
albu.IAAAdditiveGaussianNoise(),
albu.GaussNoise(),
albu.MultiplicativeNoise(
multiplier=[0.5, 1.5], per_channel=True, p=1)
],
p=0.3),
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),
albu.OneOf([
albu.CLAHE(clip_limit=2),
albu.IAASharpen(),
albu.IAAEmboss(),
albu.RandomBrightnessContrast(
brightness_limit=0.2, contrast_limit=0.2, p=0.3),
albu.RandomGamma(gamma_limit=(85, 115), p=0.3),
],
p=0.3),
albu.JpegCompression(quality_lower=40, quality_upper=100, p=0.5),
albu.Cutout(
num_holes=25, max_h_size=5, max_w_size=5, fill_value=0, p=0.3),
],
p=1)
def create_datasets(train_file_list, val_file_list):
train_transform = A.Compose([
A.RandomBrightnessContrast(p=0.5),
A.GaussNoise(p=.25),
A.ISONoise(p=.15),
A.RandomShadow(p=.2),
A.MotionBlur(p=.1),
#A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
ToTensorV2(),
])
train_dataset = GroundDataset(images_filepaths=train_file_list,
transform=train_transform)
val_transform = A.Compose([
#A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
ToTensorV2(),
])
val_dataset = GroundDataset(images_filepaths=val_file_list,
transform=val_transform)
return train_dataset, val_dataset
def __init__(self, folds, img_height, img_width, mean, std):
df = pd.read_csv('../input/train_folds.csv')
df = df[[
'image_id', 'grapheme_root', 'vowel_diacritic',
'consonant_diacritic', 'kfold'
]]
df = df[df.kfold.isin(folds)].reset_index(drop=True)
self.image_ids = df.image_id.values
self.grapheme_root = df.grapheme_root.values
self.vowel_diacritic = df.vowel_diacritic.values
self.consonant_diacritic = df.consonant_diacritic
if len(folds) == 1:
self.aug = albumentations.Compose([
albumentations.Resize(img_height, img_width),
albumentations.Normalize(mean, std, always_apply=True)
])
else:
self.aug = albumentations.Compose([
albumentations.Resize(img_height, img_width),
albumentations.ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.1,
rotate_limit=5,
p=0.9),
albumentations.Rotate(limit=5),
albumentations.RandomContrast(limit=0.2),
albumentations.GaussianBlur(blur_limit=7),
albumentations.RandomGamma(),
albumentations.RandomShadow(),
albumentations.GaussNoise(),
albumentations.ChannelShuffle(),
#albumentations.Cutout(),
albumentations.Equalize(),
albumentations.MultiplicativeNoise(),
albumentations.Normalize(mean, std, always_apply=True)
])
def augment(self, img, mask, do_affine_transform = True):
if do_affine_transform:
afine_transform = A.Compose([
A.HorizontalFlip(p=0.4),
A.OneOf([
A.GridDistortion(interpolation=cv2.INTER_NEAREST, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0),
A.ElasticTransform(interpolation=cv2.INTER_NEAREST, alpha_affine=10, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0),
A.ShiftScaleRotate(interpolation=cv2.INTER_NEAREST, shift_limit=0.03, rotate_limit=4, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0),
A.OpticalDistortion(interpolation=cv2.INTER_NEAREST, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0)
], p=0.6),
], additional_targets={'mask': 'image'})
afine_transformed = afine_transform(image=img, mask=mask)
img = afine_transformed["image"]
mask = afine_transformed["mask"]
transform = A.Compose([
A.IAAAdditiveGaussianNoise(p=0.05),
A.OneOf([
A.IAASharpen(p=1.0),
A.Blur(blur_limit=3, p=1.0),
] , p=0.5),
A.OneOf([
A.RandomBrightnessContrast(p=1.0),
A.HueSaturationValue(p=1.0),
A.RandomGamma(p=1.0),
], p=0.5),
A.OneOf([
A.RandomFog(p=1.0),
A.RandomRain(p=1.0),
A.RandomShadow(p=1.0),
A.RandomSnow(p=1.0),
A.RandomSunFlare(p=1.0)
], p=0.05),
])
transformed = transform(image=img)
img = transformed["image"]
return img, mask
# -*- coding: utf-8 -*-
# @Description: 放置一些图像变换
# @Author: CaptainHu
# @Date: 2021-05-12 17:21:53
# @LastEditors: CaptainHu
import albumentations as A
v1=A.Compose(
[
A.RandomBrightnessContrast(),
A.RandomGamma(),
A.RandomSunFlare(p=0.3),
]
)
v2=A.Compose([
A.RandomBrightnessContrast(p=1),
A.RandomGamma(),
A.RandomFog(),
A.RandomShadow(p=0.8),
])
def __call__(self, img):
img = aug(np.array(img), albu.RandomShadow())
img = Image.fromarray(img)
return img
def get_transform_imagenet(use_albu_aug):
if use_albu_aug:
train_transform = al.Compose([
# al.Flip(p=0.5),
al.Resize(256, 256, interpolation=2),
al.RandomResizedCrop(224,
224,
scale=(0.08, 1.0),
ratio=(3. / 4., 4. / 3.),
interpolation=2),
al.HorizontalFlip(),
al.OneOf(
[
al.OneOf(
[
al.ShiftScaleRotate(
border_mode=cv2.BORDER_CONSTANT,
rotate_limit=30), # , p=0.05),
al.OpticalDistortion(
border_mode=cv2.BORDER_CONSTANT,
distort_limit=5.0,
shift_limit=0.1),
# , p=0.05),
al.GridDistortion(border_mode=cv2.BORDER_CONSTANT
), # , p=0.05),
al.ElasticTransform(
border_mode=cv2.BORDER_CONSTANT,
alpha_affine=15), # , p=0.05),
],
p=0.1),
al.OneOf(
[
al.RandomGamma(), # p=0.05),
al.HueSaturationValue(), # p=0.05),
al.RGBShift(), # p=0.05),
al.CLAHE(), # p=0.05),
al.ChannelShuffle(), # p=0.05),
al.InvertImg(), # p=0.05),
],
p=0.1),
al.OneOf(
[
al.RandomSnow(), # p=0.05),
al.RandomRain(), # p=0.05),
al.RandomFog(), # p=0.05),
al.RandomSunFlare(num_flare_circles_lower=1,
num_flare_circles_upper=2,
src_radius=110),
# p=0.05, ),
al.RandomShadow(), # p=0.05),
],
p=0.1),
al.RandomBrightnessContrast(p=0.1),
al.OneOf(
[
al.GaussNoise(), # p=0.05),
al.ISONoise(), # p=0.05),
al.MultiplicativeNoise(), # p=0.05),
],
p=0.1),
al.OneOf(
[
al.ToGray(), # p=0.05),
al.ToSepia(), # p=0.05),
al.Solarize(), # p=0.05),
al.Equalize(), # p=0.05),
al.Posterize(), # p=0.05),
al.FancyPCA(), # p=0.05),
],
p=0.1),
al.OneOf(
[
# al.MotionBlur(blur_limit=1),
al.Blur(blur_limit=[3, 5]),
al.MedianBlur(blur_limit=[3, 5]),
al.GaussianBlur(blur_limit=[3, 5]),
],
p=0.1),
al.OneOf(
[
al.CoarseDropout(), # p=0.05),
al.Cutout(), # p=0.05),
al.GridDropout(), # p=0.05),
al.ChannelDropout(), # p=0.05),
al.RandomGridShuffle(), # p=0.05),
],
p=0.1),
al.OneOf(
[
al.Downscale(), # p=0.1),
al.ImageCompression(quality_lower=60), # , p=0.1),
],
p=0.1),
],
p=0.5),
al.Normalize(),
ToTensorV2()
])
else:
train_transform = transforms.Compose([
transforms.Resize(256),
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
])
test_transform = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
])
if use_albu_aug:
train_transform = MultiDataTransformAlbu(train_transform)
else:
train_transform = MultiDataTransform(train_transform)
return train_transform, test_transform
def augment(self,
img1, bbox1 = [], keypoints1 = [], filtered_objs1 = [],
img0 = None, bbox0 = [], keypoints0 = [], filtered_objs0 = [],
do_img_aug = True, do_affine_aug = False, img1_to_img0 = False
):
if img0 is None:
img0 = img1.copy()
replay_img_aug = []
keypoints = keypoints1 + keypoints0
bboxes = bbox1 + bbox0
# Afine augmentations
# --------------------------------------
if do_affine_aug:
afine_transform = A.ReplayCompose(
[
A.HorizontalFlip(p=0.4),
A.OneOf([
# A.GridDistortion(interpolation=cv2.INTER_NEAREST, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0),
# A.ElasticTransform(interpolation=cv2.INTER_NEAREST, alpha_affine=10, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0),
A.ShiftScaleRotate(interpolation=cv2.INTER_NEAREST, shift_limit=0.035, rotate_limit=5, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0),
# A.OpticalDistortion(interpolation=cv2.INTER_NEAREST, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0),
], p=0.65),
],
additional_targets={"img0": "image"},
keypoint_params=A.KeypointParams(format="xy", remove_invisible=False),
bbox_params=A.BboxParams(format='coco', label_fields=["bbox_ids"]), # coco format: [x-min, y-min, width, height]
)
transformed = afine_transform(image=img1, img0=img0, keypoints=keypoints, bboxes=bboxes, bbox_ids=np.arange(len(bboxes)))
replay_img_aug.append(transformed["replay"])
img1 = transformed["image"]
img0 = transformed["img0"]
transformed_keypoints = transformed['keypoints']
transformed_bboxes = transformed['bboxes']
bbox_ids = transformed["bbox_ids"]
# it can happend that bounding boxes are removed, we have to account for that
# and also remove the objects and keypoints in question
idx_offset = len(bbox1)
keypoints1 = []
keypoints0 = []
bbox1 = []
bbox0 = []
tmp_filtered_objs1 = []
tmp_filtered_objs0 = []
for i, bbox_id in enumerate(bbox_ids):
kp_idx_start = bbox_id * 8
kp_idx_end = bbox_id * 8 + 8
if bbox_id < idx_offset:
tmp_filtered_objs1.append(filtered_objs1[i])
bbox1.append(transformed_bboxes[i])
keypoints1 += transformed_keypoints[kp_idx_start:kp_idx_end]
else:
tmp_filtered_objs0.append(filtered_objs0[i])
bbox0.append(transformed_bboxes[i])
keypoints0 += transformed_keypoints[kp_idx_start:kp_idx_end]
filtered_objs1 = tmp_filtered_objs1
filtered_objs0 = tmp_filtered_objs0
# Translate img0 + bbox0/keypoints0 for single track centernet
# --------------------------------------
if img1_to_img0:
transform = A.Compose(
[A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.15, rotate_limit=0, always_apply=True, border_mode=cv2.BORDER_CONSTANT)],
keypoint_params=A.KeypointParams(format="xy", remove_invisible=False),
bbox_params=A.BboxParams(format='coco', label_fields=[])
)
keypoints = list(np.array(piped_params["gt_2d_info"])[:,:2] * self.params.R)
transformed = transform(image=img1, keypoints=keypoints1, bboxes=bboxes1)
img0 = transformed["image"]
bboxes0 = transformed['bboxes']
keypoints0 = transformed['keypoints']
# Augmentation for images
# --------------------------------------
if do_img_aug:
transform = A.ReplayCompose([
A.IAAAdditiveGaussianNoise(p=0.02),
A.OneOf([
A.IAASharpen(p=1.0),
A.Blur(blur_limit=3, p=1.0),
] , p=0.5),
A.OneOf([
A.RandomBrightnessContrast(p=1.0),
A.HueSaturationValue(p=1.0),
A.RandomGamma(p=1.0),
], p=0.6),
A.OneOf([
A.RandomFog(p=1.0),
A.RandomRain(p=1.0),
A.RandomShadow(p=1.0),
A.RandomSnow(p=1.0)
], p=0.02),
], additional_targets={"img0": "image"})
transformed = transform(image=img1, img0=img0)
img1 = transformed["image"]
img0 = transformed["img0"]
return img1, bbox1, keypoints1, filtered_objs1, img0, bbox0, keypoints0, filtered_objs0, replay_img_aug
import albumentations as A
transform_fn = A.Compose([
A.OneOf([
A.IAAAdditiveGaussianNoise(),
A.GaussNoise(),
], p=.2),
A.OneOf([
A.MotionBlur(p=.2),
A.MedianBlur(blur_limit=3, p=.2),
A.Blur(blur_limit=3, p=.2),
], p=.2),
A.OneOf([
A.CLAHE(clip_limit=2),
A.IAASharpen(),
A.IAAEmboss(),
A.RandomBrightnessContrast(),
], p=0.2),
A.OneOf([
A.ChannelShuffle(),
A.HueSaturationValue(),
A.RGBShift(),
A.ToSepia(),
], p=0.2),
A.OneOf([
A.RandomSunFlare(flare_roi=(0, 0, 1., 1.), src_radius=100, p=.1),
A.RandomFog(fog_coef_lower=0.2, fog_coef_upper=0.3, p=.1),
A.RandomShadow(p=.1),
A.RandomRain(p=.1, blur_value=1),
], p=0.1)
])
"div255":
lambda array: array / 255,
}
augmentations = {
"strong":
albu.Compose([
albu.Flip(),
albu.ShiftScaleRotate(shift_limit=0.0,
scale_limit=0.2,
rotate_limit=30,
p=0.4),
albu.OpticalDistortion(),
albu.ElasticTransform(),
albu.GaussNoise(),
albu.RandomShadow(),
albu.OneOf(
[
albu.CLAHE(clip_limit=2),
albu.IAASharpen(),
albu.IAAEmboss(),
albu.RandomBrightnessContrast(),
albu.RandomGamma(),
albu.MedianBlur(),
],
p=0.5,
),
albu.OneOf(
[albu.RGBShift(), albu.HueSaturationValue()], p=0.5),
]),
"weak":
def getdata(img, count, disp=False):
#randomly transform the template image to generate sample data
#need to add a new function that generates data by registering real -
#input images with template and thus generating transform matrix
xtrain = []
ytrain = []
d = 20
pts1 = np.float32([[0, 0], [width, 0], [width, height]])
'''
cv2.circle(img, tuple(pts1[0]), 5, (0, 0, 255), -1)
cv2.circle(img, tuple(pts1[1]), 5, (0, 0, 255), -1)
cv2.circle(img, tuple(pts1[2]), 5, (0, 0, 255), -1)
cv2.imshow("Image", img)
'''
aug = A.Compose(
[
A.RandomBrightnessContrast(p=.5),
A.RandomGamma(p=.5),
A.RandomRain(
brightness_coefficient=0.9, drop_width=1, blur_value=5, p=.5),
A.RandomShadow(num_shadows_lower=1,
num_shadows_upper=1,
shadow_dimension=5,
shadow_roi=(0, 0.5, 1, 1),
p=.5),
A.RandomFog(
fog_coef_lower=0.1, fog_coef_upper=0.5, alpha_coef=0.1, p=.5),
#A.RandomSunFlare(flare_roi=(0, 0, 0.2, 0.2), angle_lower=0.2, p=.5),
#A.CLAHE(p=1),
A.HueSaturationValue(hue_shift_limit=3,
sat_shift_limit=50,
val_shift_limit=50,
p=.5),
],
p=.8)
for i in range(count):
d0 = random.sample(range(-d, d), 2)
d1 = random.sample(range(-d, d), 2)
d2 = random.sample(range(-d, d), 2)
#import pdb;pdb.set_trace()
pts2 = np.float32([pts1[0] + d0, pts1[1] + d1, pts1[2] + d2])
matrix = cv2.getAffineTransform(pts1, pts2)
result = cv2.warpAffine(img, matrix, (width, height))
#augmentations
result = aug(image=result)['image']
#import pdb;pdb.set_trace()
matrix = cv2.invertAffineTransform(matrix)
matrix = matrix.flatten()
xtrain.append(result)
ytrain.append(matrix)
if disp == True:
cv2.imshow("Affine transformation", result)
cv2.waitKey(30)
cv2.destroyAllWindows()
xtrain = np.array(xtrain, dtype=np.float32)
ytrain = np.array(ytrain, dtype=np.float32)
return (xtrain / 255.0, ytrain)
def __call__(self, data):
rgb, thermal, depth, audio, label, id = data
rgb = rgb.astype(np.float32)
height, width, _ = rgb.shape
albumentations_transform_pixel = {
'Blur': albumentations.Blur(),
#'CLAHE':albumentations.CLAHE(),
'ChannelDropout': albumentations.ChannelDropout(),
'ChannelShuffle': albumentations.ChannelShuffle(),
'CoarseDropout': albumentations.CoarseDropout(),
#'Equalize':albumentations.Equalize(),
#'FancyPCA':albumentations.FancyPCA(),
'GaussNoise': albumentations.GaussNoise(),
'GaussianBlur': albumentations.GaussianBlur(),
#'GlassBlur':albumentations.GlassBlur(),
'HueSaturationValue': albumentations.HueSaturationValue(),
'IAAAdditiveGaussianNoise':
albumentations.IAAAdditiveGaussianNoise(),
#'ISONoise':albumentations.ISONoise(),
'RGBShift': albumentations.RGBShift(),
'RandomBrightnessContrast':
albumentations.RandomBrightnessContrast(),
'RandomFog': albumentations.RandomFog(),
#'RandomGamma':albumentations.RandomGamma(),
'RandomRain': albumentations.RandomRain(),
'RandomShadow': albumentations.RandomShadow(),
'RandomSnow': albumentations.RandomSnow(),
'RandomSunFlare': albumentations.RandomSunFlare(),
'Solarize': albumentations.Solarize(),
}
albumentations_transform_bbox = {
#'HorizontalFlip':albumentations.HorizontalFlip(),
#'VerticalFlip':albumentations.VerticalFlip(),
#'CenterCrop':albumentations.CenterCrop(height=height-10, width=width-10, p=0.5),
#'RandomCropNearBBox':albumentations.RandomCropNearBBox(p=0.5),
#'Crop':albumentations.Crop(x_min=10, y_min =10, y_max=height-10, x_max=width-10, p=0.5),
#'ElasticTransform':albumentations.ElasticTransform(),
#'ShiftScaleRotate':albumentations.ShiftScaleRotate(),
}
transform = np.random.choice(
['None'] + list(albumentations_transform_pixel.keys()) +
list(albumentations_transform_bbox.keys()))
if transform in albumentations_transform_pixel:
aug = albumentations.Compose(
[albumentations_transform_pixel[transform]],
bbox_params={
'format': 'pascal_voc',
'label_fields': ['labels']
})
try:
annots = np.array(annots).astype(np.float32)
aug_result = aug(image=rgb,
bboxes=annots[:, :4],
labels=annots[:, 4])
rgb = aug_result['image']
annots = np.hstack([
aug_result['bboxes'],
np.array(aug_result['labels']).reshape(-1, 1)
])
except Exception as e:
print(
f"transform={transform} aug_result['bboxes']={aug_result['bboxes']} aug_result['labels']={aug_result['labels']}"
)
raise Exception(e)
elif transform in albumentations_transform_bbox:
aug = albumentations.Compose(
[albumentations_transform_bbox[transform]],
bbox_params={
'format': 'pascal_voc',
'label_fields': ['labels']
})
try:
annots = np.array(annots).astype(np.float32)
aug_result = aug(image=rgb,
bboxes=annots[:, :4],
labels=annots[:, 4])
rgb = aug_result['image']
label = np.hstack([
aug_result['bboxes'],
np.array(aug_result['labels']).reshape(-1, 1)
])
except Exception as e:
print(
f"transform={transform} aug_result['bboxes']={aug_result['bboxes']} aug_result['labels']={aug_result['labels']}"
)
raise Exception(e)
return rgb, thermal, depth, audio, label, id
def get_transforms(aug_type: str):
"""
Data augmentation 객체 생성
Args:
aug_type(str) : augmentation타입 지정
Returns :
list :: train, validation, test데이터 셋에 대한 transform
"""
# TODO: Normalize
if False:
pass
else:
norm_mean = (0, 0, 0)
norm_std = (1, 1, 1)
if aug_type == 'no':
train_transform = A.Compose(
[A.Normalize(mean=norm_mean, std=norm_std),
ToTensorV2()])
val_transform = A.Compose(
[A.Normalize(mean=norm_mean, std=norm_std),
ToTensorV2()])
test_transform = A.Compose(
[A.Normalize(mean=norm_mean, std=norm_std),
ToTensorV2()])
elif aug_type == 'dev':
pass
elif aug_type == 'final':
train_transform = A.Compose([
A.HorizontalFlip(p=0.5),
A.RandomResizedCrop(512,
512,
p=0.8,
scale=(0.7, 1.0),
ratio=(0.5, 1.5)),
A.Rotate(limit=30, p=0.8),
A.Cutout(num_holes=4, max_h_size=16, max_w_size=16, p=0.8),
A.ElasticTransform(alpha=40, p=0.8),
A.CLAHE(clip_limit=3.0, p=0.8),
A.Normalize(mean=norm_mean, std=norm_std),
ToTensorV2()
])
val_transform = A.Compose(
[A.Normalize(mean=norm_mean, std=norm_std),
ToTensorV2()])
test_transform = A.Compose(
[A.Normalize(mean=norm_mean, std=norm_std),
ToTensorV2()])
# TODO: 아래 코드 정리 중
elif aug_type == 'basic':
train_transform = A.Compose([
A.Normalize(mean=(0.46009655, 0.43957878, 0.41827092),
std=(0.2108204, 0.20766491, 0.21656131),
max_pixel_value=255.0,
p=1.0),
ToTensorV2()
])
val_transform = A.Compose([
A.Normalize(mean=(0.46009655, 0.43957878, 0.41827092),
std=(0.2108204, 0.20766491, 0.21656131),
max_pixel_value=255.0,
p=1.0),
ToTensorV2()
])
test_transform = A.Compose([ToTensorV2()])
elif aug_type == "aug1":
train_transform = A.Compose([
A.OneOf([
A.ElasticTransform(alpha=120,
sigma=120 * 0.05,
alpha_affine=120 * 0.03,
p=0.5),
A.GridDistortion(p=1.0),
A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1)
],
p=0.8),
A.VerticalFlip(p=0.5),
A.RandomBrightnessContrast(p=0.8),
A.RandomGamma(p=0.8),
A.RandomRotate90(p=0.5),
ToTensorV2()
])
val_transform = A.Compose([ToTensorV2()])
test_transform = A.Compose([ToTensorV2()])
elif aug_type == "aug2":
train_transform = A.Compose([
A.OneOf([
A.RandomShadow(p=1),
A.RandomSunFlare(num_flare_circles_lower=1,
num_flare_circles_upper=5,
src_radius=250,
p=1),
A.RandomRain(p=1),
A.RandomSnow(brightness_coeff=1.5, p=1),
A.RandomFog(
fog_coef_lower=0.8, fog_coef_upper=1, alpha_coef=0.08, p=1)
],
p=0.8),
ToTensorV2()
])
val_transform = A.Compose([ToTensorV2()])
test_transform = A.Compose([ToTensorV2()])
elif aug_type == "aug3":
train_transform = A.Compose([
A.OneOf([
A.HueSaturationValue(hue_shift_limit=0.2,
sat_shift_limit=0.2,
val_shift_limit=0.2,
p=1),
A.MultiplicativeNoise(
multiplier=(0.9, 1.1), per_channel=True, p=1),
A.RGBShift(r_shift_limit=0.1,
g_shift_limit=0.1,
b_shift_limit=0.1,
p=1),
A.ChannelShuffle(0.05)
],
p=0.8),
ToTensorV2()
])
val_transform = A.Compose([ToTensorV2()])
test_transform = A.Compose([ToTensorV2()])
elif aug_type == "aug4":
train_transform = A.Compose([
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.RandomRotate90(p=0.5),
ToTensorV2()
])
val_transform = A.Compose([ToTensorV2()])
test_transform = A.Compose([ToTensorV2()])
elif aug_type == "aug5":
train_transform = A.Compose([
A.VerticalFlip(p=0.5),
A.RandomRotate90(p=0.5),
#A.ElasticTransform(p=1, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03),
#A.GridDistortion(p=1.0),
#A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1)
#A.VerticalFlip(p=0.5),
#A.RandomBrightnessContrast(p=0.8),
#A.RandomGamma(p=0.8),
#A.RandomRotate90(p=0.5),
#A.MultiplicativeNoise(multiplier=(0.9, 1.1), per_channel=True, p=0.8),
ToTensorV2()
])
val_transform = A.Compose([ToTensorV2()])
test_transform = A.Compose([ToTensorV2()])
return train_transform, val_transform, test_transform
def get_train_transforms_mmdetection(input_size,
use_crop=False,
use_no_color_aug=False,
use_center_crop=False,
center_crop_ratio=0.9,
use_gray=False):
if isinstance(input_size, int):
input_size = (input_size[0], input_size[1])
return al.Compose([
al.RandomResizedCrop(height=input_size[0],
width=input_size[1],
scale=(0.4, 1.0),
interpolation=0,
p=0.5),
al.Resize(input_size[0], input_size[1], p=1.0),
al.HorizontalFlip(p=0.5),
al.OneOf([
al.ShiftScaleRotate(border_mode=0,
shift_limit=(-0.2, 0.2),
scale_limit=(-0.2, 0.2),
rotate_limit=(-20, 20)),
al.OpticalDistortion(border_mode=0,
distort_limit=[-0.5, 0.5],
shift_limit=[-0.5, 0.5]),
al.GridDistortion(
num_steps=5, distort_limit=[-0., 0.3], border_mode=0),
al.ElasticTransform(border_mode=0),
al.IAAPerspective(),
al.RandomGridShuffle()
],
p=0.1),
al.Rotate(limit=(-25, 25), border_mode=0, p=0.1),
al.OneOf([
al.RandomBrightnessContrast(brightness_limit=(-0.2, 0.2),
contrast_limit=(-0.2, 0.2)),
al.HueSaturationValue(hue_shift_limit=(-20, 20),
sat_shift_limit=(-30, 30),
val_shift_limit=(-20, 20)),
al.RandomGamma(gamma_limit=(30, 150)),
al.RGBShift(),
al.CLAHE(clip_limit=(1, 15)),
al.ChannelShuffle(),
al.InvertImg(),
],
p=0.1),
al.RandomSnow(p=0.05),
al.RandomRain(p=0.05),
al.RandomFog(p=0.05),
al.RandomSunFlare(num_flare_circles_lower=1,
num_flare_circles_upper=2,
src_radius=110,
p=0.05),
al.RandomShadow(p=0.05),
al.GaussNoise(var_limit=(10, 20), p=0.05),
al.ISONoise(color_shift=(0, 15), p=0.05),
al.MultiplicativeNoise(p=0.05),
al.OneOf([
al.ToGray(p=1. if use_gray else 0.05),
al.ToSepia(p=0.05),
al.Solarize(p=0.05),
al.Equalize(p=0.05),
al.Posterize(p=0.05),
al.FancyPCA(p=0.05),
],
p=0.05),
al.OneOf([
al.MotionBlur(blur_limit=(3, 7)),
al.Blur(blur_limit=(3, 7)),
al.MedianBlur(blur_limit=3),
al.GaussianBlur(blur_limit=3),
],
p=0.05),
al.CoarseDropout(p=0.05),
al.Cutout(num_holes=30,
max_h_size=37,
max_w_size=37,
fill_value=0,
p=0.05),
al.GridDropout(p=0.05),
al.ChannelDropout(p=0.05),
al.Downscale(scale_min=0.5, scale_max=0.9, p=0.1),
al.ImageCompression(quality_lower=60, p=0.2),
al.Normalize(),
ToTensorV2()
])
def get_train_transforms_atopy(input_size,
use_crop=False,
use_no_color_aug=False):
if use_crop:
resize = [
al.Resize(int(input_size * 1.2), int(input_size * 1.2)),
al.RandomSizedCrop(min_max_height=(int(input_size * 0.6),
int(input_size * 1.2)),
height=input_size,
width=input_size)
]
else:
resize = [al.Resize(input_size, input_size)]
return al.Compose(resize + [
al.Flip(p=0.5),
al.OneOf([
al.RandomRotate90(),
al.Rotate(limit=180),
], p=0.5),
al.OneOf([
al.ShiftScaleRotate(),
al.OpticalDistortion(),
al.GridDistortion(),
al.ElasticTransform(),
],
p=0.3),
al.RandomGridShuffle(p=0.05),
al.OneOf([
al.RandomGamma(),
al.HueSaturationValue(),
al.RGBShift(),
al.CLAHE(),
al.ChannelShuffle(),
al.InvertImg(),
],
p=0.1),
al.RandomSnow(p=0.05),
al.RandomRain(p=0.05),
al.RandomFog(p=0.05),
al.RandomSunFlare(p=0.05),
al.RandomShadow(p=0.05),
al.RandomBrightnessContrast(p=0.05),
al.GaussNoise(p=0.2),
al.ISONoise(p=0.2),
al.MultiplicativeNoise(p=0.2),
al.ToGray(p=0.05),
al.ToSepia(p=0.05),
al.Solarize(p=0.05),
al.Equalize(p=0.05),
al.Posterize(p=0.05),
al.FancyPCA(p=0.05),
al.OneOf([
al.MotionBlur(blur_limit=3),
al.Blur(blur_limit=3),
al.MedianBlur(blur_limit=3),
al.GaussianBlur(blur_limit=3),
],
p=0.05),
al.CoarseDropout(p=0.05),
al.Cutout(p=0.05),
al.GridDropout(p=0.05),
al.ChannelDropout(p=0.05),
al.Downscale(p=0.1),
al.ImageCompression(quality_lower=60, p=0.2),
al.Normalize(),
ToTensorV2()
])
def __init__(self, folds, img_height, img_width, mean, std):
df = pd.read_csv('../input/dataset/train_folds.csv')
df = df[['Image', 'label', 'kfold']]
df = df[df.kfold.isin(folds)].reset_index(drop=True)
self.image_ids = df.Image.values
self.labels = df.label.values
if len(folds) == 1:
self.aug = albumentations.Compose([
albumentations.Resize(img_height, img_width),
albumentations.Normalize(mean, std, always_apply=True)
])
else:
self.aug = albumentations.Compose([
albumentations.Resize(img_height, img_width),
albumentations.OneOf([
albumentations.ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.1,
rotate_limit=45),
albumentations.Rotate(limit=5),
albumentations.RandomGamma(),
albumentations.RandomShadow(),
albumentations.RandomGridShuffle(),
albumentations.ElasticTransform(),
albumentations.RGBShift(),
]),
albumentations.OneOf([
albumentations.OneOf([
albumentations.Blur(),
albumentations.MedianBlur(),
albumentations.MotionBlur(),
albumentations.GaussianBlur(),
]),
albumentations.OneOf([
albumentations.GaussNoise(),
albumentations.IAAAdditiveGaussianNoise(),
albumentations.ISONoise()
]),
]),
albumentations.OneOf([
albumentations.RandomBrightness(),
albumentations.RandomContrast(),
albumentations.RandomBrightnessContrast(),
]),
albumentations.OneOf([
albumentations.OneOf([
albumentations.Cutout(),
albumentations.CoarseDropout(),
albumentations.GridDistortion(),
albumentations.GridDropout(),
albumentations.OpticalDistortion()
]),
albumentations.OneOf([
albumentations.HorizontalFlip(),
albumentations.VerticalFlip(),
albumentations.RandomRotate90(),
albumentations.Transpose()
]),
]),
# albumentations.OneOf([
# albumentations.RandomSnow(),
# albumentations.RandomRain(),
# albumentations.RandomFog(),
# ]),
albumentations.Normalize(mean, std, always_apply=True)
])
from PIL import Image
import numpy as np
from torch.utils.data import Dataset
from mypath import Path
from torchvision import transforms
from dataloaders import custom_transforms as tr
from numpy import *
import albumentations as A
import cv2
resize_width = 640
resize_height = 480
aug_transform = A.Compose([
A.RandomScale(scale_limit=[-0.95, 0], p=0.95),
A.RandomShadow(shadow_roi=(0.25, 0.25, 0.75, 0.75)),
A.PadIfNeeded(min_width=resize_width,
min_height=resize_height,
border_mode=cv2.BORDER_CONSTANT)
])
class ICDARSegmentation(Dataset):
"""
icdar_challenge4 dataset
"""
NUM_CLASSES = 2
def __init__(
self,
args,
def train_process(data_path, config):
def _worker_init_fn_():
import random
import numpy as np
import torch
random_seed = config.random_seed
torch.manual_seed(random_seed)
np.random.seed(random_seed)
random.seed(random_seed)
if torch.cuda.is_available():
torch.cuda.manual_seed(random_seed)
input_size = (config.img_height, config.img_width)
PAD_VALUE = (0, 0, 0)
IGNORE_INDEX = 255
transforms = [
abm.RandomResizedCrop(
scale=(0.7, 1),
ratio=(1.5, 2),
height=config.img_height,
width=config.img_width,
interpolation=cv2.INTER_NEAREST,
always_apply=True,
),
abm.OneOf([abm.IAAAdditiveGaussianNoise(),
abm.GaussNoise()], p=0.5),
abm.OneOf(
[
abm.MedianBlur(blur_limit=3),
abm.GaussianBlur(blur_limit=3),
abm.MotionBlur(blur_limit=3),
],
p=0.5,
),
abm.OneOf([
abm.ShiftScaleRotate(
rotate_limit=7,
interpolation=cv2.INTER_NEAREST,
border_mode=cv2.BORDER_CONSTANT,
value=PAD_VALUE,
mask_value=IGNORE_INDEX,
p=1.0,
),
abm.ElasticTransform(
interpolation=cv2.INTER_NEAREST,
border_mode=cv2.BORDER_CONSTANT,
alpha_affine=30,
value=PAD_VALUE,
mask_value=IGNORE_INDEX,
p=1.0,
),
abm.Perspective(
scale=(0.05),
interpolation=cv2.INTER_NEAREST,
pad_mode=cv2.BORDER_CONSTANT,
pad_val=PAD_VALUE,
mask_pad_val=IGNORE_INDEX,
keep_size=True,
fit_output=True,
p=1.0,
),
]),
abm.RandomGamma(gamma_limit=(80, 120), p=0.5),
abm.RandomBrightnessContrast(brightness_limit=(-0.5, 0.5),
contrast_limit=(-0.5, 0.5),
p=0.5),
abm.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
p=0.5),
abm.RandomShadow(p=0.5),
abm.ChannelShuffle(p=0.5),
abm.ChannelDropout(p=0.5),
abm.HorizontalFlip(p=0.5),
abm.ImageCompression(quality_lower=50, p=0.5),
abm.Cutout(num_holes=100, max_w_size=8, max_h_size=8, p=0.5),
]
data_transform = DataTransformBase(transforms=transforms,
input_size=input_size,
normalize=True)
train_dataset = EgoRailDataset(data_path=data_path,
phase="train",
transform=data_transform)
val_dataset = EgoRailDataset(data_path=data_path,
phase="val",
transform=data_transform)
# train_dataset.weighted_class()
weighted_values = [8.90560578, 1.53155476]
train_data_loader = DataLoader(
train_dataset,
batch_size=config.batch_size,
shuffle=True,
num_workers=config.num_workers,
drop_last=True,
worker_init_fn=_worker_init_fn_(),
)
val_data_loader = DataLoader(
val_dataset,
batch_size=config.batch_size,
shuffle=False,
num_workers=config.num_workers,
drop_last=True,
)
data_loaders_dict = {"train": train_data_loader, "val": val_data_loader}
model = BiSeNetV2(n_classes=config.num_classes)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
criterion = OHEMCELoss(thresh=config.ohem_ce_loss_thresh,
weighted_values=weighted_values)
base_lr_rate = config.lr_rate / (config.batch_size *
config.batch_multiplier)
base_weight_decay = config.weight_decay * (config.batch_size *
config.batch_multiplier)
def _lambda_epoch(epoch):
import math
max_epoch = config.num_epochs
return math.pow((1 - epoch * 1.0 / max_epoch), 0.9)
optimizer = torch.optim.SGD(
model.parameters(),
lr=base_lr_rate,
momentum=config.momentum,
weight_decay=base_weight_decay,
)
scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=_lambda_epoch)
trainer = BiSeNetV2Trainer(
model=model,
criterion=criterion,
metric_func=None,
optimizer=optimizer,
data_loaders_dict=data_loaders_dict,
config=config,
scheduler=scheduler,
device=device,
)
if config.snapshot and os.path.isfile(config.snapshot):
trainer.resume_checkpoint(config.snapshot)
with torch.autograd.set_detect_anomaly(True):
trainer.train()
def shadow(img, msk):
aug = A.Compose([A.RandomShadow(always_apply=True)])
data = aug(image=img)
return data['image'], msk
A.ISONoise(p=0.4),
A.JpegCompression(
quality_lower=50, quality_upper=70, always_apply=False, p=0.8),
],
p=0.6),
A.OneOf([
A.MotionBlur(blur_limit=10, p=.8),
A.MedianBlur(blur_limit=3, p=0.75),
A.GaussianBlur(blur_limit=7, p=0.75),
],
p=0.8),
A.OneOf([
A.RandomBrightnessContrast(
brightness_limit=0.3, contrast_limit=0.3, p=0.75),
A.RandomShadow(num_shadows_lower=1,
num_shadows_upper=18,
shadow_dimension=6,
p=0.85),
],
p=0.8),
])
def GenerateTrainingBlocks(data_folder,
gt_folder,
dataset_path='./dataset',
M=256,
N=256):
print(data_folder)
print('Generating training blocks!!!')
train_path = dataset_path + '/' + data_folder + '_Trainblocks'
def get_transform(size, transform_type="weak", min_visibility=0):
"""Creates transformation for COCO dataset
Args:
size (int): image size to return
transform_type (str):
'weak': resizes and normalizes image and bbox
'strong': performs different image effects, resizes and normalizes image and bbox
min_visibility (int): minimum fraction of area for a bounding box
Returns:
albu.core.transforms_interface.BasicTransform: image and bbox transformation
"""
bbox_params = {
'format': 'coco',
'min_visibility': min_visibility,
'label_fields': ['category_id']
}
augs = {
'strong':
albu.Compose(
[
albu.Resize(size, size),
albu.HorizontalFlip(),
# albu.VerticalFlip(p=0.1),
albu.ShiftScaleRotate(shift_limit=0.05,
scale_limit=0.15,
rotate_limit=20,
p=.4,
border_mode=cv2.BORDER_CONSTANT),
albu.OneOf([
albu.Blur(),
albu.MotionBlur(),
albu.MedianBlur(),
albu.GaussianBlur(),
],
p=0.2),
albu.OneOf([
albu.GaussNoise(var_limit=(10, 35)),
albu.IAAAdditiveGaussianNoise(),
albu.JpegCompression(quality_lower=50),
],
p=0.2),
albu.OneOf(
[
albu.RandomRain(),
# albu.RandomSunFlare(),
albu.RandomShadow()
],
p=0.15),
albu.OneOf([
albu.CLAHE(clip_limit=2),
albu.IAASharpen(alpha=(0.1, 0.3)),
albu.IAAEmboss(alpha=(0.1, 0.4)),
albu.RandomGamma(),
albu.RandomBrightnessContrast(),
],
p=0.2),
# albu.HueSaturationValue(p=0.25),
],
bbox_params=bbox_params),
'weak':
albu.Compose(
[
albu.Resize(size, size),
# albu.HorizontalFlip(),
],
bbox_params=bbox_params),
}
aug_fn = augs[transform_type]
normalize = albu.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
pipeline = albu.Compose([
aug_fn,
# ])
normalize
])
return pipeline
