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),