def __init__(
self,
df,
batch_size,
num_classes,
data_dir: str = "/media/hdd/Datasets/asl/",
img_size=(256, 256),
):
super().__init__()
self.df = df
self.data_dir = data_dir
self.batch_size = batch_size
self.train_transform = A.Compose(
[
A.RandomResizedCrop(img_size, img_size, p=1.0),
A.Transpose(p=0.5),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.ShiftScaleRotate(p=0.5),
A.HueSaturationValue(hue_shift_limit=0.2,
sat_shift_limit=0.2,
val_shift_limit=0.2,
p=0.5),
A.RandomBrightnessContrast(brightness_limit=(-0.1, 0.1),
contrast_limit=(-0.1, 0.1),
p=0.5),
A.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
max_pixel_value=255.0,
p=1.0,
),
A.CoarseDropout(p=0.5),
A.Cutout(p=0.5),
ToTensorV2(p=1.0),
],
p=1.0,
)
self.valid_transform = A.Compose(
[
A.CenterCrop(img_size, img_size, p=1.0),
A.Resize(img_size, img_size),
A.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
max_pixel_value=255.0,
p=1.0,
),
ToTensorV2(p=1.0),
],
p=1.0,
)
def get_training_augmentation_both():
train_transform = [
albu.VerticalFlip(p=0.6),
albu.HorizontalFlip(p=0.6),
albu.ShiftScaleRotate(
scale_limit=0.3, rotate_limit=15, shift_limit=0.1, p=0.6, border_mode=0
),
albu.GridDistortion(p=0.6),
albu.OpticalDistortion(p=0.6, distort_limit=0.1, shift_limit=0.2),
albu.RandomBrightnessContrast(p=0.6),
]
return train_transform
def get_training_augmentation():
train_transform = [
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.5),
albu.ShiftScaleRotate(shift_limit=0.25,
scale_limit=0.25,
rotate_limit=90,
p=0.5),
albu.GridDistortion(p=0.5),
albu.Resize(384, 576)
]
return albu.Compose(train_transform)
def light_training_transforms_xray(crop_size=256):
return A.Compose([
A.RandomResizedCrop(height=crop_size, width=crop_size),
A.OneOf([
A.Transpose(),
A.VerticalFlip(),
A.HorizontalFlip(),
A.RandomRotate90(),
A.NoOp()
],
p=1.0),
])
def __init__(self,
img_paths,
basepath_2_ohe=None,
img_size=1024,
transform=None,
return_label=True,
is_trainset=True,
in_channels=4,
crop_size=0,
random_crop=False,
cherrypicked_mitotic_spindle_df=None,
cherrypicked_aggresome_df=None,
mitotic_img_prob=None,
max_num_mitotic_cells_per_img=None,
aggresome_img_prob=None,
max_num_aggresome_cells_per_img=None
):
self.is_trainset = is_trainset
self.img_size = img_size
self.return_label = return_label
self.in_channels = in_channels
self.transform = transform
self.crop_size = crop_size
self.random_crop = random_crop
self.img_paths = img_paths
if is_trainset:
self.basepath_2_ohe = basepath_2_ohe
self.mitotic_aggresome_balancing = cherrypicked_aggresome_df is not None
if self.mitotic_aggresome_balancing:
assert cherrypicked_mitotic_spindle_df is not None, 'when balancing minor classes, both Aggresome and Mitotic must be included'
self.cherrypicked_aggresome_df = cherrypicked_aggresome_df
self.cherrypicked_mitotic_spindle_df = cherrypicked_mitotic_spindle_df
self.minority_aug = A.Compose([
A.HorizontalFlip(p=0.7),
A.VerticalFlip(p=0.7),
A.RandomRotate90(p=0.5),
A.ShiftScaleRotate(p=0.8, rotate_limit=0),
A.GaussianBlur(p=0.2)])
self.indices_of_mitotic_cells = list(range(len(cherrypicked_mitotic_spindle_df)))
self.indices_of_aggresome_cells = list(range(len(cherrypicked_aggresome_df)))
self.mitotic_img_prob = 0.1 if mitotic_img_prob is None else mitotic_img_prob
self.aggresome_img_prob = 0.1 if aggresome_img_prob is None else aggresome_img_prob
self.max_num_mitotic_cells_per_img = 4 if max_num_mitotic_cells_per_img is None else max_num_mitotic_cells_per_img
self.max_num_aggresome_cells_per_img = 4 if max_num_aggresome_cells_per_img is None else max_num_aggresome_cells_per_img
self.img_paths_len = len(self.img_paths)
self.num = self.img_paths_len
else:
self.num = len(self.img_paths)
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 get_light_augmentations(image_size):
min_size = min(image_size[0], image_size[1])
return A.Compose([
A.RandomSizedCrop(min_max_height=(int(min_size * 0.85), min_size),
height=image_size[0],
width=image_size[1], p=1.0),
A.OneOf([A.HorizontalFlip(),
A.VerticalFlip(),
A.RandomRotate90()
])
])
def get_training_augmentation():
# for train
train_transform = [
albu.Resize(height=configs.input_size, width=configs.input_size),
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.5),
albu.Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225),
p=1),
AT.ToTensor(),
]
return albu.Compose(train_transform)
def __init__(self, crop_size=(256, 256)):
self.transform = alb.Compose([
alb.Rotate(limit=90, p=0.5),
alb.RandomSizedCrop(min_max_height=(int(0.8 * crop_size[0]),
int(1.2 * crop_size[0])),
height=crop_size[0],
width=crop_size[1]),
alb.RandomRotate90(p=0.5),
alb.VerticalFlip(p=0.5),
alb.HorizontalFlip(p=0.5),
alb.Cutout(num_holes=8, max_h_size=8, max_w_size=8)
])
def get_transform(size):
transform = A.Compose([
A.RandomResizedCrop(size,
size,
scale=(0.7, 1.0),
ratio=(0.9, 1.1),
always_apply=True),
A.RandomRotate90(p=0.3),
A.HorizontalFlip(p=0.3),
A.VerticalFlip(p=0.1)
])
return transform
def __random_transform(self, img, masks):
composition = albu.Compose([
albu.HorizontalFlip(),
albu.VerticalFlip(),
albu.ShiftScaleRotate(rotate_limit=30, shift_limit=0.1)
])
composed = composition(image=img, mask=masks)
aug_img = composed['image']
aug_masks = composed['mask']
return aug_img, aug_masks
def __init__(self, image_list):
self.image_list = image_list
self.aug = A.Compose({
A.Resize(224),
# A.CenterCrop(100, 100),
# A.RandomCrop(80, 80),
A.HorizontalFlip(p=0.5),
A.Rotate(limit=(-90, 90)),
A.VerticalFlip(p=0.5),
A.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
})
def pw_transforms(image_size=IMAGE_SIZE): #дополнить
result = albu.Compose([
albu.RandomBrightnessContrast(brightness_limit=0.2,
contrast_limit=0.2,
p=0.3),
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.5),
albu.RandomRotate90(p=0.5),
albu.ShiftScaleRotate(0, (-0.5, 0.5), 0)
])
return result
def case1_cls_train_augs(name, **kwargs):
return [
A.Compose([
A.HorizontalFlip(),
A.VerticalFlip(),
A.RandomRotate90(),
A.ShiftScaleRotate(
rotate_limit=30, border_mode=cv2.BORDER_CONSTANT, value=0),
A.Normalize()
],
p=1.0),
]
def get_augumentation(phase,
width=512,
height=512,
min_area=0.,
min_visibility=0.):
list_transforms = []
if phase == 'train':
list_transforms.extend([
albu.augmentations.transforms.LongestMaxSize(max_size=width,
always_apply=True),
albu.PadIfNeeded(min_height=height,
min_width=width,
always_apply=True,
border_mode=0,
value=[0, 0, 0]),
albu.augmentations.transforms.RandomResizedCrop(height=height,
width=width,
p=0.3),
albu.augmentations.transforms.Flip(),
albu.augmentations.transforms.Transpose(),
albu.OneOf([
albu.RandomBrightnessContrast(brightness_limit=0.5,
contrast_limit=0.4),
albu.RandomGamma(gamma_limit=(50, 150)),
albu.NoOp()
]),
albu.OneOf([
albu.RGBShift(r_shift_limit=20,
b_shift_limit=15,
g_shift_limit=15),
albu.HueSaturationValue(hue_shift_limit=5, sat_shift_limit=5),
albu.NoOp()
]),
albu.CLAHE(p=0.8),
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.5),
])
if (phase == 'test' or phase == 'valid'):
list_transforms.extend([albu.Resize(height=height, width=width)])
list_transforms.extend([
albu.Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225),
p=1),
ToTensor()
])
if (phase == 'test'):
return albu.Compose(list_transforms)
return albu.Compose(list_transforms,
bbox_params=albu.BboxParams(
format='coco',
min_area=min_area,
min_visibility=min_visibility,
label_fields=['category_id']))
def get_tfms_faster(ds):
"""Function that returns the transformations to
be applied to both loaders (training, validation)
Keyword arguments:
- cropsize: tupple
- scalling: list of two values
"""
if ds == "datamatrix":
train_tfms = albu.Compose([
albu.OneOf([
albu.augmentations.transforms.RandomSizedBBoxSafeCrop(
480, 640, p=0.2),
albu.augmentations.transforms.RandomSizedBBoxSafeCrop(
960, 1280, p=0.2),
albu.augmentations.transforms.Resize(750, 1000, p=0.6),
],
p=1),
albu.augmentations.transforms.RandomBrightness(limit=0.5),
albu.augmentations.transforms.RandomContrast(limit=0.5),
albu.HorizontalFlip(),
ToTensor(),
],
bbox_params=albu.BboxParams(
format='pascal_voc',
min_area=0.,
min_visibility=0.,
label_fields=['labels']))
elif ds == "coco":
train_tfms = albu.Compose([
albu.augmentations.transforms.RandomBrightness(limit=0.5),
albu.augmentations.transforms.RandomContrast(limit=0.5),
albu.HorizontalFlip(),
albu.VerticalFlip(),
ToTensor(),
],
bbox_params=albu.BboxParams(
format='pascal_voc',
min_area=0.,
min_visibility=0.,
label_fields=['labels']))
val_tfms = albu.Compose([
ToTensor(),
],
bbox_params=albu.BboxParams(
format='pascal_voc',
min_area=0.,
min_visibility=0.,
label_fields=['labels']))
return train_tfms, val_tfms
def pet_augmentation():
transform_list = [
albu.Resize(320, 320),
albu.RandomRotate90(p=0.5),
albu.VerticalFlip(p=0.5),
albu.HorizontalFlip(p=0.5),
albu.MultiplicativeNoise(p=0.7,
multiplier=(0.5, 1.5),
elementwise=True),
albu.GaussianBlur(p=0.5, blur_limit=3)
]
return albu.Compose(transform_list)
def light_training_transforms():
return A.Compose([
A.OneOf([
A.Transpose(),
A.VerticalFlip(),
A.HorizontalFlip(),
A.RandomRotate90(),
A.NoOp()
],
p=1.0),
A.Normalize()
])
def parse_albu_short(config, always_apply=False):
if isinstance(config, str):
if config == 'hflip':
return A.HorizontalFlip(always_apply=always_apply)
if config == 'vflip':
return A.VerticalFlip(always_apply=always_apply)
if config == 'transpose':
return A.Transpose(always_apply=always_apply)
raise Exception(f'Unknwon augmentation {config}')
assert type(config) == dict
return parse_albu([config])
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 data_augmentation(batch_images, batch_masks):
images = []
masks = []
for image, mask in zip(batch_images, batch_masks):
#Rotations
for i in range(0, 4):
transform_image, transform_mask = A.RandomRotate90(p=1).apply(
image, factor=i), A.RandomRotate90(p=1).apply(mask, factor=i)
images.append(transform_image)
masks.append(transform_mask)
#Horizontal Flip
transform_image, transform_mask = A.HorizontalFlip(
p=1).apply(image), A.HorizontalFlip(p=1).apply(mask)
images.append(transform_image)
masks.append(transform_mask)
#Vertical Flip
transform_image, transform_mask = A.VerticalFlip(
p=1).apply(image), A.VerticalFlip(p=1).apply(mask)
images.append(transform_image)
masks.append(transform_mask)
#Diagonal flip 1
transform_image, transform_mask = A.Transpose(
p=1).apply(image), A.Transpose(p=1).apply(mask)
images.append(transform_image)
masks.append(transform_mask)
#Diagonal flip 2
transform_image, transform_mask = A.RandomRotate90(p=1).apply(
image, factor=2), A.RandomRotate90(p=1).apply(mask, factor=2)
transform_image, transform_mask = A.Transpose(
p=1).apply(transform_image), A.Transpose(p=1).apply(transform_mask)
images.append(transform_image)
masks.append(transform_mask)
all_images = np.array(images)
all_masks = np.array(masks)
return all_images, all_masks
def generate_transforms2(img_size):
train_transform = Compose([
# A.RandomCrop(p=1, height=img_size, width=img_size),
A.Resize(height=img_size, width=img_size),
A.RandomSunFlare(p=1),
A.RandomFog(p=1),
A.RandomBrightness(p=1),
A.Rotate(p=1, limit=90),
A.RGBShift(p=1),
A.RandomSnow(p=1),
A.HorizontalFlip(p=1),
A.VerticalFlip(p=1),
A.RandomContrast(limit=0.5, p=1),
A.HueSaturationValue(p=1,
hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=50),
# A.Cutout(p=1),
# A.Transpose(p=1),
A.JpegCompression(p=1),
A.CoarseDropout(p=1),
A.IAAAdditiveGaussianNoise(loc=0,
scale=(2.5500000000000003, 12.75),
per_channel=False,
p=1),
A.IAAAffine(scale=1.0,
translate_percent=None,
translate_px=None,
rotate=0.0,
shear=0.0,
order=1,
cval=0,
mode='reflect',
p=1),
A.IAAAffine(rotate=90., p=1),
A.IAAAffine(rotate=180., p=1),
Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225),
max_pixel_value=255.0,
p=1.0),
ToTensorV2()
])
val_transform = Compose([
Resize(height=img_size, width=img_size),
Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225),
max_pixel_value=255.0,
p=1.0),
ToTensorV2(),
])
return {"train": train_transform, "val": val_transform}
def __init__(self, **kwargs):
self.transforms = []
h_flip = kwargs['h_flip'] if 'h_flip' in kwargs else 0.
v_flip = kwargs['v_flip'] if 'v_flip' in kwargs else 0.
g_blur = kwargs['g_blur'] if 'g_blur' in kwargs else 0.
rot = kwargs['rotation'] if 'rotation' in kwargs else 0.
cutout = kwargs['cutout'] if 'cutout' in kwargs else 0.
cutout_dimen = kwargs['cutout_dimen'] if 'cutout_dimen' in kwargs else (0,0)
cutout_wd = kwargs['cutout_wd'] if 'cutout_wd' in kwargs else 0.
padding = kwargs['padding'] if 'padding' in kwargs else 0.
crop = kwargs['crop'] if 'crop' in kwargs else 0.
crop_prob = kwargs['crop_prob'] if 'crop_prob' in kwargs else 0.
mean = kwargs['mean'] if 'mean' in kwargs else (.5,.5,.5)
std = kwargs['std'] if 'std' in kwargs else (.5,.5,.5)
train = kwargs['train'] if 'train' in kwargs else True
print(padding, padding[0], padding[1])
print('Transformations')
print(kwargs)
if train:
if padding[0] > 0 or padding[1] > 0:
self.transforms += [A.PadIfNeeded(min_height = padding[0],
min_width = padding[1],
mask_value = tuple([x * 255.0 for x in mean]),
always_apply=True)]
if crop_prob > 0:
self.transforms += [A.RandomCrop(height = crop[0], width=crop[1], always_apply=True)]
if h_flip > 0: # Horizontal Flip
self.transforms += [A.HorizontalFlip(p=h_flip)]
if v_flip > 0: # Vertical Flip
self.transforms += [A.VerticalFlip(p=v_flip)]
if g_blur > 0: # Patch Gaussian Augmentation
self.transforms += [A.GaussianBlur(p=g_blur)]
if rot > 0: # Rotate image
self.transforms += [A.Rotate(limit=rot)]
if cutout > 0: # CutOut
self.transforms += [A.CoarseDropout(
p=cutout, max_holes=1, fill_value=tuple([x * 255.0 for x in mean]),
max_height=cutout_dimen[0], max_width=cutout_dimen[1], min_height=1, min_width=1
)]
self.transforms += [
A.Normalize(mean=mean, std=std, always_apply=True),
# convert the data to torch.FloatTensor
# with values within the range [0.0 ,1.0]
ToTensor()
]
self.transform = A.Compose(self.transforms)
def __init__(self, data_dir, img_size, class_names=None, bbox_sizes=None):
"""
Arguments
---------
data_dir : str
path to the data directory (which has pickled files)
img_size : tuple
Desired output image size
IMPORTANT : (WIDTH, HEIGHT)
class_names : list
list of classes to extract data other than mouse
bbox_sizes : list
Will draw a box which is centered at the class's point,
as the size defined.
The order of class names and bbox_sizes should match.
[(half_width, half_height)]
i.e. x_min = ctr_x - half_width
"""
self.class_names = ['mouse']
if not (class_names is None):
self.class_names.extend(class_names)
self.bbox_sizes = bbox_sizes
self.img_size = img_size
self.data_dir = Path(data_dir)
self.raw_data = []
for pk_name in os.listdir(self.data_dir):
with open(self.data_dir / pk_name, 'rb') as f:
self.raw_data.extend(pickle.load(f))
self.n = len(self.raw_data)
self.output_size = img_size
self.aug = A.Compose(
[
# A.OneOf([
# A.RandomGamma((40,200),p=1),
# A.RandomBrightness(limit=0.5, p=1),
# A.RandomContrast(limit=0.5,p=1),
# A.RGBShift(40,40,40,p=1),
# A.Downscale(scale_min=0.25,scale_max=0.5,p=1),
# A.ChannelShuffle(p=1),
# ], p=0.8),
# A.InvertImg(p=0.5),
A.VerticalFlip(p=0.5),
A.HorizontalFlip(p=0.5),
# A.RandomRotate90(p=1),
A.Resize(img_size[1], img_size[0]),
# A.Cutout(8,img_size[0]//12,img_size[1]//12)
],
# (x1, y1, x2, y2) format, all normalized
bbox_params=A.BboxParams(format='albumentations',
label_fields=['bbox_labels']),
)
def augment(img_size, mean=[0.5] * 3, std=[0.5] * 3):
aug_seq1 = A.OneOf([
A.HorizontalFlip(p=1.0),
A.VerticalFlip(p=1.0),
A.Transpose(p=1.0),
],
p=1.0)
aug_seq2 = A.OneOf(
[
# A.RandomGamma(always_apply=False, p=1.0, gamma_limit=(80, 120), eps=1e-07),
A.RandomBrightnessContrast(always_apply=False,
p=1.0,
brightness_limit=(-0.2, 0.2),
contrast_limit=(-0.2, 0.2),
brightness_by_max=True),
],
p=1.0)
aug_seq3 = A.OneOf([
A.RGBShift(always_apply=False,
p=1.0,
r_shift_limit=(-10, 10),
g_shift_limit=(-10, 10),
b_shift_limit=(-10, 10)),
A.HueSaturationValue(always_apply=False,
p=1.0,
hue_shift_limit=(-4, 4),
sat_shift_limit=(-30, 30),
val_shift_limit=(-20, 20)),
],
p=1.0)
aug_seq4 = A.OneOf([
A.MultiplicativeNoise(
always_apply=False,
p=1.0,
multiplier=(0.8999999761581421, 1.100000023841858),
per_channel=True,
elementwise=True),
A.MotionBlur(always_apply=False, p=1.0, blur_limit=(3, 7)),
A.GaussNoise(always_apply=False, p=1.0, var_limit=(10.0, 50.0)),
A.Blur(always_apply=False, p=1.0, blur_limit=(3, 7)),
],
p=1.0)
aug_seq = A.Compose([
A.Resize(img_size, img_size),
aug_seq1,
aug_seq2,
aug_seq3,
aug_seq4,
A.Normalize(mean=mean, std=std),
# A.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
])
return aug_seq
def __init__(self, train=True, **transform_args):
## ARGS
horizontal_flip_prob = transform_args['horizontal_flip_prob']
vertical_flip_prob = transform_args['vertical_flip_prob']
gaussian_blur_prob = transform_args['gaussian_blur_prob']
rotate_degree = transform_args['rotate_degree']
cutout = transform_args['cutout']
cutout_height = transform_args['cutout_height']
cutout_width = transform_args['cutout_width']
mean = (0.5, 0.5, 0.5)
std = (0.5, 0.5, 0.5)
# Train phase transformations
transforms_list = []
if train:
if horizontal_flip_prob > 0: # Horizontal Flip
transforms_list += [A.HorizontalFlip(p=horizontal_flip_prob)]
if vertical_flip_prob > 0: # Vertical Flip
transforms_list += [A.VerticalFlip(p=vertical_flip_prob)]
if gaussian_blur_prob > 0: # Patch Gaussian Augmentation
transforms_list += [A.GaussianBlur(p=gaussian_blur_prob)]
if rotate_degree > 0: # Rotate image
transforms_list += [A.Rotate(limit=rotate_degree)]
if cutout > 0: # CutOut
transforms_list += [
A.CoarseDropout(p=cutout,
max_holes=1,
fill_value=tuple([x * 255.0
for x in mean]),
max_height=cutout_height,
max_width=cutout_width,
min_height=1,
min_width=1)
]
transforms_list += [
# normalize the data with mean and standard deviation to keep values in range [-1, 1]
# since there are 3 channels for each image,
# we have to specify mean and std for each channel
A.Normalize(mean=mean, std=std, always_apply=True),
# convert the data to torch.FloatTensor
# with values within the range [0.0 ,1.0]
ToTensor()
]
self.transform = A.Compose(transforms_list)
def get_training_augmentation():
train_transform = [
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.ShiftScaleRotate(scale_limit=0.0,
rotate_limit=360,
shift_limit=0.1,
p=1,
border_mode=0),
A.PadIfNeeded(min_height=256,
min_width=256,
always_apply=True,
border_mode=0),
A.RandomCrop(height=256, width=256, always_apply=True),
# To prevent overfitting
A.IAAAdditiveGaussianNoise(p=0.3),
### We do not use these transformations since our validation data is not different regarding
# HUE, contrast brightness and saturation
# and very uniform ###
# Satellite pictures always have the same perspective,
# Therefore we do not want our model to learn the concept of perspective
# 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 main(opt):
device = torch.device("cuda")
current_checkpoint = [
os.path.join("./artifacts_train", "checkpoints", opt.version, name)
for name in os.listdir(os.path.join("./artifacts_train", "checkpoints", opt.version))
if not name.startswith(".")
]
checkpoint = sorted(current_checkpoint, key=lambda x: int(x.split("/")[-1].split("_")[0]), reverse=True)[0]
print(f"Checkpoint: {checkpoint}")
path_to_img = [os.path.join(opt.data_dir, name) for name in os.listdir(opt.data_dir) if not name.startswith(".")]
val_trans = albu.Compose([
albu.RandomResizedCrop(*opt.input_shape),
albu.VerticalFlip(),
albu.HorizontalFlip(),
albu.ShiftScaleRotate(p=0.5),
albu.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5),
albu.RandomBrightnessContrast(brightness_limit=(-0.1,0.1), contrast_limit=(-0.1, 0.1), p=0.5),
albu.Normalize()
])
model = timm.create_model(opt.model_arch, pretrained=False)
model.classifier = nn.Linear(model.classifier.in_features, 5)
model.load_state_dict(torch.load(checkpoint, map_location=device)["model_state_dict"])
model.to(device)
model.eval()
predicts = []
for path in path_to_img:
img = cv2.imread(path)
tta_preds = []
for _ in range(opt.tta):
img_inp = val_trans(image=img)["image"]
img_inp = img_inp.transpose(2, 0, 1)
img_inp = torch.from_numpy(img_inp)[None, ...]
img_inp = img_inp.to(device)
with torch.no_grad():
logit = model(img_inp)
tta_preds.append(F.softmax(logit, dim=-1)[None, ...])
tta_pred = torch.cat(tta_preds, dim=0).mean(dim=0)
_, predicted = torch.max(tta_pred.data, 1)
predicts += list(predicted.cpu().numpy())
submission_df = pd.DataFrame(zip(path_to_img, predicts), columns=["image_id", "label"])
submission_df["image_id"] = submission_df["image_id"].apply(lambda x: x.split("/")[-1])
submission_df.to_csv("submission.csv", index=False)
def __init__(
self, horizontal_flip_prob=0.0, vertical_flip_prob=0.0, gaussian_blur_prob=0.0,
rotate_degree=0.0, cutout=0.0, cutout_height=0, cutout_width=0,
mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5), train=True
):
"""Create data transformation pipeline
Args:
horizontal_flip_prob: Probability of an image being horizontally flipped.
Defaults to 0.
vertical_flip_prob: Probability of an image being vertically flipped.
Defaults to 0.
rotate_degree: Angle of rotation for image augmentation.
Defaults to 0.
cutout: Probability that cutout will be performed.
Defaults to 0.
cutout_height: Max height of the cutout box.
Defaults to 0.
cutout_width: Max width of the cutout box.
Defaults to 0.
mean: Mean value. Defaults to 0.5 for each channel.
std: Standard deviation value. Defaults to 0.5 for each channel.
"""
transforms_list = []
if train:
if horizontal_flip_prob > 0: # Horizontal Flip
transforms_list += [A.HorizontalFlip(p=horizontal_flip_prob)]
if vertical_flip_prob > 0: # Vertical Flip
transforms_list += [A.VerticalFlip(p=vertical_flip_prob)]
if gaussian_blur_prob > 0: # Patch Gaussian Augmentation
transforms_list += [A.GaussianBlur(p=gaussian_blur_prob)]
if rotate_degree > 0: # Rotate image
transforms_list += [A.Rotate(limit=rotate_degree)]
if cutout > 0: # CutOut
transforms_list += [A.CoarseDropout(
p=cutout, max_holes=1, fill_value=tuple([x * 255.0 for x in mean]),
max_height=cutout_height, max_width=cutout_width, min_height=1, min_width=1
)]
transforms_list += [
# normalize the data with mean and standard deviation to keep values in range [-1, 1]
# since there are 3 channels for each image,
# we have to specify mean and std for each channel
A.Normalize(mean=mean, std=std, always_apply=True),
# convert the data to torch.FloatTensor
# with values within the range [0.0 ,1.0]
ToTensor()
]
self.transform = A.Compose(transforms_list)
def get_spacenet6_augmentation(config, is_train):
"""
"""
if is_train:
augmentation = [
# random flip
albu.HorizontalFlip(
p=config.TRANSFORM.TRAIN_HORIZONTAL_FLIP_PROB
),
albu.VerticalFlip(
p=config.TRANSFORM.TRAIN_VERTICAL_FLIP_PROB
),
# random rotate
albu.ShiftScaleRotate(
scale_limit=0.0,
rotate_limit=config.TRANSFORM.TRAIN_RANDOM_ROTATE_DEG,
shift_limit=0.0,
p=config.TRANSFORM.TRAIN_RANDOM_ROTATE_PROB,
border_mode=0),
# random crop
albu.RandomCrop(
width=config.TRANSFORM.TRAIN_RANDOM_CROP_SIZE[0],
height=config.TRANSFORM.TRAIN_RANDOM_CROP_SIZE[1],
always_apply=True
),
# speckle noise
albu.Lambda(
image=functools.partial(
_random_speckle_noise,
speckle_std=config.TRANSFORM.TRAIN_SPECKLE_NOISE_STD,
p=config.TRANSFORM.TRAIN_SPECKLE_NOISE_PROB
)
),
# random brightness
albu.Lambda(
image=functools.partial(
_random_brightness,
brightness_std=config.TRANSFORM.TRAIN_RANDOM_BRIGHTNESS_STD,
p=config.TRANSFORM.TRAIN_RANDOM_BRIGHTNESS_PROB
)
),
]
else:
augmentation = [
albu.PadIfNeeded(
min_width=config.TRANSFORM.TEST_SIZE[0],
min_height=config.TRANSFORM.TEST_SIZE[1],
always_apply=True,
border_mode=0
)
]
return albu.Compose(augmentation)
