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 augment(self, img0, img1):
transform = A.Compose([
A.IAAAdditiveGaussianNoise(p=0.05),
A.OneOf([
A.IAASharpen(p=1.0),
A.Blur(blur_limit=3, p=1.0),
],
p=0.5),
A.OneOf([
A.RandomBrightnessContrast(p=1.0),
A.HueSaturationValue(p=1.0),
A.RandomGamma(p=1.0),
],
p=0.5),
A.OneOf([
A.RandomFog(p=1.0),
A.RandomRain(p=1.0),
A.RandomShadow(p=1.0),
A.RandomSnow(p=1.0),
A.RandomSunFlare(p=1.0)
],
p=0.05),
],
additional_targets={'img1': 'image'})
transformed = transform(image=img0, img1=img1)
img0 = transformed["image"]
img1 = transformed["img1"]
return img0, img1
def get_training_augmentation():
train_transform = [
A.RandomSizedCrop(min_max_height=(300, 360), height=320, width=320,
always_apply=True),
A.HorizontalFlip(p=0.5),
A.OneOf([
A.CLAHE(),
A.RandomBrightnessContrast(),
A.RandomGamma(),
A.HueSaturationValue(),
A.NoOp()
]),
A.OneOf([
A.IAAAdditiveGaussianNoise(p=0.2),
A.IAASharpen(),
A.Blur(blur_limit=3),
A.MotionBlur(blur_limit=3),
A.NoOp()
]),
A.OneOf([
A.RandomFog(),
A.RandomSunFlare(),
A.RandomRain(),
A.RandomSnow(),
A.NoOp()
]),
A.Normalize(),
]
return A.Compose(train_transform)
def __init__(self):
self.augmentor = A.Compose(
[
A.MotionBlur(p=0.25),
A.ColorJitter(p=0.5),
A.RandomRain(p=0.1), # random occlusion
A.RandomSunFlare(p=0.1),
A.JpegCompression(p=0.25),
A.ISONoise(p=0.25)
],
p=1.0)
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 get_training_augmentation(min_area=0., min_visibility=0.):
train_transform = [
albu.OneOf([
albu.MotionBlur(p=.2),
albu.MedianBlur(blur_limit=3, p=0.1),
albu.Blur(blur_limit=3, p=0.1),
],
p=0.2),
albu.ShiftScaleRotate(shift_limit=0,
scale_limit=0,
rotate_limit=15,
p=0.5),
albu.OneOf([
albu.CLAHE(clip_limit=2),
albu.IAASharpen(),
albu.IAAEmboss(),
],
p=0.3),
albu.OneOf([
albu.RandomFog(fog_coef_lower=0.1, fog_coef_upper=0.15, p=0.1),
albu.RandomShadow(p=0.1),
albu.RandomBrightness(limit=0.3, p=0.2),
albu.RandomRain(slant_lower=0,
slant_upper=8,
drop_length=0,
blur_value=4,
brightness_coefficient=0.8,
rain_type='heavy',
p=0.1),
albu.RandomSunFlare(p=0.2),
]),
albu.OneOf([
albu.RGBShift(p=0.1),
albu.HueSaturationValue(p=0.3),
]),
albu.OneOf([
albu.HorizontalFlip(p=0.5),
albu.RandomSizedCrop(min_max_height=(720, 1380),
height=1380,
width=720,
interpolation=cv2.INTER_AREA)
],
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 __init__(self,
input_key: str = "image",
output_key: str = "flare_factor",
sunflare_params: Dict = None):
"""
Args:
input_key (str): input key to use from annotation dict
output_key (str): output key to use to store the result
sunflare_params (dict): params to init ``A.RandomSunFlare``
"""
self.input_key = input_key
self.output_key = output_key
self.sunflare_params = sunflare_params or {}
self.transform = A.RandomSunFlare(**self.sunflare_params)
def augment(self, img, mask, do_affine_transform = True):
if do_affine_transform:
afine_transform = A.Compose([
A.HorizontalFlip(p=0.4),
A.OneOf([
A.GridDistortion(interpolation=cv2.INTER_NEAREST, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0),
A.ElasticTransform(interpolation=cv2.INTER_NEAREST, alpha_affine=10, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0),
A.ShiftScaleRotate(interpolation=cv2.INTER_NEAREST, shift_limit=0.03, rotate_limit=4, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0),
A.OpticalDistortion(interpolation=cv2.INTER_NEAREST, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0)
], p=0.6),
], additional_targets={'mask': 'image'})
afine_transformed = afine_transform(image=img, mask=mask)
img = afine_transformed["image"]
mask = afine_transformed["mask"]
transform = A.Compose([
A.IAAAdditiveGaussianNoise(p=0.05),
A.OneOf([
A.IAASharpen(p=1.0),
A.Blur(blur_limit=3, p=1.0),
] , p=0.5),
A.OneOf([
A.RandomBrightnessContrast(p=1.0),
A.HueSaturationValue(p=1.0),
A.RandomGamma(p=1.0),
], p=0.5),
A.OneOf([
A.RandomFog(p=1.0),
A.RandomRain(p=1.0),
A.RandomShadow(p=1.0),
A.RandomSnow(p=1.0),
A.RandomSunFlare(p=1.0)
], p=0.05),
])
transformed = transform(image=img)
img = transformed["image"]
return img, mask
import albumentations as A
transform_fn = A.Compose([
A.OneOf([
A.IAAAdditiveGaussianNoise(),
A.GaussNoise(),
], p=.2),
A.OneOf([
A.MotionBlur(p=.2),
A.MedianBlur(blur_limit=3, p=.2),
A.Blur(blur_limit=3, p=.2),
], p=.2),
A.OneOf([
A.CLAHE(clip_limit=2),
A.IAASharpen(),
A.IAAEmboss(),
A.RandomBrightnessContrast(),
], p=0.2),
A.OneOf([
A.ChannelShuffle(),
A.HueSaturationValue(),
A.RGBShift(),
A.ToSepia(),
], p=0.2),
A.OneOf([
A.RandomSunFlare(flare_roi=(0, 0, 1., 1.), src_radius=100, p=.1),
A.RandomFog(fog_coef_lower=0.2, fog_coef_upper=0.3, p=.1),
A.RandomShadow(p=.1),
A.RandomRain(p=.1, blur_value=1),
], p=0.1)
])
def __call__(self, data):
rgb, thermal, depth, audio, label, id = data
rgb = rgb.astype(np.float32)
height, width, _ = rgb.shape
albumentations_transform_pixel = {
'Blur': albumentations.Blur(),
#'CLAHE':albumentations.CLAHE(),
'ChannelDropout': albumentations.ChannelDropout(),
'ChannelShuffle': albumentations.ChannelShuffle(),
'CoarseDropout': albumentations.CoarseDropout(),
#'Equalize':albumentations.Equalize(),
#'FancyPCA':albumentations.FancyPCA(),
'GaussNoise': albumentations.GaussNoise(),
'GaussianBlur': albumentations.GaussianBlur(),
#'GlassBlur':albumentations.GlassBlur(),
'HueSaturationValue': albumentations.HueSaturationValue(),
'IAAAdditiveGaussianNoise':
albumentations.IAAAdditiveGaussianNoise(),
#'ISONoise':albumentations.ISONoise(),
'RGBShift': albumentations.RGBShift(),
'RandomBrightnessContrast':
albumentations.RandomBrightnessContrast(),
'RandomFog': albumentations.RandomFog(),
#'RandomGamma':albumentations.RandomGamma(),
'RandomRain': albumentations.RandomRain(),
'RandomShadow': albumentations.RandomShadow(),
'RandomSnow': albumentations.RandomSnow(),
'RandomSunFlare': albumentations.RandomSunFlare(),
'Solarize': albumentations.Solarize(),
}
albumentations_transform_bbox = {
#'HorizontalFlip':albumentations.HorizontalFlip(),
#'VerticalFlip':albumentations.VerticalFlip(),
#'CenterCrop':albumentations.CenterCrop(height=height-10, width=width-10, p=0.5),
#'RandomCropNearBBox':albumentations.RandomCropNearBBox(p=0.5),
#'Crop':albumentations.Crop(x_min=10, y_min =10, y_max=height-10, x_max=width-10, p=0.5),
#'ElasticTransform':albumentations.ElasticTransform(),
#'ShiftScaleRotate':albumentations.ShiftScaleRotate(),
}
transform = np.random.choice(
['None'] + list(albumentations_transform_pixel.keys()) +
list(albumentations_transform_bbox.keys()))
if transform in albumentations_transform_pixel:
aug = albumentations.Compose(
[albumentations_transform_pixel[transform]],
bbox_params={
'format': 'pascal_voc',
'label_fields': ['labels']
})
try:
annots = np.array(annots).astype(np.float32)
aug_result = aug(image=rgb,
bboxes=annots[:, :4],
labels=annots[:, 4])
rgb = aug_result['image']
annots = np.hstack([
aug_result['bboxes'],
np.array(aug_result['labels']).reshape(-1, 1)
])
except Exception as e:
print(
f"transform={transform} aug_result['bboxes']={aug_result['bboxes']} aug_result['labels']={aug_result['labels']}"
)
raise Exception(e)
elif transform in albumentations_transform_bbox:
aug = albumentations.Compose(
[albumentations_transform_bbox[transform]],
bbox_params={
'format': 'pascal_voc',
'label_fields': ['labels']
})
try:
annots = np.array(annots).astype(np.float32)
aug_result = aug(image=rgb,
bboxes=annots[:, :4],
labels=annots[:, 4])
rgb = aug_result['image']
label = np.hstack([
aug_result['bboxes'],
np.array(aug_result['labels']).reshape(-1, 1)
])
except Exception as e:
print(
f"transform={transform} aug_result['bboxes']={aug_result['bboxes']} aug_result['labels']={aug_result['labels']}"
)
raise Exception(e)
return rgb, thermal, depth, audio, label, id
def get_transforms(aug_type: str):
"""
Data augmentation 객체 생성
Args:
aug_type(str) : augmentation타입 지정
Returns :
list :: train, validation, test데이터 셋에 대한 transform
"""
# TODO: Normalize
if False:
pass
else:
norm_mean = (0, 0, 0)
norm_std = (1, 1, 1)
if aug_type == 'no':
train_transform = A.Compose(
[A.Normalize(mean=norm_mean, std=norm_std),
ToTensorV2()])
val_transform = A.Compose(
[A.Normalize(mean=norm_mean, std=norm_std),
ToTensorV2()])
test_transform = A.Compose(
[A.Normalize(mean=norm_mean, std=norm_std),
ToTensorV2()])
elif aug_type == 'dev':
pass
elif aug_type == 'final':
train_transform = A.Compose([
A.HorizontalFlip(p=0.5),
A.RandomResizedCrop(512,
512,
p=0.8,
scale=(0.7, 1.0),
ratio=(0.5, 1.5)),
A.Rotate(limit=30, p=0.8),
A.Cutout(num_holes=4, max_h_size=16, max_w_size=16, p=0.8),
A.ElasticTransform(alpha=40, p=0.8),
A.CLAHE(clip_limit=3.0, p=0.8),
A.Normalize(mean=norm_mean, std=norm_std),
ToTensorV2()
])
val_transform = A.Compose(
[A.Normalize(mean=norm_mean, std=norm_std),
ToTensorV2()])
test_transform = A.Compose(
[A.Normalize(mean=norm_mean, std=norm_std),
ToTensorV2()])
# TODO: 아래 코드 정리 중
elif aug_type == 'basic':
train_transform = A.Compose([
A.Normalize(mean=(0.46009655, 0.43957878, 0.41827092),
std=(0.2108204, 0.20766491, 0.21656131),
max_pixel_value=255.0,
p=1.0),
ToTensorV2()
])
val_transform = A.Compose([
A.Normalize(mean=(0.46009655, 0.43957878, 0.41827092),
std=(0.2108204, 0.20766491, 0.21656131),
max_pixel_value=255.0,
p=1.0),
ToTensorV2()
])
test_transform = A.Compose([ToTensorV2()])
elif aug_type == "aug1":
train_transform = A.Compose([
A.OneOf([
A.ElasticTransform(alpha=120,
sigma=120 * 0.05,
alpha_affine=120 * 0.03,
p=0.5),
A.GridDistortion(p=1.0),
A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1)
],
p=0.8),
A.VerticalFlip(p=0.5),
A.RandomBrightnessContrast(p=0.8),
A.RandomGamma(p=0.8),
A.RandomRotate90(p=0.5),
ToTensorV2()
])
val_transform = A.Compose([ToTensorV2()])
test_transform = A.Compose([ToTensorV2()])
elif aug_type == "aug2":
train_transform = A.Compose([
A.OneOf([
A.RandomShadow(p=1),
A.RandomSunFlare(num_flare_circles_lower=1,
num_flare_circles_upper=5,
src_radius=250,
p=1),
A.RandomRain(p=1),
A.RandomSnow(brightness_coeff=1.5, p=1),
A.RandomFog(
fog_coef_lower=0.8, fog_coef_upper=1, alpha_coef=0.08, p=1)
],
p=0.8),
ToTensorV2()
])
val_transform = A.Compose([ToTensorV2()])
test_transform = A.Compose([ToTensorV2()])
elif aug_type == "aug3":
train_transform = A.Compose([
A.OneOf([
A.HueSaturationValue(hue_shift_limit=0.2,
sat_shift_limit=0.2,
val_shift_limit=0.2,
p=1),
A.MultiplicativeNoise(
multiplier=(0.9, 1.1), per_channel=True, p=1),
A.RGBShift(r_shift_limit=0.1,
g_shift_limit=0.1,
b_shift_limit=0.1,
p=1),
A.ChannelShuffle(0.05)
],
p=0.8),
ToTensorV2()
])
val_transform = A.Compose([ToTensorV2()])
test_transform = A.Compose([ToTensorV2()])
elif aug_type == "aug4":
train_transform = A.Compose([
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.RandomRotate90(p=0.5),
ToTensorV2()
])
val_transform = A.Compose([ToTensorV2()])
test_transform = A.Compose([ToTensorV2()])
elif aug_type == "aug5":
train_transform = A.Compose([
A.VerticalFlip(p=0.5),
A.RandomRotate90(p=0.5),
#A.ElasticTransform(p=1, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03),
#A.GridDistortion(p=1.0),
#A.OpticalDistortion(distort_limit=2, shift_limit=0.5, p=1)
#A.VerticalFlip(p=0.5),
#A.RandomBrightnessContrast(p=0.8),
#A.RandomGamma(p=0.8),
#A.RandomRotate90(p=0.5),
#A.MultiplicativeNoise(multiplier=(0.9, 1.1), per_channel=True, p=0.8),
ToTensorV2()
])
val_transform = A.Compose([ToTensorV2()])
test_transform = A.Compose([ToTensorV2()])
return train_transform, val_transform, test_transform
alb.OneOf([
alb.GridDistortion(num_steps=8, distort_limit=0.5, p=1.0),
alb.OpticalDistortion(
distort_limit=0.5,
shift_limit=0.5,
p=1.0,
),
alb.ElasticTransform(alpha=3, p=1.0)
],
p=0.7),
alb.RandomResizedCrop(height=width_size,
width=width_size,
scale=(0.8, 1.2),
p=0.7),
alb.RGBShift(p=0.5),
alb.RandomSunFlare(p=0.5),
alb.RandomFog(p=0.5),
alb.RandomBrightnessContrast(p=0.5),
alb.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=20,
val_shift_limit=20,
p=0.5),
alb.ShiftScaleRotate(shift_limit=0.025,
scale_limit=0.1,
rotate_limit=20,
p=0.5),
alb.CoarseDropout(max_holes=12,
min_holes=6,
max_height=int(width_size / 6),
max_width=int(width_size / 6),
min_height=int(width_size / 6),
def train_process(data_path, config):
def _worker_init_fn_():
import random
import numpy as np
import torch
random_seed = config.random_seed
torch.manual_seed(random_seed)
np.random.seed(random_seed)
random.seed(random_seed)
if torch.cuda.is_available():
torch.cuda.manual_seed(random_seed)
input_size = (config.img_height, config.img_width)
transforms = [
abm.RandomResizedCrop(
scale=(0.7, 1),
height=config.img_height,
width=config.img_width,
ratio=(1.5, 2),
always_apply=True,
),
abm.OneOf([abm.IAAAdditiveGaussianNoise(),
abm.GaussNoise()], p=0.5),
abm.OneOf(
[
abm.MedianBlur(blur_limit=3),
abm.GaussianBlur(blur_limit=3),
abm.MotionBlur(blur_limit=3),
],
p=0.1,
),
abm.ShiftScaleRotate(rotate_limit=10, p=0.5, border_mode=0),
abm.RandomGamma(gamma_limit=(80, 120), p=0.5),
abm.RandomBrightnessContrast(brightness_limit=(-0.5, 0.5),
contrast_limit=(-0.5, 0.5),
p=0.5),
abm.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
p=0.5),
abm.RandomShadow(p=0.5),
abm.RandomSunFlare(p=0.5),
abm.ChannelShuffle(p=0.5),
abm.ChannelDropout(p=0.5),
abm.HorizontalFlip(p=0.5),
abm.ImageCompression(quality_lower=50, p=0.5),
abm.Cutout(num_holes=100, max_w_size=8, max_h_size=8, p=0.5),
]
data_transform = DataTransformBase(transforms=transforms,
input_size=input_size,
normalize=True)
train_dataset = EgoRailDataset(data_path=data_path,
phase="train",
transform=data_transform)
val_dataset = EgoRailDataset(data_path=data_path,
phase="val",
transform=data_transform)
# train_dataset.weighted_class()
weighted_values = [8.90560578, 1.53155476]
train_data_loader = DataLoader(
train_dataset,
batch_size=config.batch_size,
shuffle=True,
num_workers=config.num_workers,
drop_last=True,
worker_init_fn=_worker_init_fn_(),
)
val_data_loader = DataLoader(
val_dataset,
batch_size=config.batch_size,
shuffle=False,
num_workers=config.num_workers,
drop_last=True,
)
data_loaders_dict = {"train": train_data_loader, "val": val_data_loader}
model = BiSeNetV2(n_classes=config.num_classes)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
criterion = OHEMCELoss(thresh=config.ohem_ce_loss_thresh,
weighted_values=weighted_values)
base_lr_rate = config.lr_rate / (config.batch_size *
config.batch_multiplier)
base_weight_decay = config.weight_decay * (config.batch_size *
config.batch_multiplier)
def _lambda_epoch(epoch):
import math
max_epoch = config.num_epochs
return math.pow((1 - epoch * 1.0 / max_epoch), 0.9)
optimizer = torch.optim.SGD(
model.parameters(),
lr=base_lr_rate,
momentum=config.momentum,
weight_decay=base_weight_decay,
)
scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=_lambda_epoch)
trainer = BiSeNetV2Trainer(
model=model,
criterion=criterion,
metric_func=None,
optimizer=optimizer,
data_loaders_dict=data_loaders_dict,
config=config,
scheduler=scheduler,
device=device,
)
if config.snapshot and os.path.isfile(config.snapshot):
trainer.resume_checkpoint(config.snapshot)
with torch.autograd.set_detect_anomaly(True):
trainer.train()
def train_function(gpu, world_size, node_rank, gpus):
import torch.multiprocessing
torch.multiprocessing.set_sharing_strategy('file_system')
torch.manual_seed(25)
np.random.seed(25)
rank = node_rank * gpus + gpu
dist.init_process_group(
backend='nccl',
init_method='env://',
world_size=world_size,
rank=rank
)
width_size = 512
batch_size = 32
accumulation_step = 5
device = torch.device("cuda:{}".format(gpu) if torch.cuda.is_available() else "cpu")
if rank == 0:
wandb.init(project='inception_v3', group=wandb.util.generate_id())
wandb.config.width_size = width_size
wandb.config.aspect_rate = 1
wandb.config.batch_size = batch_size
wandb.config.accumulation_step = accumulation_step
shutil.rmtree('tensorboard_runs', ignore_errors=True)
writer = SummaryWriter(log_dir='tensorboard_runs', filename_suffix=str(time.time()))
ranzcr_df = pd.read_csv('train_folds.csv')
ranzcr_train_df = ranzcr_df[ranzcr_df['fold'] != 1]
chestx_df = pd.read_csv('chestx_pseudolabeled_data_lazy_balancing.csv')
train_image_transforms = alb.Compose([
alb.ImageCompression(quality_lower=65, p=0.5),
alb.HorizontalFlip(p=0.5),
alb.CLAHE(p=0.5),
alb.OneOf([
alb.GridDistortion(
num_steps=8,
distort_limit=0.5,
p=1.0
),
alb.OpticalDistortion(
distort_limit=0.5,
shift_limit=0.5,
p=1.0,
),
alb.ElasticTransform(alpha=3, p=1.0)],
p=0.7
),
alb.RandomResizedCrop(
height=width_size,
width=width_size,
scale=(0.8, 1.2),
p=0.7
),
alb.RGBShift(p=0.5),
alb.RandomSunFlare(p=0.5),
alb.RandomFog(p=0.5),
alb.RandomBrightnessContrast(p=0.5),
alb.HueSaturationValue(
hue_shift_limit=20,
sat_shift_limit=20,
val_shift_limit=20,
p=0.5
),
alb.ShiftScaleRotate(shift_limit=0.025, scale_limit=0.1, rotate_limit=20, p=0.5),
alb.CoarseDropout(
max_holes=12,
min_holes=6,
max_height=int(width_size / 6),
max_width=int(width_size / 6),
min_height=int(width_size / 6),
min_width=int(width_size / 20),
p=0.5
),
alb.IAAAdditiveGaussianNoise(loc=0, scale=(2.5500000000000003, 12.75), per_channel=False, p=0.5),
alb.IAAAffine(scale=1.0, translate_percent=None, translate_px=None, rotate=0.0, shear=0.0, order=1, cval=0,
mode='reflect', p=0.5),
alb.IAAAffine(rotate=90., p=0.5),
alb.IAAAffine(rotate=180., p=0.5),
alb.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
ToTensorV2()
])
train_set = NoisyStudentDataset(ranzcr_train_df, chestx_df, train_image_transforms,
'../ranzcr/train', '../data', width_size=width_size)
train_sampler = DistributedSampler(train_set, num_replicas=world_size, rank=rank, shuffle=True)
train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=False, num_workers=4, sampler=train_sampler)
ranzcr_valid_df = ranzcr_df[ranzcr_df['fold'] == 1]
valid_image_transforms = alb.Compose([
alb.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
ToTensorV2()
])
valid_set = ImageDataset(ranzcr_valid_df, valid_image_transforms, '../ranzcr/train', width_size=width_size)
valid_loader = DataLoader(valid_set, batch_size=batch_size, num_workers=4, pin_memory=False, drop_last=False)
# ranzcr_valid_df = ranzcr_df[ranzcr_df['fold'] == 1]
# valid_image_transforms = alb.Compose([
# alb.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
# ToTensorV2()
# ])
# valid_set = ImageDataset(ranzcr_valid_df, valid_image_transforms, '../ranzcr/train', width_size=width_size)
# valid_sampler = DistributedSampler(valid_set, num_replicas=world_size, rank=rank)
# valid_loader = DataLoader(valid_set, batch_size=batch_size, num_workers=4, sampler=valid_sampler)
checkpoints_dir_name = 'inception_v3_noisy_student_{}'.format(width_size)
os.makedirs(checkpoints_dir_name, exist_ok=True)
# model = EfficientNetNoisyStudent(11, pretrained_backbone=True,
# mixed_precision=True, model_name='tf_efficientnet_b7_ns')
model = Inception(11, pretrained_backbone=True, mixed_precision=False, model_name='inception_v3')
model = SyncBatchNorm.convert_sync_batchnorm(model)
model.to(device)
model = DistributedDataParallel(model, device_ids=[gpu])
# class_weights = [354.625, 23.73913043478261, 2.777105767812362, 110.32608695652173,
# 52.679245283018865, 9.152656621728786, 4.7851333032083145,
# 8.437891632878731, 2.4620064899945917, 0.4034751151063363, 31.534942820838626]
class_names = ['ETT - Abnormal', 'ETT - Borderline', 'ETT - Normal',
'NGT - Abnormal', 'NGT - Borderline', 'NGT - Incompletely Imaged', 'NGT - Normal',
'CVC - Abnormal', 'CVC - Borderline', 'CVC - Normal', 'Swan Ganz Catheter Present']
scaler = GradScaler()
criterion = torch.nn.BCEWithLogitsLoss()
lr_start = 1e-4
lr_end = 1e-6
weight_decay = 0
epoch_num = 20
if rank == 0:
wandb.config.model_name = checkpoints_dir_name
wandb.config.lr_start = lr_start
wandb.config.lr_end = lr_end
wandb.config.weight_decay = weight_decay
wandb.config.epoch_num = epoch_num
wandb.config.optimizer = 'adam'
wandb.config.scheduler = 'CosineAnnealingLR'
wandb.config.is_loss_weights = 'no'
optimizer = Adam(model.parameters(), lr=lr_start, weight_decay=weight_decay)
scheduler = CosineAnnealingLR(optimizer, T_max=epoch_num, eta_min=lr_end, last_epoch=-1)
max_val_auc = 0
for epoch in range(epoch_num):
train_loss, train_avg_auc, train_auc, train_rocs, train_data_pr, train_duration = one_epoch_train(
model, train_loader, optimizer, criterion, device, scaler,
iters_to_accumulate=accumulation_step, clip_grads=False)
scheduler.step()
if rank == 0:
val_loss, val_avg_auc, val_auc, val_rocs, val_data_pr, val_duration = eval_model(
model, valid_loader, device, criterion, scaler)
wandb.log({'train_loss': train_loss, 'val_loss': val_loss,
'train_auc': train_avg_auc, 'val_auc': val_avg_auc, 'epoch': epoch})
for class_name, auc1, auc2 in zip(class_names, train_auc, val_auc):
wandb.log({'{} train auc'.format(class_name): auc1,
'{} val auc'.format(class_name): auc2, 'epoch': epoch})
if val_avg_auc > max_val_auc:
max_val_auc = val_avg_auc
wandb.run.summary["best_accuracy"] = val_avg_auc
print('EPOCH %d:\tTRAIN [duration %.3f sec, loss: %.3f, avg auc: %.3f]\t\t'
'VAL [duration %.3f sec, loss: %.3f, avg auc: %.3f]\tCurrent time %s' %
(epoch + 1, train_duration, train_loss, train_avg_auc,
val_duration, val_loss, val_avg_auc, str(datetime.now(timezone('Europe/Moscow')))))
torch.save(model.module.state_dict(),
os.path.join(checkpoints_dir_name, '{}_epoch{}_val_auc{}_loss{}_train_auc{}_loss{}.pth'.format(
checkpoints_dir_name, epoch + 1, round(val_avg_auc, 3), round(val_loss, 3),
round(train_avg_auc, 3), round(train_loss, 3))))
if rank == 0:
wandb.finish()
def sun_flare(img, msk):
aug = A.Compose([A.RandomSunFlare(always_apply=True, src_radius=100)])
data = aug(image=img)
return data['image'], msk
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()
])
# -*- coding: utf-8 -*-
# @Description: 放置一些图像变换
# @Author: CaptainHu
# @Date: 2021-05-12 17:21:53
# @LastEditors: CaptainHu
import albumentations as A
v1=A.Compose(
[
A.RandomBrightnessContrast(),
A.RandomGamma(),
A.RandomSunFlare(p=0.3),
]
)
v2=A.Compose([
A.RandomBrightnessContrast(p=1),
A.RandomGamma(),
A.RandomFog(),
A.RandomShadow(p=0.8),
])
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
def main(args):
if args.alg=='MAML':
model = MAML(args)
elif args.alg=='iMAML':
model = iMAML(args)
else:
raise ValueError('Not implemented Meta-Learning Algorithm')
if args.load:
model.load()
elif args.load_encoder:
model.load_encoder()
transform = A.Compose ([
A.Resize(width = 256, height = 256, p=1.0),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.Rotate((-5,5),p=0.5),
A.RandomSunFlare(flare_roi=(0, 0, 1, 0.5), angle_lower=0, angle_upper=1,
num_flare_circles_lower=1, num_flare_circles_upper=2,
src_radius=160, src_color=(255, 255, 255), always_apply=False, p=0.3),
A.RGBShift (r_shift_limit=10, g_shift_limit=10,
b_shift_limit=10, always_apply=False, p=0.2),
A. ElasticTransform (alpha=2, sigma=15, alpha_affine=25, interpolation=1,
border_mode=4, value=None, mask_value=None,
always_apply=False, approximate=False, p=0.3) ,
A.Normalize( p=1.0),
ToTensor(),
])
target_set=args.target_set
source_list = ['CVC-612', 'CVC-ColonDB', 'ETIS-LaribPolypDB', 'Kvasir-SEG']
source_list.remove(target_set)
root='/home/rabink1/Meta-Learning-Seg/polyp_sets'
with open('train_data.csv','w') as csvfile:
fields=['ID','Image_path','Label_path']
csvwriter=csv.writer(csvfile,delimiter=',')
csvwriter.writerow(fields)
for idx,each_set in enumerate(source_list):
for image in os.listdir(root+'/'+each_set+'/'+'masks') and os.listdir(root+'/'+each_set+'/'+'images'):
label_path=root+'/'+each_set+'/'+'masks'+'/'+image
image_path=root+'/'+each_set+'/'+'images'+'/'+image
csvwriter.writerow([idx,image_path,label_path])
with open('test_data.csv','w') as csvfile:
fields=['ID','Image_path','Label_path']
csvwriter=csv.writer(csvfile,delimiter=',')
csvwriter.writerow(fields)
for image in os.listdir(root+'/'+target_set+'/'+'masks') and os.listdir(root+'/'+target_set+'/'+'images'):
label_path=root+'/'+target_set+'/'+"masks"+'/'+image
image_path=root+'/'+target_set+'/'+"images"+'/'+image
csvwriter.writerow([target_set,image_path,label_path])
trainframe=pd.read_csv("train_data.csv")
testframe=pd.read_csv("test_data.csv")
train_classes=np.unique(trainframe["ID"])
train_classes=list(train_classes)
all_test_classes=np.unique(testframe["ID"])
all_test_classes=list(all_test_classes)
num_classes=args.num_way
num_instances=args.num_shot
num_meta_testing_train=args.meta_testing_train_shots
num_test_classes=args.num_test_classes
num_meta_testing_test=args.meta_testing_test_shots
train_fileroots_alltask,meta_fileroots_alltask =[],[]
for each_task in range(args.num_task):
task=Task(train_classes,num_classes,num_instances,trainframe)
train_fileroots_alltask.append(task.train_roots)
meta_fileroots_alltask.append(task.meta_roots)
test_fileroots_alltask,train_fileroots_all_task =[],[]
for each_task in range(args.num_test_task):
test_task= TestTask(all_test_classes,num_test_classes,num_meta_testing_train,num_meta_testing_test,testframe)
test_fileroots_alltask.append(test_task.test_roots)
train_fileroots_all_task.append(test_task.train_roots)
trainloader=DataLoader(MiniSet(train_fileroots_alltask,transform=transform),
batch_size=args.batch_size,num_workers=4, pin_memory=True,shuffle=True)
validloader = DataLoader(MiniSet(meta_fileroots_alltask,transform=transform),
batch_size=args.batch_size, shuffle=True, num_workers=4, pin_memory=True)
meta_train_trainloader=DataLoader(MiniSet(train_fileroots_all_task,transform=transform),
batch_size=args.batch_size,shuffle=True, num_workers=4, pin_memory=True)
testloader=DataLoader(MiniSet(test_fileroots_alltask,transform=transform),
batch_size=args.batch_size,shuffle=True, num_workers=4, pin_memory=True)
for epoch in range(args.num_epoch):
torch.cuda.empty_cache()
res, is_best = run_epoch(epoch, args, model,train_loader=zip(trainloader,validloader), test_loader=zip(meta_train_trainloader,testloader))
dict2tsv(res, os.path.join(args.result_path, args.alg, args.log_path))
if is_best:
model.save()
torch.cuda.empty_cache()
if args.lr_sched:
model.lr_sched()
return None
def __call__(self, image, boxes=None, labels=None):
#initialize the format for lib albumentations
if boxes.shape[0] == 0:
return image, boxes, labels
bbox = []
for i in boxes:
bbox.append(list(i))
#create annotations
annotations = {
'image': image,
'bboxes': boxes,
'category_id': list(labels)
}
#create translation
#Color_Level Change
if self.cfg.DATA_LOADER.AUGMENTATION_WEATHER:
trans_color_level = A.Compose([
A.Cutout(num_holes=20,
max_h_size=64,
max_w_size=64,
fill_value=255,
always_apply=False,
p=0.8),
A.Equalize(p=1),
A.HueSaturationValue(hue_shift_limit=50,
sat_shift_limit=50,
val_shift_limit=50,
always_apply=False,
p=0.8),
A.OneOf([
A.RandomFog(fog_coef_lower=0.3,
fog_coef_upper=0.7,
alpha_coef=0.08,
always_apply=False,
p=0.5),
A.RandomSnow(snow_point_lower=0.1,
snow_point_upper=0.3,
brightness_coeff=2.5,
always_apply=False,
p=0.5),
A.RandomSunFlare(flare_roi=(0, 0, 1, 0.5),
angle_lower=0,
angle_upper=1,
num_flare_circles_lower=6,
num_flare_circles_upper=10,
src_radius=400,
src_color=(255, 255, 255),
always_apply=False,
p=0.5),
A.RandomRain(slant_lower=-10,
slant_upper=10,
drop_length=20,
drop_width=1,
drop_color=(200, 200, 200),
blur_value=7,
brightness_coefficient=0.7,
rain_type=None,
always_apply=False,
p=0.5)
]),
A.OneOf([
A.RandomSizedBBoxSafeCrop(720,
960,
erosion_rate=0.0,
interpolation=1,
always_apply=False,
p=0.5),
A.RandomSizedBBoxSafeCrop(480,
640,
erosion_rate=0.0,
interpolation=1,
always_apply=False,
p=0.5),
A.RandomSizedBBoxSafeCrop(240,
320,
erosion_rate=0.0,
interpolation=1,
always_apply=False,
p=0.5),
]),
])
else:
trans_color_level = A.Compose([
A.Cutout(num_holes=20,
max_h_size=64,
max_w_size=64,
fill_value=255,
always_apply=False,
p=0.5),
A.Equalize(p=1),
A.HueSaturationValue(hue_shift_limit=50,
sat_shift_limit=50,
val_shift_limit=50,
always_apply=False,
p=0.5),
A.OneOf([
A.RandomSizedBBoxSafeCrop(720,
960,
erosion_rate=0.0,
interpolation=1,
always_apply=False,
p=0.5),
A.RandomSizedBBoxSafeCrop(480,
640,
erosion_rate=0.0,
interpolation=1,
always_apply=False,
p=0.5),
A.RandomSizedBBoxSafeCrop(240,
320,
erosion_rate=0.0,
interpolation=1,
always_apply=False,
p=0.5),
]),
])
#Spatial_Level
if self.cfg.DATA_LOADER.AUGMENTATION_SPATIAL_LEVEL:
trans_rotate_level = A.Compose([
A.OneOf([
A.Rotate(limit=90,
interpolation=1,
border_mode=4,
value=None,
mask_value=None,
always_apply=False,
p=0.5),
A.RandomRotate90(always_apply=False, p=0.5),
A.VerticalFlip(always_apply=False, p=0.5),
A.HorizontalFlip(always_apply=False, p=0.5)
]),
])
#Apply the trans
aug = get_aug(trans_color_level)
augmented = aug(**annotations)
img = augmented['image']
bbox = augmented['bboxes']
bbox = np.array(bbox)
label = augmented['category_id']
#try rotate
if self.cfg.DATA_LOADER.AUGMENTATION_SPATIAL_LEVEL:
aug1 = get_aug(trans_rotate_level)
augmented1 = aug1(**augmented)
img1 = augmented1['image']
bbox1 = augmented1['bboxes']
bbox1 = np.array(bbox1)
label1 = augmented1['category_id']
#if rotate fail
if bbox1.shape[0] == 0:
return img, bbox.astype(np.float32), np.array(label)
else:
return img1, bbox1.astype(np.float32), np.array(label1)
else:
return img, bbox.astype(np.float32), np.array(label)
test = df[valid_idx]
print("Fold", i)
print(i, train_idxes)
# train = df.iloc[k_train]
# test = df.iloc[k_test]
# for k fold column
column_name = "traveler" + str(i)
summary_upload[column_name] = 0
AUGMENTATIONS = albumentations.Compose([
# albumentations.Transpose(p=0.5),
albumentations.RandomSunFlare(flare_roi=(0, 0, 1, 1),
angle_lower=0.5,
p=0.5),
albumentations.HorizontalFlip(p=0.5),
albumentations.VerticalFlip(p=0.5),
albumentations.GaussNoise(mean=100, p=0.5),
albumentations.Normalize(std=(0.9, 0.9, 0.9), p=0.2),
albumentations.RGBShift(r_shift_limit=20,
g_shift_limit=20,
b_shift_limit=20,
p=0.5),
albumentations.OneOf([
albumentations.RandomBrightnessContrast(brightness_limit=0.3,
contrast_limit=0.3),
albumentations.RandomBrightnessContrast(brightness_limit=0.1,
contrast_limit=0.1)
],
def __getitem__(self, idx):
net_h, net_w = self._update_net_size(idx)
# base_grid_h, base_grid_w = net_h // self.downsample, net_w // self.downsample
# determine the first and the last indices of the batch
l_bound, r_bound = self.get_inst_bounds(idx)
if r_bound > len(self.instances):
r_bound = len(self.instances)
l_bound = r_bound - self.batch_size
x_batch = np.zeros(
(r_bound - l_bound, net_h, net_w, 3)) # input images
# list of groundtruth boxes
t_batch = np.zeros(
(r_bound - l_bound, 1, 1, 1, self.max_box_per_image, 4))
# [print(net_h // self.downsample[i], net_w // self.downsample[i]) for i in reversed(range(self.output_layers_count))]
# According to reversed outputs - because of anchors
yolos = [
np.zeros((r_bound - l_bound, net_h // self.downsample[i],
net_w // self.downsample[i], self.anchors_per_output,
4 + 1 + len(self.labels)))
for i in reversed(range(self.output_layers_count))
]
instance_count = 0
true_box_index = 0
fill_value = [127] * 3
if self.infer_sz is None:
augmentations = [
albu.OneOf([
albu.IAAAdditiveGaussianNoise(),
albu.GaussNoise(),
],
p=0.2),
albu.OneOf([
albu.MotionBlur(p=0.2),
albu.MedianBlur(blur_limit=3, p=0.1),
albu.Blur(blur_limit=3, p=0.1),
],
p=0.2),
albu.OneOf([
albu.CLAHE(clip_limit=2),
albu.IAASharpen(),
albu.IAAEmboss(),
albu.RandomBrightnessContrast(),
],
p=0.3),
albu.HueSaturationValue(p=0.3),
albu.JpegCompression(quality_lower=50, quality_upper=100,
p=.5),
albu.MultiplicativeNoise(multiplier=[.5, 1.5],
per_channel=True,
p=.5),
albu.OneOf([
albu.RandomRain(),
albu.RandomFog(),
albu.RandomSunFlare(),
albu.RandomShadow(),
],
p=0.1),
ResizeKeepingRatio(target_wh=(net_w, net_h),
always_apply=True),
albu.PadIfNeeded(min_height=net_h,
min_width=net_w,
border_mode=0,
value=fill_value,
always_apply=True),
albu.ShiftScaleRotate(shift_limit=.25,
scale_limit=.25,
rotate_limit=15,
interpolation=3,
border_mode=0,
value=fill_value,
p=.7),
]
else:
augmentations = [
ResizeKeepingRatio(target_wh=(net_w, net_h),
always_apply=True),
albu.PadIfNeeded(min_height=net_h,
min_width=net_w,
border_mode=0,
value=fill_value,
always_apply=True),
]
transform = albu.Compose(augmentations,
bbox_params=albu.BboxParams(
format='pascal_voc',
min_visibility=0.1,
label_fields=['cat_name']))
# do the logic to fill in the inputs and the output
for inst_idx in range(l_bound, r_bound):
# augment input image and fix object's position and size
img, all_objs = self._aug_image(inst_idx, net_h, net_w, transform)
for objbox in all_objs:
# find the best anchor box for this object
max_anchor = None
max_index = -1
max_iou = -1
# print(objbox)
shifted_box = BoundBox(0, 0, objbox.xmax - objbox.xmin,
objbox.ymax - objbox.ymin)
# Get best matching anchor
for i in range(len(self.anchors)):
anchor = self.anchors[i]
iou = bbox_iou(shifted_box, anchor)
if max_iou < iou:
max_anchor = anchor
max_index = i
max_iou = iou
output_idx = max_index // self.anchors_per_output
output_anchor_idx = max_index % self.anchors_per_output
# determine the yolo to be responsible for this bounding box
yolo = yolos[output_idx]
# [52, 26, 13]
grid_h, grid_w = yolo.shape[1:3]
# determine the position of the bounding box on the grid
center_x = .5 * (objbox.xmin + objbox.xmax)
center_x = center_x / float(net_w) * grid_w # sigma(t_x) + c_x
center_y = .5 * (objbox.ymin + objbox.ymax)
center_y = center_y / float(net_h) * grid_h # sigma(t_y) + c_y
# if max_anchor.xmax == 0 or max_anchor.ymax == 0:
# print('>>>>> {}'.format(max_anchor))
# determine the sizes of the bounding box
w = np.log((objbox.xmax - objbox.xmin) /
float(max_anchor.xmax)) # t_w
h = np.log((objbox.ymax - objbox.ymin) /
float(max_anchor.ymax)) # t_h
box = [center_x, center_y, w, h]
if any(np.isinf(box)):
print(objbox, box, np.isinf(box))
# determine the index of the label
obj_indx = self.labels.index(objbox.class_name)
# print(self.labels, objbox.class_name, obj_indx)
# determine the location of the cell responsible for this object
grid_x = int(np.floor(center_x))
grid_y = int(np.floor(center_y))
# assign ground truth x, y, w, h, confidence and class probs to y_batch
yolo[instance_count, grid_y, grid_x, output_anchor_idx] = 0
yolo[instance_count, grid_y, grid_x, output_anchor_idx,
0:4] = box
yolo[instance_count, grid_y, grid_x, output_anchor_idx, 4] = 1.
yolo[instance_count, grid_y, grid_x, output_anchor_idx,
5 + obj_indx] = 1
# assign the true box to t_batch
true_box = [
center_x, center_y, objbox.xmax - objbox.xmin,
objbox.ymax - objbox.ymin
]
# print(true_box)
t_batch[instance_count, 0, 0, 0, true_box_index] = true_box
true_box_index += 1
true_box_index = true_box_index % self.max_box_per_image
# assign input image to x_batch
if self.norm:
# print(net_h, net_w, x_batch.shape, img.shape)
x_batch[instance_count] = self.norm(img)
# assert np.amax(x_batch) <= 1
# assert np.amin(x_batch) >= 0
else:
# plot image and bounding boxes for sanity check
for objbox in all_objs:
cv2.rectangle(img, (objbox.xmin, objbox.ymin),
(objbox.xmax, objbox.ymax), (255, 255, 0), 2)
cv2.putText(img, objbox.class_name,
(objbox.xmin + 2, objbox.ymin + 2), 0,
2e-3 * img.shape[0], (255, 0, 0), 2)
# print(train_instance['filename'])
# print(obj['name'])
x_batch[instance_count] = img
# increase instance counter in the current batch
instance_count += 1
dummies = [
np.zeros((r_bound - l_bound, 1))
for i in range(self.output_layers_count)
]
if self.norm:
return [x_batch, t_batch] + [yolo
for yolo in reversed(yolos)], dummies
else:
return x_batch
def get_train_transforms(height: int = 437,
width: int = 582,
level: str = 'hard'):
if level == 'light':
return A.Compose([
A.HorizontalFlip(p=0.5),
A.IAAAdditiveGaussianNoise(p=0.2),
A.OneOf([
A.CLAHE(p=1.0),
A.RandomBrightness(p=1.0),
A.RandomGamma(p=1.0),
],
p=0.5),
A.OneOf([
A.IAASharpen(p=1.0),
A.Blur(blur_limit=3, p=1.0),
A.MotionBlur(blur_limit=3, p=1.0),
],
p=0.5),
A.OneOf([
A.RandomContrast(p=1.0),
A.HueSaturationValue(p=1.0),
],
p=0.5),
A.Resize(height=height, width=width, p=1.0),
A.PadIfNeeded(pad_to_multiple(height),
pad_to_multiple(width),
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0)
],
p=1.0)
elif level == 'hard':
return A.Compose([
A.HorizontalFlip(p=0.5),
A.IAAAdditiveGaussianNoise(p=0.2),
A.OneOf([
A.GridDistortion(border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
p=1.0),
A.ElasticTransform(alpha_affine=10,
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
p=1.0),
A.ShiftScaleRotate(shift_limit=0,
scale_limit=0,
rotate_limit=10,
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
p=1.0),
A.OpticalDistortion(border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
p=1.0),
],
p=0.5),
A.OneOf([
A.CLAHE(p=1.0),
A.RandomBrightness(p=1.0),
A.RandomGamma(p=1.0),
A.ISONoise(p=1.0)
],
p=0.5),
A.OneOf([
A.IAASharpen(p=1.0),
A.Blur(blur_limit=3, p=1.0),
A.MotionBlur(blur_limit=3, p=1.0),
],
p=0.5),
A.OneOf([
A.RandomContrast(p=1.0),
A.HueSaturationValue(p=1.0),
],
p=0.5),
A.Resize(height=height, width=width, p=1.0),
A.Cutout(p=0.3),
A.PadIfNeeded(pad_to_multiple(height),
pad_to_multiple(width),
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0)
],
p=1.0)
elif level == 'hard_weather':
return A.Compose([
A.HorizontalFlip(p=0.5),
A.IAAAdditiveGaussianNoise(p=0.2),
A.OneOf([
A.GridDistortion(border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
p=1.0),
A.ElasticTransform(alpha_affine=10,
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
p=1.0),
A.ShiftScaleRotate(shift_limit=0,
scale_limit=0,
rotate_limit=10,
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
p=1.0),
A.OpticalDistortion(border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
p=1.0),
],
p=0.5),
A.OneOf([
A.CLAHE(p=1.0),
A.RandomBrightness(p=1.0),
A.RandomGamma(p=1.0),
A.ISONoise(p=1.0)
],
p=0.5),
A.OneOf([
A.IAASharpen(p=1.0),
A.Blur(blur_limit=3, p=1.0),
A.MotionBlur(blur_limit=3, p=1.0),
],
p=0.5),
A.OneOf([
A.RandomContrast(p=1.0),
A.HueSaturationValue(p=1.0),
],
p=0.5),
A.OneOf([
A.RandomFog(fog_coef_upper=0.8, p=1.0),
A.RandomRain(p=1.0),
A.RandomSnow(p=1.0),
A.RandomSunFlare(src_radius=100, p=1.0)
],
p=0.4),
A.Resize(height=height, width=width, p=1.0),
A.Cutout(p=0.3),
A.PadIfNeeded(pad_to_multiple(height),
pad_to_multiple(width),
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0)
],
p=1.0)
image_path = f'{DIR}/1360648.jpg'
if FGVC8_CAM:
DIR = "../input/iwildcam2021-fgvc8/train"
image_path = f'{DIR}/86760c00-21bc-11ea-a13a-137349068a90.jpg'
#%%
chosen_image = cv2.imread(image_path)
plt.imshow(chosen_image)
#%%
# ref)
# Albumentations part adapted from my good friend Hongnan's notebbok in the Global Wheat Detection competition (https://www.kaggle.com/reighns/augmentations-data-cleaning-and-bounding-boxes#Bounding-Boxes-with-Albumentations)
#%%
albumentation_list = [
A.RandomSunFlare(p=1),
A.RandomFog(p=1),
A.RandomBrightness(p=1),
A.RandomCrop(p=1, height=512, width=512),
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),
