def __init__(self, n, m):
self.n = n
self.m = m
m_ratio = self.m / 30.0
self.augment_list = (
A.CLAHE(always_apply=True),
A.Equalize(always_apply=True),
A.InvertImg(always_apply=True),
A.Rotate(limit=30 * m_ratio, always_apply=True),
A.Posterize(num_bits=int(4 * m_ratio), always_apply=True),
A.Solarize(threshold=m_ratio, always_apply=True),
A.RGBShift(r_shift_limit=110 * m_ratio,
g_shift_limit=110 * m_ratio,
b_shift_limit=110 * m_ratio,
always_apply=True),
A.HueSaturationValue(hue_shift_limit=20 * m_ratio,
sat_shift_limit=30 * m_ratio,
val_shift_limit=20 * m_ratio,
always_apply=True),
A.RandomContrast(limit=m_ratio, always_apply=True),
A.RandomBrightness(limit=m_ratio, always_apply=True),
# A.Sharpen(always_apply=True), 0.1, 1.9),
A.ShiftScaleRotate(shift_limit=0.3 * m_ratio,
shift_limit_y=0,
rotate_limit=0,
always_apply=True),
A.ShiftScaleRotate(shift_limit=0.3 * m_ratio,
shift_limit_x=0,
rotate_limit=0,
always_apply=True),
A.Cutout(num_holes=int(8 * m_ratio), always_apply=True),
A.IAAAffine(shear=0.3 * m_ratio, always_apply=True))
assert self.n <= len(self.augment_list)
def acase2_augs(name, **kwargs):
return [
A.Compose(
[A.Posterize(),
A.GridDistortion(num_steps=4),
A.Normalize()],
p=1.0),
A.Compose(
[A.Downscale(),
A.GridDistortion(num_steps=4),
A.Normalize()],
p=1.0),
]
def setup_augmentors(self, augmentations):
self.augmentors = []
for aug_name, aug_config in augmentations.items():
aug = None
def get_albu(aug):
return albu.Compose(aug)
if aug_name == 'image_compression':
aug = get_albu([
albu.ImageCompression(
quality_lower=aug_config.get('quality_lower', 90),
quality_upper=aug_config.get('quality_upper'),
p=aug_config.get('probabilty', 0.5))
])
elif aug_name == 'posterize':
aug = get_albu([
albu.Posterize(num_bits=aug_config.get('num_bits', 4),
p=aug_config.get('probability', 0.5))
])
elif aug_name == 'blur':
aug = get_albu([
albu.Blur(blur_limit=aug_config.get('blur_limit', 7),
p=aug_config.get('probabilty', 0.5))
])
elif aug_name == 'median_blur':
aug = get_albu([
albu.MedianBlur(blur_limit=aug_config.get('blur_limit', 7),
p=aug_config.get('probabilty', 0.5))
])
elif aug_name == 'iso_noise':
aug = get_albu([
albu.ISONoise(
color_shift=(aug_config.get('min_color_shift', 0.01),
aug_config.get('max_color_shift', 0.05)),
intensity=(aug_config.get('min_intensity', 0.1),
aug_config.get('min_intensity', 0.5)),
p=aug_config.get('probabilty', 0.5))
])
if not aug:
continue
aug.name, aug.p, aug.base = aug_name, aug_config[
'probability'], self
self.augmentors.append(aug)
return
def get_yolo_transform(img_size, mode='train'):
if mode == 'train':
scale = 1.1
transform = A.Compose([
A.LongestMaxSize(max_size=int(img_size * scale)),
A.PadIfNeeded(min_height=int(img_size * scale),
min_width=int(img_size * scale),
border_mode=cv2.BORDER_CONSTANT),
A.RandomCrop(width=img_size, height=img_size),
A.ColorJitter(
brightness=0.6, contrast=0.6, saturation=0.6, hue=0.6, p=0.4),
A.OneOf([
A.ShiftScaleRotate(
rotate_limit=10, border_mode=cv2.BORDER_CONSTANT, p=0.4),
A.IAAAffine(shear=10, mode='constant', p=0.4)
],
p=1.0),
A.HorizontalFlip(p=0.5),
A.Blur(p=0.1),
A.CLAHE(p=0.1),
A.Posterize(p=0.1),
A.ToGray(p=0.1),
A.ChannelShuffle(p=0.05),
A.Normalize(mean=[0, 0, 0], std=[1, 1, 1], max_pixel_value=255),
ToTensorV2()
],
bbox_params=A.BboxParams(format='yolo',
min_visibility=0.4,
label_fields=[]))
elif mode == 'test':
transform = A.Compose([
A.LongestMaxSize(max_size=img_size),
A.PadIfNeeded(min_height=img_size,
min_width=img_size,
border_mode=cv2.BORDER_CONSTANT),
A.Normalize(mean=[0, 0, 0], std=[1, 1, 1], max_pixel_value=255),
ToTensorV2(),
],
bbox_params=A.BboxParams(format="yolo",
min_visibility=0.4,
label_fields=[]))
else:
raise ValueError("'mode' can only accept 'train' or 'test'")
return transform
def __getitem__(self, index: int) -> Tuple[Any, Any]:
coco = self.coco
img_id = self.ids[index]
ann_ids = coco.getAnnIds(imgIds=img_id)
bboxes = coco.loadAnns(ann_ids)
path = coco.loadImgs(img_id)[0]['file_name']
# image = Image.open(os.path.join(self.root, path)).convert('RGB')
image = Image.open(os.path.join(self.root, path)).convert('RGB')
image = np.array(image)
IMAGE_SIZE = 416
import albumentations as A
from albumentations.pytorch import ToTensorV2
import cv2
transforms = A.Compose([
A.LongestMaxSize(max_size=int(IMAGE_SIZE)),
A.PadIfNeeded(min_height=int(IMAGE_SIZE),
min_width=int(IMAGE_SIZE),
border_mode=cv2.BORDER_CONSTANT),
A.RandomCrop(width=IMAGE_SIZE, height=IMAGE_SIZE),
A.ColorJitter(
brightness=0.6, contrast=0.6, saturation=0.6, hue=0.6, p=0.6),
A.ShiftScaleRotate(
rotate_limit=10, p=0.4, border_mode=cv2.BORDER_CONSTANT),
A.HorizontalFlip(p=0.5),
A.Blur(p=0.2),
A.CLAHE(p=0.2),
A.Posterize(p=0.2),
A.ToGray(p=0.1),
ToTensorV2()
],
bbox_params=A.BboxParams(format="coco",
min_visibility=0.4,
label_fields=[]))
argumentations = transforms(image=image, bboxes=[[12, 23, 43, 34]])
image = argumentations['image']
bboxes = argumentations['bboxes']
target = torch.tensor([0, 0, 0, 0])
return image, target
def __init__(self, k: int = 5, always_apply: bool = True, p: float = 1.0):
super(RandAugmentAlb, self).__init__(always_apply, p)
self.k = k
self.candidates = [
AutoContrast(p=1.0),
A.Equalize(p=1.0),
A.InvertImg(p=1.0),
Rotate(30., p=1.0),
A.Posterize([4, 8], p=1.0),
A.Solarize([0, 256], p=1.0),
A.RandomBrightnessContrast(brightness_limit=0.,
contrast_limit=(0.05, 0.95),
p=1.0),
A.RandomBrightnessContrast(brightness_limit=(0.05, 0.95),
contrast_limit=0.,
p=1.0),
ShearX(0.3),
ShearY(0.3),
Translate(0.45),
]
def __init__(
self,
transforms=None,
mean=(0, 0, 0),
std=(1, 1, 1),
width=3,
depth=-1,
alpha=1.,
p=1.,
):
self.transforms = transforms
self.mean = mean
self.std = std
self.width = width
self.depth = depth
self.alpha = alpha
self.p = p
if self.transforms is None:
self.transforms = [
AutoContrast(cutoff=0, p=1),
albu.Equalize(mode='pil', p=1),
albu.Posterize(num_bits=(3, 4), p=1),
albu.ShiftScaleRotate(shift_limit=0, scale_limit=0, rotate_limit=5, border_mode=cv2.BORDER_CONSTANT, value=(0, 0, 0), p=1), # rotate
albu.Solarize(threshold=77, p=1),
RandomShear(shear_x=0.09, shear_y=0, border_mode=cv2.BORDER_CONSTANT, value=(0, 0, 0), p=1),
RandomShear(shear_x=0, shear_y=0.09, border_mode=cv2.BORDER_CONSTANT, value=(0, 0, 0), p=1),
VerticalShift(shift_limit=0.09, border_mode=cv2.BORDER_CONSTANT, value=(0, 0, 0), p=1),
HorizontalShift(shift_limit=0.09, border_mode=cv2.BORDER_CONSTANT, value=(0, 0, 0), p=1),
# ImageNet-C
albu.HueSaturationValue(hue_shift_limit=0, sat_shift_limit=(-36, 0), val_shift_limit=0, p=1), # saturation
albu.RandomContrast(limit=(-0.36, 0), p=1),
albu.RandomBrightness(limit=(-0.36, 0), p=1),
albu.OneOf([ # sharpness
albu.IAASharpen(alpha=(0.1, 0.5), lightness=0, p=1),
albu.Blur(blur_limit=7, p=1),
], p=0.5),
]
hue_shift_limit=5, sat_shift_limit=5, val_shift_limit=5, p=1),
A.RandomBrightnessContrast(p=1),
],
p=0.5),
A.JpegCompression(p=0.2),
A.OneOf([
A.MedianBlur(p=1),
A.Blur(p=1),
], p=0.3)
],
p=1)
composition = A.Compose([
A.OneOf([
A.JpegCompression(p=1),
A.MedianBlur(p=1),
A.Blur(p=1),
], p=0.8)
],
p=1)
composition = A.Compose([
A.Posterize(p=0.5, num_bits=4),
], p=1)
imglist = []
for i in range(4):
transformed = composition(image=img, mask=mask[:, :, 0:3])
imglist += [transformed['image'], transformed['mask']]
plot_img(tuple(imglist), nrow=2)
SAVE_MODEL = True
LOAD_MODEL = True
# Data augmentation for images
train_transforms = A.Compose(
[
A.Resize(width=96, height=96),
A.Rotate(limit=15, border_mode=cv2.BORDER_CONSTANT, p=0.8),
A.IAAAffine(shear=15, scale=1.0, mode="constant", p=0.2),
A.RandomBrightnessContrast(contrast_limit=0.5, brightness_limit=0.5, p=0.2),
A.OneOf([
A.GaussNoise(p=0.8),
A.CLAHE(p=0.8),
A.ImageCompression(p=0.8),
A.RandomGamma(p=0.8),
A.Posterize(p=0.8),
A.Blur(p=0.8),
], p=1.0),
A.OneOf([
A.GaussNoise(p=0.8),
A.CLAHE(p=0.8),
A.ImageCompression(p=0.8),
A.RandomGamma(p=0.8),
A.Posterize(p=0.8),
A.Blur(p=0.8),
], p=1.0),
A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=0, p=0.2, border_mode=cv2.BORDER_CONSTANT),
A.Normalize(
mean=[0.4897, 0.4897, 0.4897],
std=[0.2330, 0.2330, 0.2330],
max_pixel_value=255.0,
def posterize(m, minval=0, maxval=8):
level = int(M2Level(m, minval, maxval))
return albu.Posterize(
num_bits=(level, level),
p=1)
albumentations.RandomCrop(width=IMAGE_SIZE, height=IMAGE_SIZE),
albumentations.ColorJitter(brightness=0.6, contrast=0.6, saturation=0.6, hue=0.6, p=0.4),
albumentations.OneOf(
[
albumentations.ShiftScaleRotate(
rotate_limit=20, p=0.5, border_mode=cv2.BORDER_CONSTANT
),
albumentations.IAAAffine(shear=15, p=0.5, mode="constant"),
],
p=1.0,
),
albumentations.HorizontalFlip(p=0.5),
albumentations.Blur(p=0.1),
albumentations.Posterize(p=0.1),
albumentations.CLAHE(p=0.1),
albumentations.ToGray(p=0.1),
albumentations.ChannelShuffle(p=0.05),
albumentations.Normalize(mean=[0, 0, 0], std=[1, 1, 1], max_pixel_value=255,),
ToTensorV2(),
],
bbox_params=albumentations.BboxParams(format="yolo", min_visibility=0.4, label_fields=[],),
)
test_transforms = albumentations.Compose(
[
albumentations.LongestMaxSize(max_size=IMAGE_SIZE),
albumentations.PadIfNeeded(
min_height=IMAGE_SIZE, min_width=IMAGE_SIZE, border_mode=cv2.BORDER_CONSTANT
),
albumentations.Normalize(mean=[0, 0, 0], std=[1, 1, 1], max_pixel_value=255,),
def get_images(self, imgpath):
# Pick random clone, crypt or fufi
u01 = np.random.uniform()
if u01 < self.cpfr_frac[0]:
img, mask = self.all_svs_opened[imgpath].fetch_clone(
prop_displ=0.45)
elif u01 < np.sum(self.cpfr_frac[0:2]):
img, mask = self.all_svs_opened[imgpath].fetch_partial(
prop_displ=0.45)
elif u01 < np.sum(self.cpfr_frac[0:3]):
img, mask = self.all_svs_opened[imgpath].fetch_fufi(
prop_displ=0.45)
else:
img, mask = self.all_svs_opened[imgpath].fetch_rndmtile()
if self.dilate_masks == True:
n_dil = int(5 / self.um_per_pixel) # if mpp is one or less than 1
# dilate if desired
for i in range(mask.shape[2]):
mask[:, :, i] = cv2.morphologyEx(mask[:, :, i].copy(),
cv2.MORPH_DILATE,
st_3,
iterations=n_dil)
if self.aug == True:
composition = A.Compose([
A.HorizontalFlip(),
A.VerticalFlip(),
A.Rotate(border_mode=cv2.BORDER_CONSTANT),
A.OneOf([
A.ElasticTransform(alpha=1000,
sigma=30,
alpha_affine=30,
border_mode=cv2.BORDER_CONSTANT,
p=1),
A.GridDistortion(border_mode=cv2.BORDER_CONSTANT, p=1),
],
p=0.5),
A.CLAHE(p=0.2),
A.HueSaturationValue(hue_shift_limit=12,
sat_shift_limit=12,
val_shift_limit=12,
p=0.3),
A.RandomBrightnessContrast(p=0.3),
A.Posterize(p=0.1, num_bits=4),
A.OneOf([
A.JpegCompression(p=1),
A.MedianBlur(p=1),
A.Blur(p=1),
A.GlassBlur(p=1, max_delta=2, sigma=0.4),
A.IAASharpen(p=1)
],
p=0.3)
],
p=1)
transformed = composition(image=img, mask=mask)
img, mask = transformed['image'], transformed['mask']
mask_list = [mask[:, :, ii] for ii in range(mask.shape[2])]
if self.stride_bool:
mask_list = [cv2.pyrDown(mask_ii.copy()) for mask_ii in mask_list]
mask_list = [
cv2.threshold(mask_ii, 120, 255, cv2.THRESH_BINARY)[1]
for mask_ii in mask_list
]
## convert to floating point space, normalize and mask non-used clones
img = img.astype(np.float32) / 255
mask_list = [mask_ii.astype(np.float32) / 255 for mask_ii in mask_list]
if self.normalize:
img = (img - self.norm_mean) / self.norm_std
return img, np.stack(mask_list, axis=2)
def get_train_transforms_atopy(input_size,
use_crop=False,
use_no_color_aug=False):
if use_crop:
resize = [
al.Resize(int(input_size * 1.2), int(input_size * 1.2)),
al.RandomSizedCrop(min_max_height=(int(input_size * 0.6),
int(input_size * 1.2)),
height=input_size,
width=input_size)
]
else:
resize = [al.Resize(input_size, input_size)]
return al.Compose(resize + [
al.Flip(p=0.5),
al.OneOf([
al.RandomRotate90(),
al.Rotate(limit=180),
], p=0.5),
al.OneOf([
al.ShiftScaleRotate(),
al.OpticalDistortion(),
al.GridDistortion(),
al.ElasticTransform(),
],
p=0.3),
al.RandomGridShuffle(p=0.05),
al.OneOf([
al.RandomGamma(),
al.HueSaturationValue(),
al.RGBShift(),
al.CLAHE(),
al.ChannelShuffle(),
al.InvertImg(),
],
p=0.1),
al.RandomSnow(p=0.05),
al.RandomRain(p=0.05),
al.RandomFog(p=0.05),
al.RandomSunFlare(p=0.05),
al.RandomShadow(p=0.05),
al.RandomBrightnessContrast(p=0.05),
al.GaussNoise(p=0.2),
al.ISONoise(p=0.2),
al.MultiplicativeNoise(p=0.2),
al.ToGray(p=0.05),
al.ToSepia(p=0.05),
al.Solarize(p=0.05),
al.Equalize(p=0.05),
al.Posterize(p=0.05),
al.FancyPCA(p=0.05),
al.OneOf([
al.MotionBlur(blur_limit=3),
al.Blur(blur_limit=3),
al.MedianBlur(blur_limit=3),
al.GaussianBlur(blur_limit=3),
],
p=0.05),
al.CoarseDropout(p=0.05),
al.Cutout(p=0.05),
al.GridDropout(p=0.05),
al.ChannelDropout(p=0.05),
al.Downscale(p=0.1),
al.ImageCompression(quality_lower=60, p=0.2),
al.Normalize(),
ToTensorV2()
])
def get_train_transforms_mmdetection(input_size,
use_crop=False,
use_no_color_aug=False,
use_center_crop=False,
center_crop_ratio=0.9,
use_gray=False):
if isinstance(input_size, int):
input_size = (input_size[0], input_size[1])
return al.Compose([
al.RandomResizedCrop(height=input_size[0],
width=input_size[1],
scale=(0.4, 1.0),
interpolation=0,
p=0.5),
al.Resize(input_size[0], input_size[1], p=1.0),
al.HorizontalFlip(p=0.5),
al.OneOf([
al.ShiftScaleRotate(border_mode=0,
shift_limit=(-0.2, 0.2),
scale_limit=(-0.2, 0.2),
rotate_limit=(-20, 20)),
al.OpticalDistortion(border_mode=0,
distort_limit=[-0.5, 0.5],
shift_limit=[-0.5, 0.5]),
al.GridDistortion(
num_steps=5, distort_limit=[-0., 0.3], border_mode=0),
al.ElasticTransform(border_mode=0),
al.IAAPerspective(),
al.RandomGridShuffle()
],
p=0.1),
al.Rotate(limit=(-25, 25), border_mode=0, p=0.1),
al.OneOf([
al.RandomBrightnessContrast(brightness_limit=(-0.2, 0.2),
contrast_limit=(-0.2, 0.2)),
al.HueSaturationValue(hue_shift_limit=(-20, 20),
sat_shift_limit=(-30, 30),
val_shift_limit=(-20, 20)),
al.RandomGamma(gamma_limit=(30, 150)),
al.RGBShift(),
al.CLAHE(clip_limit=(1, 15)),
al.ChannelShuffle(),
al.InvertImg(),
],
p=0.1),
al.RandomSnow(p=0.05),
al.RandomRain(p=0.05),
al.RandomFog(p=0.05),
al.RandomSunFlare(num_flare_circles_lower=1,
num_flare_circles_upper=2,
src_radius=110,
p=0.05),
al.RandomShadow(p=0.05),
al.GaussNoise(var_limit=(10, 20), p=0.05),
al.ISONoise(color_shift=(0, 15), p=0.05),
al.MultiplicativeNoise(p=0.05),
al.OneOf([
al.ToGray(p=1. if use_gray else 0.05),
al.ToSepia(p=0.05),
al.Solarize(p=0.05),
al.Equalize(p=0.05),
al.Posterize(p=0.05),
al.FancyPCA(p=0.05),
],
p=0.05),
al.OneOf([
al.MotionBlur(blur_limit=(3, 7)),
al.Blur(blur_limit=(3, 7)),
al.MedianBlur(blur_limit=3),
al.GaussianBlur(blur_limit=3),
],
p=0.05),
al.CoarseDropout(p=0.05),
al.Cutout(num_holes=30,
max_h_size=37,
max_w_size=37,
fill_value=0,
p=0.05),
al.GridDropout(p=0.05),
al.ChannelDropout(p=0.05),
al.Downscale(scale_min=0.5, scale_max=0.9, p=0.1),
al.ImageCompression(quality_lower=60, p=0.2),
al.Normalize(),
ToTensorV2()
])
def get_transform_imagenet(use_albu_aug):
if use_albu_aug:
train_transform = al.Compose([
# al.Flip(p=0.5),
al.Resize(256, 256, interpolation=2),
al.RandomResizedCrop(224,
224,
scale=(0.08, 1.0),
ratio=(3. / 4., 4. / 3.),
interpolation=2),
al.HorizontalFlip(),
al.OneOf(
[
al.OneOf(
[
al.ShiftScaleRotate(
border_mode=cv2.BORDER_CONSTANT,
rotate_limit=30), # , p=0.05),
al.OpticalDistortion(
border_mode=cv2.BORDER_CONSTANT,
distort_limit=5.0,
shift_limit=0.1),
# , p=0.05),
al.GridDistortion(border_mode=cv2.BORDER_CONSTANT
), # , p=0.05),
al.ElasticTransform(
border_mode=cv2.BORDER_CONSTANT,
alpha_affine=15), # , p=0.05),
],
p=0.1),
al.OneOf(
[
al.RandomGamma(), # p=0.05),
al.HueSaturationValue(), # p=0.05),
al.RGBShift(), # p=0.05),
al.CLAHE(), # p=0.05),
al.ChannelShuffle(), # p=0.05),
al.InvertImg(), # p=0.05),
],
p=0.1),
al.OneOf(
[
al.RandomSnow(), # p=0.05),
al.RandomRain(), # p=0.05),
al.RandomFog(), # p=0.05),
al.RandomSunFlare(num_flare_circles_lower=1,
num_flare_circles_upper=2,
src_radius=110),
# p=0.05, ),
al.RandomShadow(), # p=0.05),
],
p=0.1),
al.RandomBrightnessContrast(p=0.1),
al.OneOf(
[
al.GaussNoise(), # p=0.05),
al.ISONoise(), # p=0.05),
al.MultiplicativeNoise(), # p=0.05),
],
p=0.1),
al.OneOf(
[
al.ToGray(), # p=0.05),
al.ToSepia(), # p=0.05),
al.Solarize(), # p=0.05),
al.Equalize(), # p=0.05),
al.Posterize(), # p=0.05),
al.FancyPCA(), # p=0.05),
],
p=0.1),
al.OneOf(
[
# al.MotionBlur(blur_limit=1),
al.Blur(blur_limit=[3, 5]),
al.MedianBlur(blur_limit=[3, 5]),
al.GaussianBlur(blur_limit=[3, 5]),
],
p=0.1),
al.OneOf(
[
al.CoarseDropout(), # p=0.05),
al.Cutout(), # p=0.05),
al.GridDropout(), # p=0.05),
al.ChannelDropout(), # p=0.05),
al.RandomGridShuffle(), # p=0.05),
],
p=0.1),
al.OneOf(
[
al.Downscale(), # p=0.1),
al.ImageCompression(quality_lower=60), # , p=0.1),
],
p=0.1),
],
p=0.5),
al.Normalize(),
ToTensorV2()
])
else:
train_transform = transforms.Compose([
transforms.Resize(256),
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
])
test_transform = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
])
if use_albu_aug:
train_transform = MultiDataTransformAlbu(train_transform)
else:
train_transform = MultiDataTransform(train_transform)
return train_transform, test_transform
),
A.RandomCrop(width=IMAGE_SIZE, height=IMAGE_SIZE),
A.ColorJitter(
brightness=0.6, contrast=0.6, saturation=0.6, hue=0.6, p=0.4),
A.OneOf(
[
A.ShiftScaleRotate(
rotate_limit=10, p=0.4, border_mode=cv2.BORDER_CONSTANT),
A.IAAAffine(shear=10, p=0.4, mode="constant"),
],
p=1.0,
),
A.HorizontalFlip(p=0.5),
A.Blur(p=0.1),
A.CLAHE(p=0.1),
A.Posterize(p=0.1),
A.ToGray(p=0.1),
A.ChannelShuffle(p=0.05),
A.Normalize(
mean=[0, 0, 0],
std=[1, 1, 1],
max_pixel_value=255,
),
ToTensorV2(),
],
bbox_params=A.BboxParams(
format="yolo",
min_visibility=0.4,
label_fields=[],
),
)
"""
min_transforms = A.Compose([
A.LongestMaxSize(max_size=int(IMAGE_SIZE)),
A.PadIfNeeded(min_height=int(IMAGE_SIZE),
min_width=int(IMAGE_SIZE),
border_mode=cv2.BORDER_CONSTANT),
A.RandomCrop(width=IMAGE_SIZE, height=IMAGE_SIZE),
A.ColorJitter(brightness=0.6, contrast=0.6, saturation=0.6, hue=0.6,
p=0.6),
A.ShiftScaleRotate(rotate_limit=10, p=0.4,
border_mode=cv2.BORDER_CONSTANT),
A.HorizontalFlip(p=0.5),
A.Blur(p=0.2),
A.CLAHE(p=0.2),
A.Posterize(p=0.2),
A.ToGray(p=0.1),
ToTensorV2()
],
bbox_params=A.BboxParams(format="yolo",
min_visibility=0.4,
label_fields=[]))
max_transforms = A.Compose([
A.LongestMaxSize(max_size=int(IMAGE_SIZE)),
A.PadIfNeeded(min_height=int(IMAGE_SIZE),
min_width=int(IMAGE_SIZE),
border_mode=cv2.BORDER_CONSTANT),
ToTensorV2()
],
bbox_params=A.BboxParams(format="yolo",
