def __init__(self, root_dir, partition, augment):
self.root_dir = root_dir
self.list_IDs = os.listdir(os.path.join(self.root_dir, 'y_{}'.format(partition)))
self.partition = partition
self.augment = augment
self.to_tensor = transforms.ToTensor()
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),
RGBShift(p=0.3),
RandomGamma(p=0.5),
CLAHE(p=0.5)
]
)
def aug_image(image):
from albumentations import (
HorizontalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90, RandomGamma, VerticalFlip,
Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, RandomBrightnessContrast, IAAPiecewiseAffine,
IAASharpen, IAAEmboss, Flip, OneOf, Compose, Rotate, RandomContrast, RandomBrightness, RandomCrop, Resize, OpticalDistortion
)
transforms = Compose([
#Rotate(limit=30, p=0.5),
#Rotate(limit=180, p=0.5),
#RandomRotate90(p=1.0)
#Transpose(p=1.0)
# Resize(248,248, p=1), # resize 후 크롭
# RandomCrop(224,224, p=1), # 위에꺼랑 세트
OneOf([
RandomContrast(p=1, limit=(-0.5,2)), # -0.5 ~ 2 까지가 현장과 가장 비슷함 -- RandomBrightnessContrast
RandomBrightness(p=1, limit=(-0.2,0.4)),
RandomGamma(p=1, gamma_limit=(80,200)),
], p=1),
# OneOf([
# Rotate(limit=30, p=0.3),
# RandomRotate90(p=0.3),
# VerticalFlip(p=0.3)
# ], p=0.3),
MotionBlur(p=0.2), # 움직일때 흔들리는 것 같은 이미지
#ShiftScaleRotate(shift_limit=0.001, scale_limit=0.1, rotate_limit=30, p=0.3, border_mode=1),
#Resize(224,224, p=1),
],
p=1)
return transforms(image=image)['image']
def augmentation(image,
mask,
noise=False,
transform=False,
clahe=True,
r_bright=True,
r_gamma=True):
aug_list = [
VerticalFlip(p=0.5),
HorizontalFlip(p=0.5),
RandomRotate90(p=0.5),
]
if r_bright:
aug_list += [RandomBrightnessContrast(p=.5)]
if r_gamma:
aug_list += [RandomGamma(p=.5)]
if clahe:
aug_list += [CLAHE(p=1., always_apply=True)]
if noise:
aug_list += [GaussNoise(p=.5, var_limit=1.)]
if transform:
aug_list += [
ElasticTransform(p=.5,
sigma=1.,
alpha_affine=20,
border_mode=0)
]
aug = Compose(aug_list)
augmented = aug(image=image, mask=mask)
image_heavy = augmented['image']
mask_heavy = augmented['mask']
return image_heavy, mask_heavy
def create_generator(
mode="train",
augmenter=True,
batch_size=32,
labels_encoding_mode="smooth",
smooth_factor=0.1,
h=227,
w=227,
):
my_augmenter = (
Compose([
HorizontalFlip(p=0.5),
RandomGamma(gamma_limit=(80, 120), p=0.5),
Resize(h, w, cv2.INTER_AREA),
# ToFloat(max_value=255)
]) if augmenter else False)
gen = HDF5ImageGenerator(
src="/storage/datasets/mnist_test.h5",
scaler=True,
labels_encoding=labels_encoding_mode,
smooth_factor=smooth_factor,
batch_size=batch_size,
augmenter=my_augmenter,
mode=mode,
)
return gen
def __init__(self, is_train: bool, to_pytorch: bool):
if is_train:
self._aug = Compose([
OneOf([
Compose([
SmallestMaxSize(
max_size=min(data_height, data_width) * 1.1, p=1),
RandomCrop(height=data_height, width=data_width, p=1)
],
p=1),
Resize(height=data_height, width=data_width, p=1)
],
p=1),
GaussNoise(p=0.5),
RandomGamma(p=0.5),
RandomBrightnessContrast(p=0.5),
HorizontalFlip(p=0.5)
],
p=1)
else:
self._aug = Compose([
SmallestMaxSize(max_size=min(data_height, data_width), p=1),
CenterCrop(height=data_height, width=data_width, p=1)
],
p=1)
self._need_to_pytorch = to_pytorch
def box_segmentation_aug():
return Compose([
OneOf([
RandomBrightnessContrast(brightness_limit=0.2, p=0.5),
RandomGamma(gamma_limit=50, p=0.5),
ChannelShuffle(p=0.5)
]),
OneOf([
ImageCompression(quality_lower=0, quality_upper=20, p=0.5),
MultiplicativeNoise(multiplier=(0.3, 0.8),
elementwise=True,
per_channel=True,
p=0.5),
Blur(blur_limit=(15, 15), p=0.5)
]),
OneOf([
CenterCrop(height=1000, width=1000, p=0.1),
RandomGridShuffle(grid=(3, 3), p=0.2),
CoarseDropout(max_holes=20,
max_height=100,
max_width=100,
fill_value=53,
p=0.2)
]),
OneOf([
GridDistortion(p=0.5, num_steps=2, distort_limit=0.2),
ElasticTransform(alpha=157, sigma=80, alpha_affine=196, p=0.5),
OpticalDistortion(distort_limit=0.5, shift_limit=0.5, p=0.5)
]),
OneOf([
VerticalFlip(p=0.5),
HorizontalFlip(p=0.5),
Rotate(limit=44, p=0.5)
])
])
def aug_with_crop(width=640, height=480, crop_prob=1):
return Compose(
[
# RandomCrop(width=480, height=640, p=crop_prob),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
RandomRotate90(p=0.5),
Transpose(p=0.5),
ShiftScaleRotate(
shift_limit=0.01, scale_limit=0.04, rotate_limit=0, p=0.25),
RandomBrightnessContrast(p=0.5),
RandomGamma(p=0.25),
IAAEmboss(p=0.25),
Blur(p=0.01, blur_limit=3),
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)
],
p=1)
def get_augmenter(p=1.0):
return Compose([
ElasticTransform(
p=0.8, alpha_affine=10, border_mode=cv2.BORDER_REPLICATE),
RandomGamma(p=0.8, gamma_limit=(50, 150)),
],
p=p)
def hard_transform(image_size=224, p=0.5):
transforms = [
Cutout(
num_holes=4,
max_w_size=image_size // 4,
max_h_size=image_size // 4,
p=p
),
ShiftScaleRotate(
shift_limit=0.1,
scale_limit=0.1,
rotate_limit=15,
border_mode=cv2.BORDER_REFLECT,
p=p
),
IAAPerspective(scale=(0.02, 0.05), p=p),
OneOf(
[
HueSaturationValue(p=p),
ToGray(p=p),
RGBShift(p=p),
ChannelShuffle(p=p),
]
),
RandomBrightnessContrast(
brightness_limit=0.5, contrast_limit=0.5, p=p
),
RandomGamma(p=p),
CLAHE(p=p),
JpegCompression(quality_lower=50, p=p),
]
transforms = Compose(transforms)
return transforms
def __init__(
self,
image_ids,
transform=True,
preprocessing_fn=None
):
"""
Dataset class for segmentation problem
:param image_ids: ids of the images, list
:param transform: True/False, no transform in validation :param preprocessing_fn: a function for preprocessing image
"""
# we create a empty dictionary to store iamge # and mask paths
self.data = defaultdict(dict)
# for augmentations
self.transform = transform
# preprocessing function to normalize
# images
self.preprocessing_fn = preprocessing_fn
# albumentation augmentations
# we have shift, scale & rotate
# applied with 80% probability
# and then one of gamma and brightness/contrast # is applied to the image
# albumentation takes care of which augmentation # is applied to image and mask
self.aug = Compose(
[
ShiftScaleRotate(
shift_limit=0.0625,
scale_limit=0.1,
rotate_limit=10,
p=0.8
),
OneOf(
[
RandomGamma(
gamma_limit=(90, 110)
),
RandomBrightnessContrast(
brightness_limit=0.1,
contrast_limit=0.1
),
],
p=0.5,
),
]
)
# going over all image_ids to store # image and mask paths
for imgid in image_ids:
TRAIN_PATH="/content/drive/MyDrive/Colab_Notebooks/AAMPL/image_classification/Classification/input/train_png"
# files = glob.glob(os.path.join(TRAIN_PATH, imgid, "*.png"))
files = glob.glob("/content/drive/MyDrive/Colab_Notebooks/AAMPL/image_classification/Classification/input/train_png/" + imgid + "*.png")
self.data[counter] = {
"img_path": os.path.join(
TRAIN_PATH, imgid + ".png"
),
"mask_path": os.path.join(
TRAIN_PATH, imgid + "_mask.png"
),
}
def flow(data_dir, Timage, Tmask, batch, size1, size2, augument=False):
images_ = os.listdir(data_dir + Timage)
shuffle(images_)
ids_int = list(range(len(images_)))
NORMALIZE = 127.5
while True:
try:
for start in range(0, len(ids_int), batch):
x_batch = []
y_batch = []
end = min(start + batch, len(images_))
batch_create = ids_int[start:end]
jbs = dict()
for loads in batch_create:
try:
img = cv2.imread(
os.path.join(data_dir, Timage, images_[loads]))
height_o_image, width_o_image = img.shape[
0], img.shape[1]
if height_o_image % 2 != 0:
height_o_image = height_o_image - 1
if width_o_image % 2 != 0:
width_o_image = width_o_image - 1
jbs["width"] = width_o_image * 2
jbs["height"] = height_o_image * 2
img = cv2.resize(img, (width_o_image, height_o_image))
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
masks = cv2.imread(
os.path.join(data_dir, Tmask, images_[loads]))
masks = cv2.resize(masks,
(jbs["width"], jbs["height"]))
except:
continue
if augument:
aug = Compose([
VerticalFlip(p=0.1),
Transpose(p=0.01),
RandomGamma(p=0.06),
OpticalDistortion(p=0.00,
distort_limit=0.7,
shift_limit=0.3)
])
augmented = aug(image=img, mask=masks)
img = augmented['image']
masks = augmented['mask']
x_batch.append(img)
y_batch.append(masks)
else:
x_batch.append(img)
y_batch.append(masks)
x_batch = np.array(x_batch) / NORMALIZE
x_batch = x_batch - 1
y_batch = np.array(y_batch) / NORMALIZE
y_batch = y_batch - 1
yield x_batch, y_batch
except:
continue
def color_aug(p=0.5):
return Compose(
[
RandomBrightness(p=0.5),
RandomGamma(p=0.5),
RGBShift(p=0.5),
],
p=p)
def __init__(self):
self.aug = Compose([
ShiftScaleRotate(p=1,
shift_limit=0.05,
scale_limit=0.05,
rotate_limit=5,
border_mode=cv2.BORDER_CONSTANT),
RandomGamma(p=1, gamma_limit=(80, 120)),
# RandomBrightnessContrast(p=1, brightness_limit=0.3, contrast_limit=0.3),
])
def __init__(self, p=0.5):
self.aug = Compose([
RandomBrightnessContrast(),
RandomGamma(),
CLAHE(),
OneOf([
GaussNoise(),
Cutout(num_holes=10, max_h_size=5, max_w_size=5)
])
])
def strong_tta(p=0.9):
return Compose(
[
Blur(blur_limit=3),
OneOf([RandomContrast(p=.5),
RandomBrightness(p=.5)]),
RandomGamma(),
#RandomSizedCrop(p=0.9, min_max_height=(65, 101), height=101, width=101),
],
p=p)
def _transform_generic_np(self, npimages, prob):
"""So, we assume these images are batched numpy values, scaled from 0..255"""
batchsz, height, width, channels = npimages.shape
assert height == width, "We assume squares as inputs."
assert channels == 3, "We assume RGB images."
assert npimages.dtype == np.uint8
assert 0 <= npimages.min() and npimages.max() <= 255
# make these the images that albumentation requires.
outputs = np.zeros((batchsz, self.outsz, self.outsz, channels),
dtype=np.uint8)
ops = Compose( \
[ \
Compose( \
[ \
OneOf([ \
IAAAdditiveGaussianNoise(p=1.0), \
GaussNoise(p=1.0), \
], p=0.5), \
OneOf([ \
MotionBlur(p=1.0), \
MedianBlur(blur_limit=3, p=1.0), \
Blur(blur_limit=3, p=1.0), \
], p=0.5), \
RandomGamma(p=0.5), \
Rotate(limit=45, interpolation=cv2.INTER_CUBIC, p=0.5), \
ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, interpolation=cv2.INTER_CUBIC, p=0.5), \
OneOf([ \
OpticalDistortion(interpolation=cv2.INTER_CUBIC, p=1.0), \
GridDistortion(interpolation=cv2.INTER_CUBIC, p=1.0), \
IAAPiecewiseAffine(p=1.0), \
], p=0.5), \
OneOf([ \
CLAHE(clip_limit=2, p=1.0), \
IAASharpen(p=1.0), \
IAAEmboss(p=1.0), \
RandomContrast(p=1.0), \
RandomBrightness(p=1.0), \
], p=0.5), \
HueSaturationValue(p=0.5), \
], \
p=prob \
), \
Resize(self.outsz, self.outsz, interpolation=cv2.INTER_CUBIC), \
], \
p=1.0 \
)
# So, the output of ops, should be a dictionary containing an image
for idx in range(0, batchsz):
vvv = ops(image=npimages[idx])["image"]
outputs[idx] = vvv
return outputs
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 __getitem__(self, index):
'''
The method to get one data from dataset.
index: int, the index of the sample in dataset.
'''
#get data from dataset
img_path = self.img_paths[index]
mask_path = self.mask_paths[index]
img = cv2.imread(img_path)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
#modify the mask to satisfied our requirments for the mask
if not os.path.exists(mask_path):
mask = np.zeros((img.shape[0], img.shape[1]), dtype=np.float32)
else:
mask = cv2.imread(mask_path, 0)
mask[mask > 1] = 2
mask[mask < 1] = 1
mask[mask > 1] = 0
if isinstance(self.img_size, tuple):
height = self.img_size[1]
width = self.img_size[0]
elif isinstance(self.img_size, int):
width = height = self.img_size
if self.augumentation:
#augmentation methods
task = Compose([
RandomBrightnessContrast(),
RandomGamma(),
HorizontalFlip(),
VerticalFlip(),
ChannelShuffle(),
PadIfNeeded(height, width),
])
#augmentation
augument_data = task(image=img, mask=mask)
img = augument_data["image"]
mask = augument_data["mask"]
resize = Compose([
Resize(height=height, width=width, always_apply=True),
Normalize(mean=(0.5, 0.5, 0.5),
std=(0.5, 0.5, 0.5),
always_apply=True)
])
#resize data
resize_data = resize(image=img, mask=mask)
img, mask = resize_data["image"], resize_data["mask"]
if img.ndim > 2:
img = np.transpose(img, axes=[2, 0, 1])
elif img.ndim == 2:
img = np.expand_dims(img, axis=0)
return torch.from_numpy(img.astype(np.float32)), torch.from_numpy(
mask.astype(np.float32))
def data_augmentation(original_image, original_mask, mode):
"""进行样本和掩膜的随机增强
Args:
original_image: 原始图片
original_mask: 原始掩膜
Return:
image_aug: 增强后的图片
mask_aug: 增强后的掩膜
"""
original_height, original_width = original_image.shape[:2]
augmentations = Compose([
RandomRotate90(p=0.3),
HorizontalFlip(p=0.3),
Rotate(limit=15, p=0.3),
CLAHE(p=0.3),
HueSaturationValue(20, 5, 5, p=0.7),
# 亮度、对比度
RandomGamma(gamma_limit=(80, 120), p=0.4),
RandomBrightnessContrast(p=0.4),
#
# # 模糊
# OneOf([
# # MotionBlur(p=0.1),
# MedianBlur(blur_limit=3, p=0.1),
# Blur(blur_limit=3, p=0.1),
# ], p=0.3),
#
# OneOf([
# IAAAdditiveGaussianNoise(),
# GaussNoise(),
# ], p=0.2)
])
augmentations2 = Compose([
# HorizontalFlip(p=0.2),
# HueSaturationValue(p=1),
Rotate(limit=15, p=0.2),
# CenterCrop(p=0.3, height=original_height, width=original_width),
# 直方图均衡化
# CLAHE(p=0.4),
])
if mode == 'train':
augmented = augmentations(image=original_image, mask=original_mask)
image_aug = augmented['image']
mask_aug = augmented['mask']
return image_aug, mask_aug
elif mode == 'validation':
augmented = augmentations2(image=original_image, mask=original_mask)
image_aug = augmented['image']
mask_aug = augmented['mask']
return image_aug, mask_aug
def aug():
return Compose_alb([
HorizontalFlip(),
ShiftScaleRotate(rotate_limit=10, border_mode=0),
RandomGamma(),
RandomBrightness(),
RandomContrast(),
ElasticTransform(border_mode=0),
GaussianBlur()
],
p=1)
def get_medium_augmentations(width, height):
return [
HorizontalFlip(p=1),
VerticalFlip(p=1),
RandomSizedCrop((height - 4, height - 2), height, width, p=1),
RandomContrast(p=1),
RandomBrightness(p=1),
RandomGamma(p=1),
ShiftScaleRotate(p=1),
Blur(blur_limit=3, p=1)
]
def soft_aug(p=0.5):
return Compose([
HorizontalFlip(p=0.5),
ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=30, p=0.2),
OneOf([
RandomContrast(),
RandomGamma(),
RandomBrightness()
# RandomBrightnessContrast(),
], p=0.3)
], p=p)
def hard_transforms(image_size):
min_holes, max_holes = 1, 2
size = 30
return [
# Random shifts, stretches and turns with a 50% probability
ShiftScaleRotate(
shift_limit=0.2,
scale_limit=0.2,
rotate_limit=180,
border_mode=BORDER_CONSTANT,
p=0.1
),
IAAPerspective(scale=(0.02, 0.05), p=0.1),
# Random brightness / contrast with a 30% probability
RandomBrightnessContrast(
brightness_limit=0.2, contrast_limit=0.2, p=0.1
),
OneOf([
GaussNoise(var_limit=1.0, p=1.0),
MultiplicativeNoise(multiplier=(0.9, 1), p=1.0)
], p=0.1),
OneOf([
GaussianBlur(blur_limit=3, p=1.0),
Blur(p=1.0),
], p=0.1),
# CoarseDropout(
# min_holes=min_holes,
# max_holes=max_holes,
# # min_height=image_height // 4,
# # max_height=image_height // 4,
# # min_width=image_width // 4,
# # max_width=image_width // 4,
# min_height=size,
# max_height=size,
# min_width=size,
# max_width=size,
# fill_value=0,
# p=1.0
# ),
# Random gamma changes with a 30% probability
RandomGamma(gamma_limit=(85, 115), p=0.1),
ImageCompression(
quality_lower=70,
quality_upper=100,
p=0.1
),
]
def train_val_dataloaders(train_path: str, val_path: str, augment: bool,
batch_size: int):
"""Form the dataloaders for training and validation and store them in the dictionary.
:param train_path: path to images for trainin
:param val_path: path to images for validation
:param batch_size: size of the batch
:return: the dictionary with dataloaders
"""
if augment:
train_transform = Compose([
Blur(p=0.1),
ChannelDropout(p=0.1),
Flip(p=0.5),
GaussNoise((10.0, 30.0), 25.0, p=0.1),
HueSaturationValue(p=0.1),
RandomBrightnessContrast(brightness_limit=(-0.20, 0.50), p=0.1),
RandomGamma(p=0.1),
RandomRotate90(p=0.5),
RGBShift(p=0.1),
Transpose(p=0.25),
Resize(224, 224, p=1.0),
Normalize(),
ToTensorV2(),
])
else:
train_transform = Compose(
[Resize(224, 224), Normalize(),
ToTensorV2()])
val_transforms = Compose([Resize(224, 224), Normalize(), ToTensorV2()])
train_dataset = AlbumentationsImageFolder(train_path, train_transform)
val_dataset = AlbumentationsImageFolder(val_path, val_transforms)
dataloader = dict()
dataloader["train"] = torch.utils.data.DataLoader(
dataset=train_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=4,
drop_last=True,
)
dataloader["val"] = torch.utils.data.DataLoader(
dataset=val_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=4,
drop_last=True,
)
return dataloader
def aug_with_crop(image_size=384, crop_prob=0.5):
return Compose([
RandomCrop(width=image_size, height=image_size, p=crop_prob),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
RandomRotate90(p=0.5),
Transpose(p=0.5),
ShiftScaleRotate(shift_limit=0.1, scale_limit=0.2, rotate_limit=45, p=0.5),
RandomGamma(p=0.25),
Resize(height=image_size, width=image_size)
], p=1)
def train_transform(size=28):
return Compose([
RandomCrop(size, size),
ShiftScaleRotate(shift_limit=0.1,
scale_limit=(0.8, 1.2),
rotate_limit=10,
border_mode=cv2.BORDER_REPLICATE,
p=0.3),
RandomGamma(gamma_limit=(95, 105), p=0.3),
RandomBrightnessContrast(0.1, p=0.3),
post_transform()
])
def __init__(self,
image_ids,
arguments,
transform=True,
preprocessing_fn=None):
"""
Dataset class for segmentation problem
-> image_ids: ids of the image, list
-> transform: True/False, no transform in validation
-> preprocessing_fn: a function for preprocessing image
"""
self.data = defaultdict(dict)
self.counter = 0
# get the arguments
self.args = arguments
# for augmentation
self.transform = transform
# preprocessing function
self.preprocessing_fn = preprocessing_fn
# albumentation augmentation
# have shift, scale & rotate features
# and is applied with 80% probability.
# Gamma controls the and brightness /
# contrast i.e. applied to the image.
# Albumentation takes care of which augmentation
# is applied to image and mask
self.aug = Compose([
ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.1,
rotate_limit=10,
p=0.8),
OneOf(
[
RandomGamma(gamma_limit=(90, 110)),
RandomBrightnessContrast(brightness_limit=0.1,
contrast_limit=0.1),
],
p=0.5,
),
])
# going pver all image_ids to store
# image and mask paths
for imgid in image_ids:
imgid = imgid.split('.')[0]
self.data[self.counter] = {
"img_path": os.path.join(self.args.image_path, imgid + ".png"),
"mask_path": os.path.join(self.args.mask_path, imgid + ".png"),
}
self.counter += 1
def __init__(self,
path,
input_size,
batch_size,
augmentations,
mode='train'):
'''
Initialises the attributes of the class
Args:
path (str): Path to the dataset directory
input_size (int): Height/Width of the input image
batch_size (int): Batch size to be used
augmentations (str): If set to "train", image augmentations are applied
Returns:
None
'''
random.seed(42)
labels = {
name: index
for index in range(1) for name in glob.glob(path + '/*.JPG')
}
l = list(labels.items())
labels = dict(l)
self.path = path
self.names = list(labels.keys())
self.labels = list(labels.values())
self.input_size = input_size
self.batch_size = batch_size
AUGMENTATIONS_TRAIN = Compose([
HorizontalFlip(p=0.5),
RandomContrast(limit=0.2, p=0.5),
RandomGamma(gamma_limit=(80, 120), p=0.5),
RandomBrightness(limit=0.2, p=0.5),
HueSaturationValue(hue_shift_limit=5,
sat_shift_limit=20,
val_shift_limit=10,
p=.9),
RandomRotate90(),
Resize(input_size, input_size),
ToFloat(max_value=255)
])
AUGMENTATIONS_TEST = Compose(
[Resize(input_size, input_size),
ToFloat(max_value=255)])
self.augment = AUGMENTATIONS_TRAIN if augmentations == 'train' else AUGMENTATIONS_TEST
def aug_with_crop(image_size):
return Compose([
RandomCrop(width=image_size, height=image_size, p=1.),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
RandomRotate90(p=0.5),
Transpose(p=0.5),
ShiftScaleRotate(shift_limit=0.01, scale_limit=0.04, rotate_limit=0, p=0.25),
RandomBrightnessContrast(p=0.5),
RandomGamma(p=0.25),
GridDistortion(p=0.5)
], p=1)
def TTA(img, model, model_name, seed=88, niter=4):
input_size = int(model.get_input_at(0).get_shape()[1])
AUGMENTATIONS = Compose([
HorizontalFlip(p=0.25),
RandomSizedCrop(min_max_height=(int(input_size * 0.75), input_size),
height=input_size,
width=input_size,
p=0.5),
OneOf([
ShiftScaleRotate(rotate_limit=25),
ElasticTransform(
alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03),
GridDistortion(),
OpticalDistortion(distort_limit=2, shift_limit=0.5),
],
p=0.5),
OneOf([RandomContrast(),
RandomGamma(),
RandomBrightness()], p=0.5),
OneOf(
[Blur(), MedianBlur(),
GaussNoise(), GaussianBlur()], p=0.5)
],
p=0.5)
np.random.seed(seed)
original_img = img.copy()
inverted_img = np.invert(img.copy())
hflipped_img = np.fliplr(img.copy())
original_img_array = np.empty(
(niter + 1, img.shape[0], img.shape[1], img.shape[2]))
inverted_img_array = original_img_array.copy()
hflipped_img_array = original_img_array.copy()
original_img_array[0] = original_img
inverted_img_array[0] = inverted_img
hflipped_img_array[0] = hflipped_img
for each_iter in range(niter):
original_img_array[each_iter +
1] = AUGMENTATIONS(image=original_img)['image']
inverted_img_array[each_iter +
1] = AUGMENTATIONS(image=inverted_img)['image']
hflipped_img_array[each_iter +
1] = AUGMENTATIONS(image=hflipped_img)['image']
tmp_array = np.vstack(
(original_img_array, inverted_img_array, hflipped_img_array))
tmp_array = preprocess_input(tmp_array, model_name)
prediction = np.mean(model.predict(tmp_array), axis=0)
return prediction
