def get_transform(train: bool, im_size: int = 400):
if train:
transforms = A.Compose([
A.Resize(
height=im_size, width=im_size, interpolation=cv2.INTER_CUBIC),
A.ChannelShuffle(p=0.5),
A.HorizontalFlip(p=0.5),
A.ColorJitter(p=0.5),
A.VerticalFlip(p=0.5),
A.Blur(p=0.5),
A.Normalize(),
ToTensorV2(),
],
bbox_params=A.BboxParams(
format='pascal_voc',
label_fields=['category_ids']))
else:
transforms = A.Compose([
A.Resize(
height=im_size, width=im_size, interpolation=cv2.INTER_CUBIC),
A.Normalize(),
ToTensorV2(),
],
bbox_params=A.BboxParams(
format='pascal_voc',
label_fields=['category_ids']))
return transforms
def cifar_alb_trainData():
'''Apply Albumentations data transforms to the dataset and returns iterable'''
train_transform = [
A.HorizontalFlip(p=0.15),
A.ShiftScaleRotate(shift_limit=0.05,
scale_limit=0.05,
rotate_limit=15,
p=0.25),
A.RGBShift(r_shift_limit=15, g_shift_limit=15, b_shift_limit=15,
p=0.5),
A.RandomBrightnessContrast(p=0.25),
A.RandomGamma(p=0.25),
A.CLAHE(p=0.25),
A.ChannelShuffle(p=0.1),
A.ElasticTransform(p=0.1),
A.MotionBlur(blur_limit=17, p=0.1),
A.Cutout(num_holes=1,
max_h_size=16,
max_w_size=16,
fill_value=mean,
always_apply=False,
p=0.5),
A.Normalize(mean=mean, std=std),
ToTensor()
]
transforms_result = A.Compose(train_transform)
return lambda img: transforms_result(image=np.array(img))["image"]
def album(self): #이미지 변환
transform = A.Compose([
#A.RandomRotate90(),
A.Flip(p=0.2),
#A.Transpose(),
A.ChannelShuffle(p=0.3),
A.ElasticTransform(p=0.3,border_mode=cv2.BORDER_REFLECT_101,alpha_affine=40),
A.OneOf([
A.IAAAdditiveGaussianNoise(),
A.GaussNoise(),
], p=0.2),
A.OneOf([
A.MotionBlur(p=.2),
A.MedianBlur(blur_limit=3, p=0.1),
A.Blur(blur_limit=3, p=0.1),
], p=0.2),
A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2),
A.OneOf([
A.OpticalDistortion(p=0.3),
A.GridDistortion(p=.1),
A.IAAPiecewiseAffine(p=0.3),
], p=0.2),
A.OneOf([
A.CLAHE(clip_limit=2),
A.IAASharpen(),
A.IAAEmboss(),
A.RandomBrightnessContrast(),
], p=0.3),
A.HueSaturationValue(p=0.3),
])
image = cv2.cvtColor(self.srcResize, cv2.COLOR_BGR2RGB)
transformed = transform(image=image)['image']
self.update(transformed)
def get_transform(is_train):
if is_train:
return albumentations.Compose(
[
albumentations.Resize(224,224),
albumentations.OneOf([
albumentations.JpegCompression(quality_lower=20, quality_upper=70, p=0.5),
albumentations.Downscale(scale_min=0.25, scale_max=0.50, interpolation=1, p=0.5),
], p=0.6),
albumentations.HorizontalFlip(p=0.5),
albumentations.VerticalFlip(p=0.5),
# albumentations.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=45),
albumentations.GaussNoise(p=0.2),
albumentations.RandomBrightnessContrast(0.3,0.3, p=0.7),
albumentations.RandomGamma(p=0.2),
albumentations.CLAHE(p=0.2),
albumentations.ChannelShuffle(p=0.2),
albumentations.MultiplicativeNoise(multiplier=[0.5, 1.5], elementwise=True, p=0.3),
albumentations.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=10, val_shift_limit=10, p=0.7),
albumentations.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0)
])
else:
return albumentations.Compose(
[
albumentations.Resize(224,224),
albumentations.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0)
])
def get_transform(train: bool, im_size: int = 400):
if train:
aug = A.Compose([
A.OneOf([
A.RandomSizedCrop(min_max_height=(224, 720),
height=im_size,
width=im_size,
p=0.5),
A.Resize(height=im_size,
width=im_size,
interpolation=cv2.INTER_CUBIC,
p=0.5)
],
p=1),
A.ChannelShuffle(p=0.5),
A.HorizontalFlip(p=0.5),
A.ColorJitter(p=0.5),
A.Blur(p=0.5),
A.Normalize(),
ToTensorV2(),
])
else:
aug = A.Compose([
A.Resize(height=im_size,
width=im_size,
interpolation=cv2.INTER_CUBIC),
A.Normalize(),
ToTensorV2(),
])
return aug
def get_train_transforms():
return A.Compose([
A.RandomSizedCrop((140, 140), width=160, height=160, p=0.25),
A.OneOf([
A.HueSaturationValue(hue_shift_limit=0.2,
sat_shift_limit=0.2,
val_shift_limit=0.2,
p=0.9),
A.RandomBrightnessContrast(
brightness_limit=0.2, contrast_limit=0.2, p=0.9),
],
p=0.9),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.Rotate(limit=45, p=1),
A.ChannelShuffle(p=0.05),
A.FancyPCA(),
A.GaussNoise(p=0.25),
A.Blur(blur_limit=4, p=0.1),
A.Cutout(num_holes=8, max_h_size=4, max_w_size=4, fill_value=0, p=0.1),
A.Resize(
160,
160,
),
A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
ToTensorV2(p=1.0),
],
p=1.0)
def augmentations(image_size: int):
channel_augs = [
A.HueSaturationValue(p=0.5),
A.ChannelShuffle(p=0.5),
]
result = [
# *pre_transform(image_size),
A.OneOf([
A.IAAAdditiveGaussianNoise(),
A.GaussNoise(),
], p=0.5),
A.OneOf([
A.MotionBlur(blur_limit=3, p=0.7),
A.MedianBlur(blur_limit=3, p=1.0),
A.Blur(blur_limit=3, p=0.7),
],
p=0.5),
A.OneOf(channel_augs),
A.OneOf([
A.CLAHE(clip_limit=2),
A.IAASharpen(),
A.IAAEmboss(),
],
p=0.5),
A.RandomBrightnessContrast(brightness_limit=0.5,
contrast_limit=0.5,
p=0.5),
A.RandomGamma(p=0.5),
A.OneOf([A.MedianBlur(p=0.5), A.MotionBlur(p=0.5)]),
A.RandomGamma(gamma_limit=(85, 115), p=0.5),
]
return A.Compose(result, bbox_params=BBOX_PARAMS)
def __init__(self, input_shape, train):
self.transform = None
try:
import albumentations as A
check_version(A.__version__, '1.0.3',
hard=True) # version requirement
if train:
# lane mark used
self.transform = A.Compose([
A.Resize(height=input_shape[0],
width=input_shape[0],
interpolation=cv2.INTER_AREA),
A.RandomRotate90(p=0.5),
A.VerticalFlip(p=0.5),
A.HorizontalFlip(p=0.5),
A.ChannelShuffle(p=0.5),
A.OpticalDistortion(p=0.5),
A.GridDistortion(p=0.5),
A.HueSaturationValue(p=0.5),
A.RandomBrightnessContrast(0.5),
A.Transpose(p=0.5)
])
else:
self.transform = A.Compose(
[A.Resize(input_shape[0], input_shape[1])], )
except ImportError: # package not installed, skip
pass
def rgd_shuffle_mo_blur(p=1.0):
return albumentations.Compose([
albumentations.ChannelShuffle(p=p),
albumentations.MotionBlur(p=p),
albumentations.RandomBrightness(p=1)
],
p=p)
def get_next_augmentation():
train_transform = [
albu.ChannelShuffle(p=0.1),
albu.IAAAdditiveGaussianNoise(p=0.2),
albu.OneOf(
[
albu.CLAHE(p=1),
albu.RandomBrightness(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 __init__(self, used_img_size, final_img_size, transform_params):
self._ratio = max(
float(final_img_size[0]) / used_img_size[0],
float(final_img_size[1]) / used_img_size[1])
self._final_img_size = final_img_size
self._scale_compose = [
albumentations.Resize(height=int(used_img_size[0] * self._ratio),
width=int(used_img_size[1] * self._ratio),
always_apply=True),
albumentations.CenterCrop(height=self._final_img_size[0],
width=self._final_img_size[1],
always_apply=True,
p=1),
]
self._normalize_transform = albumentations.Normalize()
self._normalize_no_transform = albumentations.Normalize(mean=(0, 0, 0),
std=(1, 1, 1))
self._train_compose = self._scale_compose
if transform_params["filters"]:
self._train_compose = [
albumentations.RandomBrightnessContrast(
brightness_limit=(-0.1, 0.1),
contrast_limit=(-0.1, 0.1),
p=0.2),
albumentations.RandomGamma(gamma_limit=(90, 110), p=0.2),
albumentations.ChannelShuffle(p=0.2),
] + self._scale_compose
if transform_params["normalize"]:
self._train_compose.append(albumentations.Normalize())
else:
self._train_compose.append(
albumentations.Normalize(mean=(0, 0, 0), std=(1, 1, 1)))
def albumentation():
transform = albumentations.Compose([
albumentations.OneOf([
albumentations.GaussNoise(),
albumentations.IAAAdditiveGaussianNoise()
]),
albumentations.OneOf([
albumentations.MotionBlur(blur_limit=3, p=0.2),
albumentations.MedianBlur(blur_limit=3, p=0.1),
albumentations.Blur(blur_limit=2, p=0.1)
]),
albumentations.OneOf([
albumentations.RandomBrightness(limit=(0.1, 0.4)),
albumentations.HueSaturationValue(hue_shift_limit=(0, 128), sat_shift_limit=(0, 60), val_shift_limit=(0, 20)),
albumentations.RGBShift(r_shift_limit=30, g_shift_limit=30, b_shift_limit=30)
]),
albumentations.OneOf([
albumentations.CLAHE(),
albumentations.ChannelShuffle(),
albumentations.IAASharpen(),
albumentations.IAAEmboss(),
albumentations.RandomBrightnessContrast(),
]),
albumentations.OneOf([
albumentations.RandomGamma(gamma_limit=(35,255)),
albumentations.OpticalDistortion(),
albumentations.GridDistortion(),
albumentations.IAAPiecewiseAffine()
]),
A_torch.ToTensor(normalize={
"mean": [0.485, 0.456, 0.406],
"std" : [0.229, 0.224, 0.225]})
])
return transform
def get_transform(train: bool, im_size: int = 400):
if train:
aug = A.Compose([
A.OneOf([
A.RandomSizedCrop(min_max_height=(224, 720),
height=im_size,
width=im_size,
p=0.5),
A.Resize(height=im_size,
width=im_size,
interpolation=cv2.INTER_CUBIC,
p=0.5)
],
p=1),
A.ChannelShuffle(p=0.5),
A.HorizontalFlip(p=0.5),
A.ColorJitter(p=0.5),
# A.OneOf([
# A.ElasticTransform(alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03, p=0.5),
# A.GridDistortion(p=0.5),
# A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1)
# ], p=0.8),
A.Blur(p=0.5),
A.Normalize(),
ToTensorV2(),
])
else:
aug = A.Compose([
A.Resize(height=im_size,
width=im_size,
interpolation=cv2.INTER_CUBIC),
A.Normalize(),
ToTensorV2(),
])
return aug
def get_training_augmentation(min_area=0., min_visibility=0.):
train_transform = [
albu.OneOf([
albu.ISONoise(p=.5),
albu.GaussNoise(p=0.4),
albu.Blur(blur_limit=3, p=0.1),
]),
albu.OneOf([
albu.CLAHE(clip_limit=2),
], p=0.2),
albu.OneOf([
albu.RandomSnow(snow_point_lower=0.,
snow_point_upper=0.2,
brightness_coeff=2.,
p=0.5),
albu.RandomSunFlare(p=0.5),
]),
albu.OneOf([
albu.RGBShift(p=0.1),
albu.ChannelShuffle(p=0.2),
])
]
return albu.Compose(train_transform,
bbox_params={
'format': 'coco',
'min_area': min_area,
'min_visibility': min_visibility,
'label_fields': ['category_id']
})
def get_train_transform():
transforms = []
if args.hflip:
transforms.append(A.VerticalFlip(p=args.hflip))
if args.vflip:
transforms.append(A.HorizontalFlip(p=args.vflip))
if args.sharpen:
transforms.append(A.IAASharpen(p=args.sharpen))
if args.ssr:
transforms.append(A.ShiftScaleRotate(p=args.ssr))
if args.channelshuffle:
transforms.append(A.ChannelShuffle(p=args.channelshuffle))
# if args.clahe:
# transforms.append(A.CLAHE(p=args.clahe))
if args.oneofcgb:
transforms.append(
A.OneOf([
A.RandomContrast(),
A.RandomGamma(),
A.RandomBrightness(),
],
p=args.oneofcgb))
transforms.append(A.Resize(256, 256))
transforms.append(A.Normalize())
transforms.append(ToTensorV2(p=1))
return A.Compose(transforms)
def tr_normalization(self, img):
norm = A.Compose([
A.RGBShift(p=0.6),
A.ChannelShuffle(p=0.6),
A.RandomBrightnessContrast(p=0.6),
A.Normalize(mean=self.mean, std=self.std, p=1)
])
return norm(image=img)['image']
def test_channel_shuffle():
aug = A.Compose(
[A.ChannelShuffle(always_apply=True)], additional_targets={'image2': 'image'})
for i in range(10):
image1 = np.random.randint(low=0, high=256, size=(100, 100, 3), dtype=np.uint8)
image2 = image1.copy()
res = aug(image=image1, image2=image2)
aug1 = res['image']
aug2 = res['image2']
assert np.array_equal(aug1, aug2)
def __init__(
self,
dataset,
flip_probs=(0.1, 0.1, 0.2),
jitter_prob=0,
random_crop=True,
random_rescale_prob=0,
rescale_distr=(.8, 1.2),
crop_size=(128, 128),
# channels_first=True,
normalize=True,
hard_alternative_ds=None,
hard_prob=0):
if isinstance(flip_probs, float) or isinstance(flip_probs, int):
flip_probs = tuple(np.ones(3) * flip_probs)
self.flip_probs = flip_probs
self.jitter_prob = jitter_prob
self.random_crop = random_crop
self.crop_size = crop_size
self.dataset = dataset
# self.channels_first = channels_first
self.normalize = normalize
self.rescale_distr = rescale_distr
self.random_rescale_prob = random_rescale_prob
self.hard_alternative_ds = hard_alternative_ds
self.hard_prob = hard_prob
if hasattr(self.dataset, 'quadratic'):
self.quadratic = dataset.quadratic
else:
self.quadratic = dataset.dataset.quadratic
if self.quadratic:
additional_targets = {
'imager': 'image',
'y': 'image',
'imagell': 'image',
'imagerr': 'image'
}
else:
additional_targets = {'imager': 'image', 'y': 'image'}
self.jitter = A.Compose([
A.CLAHE(p=0.5),
A.RandomBrightnessContrast(p=.5),
A.HueSaturationValue(hue_shift_limit=40,
sat_shift_limit=50,
val_shift_limit=50,
p=1),
A.ChannelShuffle(p=.5)
],
p=1,
additional_targets=additional_targets)
def __init__(self,
used_img_size,
final_img_size,
transform_params,
custom_additional_targets=None):
if custom_additional_targets is None:
custom_additional_targets = {
"image2": "image",
"image3": "image",
"image4": "image"
}
self._custom_additional_targets = custom_additional_targets
self._ratio = max(
float(final_img_size[0]) / used_img_size[0],
float(final_img_size[1]) / used_img_size[1])
self._final_img_size = final_img_size
self._scale_compose = [
albumentations.Resize(height=int(used_img_size[0] * self._ratio),
width=int(used_img_size[1] * self._ratio),
always_apply=True),
albumentations.CenterCrop(height=self._final_img_size[0],
width=self._final_img_size[1],
always_apply=True,
p=1)
]
self._normalize_transform = albumentations.Normalize()
self._normalize_no_transform = albumentations.Normalize(mean=(0, 0, 0),
std=(1, 1, 1))
self._train_compose = self._scale_compose
if "flip" in transform_params and transform_params["flip"]:
flip_compose = [albumentations.HorizontalFlip()]
self._train_compose = flip_compose + self._train_compose
if "filters" in transform_params and transform_params["filters"]:
random_compose = [
albumentations.RandomBrightnessContrast(brightness_limit=(-0.2,
0.2),
contrast_limit=(-0.2,
0.2),
p=0.5),
albumentations.RandomGamma(gamma_limit=(90, 110), p=0.5),
albumentations.ChannelShuffle(p=0.5),
]
self._train_compose = random_compose + self._train_compose
if "normalize" in transform_params and transform_params["normalize"]:
self._train_compose.append(albumentations.Normalize())
else:
self._train_compose.append(
albumentations.Normalize(mean=(0, 0, 0), std=(1, 1, 1)))
def train_augs(self):
augs = []
if self.image_size is not None:
augs.append(A.Resize(self.image_size, self.image_size))
if self.normalize:
# imagenet normalization
augs.append(
A.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
max_pixel_value=255.0,
p=1.0,
)
)
if self.apply_augs:
img_augs = [
A.HorizontalFlip(p=0.5),
A.ChannelShuffle(p=0.1),
A.OneOf(
[
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.2, contrast_limit=0.2, p=0.5
),
],
p=0.5,
),
A.ToGray(p=0.01),
A.RandomGamma(p=0.1),
A.Sharpen(p=0.1),
A.Cutout(
num_holes=8, max_h_size=64, max_w_size=64, fill_value=0, p=0.2
),
]
augs = augs + img_augs
if self.bbox_format is not None:
return A.Compose(
augs,
bbox_params=A.BboxParams(
format=self.bbox_format,
min_area=0,
min_visibility=0,
label_fields=["labels"],
),
)
return A.Compose(augs)
def augment_image_by_image(path_to_image,
path_to_destiny='Dataset/augmented_logo',
path_to_logo='Dataset/main_logo.png',
logo=True,
amount=1):
random.seed()
if logo:
input1 = cv2.imread(path_to_logo, cv2.IMREAD_UNCHANGED)
input2 = cv2.imread(path_to_image)
for _ in range(amount):
image = input2
if logo:
logo = input1
blue, green, red = random.randint(0, 255), random.randint(
0, 255), random.randint(0, 255)
logo[np.where((logo == [0, 0, 0,
255]).all(axis=2))] = blue, green, red, 255
h_bg, w_bg = image.shape[:2]
final_size_logo = random.randrange(100, min(h_bg, w_bg))
h_offset, w_offset = random.randrange(0, h_bg - final_size_logo), \
random.randrange(0, w_bg - final_size_logo)
image = overlay_transparent(image, logo, w_offset, h_offset,
(final_size_logo, final_size_logo))
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
augment = A.Compose([
A.ShiftScaleRotate(
p=1, shift_limit=0.02, rotate_limit=35, scale_limit=0.07),
A.OneOf([
A.ChannelShuffle(p=0.45),
A.HueSaturationValue(
hue_shift_limit=20, sat_shift_limit=50, val_shift_limit=50)
]),
A.Blur(p=0.4),
A.GaussNoise(p=0.6, var_limit=30),
A.GridDistortion(),
A.RandomRotate90(),
A.ElasticTransform(approximate=True, alpha=3, p=1),
],
p=1)
res = augment(image=image)
# plt.imshow(res['image'])
# plt.show()
filename = datetime.now().strftime("%Y%m%d-%H%M%S-%f") + '.jpg'
file = os.path.join(path_to_destiny, filename)
cv2.imwrite(file, res['image'])
def __call__(self, sample):
frames, targets = sample
color_twister = A.Compose([
A.ChannelShuffle(p=0.5),
A.RGBShift(
r_shift_limit=50, g_shift_limit=50, b_shift_limit=50, p=0.5),
],
p=1)
frames = [color_twister(image=frame)["image"] for frame in frames]
frames = np.array(frames).astype('uint8')
return frames, targets
def blur_and_distortion(self, kernel_size=(3, 3)): # Blur & Distortion
aug = A.Compose(
[
A.OneOf(
[
A.Blur(
blur_limit=kernel_size, p=self.p
), # Blur the input image using a random-sized kernel.
A.MotionBlur(
blur_limit=kernel_size, p=self.p
), # Apply motion blur to the input image using a random-sized kernel.
A.MedianBlur(
blur_limit=kernel_size, p=self.p
), # Blur the input image using using a median filter with a random aperture linear size.
A.GaussianBlur(
blur_limit=kernel_size, p=self.p
) # Blur the input image using using a Gaussian filter with a random kernel size.
],
p=1),
A.OneOf(
[
A.RandomGamma(gamma_limit=(80, 120), p=self.p),
A.OpticalDistortion(
distort_limit=0.05, shift_limit=0.05, p=self.p),
A.ElasticTransform(p=self.p),
A.HueSaturationValue(
p=self.p
), # Randomly change hue, saturation and value of the input image.
A.RGBShift(
p=self.p
), # Randomly shift values for each channel of the input RGB image.
A.ChannelShuffle(
p=self.p
), # Randomly rearrange channels of the input RGB image.
A.CLAHE(
p=self.p
), # Apply Contrast Limited Adaptive Histogram Equalization to the input image.
A.InvertImg(
p=self.p
), # Invert the input image by subtracting pixel values from 255.
],
p=1),
A.GaussNoise(
var_limit=(10.0, 50.0), mean=0,
p=self.p), # Apply gaussian noise to the input image.
A.RandomShadow(p=self.p) # Simulates shadows for the image
],
p=1)
return aug
def color_augment_pool():
augs = [
A.RGBShift(),
A.ToGray(),
A.ChannelShuffle(),
A.CLAHE(),
A.HueSaturationValue(),
A.RandomContrast(),
A.RandomGamma(),
A.Blur(),
A.MedianBlur(),
A.JpegCompression()
]
return augs
def get_transform(name='default', resize=512):
if name == 'default':
transform = A.Compose([
A.Resize(resize, resize),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.OneOf([
A.RandomContrast(),
A.RandomGamma(),
A.RandomBrightness(),
A.ColorJitter(brightness=0.07,
contrast=0.07,
saturation=0.1,
hue=0.1,
always_apply=False,
p=0.3),
],
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.0),
A.ShiftScaleRotate(),
])
elif name == 'train1':
transform = A.Compose([
A.RandomCrop(resize, resize, True),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.ColorJitter(brightness=0.07,
contrast=0.07,
saturation=0.1,
hue=0.1,
always_apply=False,
p=0.3),
A.ElasticTransform(alpha=120,
sigma=120 * 0.05,
alpha_affine=120 * 0.03),
A.ChannelShuffle(p=0.6)
])
elif name == 'val' or name == 'test':
transform = A.Compose([A.Resize(resize, resize)])
else:
return None
return transform
def run_train(data_path: Path):
cfg = BasicConfig(
seed=444,
name='test_center_vgg_retrain2',
num_workers=4,
gpus=(0,),
batch_size=24,
num_epochs=15,
steps=(4, 9, np.inf),
warmup_epoch=1,
cooldown_epoch=2,
train_augmentations=alb.Compose([
alb.Resize(128, 128),
alb.OneOf([
alb.MotionBlur(blur_limit=5, p=0.2),
alb.MedianBlur(blur_limit=3, p=0.1),
alb.Blur(blur_limit=5, p=0.1)
], p=0.2),
alb.OneOf([
alb.ImageCompression(70, compression_type=alb.ImageCompression.ImageCompressionType.JPEG),
alb.ImageCompression(70, compression_type=alb.ImageCompression.ImageCompressionType.WEBP)
], p=0.2),
alb.OneOf([
alb.CLAHE(clip_limit=2),
alb.IAASharpen(),
alb.IAAEmboss(),
alb.RandomBrightnessContrast(),
], p=0.1),
alb.Rotate(5, border_mode=cv2.BORDER_REFLECT, p=0.2),
alb.OneOf([
alb.RandomResizedCrop(112, 112, scale=(0.9, 1.0), ratio=(0.8, 1.1), p=0.5),
alb.Resize(112, 112, p=0.5),
], p=1.0),
alb.HorizontalFlip(p=0.5),
alb.HueSaturationValue(p=0.7),
alb.ChannelShuffle(p=0.5)
]),
normalize=True,
weight_normalize=True,
uniform_subjects=True,
classifier_mult=3,
lr_factor=0.1,
initial_lr=1e-2,
# extra_rec=(Path('/run/media/andrey/Fast/FairFace/faces_emore/train.rec'),)
)
np.random.seed(cfg.seed)
mx.random.seed(cfg.seed)
train_df = load_info(data_path, Path('data/train_df.csv'))
lib.train.train(cfg, train_df)
def __init__(self, p=0.5):
self.zhiguang = True
if self.zhiguang:
self.blur = albu.Blur(blur_limit=3, p=0.5)
self.chanelshuffle = albu.ChannelShuffle(p=0.5)
self.hueSaturation = albu.HueSaturationValue(p=0.5)
#albu.InvertImg(p=0.2),
self.togray = albu.ToGray(p=0.2)
else:
self.p = p
self.scr = albu.ShiftScaleRotate(shift_limit=0.1,
scale_limit=0.0,
rotate_limit=15,
p=self.p)
self.ig = albu.IAAAdditiveGaussianNoise(p=self.p)
self.ipa = albu.IAAPiecewiseAffine(p=self.p)
def get_training_augmentation():
train_transform = [
albu.HorizontalFlip(p=0.5),
albu.VerticalFlip(p=0.2),
albu.ShiftScaleRotate(scale_limit=0.5,
rotate_limit=50,
shift_limit=0.1,
p=1,
border_mode=0),
#320 384 448 512 640
# albu.GridDistortion(num_steps=2, distort_limit=0.2, interpolation=1, border_mode=0, value=None, always_apply=False, p=0.5),
albu.PadIfNeeded(min_height=padheight,
min_width=padwidth,
always_apply=True,
border_mode=0),
albu.Resize(height=padheight, width=padwidth),
albu.RandomCrop(height=inputheight,
width=inputwidth,
always_apply=True), #the last size
albu.ChannelShuffle(p=0.1),
albu.IAAAdditiveGaussianNoise(p=0.2),
albu.IAAPerspective(p=0.5),
albu.OneOf(
[
albu.CLAHE(p=1),
albu.RandomBrightness(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_train_transform(self):
if self.fullsizeimage:
resize_height = 640
resize_width = 1280
else:
resize_height = 512
resize_width = 512
return A.Compose(
[
A.OneOf(
[
A.RandomBrightnessContrast(p=0.5),
A.RGBShift(p=0.5),
A.HueSaturationValue(p=0.5),
A.ToGray(p=0.5),
A.ChannelDropout(p=0.5),
A.ChannelShuffle(p=0.5),
],
p=0.5,
),
A.OneOf(
[
A.Blur(p=0.5),
A.GaussNoise(p=0.5),
A.IAASharpen(p=0.5),
],
p=0.5,
),
A.OneOf(
[
A.Rotate(limit=20, p=0.5),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
],
p=0.5,
),
A.Resize(height=resize_height, width=resize_width, p=1.0),
ToTensorV2(p=1.0),
],
bbox_params=A.BboxParams(
format="pascal_voc",
min_area=0,
min_visibility=0,
label_fields=["labels"],
),
)
def bboxes_augmentation(cfg):
'''
'''
transforms = []
if cfg['smallest'] > 0:
transforms += [
albumentations.SmallestMaxSize(max_size=cfg['smallest'], p=1.0)
]
if cfg.get('random_crop', 0):
# transforms += [OneOf([albumentations.RandomCrop(height=1024, width=1024, p=0.8),
# albumentations.RandomCrop(height=720, width=720, p=0.8),], p=1.),]
if cfg.get('safe_crop', 0):
transforms += [
albumentations.RandomSizedBBoxSafeCrop(height=cfg['height'],
width=cfg['width'],
p=1.)
]
else:
transforms += [
albumentations.RandomSizedCrop(cfg['min_max_height'],
height=cfg['height'],
width=cfg['width'],
p=1.0)
]
if cfg.get('flip', 0):
transforms += [albumentations.HorizontalFlip(p=0.5)]
transforms += [
albumentations.RandomBrightness(limit=0.2, p=0.3),
albumentations.RandomContrast(limit=0.2, p=0.3),
albumentations.Blur(blur_limit=5, p=0.2),
albumentations.GaussNoise(var_limit=(5, 20), p=0.2),
albumentations.ChannelShuffle(p=0.2),
]
bbox_params = {
'format': 'pascal_voc',
'min_visibility': cfg['min_visibility'],
'label_fields': ['labels'],
'min_area': cfg['min_area']
} if cfg['bbox'] else {}
return Compose(transforms, bbox_params=bbox_params, p=1.)
