def get_augments(image_height, image_width):
train_transform = A.Compose([
A.PadIfNeeded(min_height=image_height,
min_width=image_width,
always_apply=True,
border_mode=0),
A.CropNonEmptyMaskIfExists(
image_height,
image_width,
always_apply=True,
),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
ToTensorV2(transpose_mask=True)
])
val_transform = A.Compose([
A.PadIfNeeded(min_height=image_height,
min_width=image_width,
always_apply=True,
border_mode=0),
A.CropNonEmptyMaskIfExists(image_height, image_width),
ToTensorV2(transpose_mask=True)
])
test_transform = A.Compose([ToTensorV2(transpose_mask=True)])
return (train_transform, val_transform, test_transform)
def __init__(self, path, _, autoaugment):
self.imgs_pre, self.lbls_pre = load_data(path, "pre")
self.imgs_post, self.lbls_post = load_data(path, "post")
assert len(self.imgs_pre) == len(self.imgs_post)
assert len(self.imgs_post) == len(self.lbls_post)
data_frame = pd.read_csv("/workspace/xview2/utils/index.csv")
self.idx = []
self.idx.extend(
data_frame[data_frame["1"] == 1]["idx"].values.tolist())
self.idx.extend(
data_frame[data_frame["2"] == 1]["idx"].values.tolist())
self.idx.extend(
data_frame[data_frame["3"] == 1]["idx"].values.tolist())
self.idx.extend(
data_frame[data_frame["4"] == 1]["idx"].values.tolist())
self.idx = sorted(list(set(self.idx)))
self.crop = A.CropNonEmptyMaskIfExists(p=1, width=512, height=512)
self.zoom = A.RandomScale(p=0.2,
scale_limit=(0, 0.3),
interpolation=cv2.INTER_CUBIC)
self.hflip = A.HorizontalFlip(p=0.33)
self.vflip = A.VerticalFlip(p=0.33)
self.noise = A.GaussNoise(p=0.1)
self.brctr = A.RandomBrightnessContrast(p=0.2)
self.normalize = A.Normalize()
self.use_autoaugment = autoaugment
if self.use_autoaugment:
self.autoaugment = ImageNetPolicy()
def get_transform(mode='train', H=384, W=576):
if mode == 'train':
transform = A.Compose([
A.Flip(p=.5),
A.OneOf([
A.CLAHE(clip_limit=2, p=.5),
A.IAASharpen(p=.25),
],
p=.35),
A.OneOf(
[A.RandomBrightness(),
A.RandomContrast(),
A.RandomGamma()],
p=.3),
A.OneOf([
A.ElasticTransform(
alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03),
A.GridDistortion(),
A.OpticalDistortion(distort_limit=2, shift_limit=0.5),
],
p=.3),
A.ShiftScaleRotate(scale_limit=0.2,
rotate_limit=0,
shift_limit=0,
border_mode=0,
p=.5),
A.CropNonEmptyMaskIfExists(height=int(1400 * .9),
width=int(2100 * .9),
p=.5),
A.Resize(H, W),
ToTensor()
])
else:
transform = A.Compose([A.Resize(352, 544), ToTensor()])
return transform
def __build_augmentator(self):
return albu.Compose([
albu.CropNonEmptyMaskIfExists(height=self.height, width=self.width, p=1.0),
albu.OneOf([
albu.VerticalFlip(p=0.5),
albu.HorizontalFlip(p=0.5),
], p=0.5),
], p=self.p)
def data_mask_crop1():
return A.Compose([
A.HorizontalFlip(p=0.5),
A.RandomBrightnessContrast(brightness_limit=0.15, contrast_limit=0.2, p=0.5),
A.CropNonEmptyMaskIfExists(height=200, width=200),
A.Resize(256, 256),
ToTensorV2()
])
def crop_transform(image_size: Tuple[int, int], min_scale=0.75, max_scale=1.25, input_size=5000):
return A.OneOrOther(
A.RandomSizedCrop(
(int(image_size[0] * min_scale), int(min(input_size, image_size[0] * max_scale))),
image_size[0],
image_size[1],
),
A.CropNonEmptyMaskIfExists(image_size[0], image_size[1]),
)
def data_mask_crop3():
return A.Compose([
A.HorizontalFlip(p=0.5),
A.ShiftScaleRotate(),
A.RandomBrightnessContrast(brightness_limit=0.15, contrast_limit=0.2, p=0.5),
A.CropNonEmptyMaskIfExists(height=256, width=256),
A.Resize(512, 512),
A.VerticalFlip(p=0.5),
ToTensorV2()
])
def crop_transform_xview2(image_size: Tuple[int, int], min_scale=0.4, max_scale=0.75, input_size=1024):
return A.OneOrOther(
A.RandomSizedCrop(
(int(image_size[0] * min_scale), int(min(input_size, image_size[0] * max_scale))),
image_size[0],
image_size[1],
),
A.Compose(
[A.Resize(input_size * 2, input_size * 2), A.CropNonEmptyMaskIfExists(image_size[0], image_size[1])]
),
)
def __build_augmentator(self):
return albu.Compose([
albu.CropNonEmptyMaskIfExists(height=self.height, width=self.width, p=1.0),
albu.ShiftScaleRotate(shift_limit=0.15, scale_limit=0.15, p=0.6),
albu.PadIfNeeded(256, 256),
albu.OneOf([
albu.VerticalFlip(p=0.5),
albu.HorizontalFlip(p=0.5),
], p=0.5),
albu.RandomBrightnessContrast(0.1, 0.1),
# albu.RandomGamma()
], p=self.p)
def get_cc_training_augmentation():
train_transform = [
A.CropNonEmptyMaskIfExists(height=640, width=640, always_apply=True),
A.Resize(height=256, width=256),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.PadIfNeeded(min_height=256,
min_width=256,
always_apply=True,
border_mode=0),
]
return A.Compose(train_transform)
def data_mask_crop4():
return A.Compose([
A.HorizontalFlip(p=0.5),
A.ShiftScaleRotate(),
A.RandomBrightnessContrast(brightness_limit=0.15, contrast_limit=0.2, p=0.5),
A.OneOf([
A.RandomResizedCrop(512,512,scale = (0.5,0.8),p=0.8),
A.CropNonEmptyMaskIfExists(height=300, width=300, p=0.2),
], p=0.5),
A.Resize(512, 512),
A.VerticalFlip(p=0.5),
ToTensorV2()
])
def data_clahe():
return A.Compose([
A.CLAHE(),
A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
A.HorizontalFlip(p=0.5),
A.ShiftScaleRotate(),
A.RandomBrightnessContrast(brightness_limit=0.15, contrast_limit=0.2, p=0.5),
A.OneOf([
A.RandomResizedCrop(512,512,scale = (0.5,0.8),p=0.8),
A.CropNonEmptyMaskIfExists(height=300, width=300, p=0.2),
], p=0.5),
A.Resize(512, 512),
A.VerticalFlip(p=0.5),
ToTensorV2()
])
def val():
transform = A.Compose([
A.SmallestMaxSize(520),
A.CropNonEmptyMaskIfExists(
360,
360,
ignore_values=[
0,
],
),
A.HorizontalFlip(),
ToTensorV2(),
])
return ADE20K("val", transform=transform)
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 test_crop_non_empty_mask():
def _test_crop(mask, crop, aug, n=1):
for _ in range(n):
augmented = aug(image=mask, mask=mask)
np.testing.assert_array_equal(augmented["image"], crop)
np.testing.assert_array_equal(augmented["mask"], crop)
# test general case
mask_1 = np.zeros([10, 10])
mask_1[0, 0] = 1
crop_1 = np.array([[1]])
aug_1 = A.CropNonEmptyMaskIfExists(1, 1)
# test empty mask
mask_2 = np.zeros([10, 10])
crop_2 = np.array([[0]])
aug_2 = A.CropNonEmptyMaskIfExists(1, 1)
# test ignore values
mask_3 = np.ones([2, 2])
mask_3[0, 0] = 2
crop_3 = np.array([[2]])
aug_3 = A.CropNonEmptyMaskIfExists(1, 1, ignore_values=[1])
# test ignore channels
mask_4 = np.zeros([2, 2, 2])
mask_4[0, 0, 0] = 1
mask_4[1, 1, 1] = 2
crop_4 = np.array([[[1, 0]]])
aug_4 = A.CropNonEmptyMaskIfExists(1, 1, ignore_channels=[1])
# test full size crop
mask_5 = np.random.random([10, 10, 3])
crop_5 = mask_5
aug_5 = A.CropNonEmptyMaskIfExists(10, 10)
mask_6 = np.zeros([10, 10, 3])
mask_6[0, 0, 0] = 0
crop_6 = mask_6
aug_6 = A.CropNonEmptyMaskIfExists(10, 10, ignore_values=[1])
_test_crop(mask_1, crop_1, aug_1, n=1)
_test_crop(mask_2, crop_2, aug_2, n=1)
_test_crop(mask_3, crop_3, aug_3, n=5)
_test_crop(mask_4, crop_4, aug_4, n=5)
_test_crop(mask_5, crop_5, aug_5, n=1)
_test_crop(mask_6, crop_6, aug_6, n=10)
def prepare_data(self):
# Read DataFrame
df = pd.read_csv(os.path.join(self.hparams.data_dir, 'train.csv'))
df = df[df['data_provider'] == 'radboud'].reset_index(drop=True)
#Delete rows (mask dont exist)
for idx in range(len(df)):
image_id = df.loc[idx, 'image_id']
if not os.path.exists(
os.path.join(
os.path.join(self.hparams.data_dir,
'train_label_masks/'),
image_id + '_mask.' + self.hparams.image_format)):
df = df.drop(idx, axis=0)
df = df.reset_index(drop=True)
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=2020)
for fold, (train_index, val_index) in enumerate(
skf.split(df.values, df['isup_grade'])):
df.loc[val_index, 'fold'] = int(fold)
df['fold'] = df['fold'].astype(int)
#print(df)
train_df = df[df['fold'] != self.hparams.fold]
val_df = df[df['fold'] == self.hparams.fold]
#train_df, val_df = train_test_split(train_df, stratify=train_df['isup_grade'])
train_transform = A.Compose([
A.PadIfNeeded(min_height=self.hparams.image_size,
min_width=self.hparams.image_size,
border_mode=4,
value=255,
mask_value=0,
always_apply=False,
p=1.0),
A.CropNonEmptyMaskIfExists(height=self.hparams.image_size,
width=self.hparams.image_size,
ignore_values=None,
ignore_channels=None,
always_apply=False,
p=1.0),
A.RandomResizedCrop(height=self.hparams.image_size,
width=self.hparams.image_size,
scale=(0.8, 1.2),
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.PadIfNeeded(min_height=self.hparams.image_size,
min_width=self.hparams.image_size,
border_mode=4,
value=255,
mask_value=0,
always_apply=False,
p=1.0),
A.CropNonEmptyMaskIfExists(height=self.hparams.image_size,
width=self.hparams.image_size,
ignore_values=None,
ignore_channels=None,
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)
])
self.train_dataset = PANDASegDataset(train_df,
self.hparams.data_dir,
self.hparams.image_format,
transform=train_transform)
self.val_dataset = PANDASegDataset(val_df,
self.hparams.data_dir,
self.hparams.image_format,
transform=valid_transform)
def get_augmentation(version):
if version == "v1":
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v2":
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.OneOf([
A.RandomCrop(height=256, width=256, p=1),
A.RandomCrop(height=384, width=384, p=1),
A.RandomCrop(height=512, width=512, p=1),
A.RandomCrop(height=640, width=640, p=1),
],
p=0.5),
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v3":
return {
"train":
A.Compose([
A.RandomCrop(height=1024, width=1024, p=1),
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v4":
# for 3x-scaled dataset | 256x256
return {
"train":
A.Compose([
A.RandomCrop(height=512, width=512, p=1),
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v5":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.RandomCrop(height=512, width=512, p=1),
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v6":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
always_apply=False,
p=0.25),
A.RandomBrightness(limit=0.4, always_apply=False, p=0.25),
A.RandomContrast(limit=0.2, always_apply=False, p=0.25),
A.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=50,
shadow_dimension=5,
always_apply=False,
p=0.25),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v7":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.RandomCrop(height=768, width=768, p=1),
A.Resize(height=256, width=256, p=1.0),
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
always_apply=False,
p=0.25),
A.RandomBrightness(limit=0.4, always_apply=False, p=0.25),
A.RandomContrast(limit=0.2, always_apply=False, p=0.25),
A.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=50,
shadow_dimension=5,
always_apply=False,
p=0.25),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Resize(height=256, width=256, p=1.0),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v8":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.Rotate(p=0.5),
A.RandomCrop(height=512, width=512, p=1),
A.Flip(p=0.5),
# color
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
always_apply=False,
p=0.25),
A.RandomBrightness(limit=0.4, always_apply=False, p=0.25),
A.RandomContrast(limit=0.2, always_apply=False, p=0.25),
A.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=50,
shadow_dimension=5,
always_apply=False,
p=0.25),
# transform
A.ElasticTransform(p=1, alpha=120, sigma=6, alpha_affine=0.25),
A.GridDistortion(p=0.25),
A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=0.25),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v9":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
always_apply=False,
p=0.25),
A.RandomBrightness(limit=0.4, always_apply=False, p=0.25),
A.RandomContrast(limit=0.2, always_apply=False, p=0.25),
A.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=50,
shadow_dimension=5,
always_apply=False,
p=0.25),
# transform
A.OneOf([
A.ElasticTransform(
alpha=120, sigma=6, alpha_affine=0.25, p=0.25),
A.GridDistortion(p=0.25),
A.OpticalDistortion(
distort_limit=2, shift_limit=0.5, p=0.25)
],
p=0.75),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v10":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
# size
A.OneOf([
A.CropNonEmptyMaskIfExists(height=128, width=128, p=1.0),
A.CropNonEmptyMaskIfExists(height=256, width=256, p=1.0),
A.CropNonEmptyMaskIfExists(height=384, width=384, p=1.0)
],
p=0.25),
A.PadIfNeeded(min_height=512,
min_width=512,
border_mode=4,
p=1),
# array shuffle
A.OneOf([A.MaskDropout(p=1),
A.RandomGridShuffle(p=1)], p=0.5),
# quality
A.Downscale(scale_min=0.25,
scale_max=0.75,
interpolation=0,
always_apply=False,
p=0.5),
A.GaussNoise(p=0.5),
A.OneOf([
A.GlassBlur(p=1),
A.GaussianBlur(p=1),
], p=0.5),
# colors
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
always_apply=False,
p=0.5),
A.RandomBrightness(limit=0.4, always_apply=False, p=0.5),
A.RandomContrast(limit=0.2, always_apply=False, p=0.5),
A.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=50,
shadow_dimension=5,
always_apply=False,
p=0.5),
A.CLAHE(p=0.5),
A.Equalize(p=0.5),
A.ChannelShuffle(p=0.5),
# transform
A.OneOf([
A.ElasticTransform(
alpha=120, sigma=6, alpha_affine=0.25, p=1),
A.GridDistortion(p=1),
A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1)
],
p=0.5),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v11":
# custom normalization (see other/img_normalization.py)
return {
"train":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
elif version == "v12":
# for 3x-scaled dataset | 512x512
return {
"train":
A.Compose([
A.Flip(p=0.5),
A.Rotate(p=0.5),
# size / quality
A.OneOf([
A.CropNonEmptyMaskIfExists(height=128, width=128, p=1.0),
A.CropNonEmptyMaskIfExists(height=256, width=256, p=1.0),
A.CropNonEmptyMaskIfExists(height=384, width=384, p=1.0),
A.Downscale(scale_min=0.25,
scale_max=0.75,
interpolation=0,
always_apply=False,
p=1.0),
],
p=0.25),
A.PadIfNeeded(min_height=512,
min_width=512,
border_mode=4,
p=1),
# array shuffle
A.OneOf([A.MaskDropout(p=1),
A.RandomGridShuffle(p=1)], p=0.15),
# noise
A.OneOf([
A.GaussNoise(p=1),
A.GlassBlur(p=1),
A.GaussianBlur(p=1),
],
p=0.15),
# colors
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
always_apply=False,
p=0.15),
A.RandomBrightness(limit=0.4, always_apply=False, p=0.15),
A.RandomContrast(limit=0.2, always_apply=False, p=0.15),
A.RandomShadow(shadow_roi=(0, 0, 1, 1),
num_shadows_lower=1,
num_shadows_upper=50,
shadow_dimension=5,
always_apply=False,
p=0.15),
A.OneOf([
A.CLAHE(p=1),
A.Equalize(p=1),
A.ChannelShuffle(p=1),
],
p=0.15),
# transform
A.OneOf([
A.ElasticTransform(
alpha=120, sigma=6, alpha_affine=0.25, p=1),
A.GridDistortion(p=1),
A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1)
],
p=0.15),
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
"valid":
A.Compose([
A.Normalize(mean=(0.623, 0.520, 0.650),
std=(0.278, 0.305, 0.274),
max_pixel_value=255.0,
p=1.0)
]),
}
else:
raise Exception(f"Augmentation version '{version}' is UNKNOWN!")
A.RandomBrightness(),
],
p=0.3),
# A.OneOf([
# A.ElasticTransform(alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03),
# A.GridDistortion(),
# A.OpticalDistortion(distort_limit=2, shift_limit=0.5),
# ], p=0.3),
A.ToFloat(max_value=1)
],
p=1)
AUGMENTATIONS_TRAIN_CROP = A.Compose(
[
A.OneOf([
A.CropNonEmptyMaskIfExists(256, 416, ignore_channels=[4], p=0.7),
A.RandomCrop(256, 416, p=0.3),
],
p=1.0),
A.HorizontalFlip(p=0.5),
# A.VerticalFlip(p=0.5),
# A.OneOf([
# A.RandomContrast(),
# A.RandomGamma(),
# A.RandomBrightness(),
# ], p=0.3),
A.ToFloat(max_value=1),
],
p=1)
AUGMENTATIONS_TEST = A.Compose([A.ToFloat(max_value=1)], p=1)
def get_loaders(preprocessing_fn, batch_size=12, num_workers=4):
preprocessing = get_preprocessing(preprocessing_fn)
SDD_train_PATH = r'Z:\test tasks\Sber_robo\SDD_images\imgs\train'
SDD_val_PATH = r'Z:\test tasks\Sber_robo\SDD_images\imgs\test'
train_transforms = albu.Compose(
[pre_transforms(image_size=512),
hard_transforms(crop_size=512)])
valid_transforms = pre_transforms(image_size=512)
SDD_train = SDD_dataset(SDD_train_PATH,
augmentations=train_transforms,
preprocessing=preprocessing)
SDD_val = SDD_dataset(SDD_val_PATH,
augmentations=valid_transforms,
preprocessing=preprocessing)
#############
UAVid_train_PATH = r'Z:\test tasks\Sber_robo\uavid_v1.5_official_release_image\uavid_train'
UAVid_val_PATH = r'Z:\test tasks\Sber_robo\uavid_v1.5_official_release_image\uavid_val'
train_transforms = albu.Compose(
[pre_transforms(image_size=1024),
hard_transforms(crop_size=512)])
valid_transforms = albu.Compose([
pre_transforms(image_size=1024),
albu.CropNonEmptyMaskIfExists(512, 512, p=1)
])
UAVid_train = UAVid_dataset(UAVid_train_PATH,
augmentations=train_transforms,
preprocessing=preprocessing)
UAVid_val = UAVid_dataset(UAVid_val_PATH,
augmentations=valid_transforms,
preprocessing=preprocessing)
train_dataset = SDD_train + UAVid_train
val_dataset = SDD_val + UAVid_val
print(f"found {len(SDD_train)} images for SDD")
print(f"found {len(UAVid_train)} images for UAVid")
SDD_weight = 1 / len(SDD_train)
UAVid_weight = 1 / len(UAVid_train)
samples_weight = np.array([SDD_weight] * len(SDD_train) +
[UAVid_weight] * len(UAVid_train))
sampler = WeightedRandomSampler(torch.from_numpy(samples_weight),
len(samples_weight))
train_loader = DataLoader(train_dataset,
batch_size=batch_size,
sampler=sampler,
num_workers=num_workers,
pin_memory=True,
drop_last=True)
valid_loader = DataLoader(val_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=num_workers,
pin_memory=True,
drop_last=False)
loaders = {"train": train_loader, "valid": valid_loader}
return loaders
import albumentations as A
import torch
import numpy as np
from utils import read_img_ski
p = 0.5
albu_train = A.Compose([
A.CropNonEmptyMaskIfExists(512, 512),
A.HorizontalFlip(p=p),
A.VerticalFlip(p=p),
A.RandomRotate90(p=p),
A.OneOf([
A.RandomBrightnessContrast(p=1),
A.RandomGamma(p=1),
], p=p),
A.OneOf([
A.GaussianBlur(p=1),
A.GaussNoise(p=1),
A.IAAAdditiveGaussianNoise(p=1),
A.Blur(p=1),
],
p=p),
])
albu_dev = A.Compose([
A.PadIfNeeded(1024, 1024, border_mode=0),
])
def train_transform(img, mask):
def set_transforms(self) -> dict:
d4_tansforms = [
A.SmallestMaxSize(self.img_size[0], interpolation=0, p=1.),
# D4 Group augmentations
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.RandomRotate90(p=0.5),
A.Transpose(p=0.5),
]
tensor_norm = [
ToTensor(),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
]
geometric = [
A.SmallestMaxSize(self.img_size[0], interpolation=0, p=1.),
A.ShiftScaleRotate(shift_limit=self.shift_limit,
self.scale_limit,
rotate_limit=self.rotate_limit,
interpolation=cv2.INTER_LINEAR,
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
p=0.5),
# crop and resize
A.RandomSizedCrop(
(self.crop_size[0],
min(self.crop_size[1], self.img_size[0], self.img_size[1])),
self.img_size[0],
self.img_size[1],
w2h_ratio=1.0,
interpolation=cv2.INTER_LINEAR,
always_apply=False,
p=0.2),
]
resize_crop = [
A.SmallestMaxSize(max(self.img_size[0], self.img_size[1]),
interpolation=0,
p=1.),
A.RandomCrop(self.img_size[0], self.img_size[1], p=1.),
]
train_light = [
A.SmallestMaxSize(self.img_size[0], interpolation=0, p=1.),
A.RandomCrop(self.img_size[0], self.img_size[1], p=1.),
A.HorizontalFlip(p=0.5),
A.RandomBrightnessContrast(p=0.5),
]
train_medium = train_light.append([
A.ShiftScaleRotate(shift_limit=self.shift_limit,
self.scale_limit,
rotate_limit=self.rotate_limit,
p=0.5),
A.OneOf([
A.RandomBrightnessContrast(p=0.7),
A.Equalize(p=0.3),
A.HueSaturationValue(p=0.5),
A.RGBShift(p=0.5),
A.RandomGamma(p=0.4),
A.ChannelShuffle(p=0.05),
],
p=0.9),
A.OneOf([
A.GaussNoise(p=0.5),
A.ISONoise(p=0.5),
A.MultiplicativeNoise(0.5),
],
p=0.2),
])
valid_ade = [
A.SmallestMaxSize(self.img_size, p=1.),
A.Lambda(name="Pad32", image=pad_x32, mask=pad_x32),
]
# from bloodaxe
# https://github.com/BloodAxe/Catalyst-Inria-Segmentation-Example/blob/master/inria/augmentations.py
crop = [ #(image_size: Tuple[int, int], min_scale=0.75, max_scale=1.25, input_size=5000):
A.OneOrOther(
A.RandomSizedCrop((self.crop_size[0],
min(self.crop_size[1], self.img_size[0],
self.img_size[1])), self.img_size[0],
self.img_size[1]),
A.CropNonEmptyMaskIfExists(self.img_size[0], self.img_size[1]),
)
]
safe_augmentations = [A.HorizontalFlip(), A.RandomBrightnessContrast()]
light_augmentations = [
A.HorizontalFlip(),
A.RandomBrightnessContrast(),
A.OneOf([
A.ShiftScaleRotate(scale_limit=self.scale_limit,
rotate_limit=self.rotate_limit,
border_mode=cv2.BORDER_CONSTANT),
A.IAAAffine(),
A.IAAPerspective(),
A.NoOp()
]),
A.HueSaturationValue(),
]
medium_augmentations = [
A.HorizontalFlip(),
A.ShiftScaleRotate(scale_limit=self.scale_limit,
rotate_limit=self.rotate_limit,
border_mode=cv2.BORDER_CONSTANT),
# Add occasion blur/sharpening
A.OneOf([A.GaussianBlur(),
A.IAASharpen(),
A.NoOp()]),
# Spatial-preserving augmentations:
A.OneOf(
[A.CoarseDropout(),
A.MaskDropout(max_objects=5),
A.NoOp()]),
A.GaussNoise(),
A.OneOf([
A.RandomBrightnessContrast(),
A.CLAHE(),
A.HueSaturationValue(),
A.RGBShift(),
A.RandomGamma()
]),
# Weather effects
A.RandomFog(fog_coef_lower=0.01, fog_coef_upper=0.3, p=0.1),
]
hard_augmentations = [
A.RandomRotate90(),
A.Transpose(),
A.RandomGridShuffle(),
A.ShiftScaleRotate(scale_limit=self.scale_limit,
rotate_limit=self.rotate_limit,
border_mode=cv2.BORDER_CONSTANT,
mask_value=0,
value=0),
A.ElasticTransform(border_mode=cv2.BORDER_CONSTANT,
alpha_affine=5,
mask_value=0,
value=0),
# Add occasion blur
A.OneOf([
A.GaussianBlur(),
A.GaussNoise(),
A.IAAAdditiveGaussianNoise(),
A.NoOp()
]),
# D4 Augmentations
A.OneOf(
[A.CoarseDropout(),
A.MaskDropout(max_objects=10),
A.NoOp()]),
# Spatial-preserving augmentations:
A.OneOf([
A.RandomBrightnessContrast(brightness_by_max=True),
A.HueSaturationValue(),
A.RGBShift(),
A.RandomGamma(),
A.NoOp(),
]),
# Weather effects
A.OneOf([
A.RandomFog(fog_coef_lower=0.01, fog_coef_upper=0.3, p=0.1),
A.NoOp()
]),
]
TRANSFORMS = {
"d4": d4_tansforms,
"resize_crop": resize_crop,
"geometric": geometric,
"light": train_light,
"medium": train_medium,
"ade_valid": valid_ade,
"flip_bright": safe_augmentations,
"crop": crop,
"inria_light": light_augmentations,
"inria_medium": medium_augmentations,
"inria_hard": hard_augmentations,
"inria_valid": safe_augmentations,
}
return TRANSFORMS
def get_transforms(self):
augs = []
if self.augs_name:
augs = self.set_transforms[self.augs_name]
augs.append(
A.Resize(height=self.img_size[0],
width=self.img_size[1],
p=1.0))
if self.use_d4:
augs.append(self.set_transforms["d4"])
if self.vflip:
augs.append(A.VerticalFlip(p=0.5))
if self.hflip:
augs.append(A.HorizontalFlip(p=0.5))
if self.normalise:
augs.append(A.Normalize())
return A.Compose(augs)
