def __init__(self, crop_size=800):
self.master = albumentations.Compose([
albumentations.RandomCrop(crop_size, crop_size),
albumentations.RandomRotate90(p=0.5),
albumentations.Transpose(p=0.5),
albumentations.Flip(p=0.5),
albumentations.OneOf([
albumentations.RandomBrightness(),
albumentations.RandomContrast(),
albumentations.HueSaturationValue(),
],
p=0.5),
albumentations.ElasticTransform(),
albumentations.ShiftScaleRotate(shift_limit=0.1,
scale_limit=0.02,
rotate_limit=15,
p=0.5),
albumentations.Normalize(mean=[0.798, 0.621, 0.841],
std=[0.125, 0.228, 0.089]),
])
self.to_tensor = ToTensor()
def __init__(self, split):
self.split = split
self.aug = albumentations.Compose([
albumentations.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
AT.ToTensor()
])
if self.split == 'train':
self.aug = albumentations.Compose([
albumentations.PadIfNeeded(36, 36),
albumentations.RandomCrop(32, 32),
albumentations.HorizontalFlip(),
##albumentations.RandomBrightness(),
#albumentations.ShiftScaleRotate(rotate_limit=15, scale_limit=0.10),
#albumentations.HueSaturationValue(),
albumentations.Cutout(1, 8, 8, 0.5),
#albumentations.GaussNoise(),
#albumentations.ElasticTransform(),
albumentations.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
AT.ToTensor()
])
def get_training_augmentation():
train_transform = [
# albu.Resize(320, 640),
# albu.HorizontalFlip(p=0.5),
# albu.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, shift_limit=0.1, p=0.5, border_mode=0),
# albu.GridDistortion(p=0.5),
# albu.OpticalDistortion(p=0.5, distort_limit=2, shift_limit=0.5),
# fist prize's augmentations below
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.5),
albu.ShiftScaleRotate(scale_limit=0.20, rotate_limit=10, shift_limit=0.1, p=0.5, border_mode=cv2.BORDER_CONSTANT, value=0),
albu.GridDistortion(p=0.5),
albu.RandomCrop(height=800,width=1200,p=0.5),
albu.Resize(320, 640),
albu.ChannelShuffle(),
albu.InvertImg(),
albu.ToGray(),
albu.Normalize(),
]
return albu.Compose(train_transform)
def get_album_transforms(norm_mean, norm_std):
"""get the train and test transform by albumentations"""
train_transform = AlbumentationTransforms([
A.HorizontalFlip(p=0.7),
A.PadIfNeeded(min_height=70,
min_width=70,
border_mode=4,
always_apply=False,
p=1.0),
A.RandomCrop(64, 64, always_apply=False, p=1.0),
A.Rotate(limit=30,
interpolation=1,
border_mode=4,
always_apply=False,
p=0.5),
A.Normalize(mean=norm_mean, std=norm_std),
A.Cutout(num_holes=1, max_h_size=32, max_w_size=32, p=0.7)
])
test_transform = AlbumentationTransforms(
[A.Normalize(mean=norm_mean, std=norm_std)])
return (train_transform, test_transform)
def __init__(self, image_list, label):
self.image_list = image_list
self.label = label
self.aug = A.Compose([
A.PadIfNeeded(min_height=40,
min_width=40,
always_apply=True,
border_mode=0,
value=[0, 0, 0]),
A.RandomCrop(32, 32, p=1),
#torch.FlipLR(),
A.HorizontalFlip(p=0.5),
#A.Rotate((-8.0, 8.0), p=0.5),
A.Cutout(num_holes=8,
max_h_size=8,
max_w_size=8,
fill_value=[0.4914, 0.4822, 0.4465],
p=0.5),
A.Normalize(mean=(0.4914, 0.4822, 0.4465),
std=(0.2023, 0.1994, 0.2010))
])
def ego_generator(path, size=128, is_random=True):
random_number = 7
folders = [f for f in os.listdir(path)]
while True:
if is_random:
folder = random.choice(folders)
frame_number = random.randint(0, 100)
else:
folder = folders[7]
frame_number = random_number
frame_name = 'frame_%s.jpg' % str(frame_number).zfill(4)
image = scipy.misc.imread(os.path.join(path, folder, frame_name))
image = cv2.resize(image, (640, 480))
image = A.RandomCrop(height=size, width=size,
p=1.0)(image=image)['image']
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# image = np.reshape(image, (size, size, 1))
yield image
def __init__(self, paths, labels=None, size=None, random_crop=False):
self.labels = labels if labels is not None else dict()
self.size = size
self.random_crop = random_crop
assert not "file_path_" in self.labels
self.labels["file_path_"] = paths
self._length = len(paths)
if self.size is not None and self.size > 0:
self.rescaler = albumentations.SmallestMaxSize(max_size=self.size)
if not self.random_crop:
self.cropper = albumentations.CenterCrop(height=self.size,
width=self.size)
else:
self.cropper = albumentations.RandomCrop(height=self.size,
width=self.size)
self.preprocessor = albumentations.Compose(
[self.rescaler, self.cropper])
else:
self.preprocessor = lambda **kwargs: kwargs
def __init__(self, scenes, crop_size, downsample=False):
# Make sure patches with AMSR NaNs are removed
patches_folder = '/data/users/twu/ds-2/patches'
df = pd.read_csv(os.path.join(patches_folder, 'tiles_info.txt'), header=None, names=['path', 'AMSRNaN', 'CT'])
AMSRNaNPatches = list(df[df['AMSRNaN'] == 1]['path'].values)
self.patch_paths = [patch for patch in utils.get_patch_paths(scenes) if patch not in AMSRNaNPatches]
self.crop_size = crop_size
self.downsample = downsample
# Defining a data augmentation pipeline
self.transform = A.Compose([A.RandomCrop(width=crop_size, height=crop_size, always_apply=True),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5)],
additional_targets = {'INC': 'image', 'CT': 'image', 'DST': 'image', 'AMSR': 'image'})
# Initializing data scalers
self.INC_scaler = pickle.load(open('scalers/INC_scaler.pkl', 'rb'))
self.DST_scaler = pickle.load(open('scalers/DST_scaler.pkl', 'rb'))
self.AMSR_scaler = pickle.load(open('scalers/AMSR_scaler.pkl', 'rb'))
def get_data_transform(path):
mean, stdev = [0.4802, 0.4481, 0.3975], [0.2302, 0.2265, 0.2262]
input_size = 64
train_albumentation_transform = A.Compose([
A.PadIfNeeded(min_height=70,
min_width=70,
border_mode=cv2.BORDER_REPLICATE,
always_apply=True,
p=1.0),
A.Cutout(num_holes=1,
max_h_size=64,
max_w_size=64,
always_apply=True,
p=0.7,
fill_value=[i * 255 for i in mean]),
# A.RGBShift (r_shift_limit=20, g_shift_limit=20, b_shift_limit=20, always_apply=False, p=0.5),
# A.ChannelShuffle(0.7) ,
A.RandomCrop(height=64, width=64, p=1, always_apply=False),
A.HorizontalFlip(p=0.7, always_apply=True),
A.ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0,
rotate_limit=45,
p=0.2),
A.Normalize(mean=tuple(mean),
std=tuple(stdev),
max_pixel_value=255,
always_apply=True,
p=1.0),
A.Resize(input_size, input_size),
ToTensor()
])
# Test Phase transformation
test_transforms = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(tuple(mean), tuple(stdev))
])
train_transforms = AlbumCompose(train_albumentation_transform)
# test_transforms = AlbumCompose(test_transforms)
return train_transforms, test_transforms
def get_training_augmentation(height=480, width=640):
train_transform = [
A.Resize(height=height, width=width),
A.HorizontalFlip(p=0.5),
A.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, shift_limit=0.1, p=1, border_mode=0),
A.PadIfNeeded(min_height=height, min_width=width, always_apply=True, border_mode=0),
A.RandomCrop(height=height, width=width, p=0.5),
A.IAAAdditiveGaussianNoise(p=0.05),
# A.IAAPerspective(p=0.5),
# A.OneOf(
# [
# A.CLAHE(p=1),
# A.RandomBrightness(p=1),
# A.RandomGamma(p=1),
# ],
# p=0.9,
# ),
# A.OneOf(
# [
# A.IAASharpen(p=1),
# A.Blur(blur_limit=3, p=1),
# A.MotionBlur(blur_limit=3, p=1),
# ],
# p=0.9,
# ),
# A.OneOf(
# [
# A.RandomContrast(p=1),
# A.HueSaturationValue(p=1),
# ],
# p=0.9,
# ),
]
return A.Compose(train_transform)
def get_training_augmentation():
train_transform = [
albu.HorizontalFlip(p=0.5),
albu.ShiftScaleRotate(scale_limit=0.5,
rotate_limit=0,
shift_limit=0.1,
p=1,
border_mode=0),
albu.PadIfNeeded(min_height=512,
min_width=512,
always_apply=True,
border_mode=0),
albu.RandomCrop(height=320, width=320, always_apply=True),
albu.IAAAdditiveGaussianNoise(p=0.2),
albu.IAAPerspective(p=0.5),
albu.OneOf(
[
albu.CLAHE(p=1),
albu.RandomBrightnessContrast(p=1),
albu.RandomGamma(p=1),
],
p=0.9,
),
albu.OneOf(
[
albu.IAASharpen(p=1),
albu.Blur(blur_limit=3, p=1),
albu.MotionBlur(blur_limit=3, p=1),
],
p=0.9,
),
albu.OneOf(
[
albu.RandomContrast(p=1),
albu.HueSaturationValue(p=1),
],
p=0.9,
),
]
return albu.Compose(train_transform)
def get_transforms(size: int, scope: str = 'geometric', crop='random'):
augs = {'strong': albu.Compose([albu.HorizontalFlip(),
albu.ShiftScaleRotate(shift_limit=0.0, scale_limit=0.2, rotate_limit=20, p=.4),
albu.ElasticTransform(),
albu.OpticalDistortion(),
albu.OneOf([
albu.CLAHE(clip_limit=2),
albu.IAASharpen(),
albu.IAAEmboss(),
albu.RandomBrightnessContrast(),
albu.RandomGamma()
], p=0.5),
albu.OneOf([
albu.RGBShift(),
albu.HueSaturationValue(),
], p=0.5),
]),
'weak': albu.Compose([albu.HorizontalFlip(),
]),
'geometric': albu.OneOf([albu.HorizontalFlip(always_apply=True),
albu.ShiftScaleRotate(always_apply=True, scale_limit=.5, rotate_limit=30),
albu.Transpose(always_apply=True),
albu.OpticalDistortion(always_apply=True, distort_limit=0.1, shift_limit=0.1),
albu.ElasticTransform(always_apply=True),
]),
'empty': NoOp(),
}
aug_fn = augs[scope]
crop_fn = {'random': albu.RandomCrop(size, size, always_apply=True),
'center': albu.CenterCrop(size, size, always_apply=True)}[crop]
pad = albu.PadIfNeeded(size, size)
pipeline = albu.Compose([aug_fn, crop_fn, pad])
def process(a):
r = pipeline(image=a)
return r['image']
return process
def get_training_augmentation():
train_transform = [
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.5),
albu.ShiftScaleRotate(shift_limit=0.0,
scale_limit=0.2,
rotate_limit=0.0,
p=0.5,
border_mode=0),
# albu.PadIfNeeded(min_height=1000, min_width=1600, always_apply=True, border_mode=0),
albu.RandomCrop(height=256, width=400, always_apply=True),
# albu.IAAAdditiveGaussianNoise(p=0.2),
# albu.IAAPerspective(p=0.5),
#
# albu.OneOf(
# [
# albu.CLAHE(),
# albu.RandomBrightnessContrast(),
# albu.HueSaturationValue(),
# albu.RandomGamma(),
# ],
# p=0.9,
# ),
# #
# albu.OneOf(
# [
# albu.IAASharpen(p=1),
# albu.Blur(blur_limit=3, p=1),
# albu.MotionBlur(blur_limit=3, p=1),
# ],
# p=0.9,
# ),
#
# albu.CLAHE(),
# albu.RandomBrightnessContrast(),
# albu.HueSaturationValue(),
albu.Normalize(),
albu.Lambda(image=to_tensor, mask=to_tensor),
]
return albu.Compose(train_transform)
def train_augment(image, eigenvectors, eigenvalues, pixel_avg, stdev,
shift_scale, aug_list):
"""
Takes an image from the training set, applies a random
224 x 224 crop and a horizontal flip with 50% probability.
Additionally it sums a random linear combination of the
eigenvectors of all the pixels in the training set to all
of the pixels in the training image. We also normalize the
pixel values.
Since we are not generating all of the possible transformation
combinations (but only randomly returning a single one), do
we need more epochs or do we sample more times each epoch?
"""
# Note height comes first since the 0-axis is the y-axis! Made a mistake here before
height, width = image.shape[0], image.shape[1]
crop_width = min(224, width)
crop_height = min(224, height)
augmenter = albumentations.Compose(
aug_list.get() + # We add custom augmentations separately
[
# Note height comes first in crop transformations, made a mistake here before
albumentations.RandomCrop(crop_height, crop_width)
])
alphas = np.random.normal(scale=shift_scale, size=3)
shift = np.zeros(3)
for i in range(3):
shift += alphas[i] * eigenvalues[i] * eigenvectors[i]
# Shift was normalized but not standardized, hence need to divide it by standard deviation
# Since standard deviation is less than 1 this will increase the shift and thus increase regularization...
output_image = ((augmenter(image=image)["image"] - pixel_avg) / 255 +
shift) / stdev
return ImagenetSequence.pad_image(output_image)
def get_training_augmentation():
train_transform = [
albu.HorizontalFlip(p=0.5), #水平翻转
albu.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, shift_limit=0.1, p=1, border_mode=0), # 平移缩放旋转
albu.PadIfNeeded(min_height=224, min_width=224, always_apply=True, border_mode=0), # 加padding
albu.RandomCrop(height=224, width=224, always_apply=True), # 随机剪裁
albu.IAAAdditiveGaussianNoise(p=0.2), # Add gaussian noise to the input image.
albu.IAAPerspective(p=0.5), # Perform a random four point perspective transform of the input
albu.OneOf(
[
albu.CLAHE(p=1), # 对比度受限情况下的自适应直方图均衡化算法
albu.RandomBrightnessContrast(p=1), # Randomly change brightness and contrast
albu.RandomGamma(p=1), # Gamma变换
],
p=0.9,
),
albu.OneOf(
[
albu.IAASharpen(p=1), # Sharpen the input image and overlays the result with the original image.
albu.Blur(blur_limit=3, p=1),
albu.MotionBlur(blur_limit=3, p=1),
],
p=0.9,
),
albu.OneOf(
[
albu.RandomBrightnessContrast(p=1),
albu.HueSaturationValue(p=1), # Randomly change hue, saturation and value of the input image.
],
p=0.9,
),
]
return albu.Compose(train_transform)
def _setup_transform(self, cfg):
# Albumentation example: https://albumentations.readthedocs.io/en/latest/examples.html
self.img_mask_transform = A.Compose([
A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.2, rotate_limit=175, p=0.8, border_mode=cv2.BORDER_CONSTANT),
A.Flip(),
A.Transpose(),
A.OneOf([
A.ElasticTransform(),
A.OpticalDistortion(),
A.GridDistortion(),
A.IAAPiecewiseAffine(),
]),
A.OneOf([
A.RandomCrop(height=self.size_crop,width=self.size_crop,p=0.5),
A.CenterCrop(height=self.size_crop,width=self.size_crop,p=0.5)
]),
A.Cutout(num_holes=8, max_h_size=8, max_w_size=8, fill_value=0,p=0.5),
],p=0.8)
self.img_pixel_transform = A.Compose([
A.OneOf([
A.IAAAdditiveGaussianNoise(),
A.GaussNoise(),
], p=0.2),
A.OneOf([
A.MotionBlur(p=0.2),
A.MedianBlur(blur_limit=3, p=0.1),
A.Blur(blur_limit=3, p=0.1),
], p=0.2),
A.OneOf([
A.IAASharpen(),
A.IAAEmboss(),
# A.RandomBrightnessContrast(),
], p=0.3),
A.HueSaturationValue(hue_shift_limit=3,sat_shift_limit=20,val_shift_limit=3 ,p=0.2),
],p=0.5)
# Torch transform
self.resize_transform = transforms.Resize(cfg.MODEL.IMAGE_SIZE, Image.NEAREST)
self.to_tensor_transform = transforms.ToTensor()
self.normalize_transform = transforms.Normalize(mean=cfg.TRAIN.NORMALIZE_MEAN, std=cfg.TRAIN.NORMALIZE_STD)
def __init__(self):
self.mean = [0.4890062, 0.47970363, 0.47680542]
self.std = [0.264582, 0.258996, 0.25643882]
self.train_transforms = A.Compose([
A.PadIfNeeded(min_height=40, min_width=40, always_apply=True),
A.RandomCrop(height=32, width=32, always_apply=True),
A.HorizontalFlip(p=0.5),
A.Cutout( num_holes=1, max_h_size=8, max_w_size=8, fill_value= self.mean, always_apply=False, p=0.5),
A.Normalize( mean = self.mean, std= self.std,),
ToTensorV2()
#ToTensor()
])
self.test_transforms = A.Compose([
A.Normalize( mean = self.mean, std= self.std,),
ToTensorV2()
#ToTensor()
])
def __init__(self, config):
super().__init__()
self.config = config
aux_params=dict(
pooling='avg',
dropout=0.2,
activation='sigmoid',
classes=1)
self.net = smp.Unet(encoder_name=self.config.training.model_encoder,
in_channels=1,
aux_params=aux_params) # классификационная голова
self.metrics = {
"regression": pl.metrics.MeanSquaredError(),
"classification": pl.metrics.Accuracy(self.config.prediction.threshold)
}
# грузим лучшие веса
state_dict = self._rename_layers(load(os.path.join(config.sources.ckpt_path,
f"{config.name}.ckpt"))['state_dict'])
self.net.load_state_dict(state_dict)
self.net.eval()
# TODO: вообще тут надо делать нарезку изображений на тайлы, а потом ресайз, но нет
augs_list = [
albu.PadIfNeeded(480, 80),
albu.RandomCrop(480, 80),
albu.Resize(576, 96), # должно быть кратно 32
ToTensorV2()
# без нормализации
]
self.transforms = albu.Compose(augs_list)
self.deferset = AudioDataset(config.sources.val_meta,
config.sources.data_path,
self.transforms,
False,
prob=0.5,
train_ratio=1.0)
self.deferloader = DataLoader(self.deferset, batch_size=1, shuffle=False)
def da_policy_DA8(img_size, crop_size):
train_da = albumentations.Compose([
albumentations.Resize(img_size, img_size),
albumentations.RandomCrop(p=1, height=crop_size, width=crop_size),
albumentations.CoarseDropout(p=0.5,
min_holes=1,
max_holes=2,
min_width=32,
min_height=32,
max_width=84,
max_height=84),
albumentations.RandomBrightnessContrast(p=0.5,
brightness_limit=0.2,
contrast_limit=0.25),
albumentations.Rotate(p=0.5, limit=17),
albumentations.GridDistortion(p=0.5, distort_limit=0.2, num_steps=10)
])
val_da = albumentations.Compose(
[albumentations.Resize(crop_size, crop_size)])
return train_da, val_da
def __call__(self, sample):
# img, mask = sample.image, sample.annotation
# w, h, _ = img.shape
# x1 = random.randint(0, w - self.crop_size)
# y1 = random.randint(0, h - self.crop_size)
# img = img.crop((x1, y1, x1 + self.crop_size, y1 + self.crop_size))
# mask = mask.crop((x1, y1, x1 + self.crop_size, y1 + self.crop_size))
# sample.image = img
# sample.annotation = mask
img, annot = sample.image, sample.annotation
aug = A.RandomCrop(self.crop_size, self.crop_size)
masks = []
if sample.masks_and_category is not None:
for index in sample.masks_and_category:
masks.append(index[0])
image_crop = []
bbox_crop = []
if masks is not None:
augmented = aug(image=img, bboxes=annot, masks=masks)
mask_crop = augmented['masks']
image_crop = augmented['image']
bbox_crop = augmented['bboxes']
for i, index in enumerate(sample.masks_and_category):
index[0] = mask_crop[i]
else:
augmented = aug(image=img, bboxes=annot)
image_crop = augmented['image']
bbox_crop = augmented['bboxes']
# the shape has to be at least (0,5)
if len(bbox_crop) == 0:
bbox_crop = np.zeros((0, 5))
sample.image = image_crop
sample.annotation = bbox_crop
def get_transform(args, is_train):
"""
It takes in the arguments and a boolean value, and returns a transform
object.
:param args: the global arguments
:param is_train: if the transform is for training or evaluating
:return: transform operations to be performed on the image
"""
if is_train:
transform = A.Compose([
A.RandomCrop(*args.train_size),
*get_list_of_ops(args.augmentations, A),
A.Normalize(mean=args.mean, std=args.std),
ToTensorV2()
])
else:
transform = A.Compose([
A.Resize(*args.eval_size),
A.Normalize(mean=args.mean, std=args.std),
ToTensorV2()
])
return transform
def designValidCrop(img, mask, center_threshold=70):
crop_img = np.zeros([256, 256, 3])
crop_mask = np.zeros([256, 256, 4])
for ch in range(4):
temp_mask = (mask[:, :, 0] > 0).astype(np.uint8)
if (np.sum(temp_mask) == 0):
aug = albu.RandomCrop(256, 256, always_apply=True)
augmented = aug(image=img[:, :, ch], mask=mask[:, :, ch])
crop_img[:, :, ch] = augmented['image']
crop_mask[:, :, ch] = augmented['mask']
else:
chosen_center = randomChooseCenter(temp_mask, center_threshold)
###### ==== do crop ===== ######
chosen_center = np.array(chosen_center).astype(np.int32)
if chosen_center[1] <= 128:
crop_mask[:, :, ch] = temp_mask[:, 0:256]
crop_img[:, :, ch] = img
elif chosen_center[1] >= (1600 - 128):
crop_mask[:, :, ch] = temp_mask[:, 1600 - 256:1600]
else:
crop_mask[:, :, ch] = temp_mask[:, chosen_center[1] -
128:chosen_center[1] + 128]
def da_policy_DA6(img_size, crop_size):
# additional_aug = [*
# zoom_crop(scale=(0.85, 1.15), do_rand=True),
# cutout(n_holes=(1, 2), length=(32, 84), p=.5),
# brightness(change=(0.33, 0.68), p=.5),
# contrast(scale=(0.7, 1.4), p=.5),
# ]
# return get_transforms(do_flip=False, max_warp=0.25, max_zoom=1.25, max_rotate=17, xtra_tfms=additional_aug)
train_da = albumentations.Compose([
albumentations.Resize(img_size, img_size),
albumentations.RandomCrop(p=1, height=crop_size, width=crop_size),
albumentations.RandomBrightnessContrast(p=0.5,
brightness_limit=0.2,
contrast_limit=0.25),
albumentations.Rotate(p=0.5, limit=17)
])
val_da = albumentations.Compose(
[albumentations.Resize(crop_size, crop_size)])
return train_da, val_da
def main():
image = cv2.imread("cuiyan.png")
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
def visualize(image):
plt.figure(figsize=(6, 6))
plt.axis("off")
plt.imshow(image)
# plt.show()
transform = A.Compose([
A.RandomCrop(111, 222),
A.OneOf([A.RGBShift(), A.HueSaturationValue()]),
])
random.seed(42)
transformed = transform(image=image)
visualize(transformed["image"])
A.save(transform, "./transform.json")
A.save(transform, "./transform.yml", data_format="yaml")
pprint.pprint(A.to_dict(transform))
def get_training_albumentations(size=(256, 256),
pad=10,
re_prob=0.5,
with_keypoints=False,
ms_prob=0.5):
h, w = size
train_transform = [
MultiScale(p=ms_prob),
ResizeWithKp(h, w, interpolation=cv2.INTER_CUBIC),
albu.PadIfNeeded(h + 2 * pad,
w + 2 * pad,
border_mode=cv2.BORDER_CONSTANT,
value=0),
albu.RandomCrop(height=h, width=w, always_apply=True),
AlbuRandomErasing(re_prob),
]
if with_keypoints:
return albu.Compose(train_transform,
keypoint_params=albu.KeypointParams(
format='xy', remove_invisible=False))
else:
return albu.Compose(train_transform)
def resize_transforms(input_size=256):
result = A.Compose([
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.RandomRotate90(p=1),
A.OneOf([
A.ShiftScaleRotate(scale_limit=0,
rotate_limit=(-45, 45),
shift_limit=(-0.1, 0.1),
interpolation=0,
border_mode=2,
p=0.5),
A.ElasticTransform(alpha_affine=20, sigma=30, border_mode=2, p=0.5)
]),
A.PadIfNeeded(min_height=input_size,
min_width=input_size,
always_apply=True,
border_mode=2),
A.RandomCrop(input_size, input_size, always_apply=True),
])
return result
def __init__(self,
data_csv, data_root, segmentation_root,
size=None, random_crop=False, interpolation="bicubic",
):
self.n_labels = 182
self.data_csv = data_csv
self.data_root = data_root
self.segmentation_root = segmentation_root
with open(self.data_csv, "r") as f:
self.image_paths = f.read().splitlines()
self._length = len(self.image_paths)
self.labels = {
"relative_file_path_": [l for l in self.image_paths],
"file_path_": [os.path.join(self.data_root, l)
for l in self.image_paths],
"segmentation_path_": [os.path.join(self.segmentation_root, l.replace(".jpg", ".png"))
for l in self.image_paths]
}
size = None if size is not None and size<=0 else size
self.size = size
if self.size is not None:
self.interpolation = interpolation
self.interpolation = {
"nearest": cv2.INTER_NEAREST,
"bilinear": cv2.INTER_LINEAR,
"bicubic": cv2.INTER_CUBIC,
"area": cv2.INTER_AREA,
"lanczos": cv2.INTER_LANCZOS4}[self.interpolation]
self.image_rescaler = albumentations.SmallestMaxSize(max_size=self.size,
interpolation=self.interpolation)
self.segmentation_rescaler = albumentations.SmallestMaxSize(max_size=self.size,
interpolation=cv2.INTER_NEAREST)
self.center_crop = not random_crop
if self.center_crop:
self.cropper = albumentations.CenterCrop(height=self.size, width=self.size)
else:
self.cropper = albumentations.RandomCrop(height=self.size, width=self.size)
self.preprocessor = self.cropper
def load_data(fold: int) -> Any:
torch.multiprocessing.set_sharing_strategy('file_system') # type: ignore
cudnn.benchmark = True # type: ignore
full_df = pd.read_csv('../input/train.csv')
print('full_df', full_df.shape)
train_df, val_df = train_val_split(full_df, fold)
print('train_df', train_df.shape)
num_ttas = 1
if num_ttas > 1:
transform_test = albu.Compose([
albu.PadIfNeeded(config.model.input_size, config.model.input_size),
albu.RandomCrop(height=config.model.input_size,
width=config.model.input_size),
# horizontal flip is done by the data loader
])
else:
transform_test = albu.Compose([
albu.PadIfNeeded(config.model.input_size, config.model.input_size),
albu.CenterCrop(height=config.model.input_size,
width=config.model.input_size),
])
val_dataset = ImageDataset(val_df,
mode='val',
config=config,
num_ttas=num_ttas,
augmentor=transform_test)
data_loader = torch.utils.data.DataLoader(
val_dataset,
batch_size=config.test.batch_size,
shuffle=False,
num_workers=config.general.num_workers,
drop_last=True)
return data_loader
def get_training_augmentation():
train_transform = [
A.HorizontalFlip(p=0.5),
A.ShiftScaleRotate(rotate_limit=0, shift_limit=0.1, p=1,
border_mode=0),
A.PadIfNeeded(min_height=320,
min_width=320,
always_apply=False,
border_mode=0),
A.RandomCrop(height=320, width=320, always_apply=True),
A.IAAAdditiveGaussianNoise(p=0.2),
A.IAAPerspective(p=0.5),
A.OneOf(
[
A.CLAHE(p=1),
A.RandomBrightness(p=1),
A.RandomGamma(p=1),
],
p=0.9,
),
A.OneOf(
[
A.IAASharpen(p=1),
A.Blur(blur_limit=3, p=1),
A.MotionBlur(blur_limit=3, p=1),
],
p=0.9,
),
A.OneOf(
[
A.RandomContrast(p=1),
A.HueSaturationValue(p=1),
],
p=0.9,
),
A.Lambda(mask=round_clip_0_1)
]
return A.Compose(train_transform)
def get_train_augmentation(height=336,
width=224,
scale_height=384,
scale_width=256):
train_augmentation = albu.Compose([
# albu.HorizontalFlip(),
albu.OneOf(
[albu.RandomBrightness(0.1, p=1),
albu.RandomContrast(0.1, p=1)],
p=0.9),
albu.ShiftScaleRotate(shift_limit=0.1,
scale_limit=0.0,
rotate_limit=15,
p=0.3),
albu.OneOf([
albu.IAAAdditiveGaussianNoise(p=1.0),
albu.GaussNoise(var_limit=(10., 50.), p=1),
],
p=0.7),
albu.OneOf([
albu.Compose([
albu.Resize(scale_height, scale_width, p=1.0),
albu.RandomCrop(height=height, width=width, p=1.0),
]),
albu.Resize(height, width, p=1.0),
],
p=1.0),
albu.MotionBlur(blur_limit=10, p=0.7),
albu.Normalize(mean=[0.695, 0.658, 0.592],
std=[0.191, 0.185, 0.171],
max_pixel_value=255),
albu.Cutout(num_holes=1,
max_h_size=height // 2,
max_w_size=width // 2,
p=0.5),
ToTensor()
])
return train_augmentation
