def TTA(image, model):
#get average of multi version of test image augmentation
#batch size must be 1
#imput: img:[256,1600,3],torch.Tensor
#output: pred_result:[4,256,1600],np.array
h, w, c = image.shape
horizon_trans = Compose([HorizontalFlip(p=1)])
vertical_trans = Compose([VerticalFlip(p=1)])
rotate_trans = Compose([HorizontalFlip(p=1), VerticalFlip(p=1)])
none_trans = Compose([])
trans_zoo = [horizon_trans, vertical_trans, rotate_trans, none_trans]
pred_total = np.empty((len(trans_zoo), h, w, 4))
for i, tran in enumerate(trans_zoo):
#img->norm+trans->predict->pred_mask->re-trans
#numpy.array
img_aug = tran(image=image.numpy())['image'].squeeze() #[256,1600,3]
#img_aug = normal_trans(image=img_aug)['image'].squeeze()
img_aug = torch.from_numpy(img_aug).permute(
(2, 0, 1)).unsqueeze(0).cuda() #[1,3,256,1600]
pred_aug = model(img_aug)
pred_aug = F.sigmoid(pred_aug).detach().cpu().numpy() #[1,4,256,1600]
pred_aug = pred_aug.squeeze().transpose((1, 2, 0)) #[256,1600,4]
pred_recover = tran(image=pred_aug)['image'].squeeze() #[256,1600,4]
pred_total[i] = pred_recover
pred_result = np.mean(pred_total, axis=0) #[256,1600,4]
return pred_result.transpose((2, 0, 1)) #[4,256,1600]
def get_transforms(*, data_type):
if data_type == "light_train":
return Compose([
Resize(CFG.size, CFG.size),
Transpose(p=0.5),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
ShiftScaleRotate(scale_limit=(0, 0), p=0.5),
ToTensorV2(),
])
if data_type == "train":
return Compose([
Resize(CFG.size, CFG.size),
Transpose(p=0.5),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
albumentations.OneOf([
albumentations.ElasticTransform(
alpha=1, sigma=20, alpha_affine=10),
albumentations.GridDistortion(num_steps=6, distort_limit=0.1),
albumentations.OpticalDistortion(distort_limit=0.05,
shift_limit=0.05),
],
p=0.2),
albumentations.core.composition.PerChannel(albumentations.OneOf([
albumentations.MotionBlur(p=.05),
albumentations.MedianBlur(blur_limit=3, p=.05),
albumentations.Blur(blur_limit=3, p=.05),
]),
p=1.0),
albumentations.OneOf([
albumentations.CoarseDropout(max_holes=16,
max_height=CFG.size // 16,
max_width=CFG.size // 16,
fill_value=0,
p=0.5),
albumentations.GridDropout(ratio=0.09, p=0.5),
albumentations.Cutout(num_holes=8,
max_h_size=CFG.size // 16,
max_w_size=CFG.size // 16,
p=0.2),
],
p=0.5),
albumentations.ShiftScaleRotate(
shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.5),
ToTensorV2(),
],
additional_targets={
'r': 'image',
'g': 'image',
'b': 'image',
'y': 'image',
})
elif data_type == 'valid':
return Compose([
Resize(CFG.size, CFG.size),
ToTensorV2(),
])
def get_tta_aug(tta_index=0):
tta_augs = {
1: [HorizontalFlip(always_apply=True)],
2: [VerticalFlip(always_apply=True)],
3:
[HorizontalFlip(always_apply=True),
VerticalFlip(always_apply=True)],
4: [Rotate90(always_apply=True)],
5: [Rotate90(always_apply=True),
HorizontalFlip(always_apply=True)],
6: [VerticalFlip(always_apply=True),
Rotate90(always_apply=True)],
7: [
HorizontalFlip(always_apply=True),
VerticalFlip(always_apply=True),
Rotate90(always_apply=True)
],
}
if tta_index == 0:
return Compose([Resize(img_sz, img_sz)], p=1.)
else:
return Compose(tta_augs[tta_index],
preprocessing_transforms=[
Resize(img_sz, img_sz, always_apply=True)
],
p=1.0)
def get_transforms(phase, mean, std):
list_transforms = []
if phase == "train":
if crop_image_size is not None:
list_transforms.extend(
[CropNonEmptyMaskIfExists(crop_image_size[0], crop_image_size[1], p=0.85),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
RandomBrightnessContrast(p=0.1, brightness_limit=0.1, contrast_limit=0.1)
])
else:
list_transforms.extend(
[HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
RandomBrightnessContrast(p=0.1, brightness_limit=0.1, contrast_limit=0.1)
]
)
list_transforms.extend(
[
Normalize(mean=mean, std=std, p=1),
ToTensor()
]
)
list_trfms = Compose(list_transforms)
return list_trfms
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 get_tta_aug(tta_index=None):
tta_augs = {
1: [HorizontalFlip(always_apply=True)],
2: [VerticalFlip(always_apply=True)],
3: [HorizontalFlip(always_apply=True),VerticalFlip(always_apply=True)],
4: [Rotate90(always_apply=True)],
5: [Rotate90(always_apply=True), HorizontalFlip(always_apply=True)],
6: [VerticalFlip(always_apply=True), Rotate90(always_apply=True)],
7: [HorizontalFlip(always_apply=True),VerticalFlip(always_apply=True), Rotate90(always_apply=True)],
}
return Compose(tta_augs[tta_index], p=1.0)
def get_transforms1(*, data, CFG):
if data == 'train':
return Compose([
#RandomCrop(512,512,p=1),
HorizontalFlip(p=CFG.augmentation.augmix_p),
VerticalFlip(p=CFG.augmentation.augmix_p),
RandomContrast(p=CFG.augmentation.contrast_p),
#GaussNoise(p=0.5),
RandomRotate90(p=CFG.augmentation.rotate_90_p),
#RandomGamma(p=0.5),
RandomBrightnessContrast(p=CFG.augmentation.bright_contrast_p),
RandomAugMix(severity=CFG.augmentation.augmix_s,
width=3,
alpha=1.,
p=CFG.augmentation.augmix_p),
#GaussianBlur(p=0.5),
GridMask(num_grid=CFG.augmentation.grdimask_n,
p=CFG.augmentation.grdimask_p),
Cutout(p=CFG.augmentation.cutout_p,
max_h_size=CFG.augmentation.cutout_h,
max_w_size=CFG.augmentation.cutout_w),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
elif data == 'valid':
return Compose([
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
)
])
def Auger(self):
List_Transforms = []
if self.is_train:
List_Transforms.extend([
HueSaturationValue(10, 10, 10, p=0.3),
HorizontalFlip(0.3),
VerticalFlip(p=0.3),
# May be it not work,will rescale [0,255] -> [0.0,1.0]
ToFloat(always_apply=True),
ShiftScaleRotate(
shift_limit=0.1, # no resizing
scale_limit=0.1,
rotate_limit=3, # rotate
p=0.5,
border_mode=cv2.BORDER_REFLECT),
PadIfNeeded(self.padshape, self.padshape),
])
List_Transforms.extend([
# [0.12110683835022196, 0.1308642819666743, 0.14265566800591103]
#Normalize(mean=(0.397657144,0.351649219,0.305031406),std=(0.12110683835022196, 0.1308642819666743, 0.14265566800591103)),
RandomCrop(self.shape, self.shape),
ToTensor(),
])
TR = Compose(List_Transforms)
return TR
def __build_augmentator(self):
return Compose(
[
ShiftScaleRotate(
shift_limit=0.0625, scale_limit=0.0, rotate_limit=0,
p=0.3),
OneOf([
RandomScale(scale_limit=0.05, interpolation=1, p=0.5),
Rotate(limit=7,
interpolation=1,
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=0.5)
],
p=0.5),
PadIfNeeded(always_apply=True,
min_width=self.width,
min_height=self.height),
RandomCrop(width=self.width, height=self.height),
OneOf(
[
VerticalFlip(),
# HorizontalFlip(p=0.2),
],
p=0.5),
# OneOf([
# RandomBrightness(limit=0.2, always_apply=False, p=0.5),
# RandomContrast(),
# RandomGamma()
# ], p=0.7),
],
p=self.p)
def __init__(self, root_dir, partition, augment=True):
self.root_dir = root_dir
self.list_IDs = os.listdir(
os.path.join(self.root_dir, 'x_{}'.format(partition)))
self.partition = partition
self.augment = augment
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),
RandomGamma(p=0.5),
CLAHE(p=0.5)
])
def get_transforms(config, mode):
if (mode == "val") or (mode =="test"):
transform = [
Resize(config["model"]["image_size"], config["model"]["image_size"]),
# Normalize(mean=phase_config.mean, std=phase_config.std, p=1),
ToTensor(),
]
return transform
elif mode == "train":
list_transforms = []
config_tarnsform = config[mode]["transform"]
if config_tarnsform["HorizontalFlip"]:
list_transforms.append(HorizontalFlip())
if config_tarnsform["VerticalFlip"]:
list_transforms.append(VerticalFlip())
if config_tarnsform["Contrast"]:
list_transforms.append(
OneOf([
RandomContrast(0.5),
RandomBrightness(),
], p=0.5),
)
if config_tarnsform["ShiftScaleRotate"]:
list_transforms.append(ShiftScaleRotate(shift_limit=(-0.05, 0.05), scale_limit=(-0.05, 0.05), rotate_limit=(-30,30), p=0.5))
list_transforms.extend(
[
Resize(config["model"]["image_size"], config["model"]["image_size"]),
# Normalize(mean=phase_config.mean, std=phase_config.std, p=1),
ToTensor(),
]
)
return list_transforms
def udf_transformer(phase):
list_transforms = []
# if target in [1,3,4]:
# pc_min, pc_max = 150, 50000
# else:
# pc_min, pc_max = 5, 50000
# list_transforms.extend([CropNonEmptyMaskIfExists(height = 256,
# width = 400, # modify this
# # ignore_values = [pc_min,pc_max], # [min, max],
# p=1)
# # Resize(height = 256,
# # width = 1600)
# ]
# )
# list_transforms.append(ElasticTransform(p=0.6))
# list_transforms.append(OpticalDistortion(p=0.6))
if phase == 'train':
list_transforms.append(HorizontalFlip(p=0.5))
list_transforms.append(VerticalFlip(p=0.5))
list_transforms.append(Rotate(limit=20, p=0.5))
# list_transforms.append(GaussNoise())
list_transforms.append(GridDistortion(distort_limit=(-0.2, 0.2), p =0.6))
list_transforms.append(Normalize([0.5], [0.5])) # important step
list_transforms.append(ToTensor()) # using albumentations transformers, must use ToTensor from albumentations too
return Compose(list_transforms)
def __init__(self,
root_dir,
annotation_lines,
class_number,
transform=None,
loader=default_loader):
self.annotation_lines = annotation_lines
self.class_number = class_number
self.transform = transform
self.loader = loader
self.root_dir = root_dir
curr_size = 512
min_max_height = (curr_size - curr_size // 2, curr_size - 1)
self.transform_strong = Compose([
RandomSizedCrop(min_max_height=min_max_height,
height=curr_size,
width=curr_size,
p=1.0),
OneOf([
Transpose(p=0.5),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
Rotate(p=0.5),
],
p=1.0),
ElasticTransform(alpha=curr_size,
sigma=curr_size * 0.05,
alpha_affine=10,
p=1.0)
])
class ImgAugTTATransform(AugmentationFactoryBase):
TRANSFORM_LIST = (
NoOp(p=1),
HorizontalFlip(p=1),
VerticalFlip(p=1),
Rotate(limit=(180, 180), p=1),
# Lambda(RollingY(shift=(-20, 20)).transform),
# Lambda(RollingY(shift=(-20, 20)).transform),
)
CURR_TRANSFORM = TRANSFORM_LIST[0]
def __init__(self, image_size=(126, 32)):
self.image_size = image_size
def build_train(self):
pass
def build_test(self):
print("Using {}".format(self.CURR_TRANSFORM))
return Compose([
Lambda(minmax_norm),
self.CURR_TRANSFORM,
Resize(
self.image_size[0],
self.image_size[1],
interpolation=cv2.INTER_CUBIC,
),
Lambda(normalize),
ToTensor(),
])
def train_transform(p=1):
return Compose([
VerticalFlip(p=0.5),
HorizontalFlip(p=0.5),
Normalize(p=1, mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
],
p=p)
def set_defalut(self):
self.config.update(
dict(image_dir='',
label_dir='',
mode='segm',
include=('pre', 'post'),
CV=dict(
on=True,
cur_k=0,
k_fold=5,
),
transforms=Compose([
OneOf([
HorizontalFlip(True),
VerticalFlip(True),
RandomRotate90(True)
],
p=0.5),
RandomDiscreteScale([0.75, 1.25, 1.5], p=0.5),
RandomCrop(640, 640, True),
Normalize(mean=(0.485, 0.456, 0.406, 0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225, 0.229, 0.224, 0.225),
max_pixel_value=255),
ToTensorV2(True),
]),
batch_size=1,
num_workers=0,
training=True))
def get_train_transforms():
return Compose(
[
#Resize(args.img_size, args.img_size),
RandomResizedCrop(args.img_size, args.img_size),
Transpose(p=0.5),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.25),
ShiftScaleRotate(p=0.25),
HueSaturationValue(hue_shift_limit=0.2,
sat_shift_limit=0.2,
val_shift_limit=0.2,
p=0.25),
RandomBrightnessContrast(brightness_limit=(-0.1, 0.1),
contrast_limit=(-0.1, 0.1),
p=0.5),
Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
max_pixel_value=255.0,
p=1.0),
CoarseDropout(p=0.5),
# Cutout(p=0.5),
ToTensorV2(p=1.0),
],
p=1.)
def train_transform(sz, downscale=1, p=1):
augmentation = Compose(
[
VerticalFlip(p=0.5),
HorizontalFlip(p=0.5),
RandomRotate90(p=0.5),
# GridDistortion(p=0.5, border_mode=cv2.BORDER_CONSTANT),
# RandomGamma(p=0.9, gamma_limit=(80, 150)),
HueSaturationValue(p=0.9,
hue_shift_limit=10,
sat_shift_limit=20,
val_shift_limit=10),
],
p=p)
def transform_fun(img_path):
img, mask = read_img_mask(img_path, sz, downscale=downscale)
data = {"image": img, "mask": mask}
augmented = augmentation(**data)
img, mask = augmented["image"], augmented["mask"]
img = norm_fun(img)
mask = mask_from_rgb(mask)
return img, mask
return transform_fun
def __getitem__(self, index):
path = os.path.join(self.data_dir, self.filename[index] + self.suffix)
label = None if self.ids is None else self.ids[index]
img = Image.open(path)
img = img.convert("RGB")
if self.transform is not None:
img = self.transform(img)
else:
if self.augumentation:
img = np.asarray(img)
task = [
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
RandomGamma(),
RandomBrightnessContrast(p=0.5),
PadIfNeeded(self.img_size, self.img_size),
ShiftScaleRotate(scale_limit=0.5, p=0.5)
]
aug = Compose(task)
aug_data = aug(image=img)
img = aug_data["image"]
#img = cv2.resize(img,(self.img_size,self.img_size))
img = Image.fromarray(img)
img = self.transform(img)
if label is not None:
return img, label
else:
return img
def __getitem__(self, index):
img_path = self.image_paths[index]
mask_path = self.label_paths[index]
if img_path.endswith(".npy"):
img = np.load(img_path)
else:
img = cv2.imread(img_path)
if mask_path.endswith(".npy"):
mask = np.load(mask_path)
else:
mask = cv2.imread(mask_path, 0)
if self.augmentation:
task = [
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
RandomGamma(),
RandomBrightnessContrast(p=0.5),
PadIfNeeded(self.img_size, self.img_size),
ShiftScaleRotate(scale_limit=0.5, p=0.5),
#Normalize(mean=[0.210, 0.210, 0.210], std=[0.196, 0.196, 0.196], always_apply=True)
]
aug = Compose(task)
aug_data = aug(image=img, mask=mask)
img, mask = aug_data["image"], aug_data["mask"]
img = self._normalize(img)
img = cv2.resize(img, (self.img_size, self.img_size))
mask = cv2.resize(mask, (self.img_size, self.img_size))
mask = mask // 255.0
if img.ndim < 3:
img = np.expand_dims(img, 0)
else:
img = np.transpose(img, axes=[2, 0, 1])
return torch.from_numpy(img), torch.from_numpy(mask)
def get_transform(model_name):
if 'TAPNet' in model_name:
# transform for sequences of images is very tricky
# TODO: more transforms should be adopted for better results
train_transform_ops = [
PadIfNeeded(min_height=args.input_height, min_width=args.input_width, p=1),
Normalize(p=1),
# optional transforms
Resize(height=args.input_height, width=args.input_width, p=1),
# CenterCrop(height=args.input_height, width=args.input_width, p=1)
]
else:
train_transform_ops = [
VerticalFlip(p=0.5),
HorizontalFlip(p=0.5),
PadIfNeeded(min_height=args.input_height, min_width=args.input_width, p=1),
Normalize(p=1),
# optional transforms
# Resize(height=args.input_height, width=args.input_width, p=1),
# CenterCrop(height=args.input_height, width=args.input_width, p=1)
RandomCrop(height=args.input_height, width=args.input_width, p=1),
]
valid_transform_ops = [
Normalize(p=1),
PadIfNeeded(min_height=args.input_height, min_width=args.input_width, p=1),
# optional transforms
Resize(height=args.input_height, width=args.input_width, p=1),
# CenterCrop(height=args.input_height, width=args.input_width, p=1)
]
return Compose(train_transform_ops, p=1), Compose(valid_transform_ops, p=1)
def get_transforms(*, data):
if data == 'train':
return Compose([
RandomResizedCrop(CFG.size, CFG.size),
Transpose(p=0.5),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
ShiftScaleRotate(p=0.5),
HueSaturationValue(hue_shift_limit=0.2,
sat_shift_limit=0.2,
val_shift_limit=0.2,
p=0.5),
RandomBrightnessContrast(brightness_limit=(-0.1, 0.1),
contrast_limit=(-0.1, 0.1),
p=0.5),
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensorV2(),
])
elif data == 'valid':
return Compose([
Resize(CFG.size, CFG.size),
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensorV2(),
])
def __getitem__(self, idx):
file = self.files[idx]
file_path = os.path.join(os.path.join(PATH, self.mode + '_images'),
file)
image = cv2.imread(file_path)
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
train_aug = Compose([
OneOf([
VerticalFlip(),
HorizontalFlip(),
], p=0.5),
OneOf([
MotionBlur(p=0.4),
MedianBlur(p=0.4, blur_limit=3),
Blur(p=0.5, blur_limit=3)
],
p=0.4),
OneOf([IAAAdditiveGaussianNoise(),
GaussNoise()], p=0.4),
Normalize(mean=mean, std=std, p=1),
# CLAHE(p=0.5),
ToTensor()
])
augmented = train_aug(image=image)
image = augmented['image']
label = np.array(self.labels[idx])
label = torch.tensor(label, dtype=torch.float32)
return (image, label)
def seg_transforms(phase, resize=(512, 512), mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)):
""" Get segmentation albumentation tansforms
Args:
phase: train or valid
resize: input image shape into model
Returns:
albu compose transforms
Raises:
IOError: An error occurred accessing ablumentation object.
"""
assert (phase in ['train', 'valid', 'test'])
transforms_list = []
if phase == 'train':
transforms_list.extend([
# Rotate
VerticalFlip(p=0.5),
HorizontalFlip(p=0.5),
ShiftScaleRotate(rotate_limit=20, border_mode=0, p=0.2),
RandomBrightnessContrast(brightness_limit=0.1, contrast_limit=0.1, p=0.2),
Resize(resize[0] + 64, resize[1] + 64, interpolation=Image.BILINEAR),
Normalize(mean=mean, std=std, p=1),
RandomCrop(resize[0], resize[1]),
ToTensor(),
])
else:
transforms_list.extend([
Resize(resize[0], resize[1], interpolation=Image.BILINEAR),
Normalize(mean=mean, std=std, p=1),
ToTensor(),
])
transforms = Compose(transforms_list)
return transforms
def get_transforms(phase):
list_transforms = []
if phase == "train":
list_transforms.extend(
[
OneOf([
RandomSizedCrop(min_max_height=(50, 101), height=original_height, width=original_width, p=0.5),
PadIfNeeded(min_height=original_height, min_width=original_width, p=0.5)], p=1),
VerticalFlip(p=0.5),
# RandomRotate90(p=0.5),
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),
CLAHE(p=0.8),
RandomBrightnessContrast(p=0.8),
RandomGamma(p=0.8),
]
)
list_transforms.extend(
[
Resize(height=int(original_height/4), width=int(original_width/4), interpolation=cv2.INTER_NEAREST),
Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1),
ToTensor(),
]
)
list_trfms = Compose(list_transforms)
return list_trfms
def get_raw_tta():
transform_test_raw = Compose(
[Resize(RAW_CROP_SIZE, RAW_CROP_SIZE),
ToTensor()])
transform_test_hf = Compose([
Resize(RAW_CROP_SIZE, RAW_CROP_SIZE),
HorizontalFlip(p=1, always_apply=True),
ToTensor()
])
transform_test_vf = Compose([
Resize(RAW_CROP_SIZE, RAW_CROP_SIZE),
VerticalFlip(p=1, always_apply=True),
ToTensor()
])
transform_test_tr = Compose(
[Resize(RAW_CROP_SIZE, RAW_CROP_SIZE),
Transpose(),
ToTensor()])
return [
transform_test_raw, transform_test_hf, transform_test_vf,
transform_test_tr
]
def __init__(self):
self.albumentations_transform = Compose({
Cutout(max_h_size=12, max_w_size=12, num_holes=1, p=0.5),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
})
def hard_aug(original_height=128, original_width=128, k=4):
aug = Compose([
OneOf([
RandomSizedCrop(
min_max_height=(original_height // k, original_height),
height=original_height,
width=original_width,
p=0.5),
PadIfNeeded(
min_height=original_height, min_width=original_width, p=0.5)
],
p=1),
VerticalFlip(p=0.5),
HorizontalFlip(p=0.5),
RandomRotate90(p=0.5),
Transpose(p=0.5),
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),
CLAHE(p=0.8),
RandomBrightnessContrast(p=0.8),
RandomGamma(p=0.8)
])
return aug
def transform_v2(config):
""" default transforms
Args:
config: CFG
Returns: train_tranforms, test_transforms
"""
train_transforms = Compose([
RandomResizedCrop(224, 224, scale=(0.7, 1.0)),
HorizontalFlip(),
VerticalFlip(),
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensor()
],
p=1)
test_transforms = Compose([
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensor()
],
p=1)
return train_transforms, test_transforms
def albumentations_transform(self, img):
# 训练集的增强
trans_train = Compose([
# 随机更改输入图像的色相，饱和度和值
# HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, always_apply=False, p=0.5),
# 通过用255减去像素值来反转输入图像。
# InvertImg(always_apply=False, p=1),
# 随机改变RGB三个通道的顺序
# ChannelShuffle(always_apply=False, p=0.5),
# 随机出现小黑点
# Cutout(num_holes=8, max_h_size=8, max_w_size=8, fill_value=0, always_apply=False, p=0.5),
# RandomCrop(224, 224),
OneOf([
RandomBrightness(limit=0.1, p=1),
RandomContrast(limit=0.1, p=1)
]),
# OneOf([MotionBlur(blur_limit=3),MedianBlur(blur_limit=3), GaussianBlur(blur_limit=3),], p=0.5,),
VerticalFlip(p=0.5),
HorizontalFlip(p=0.5),
# ShiftScaleRotate(
# shift_limit=0.2,
# scale_limit=0.2,
# rotate_limit=20,
# interpolation=cv2.INTER_LINEAR,
# border_mode=cv2.BORDER_REFLECT_101,
# p=1,
# ),
])
augmented = trans_train(image=img)
return augmented['image']
