def make_albu_augs(img_size: int, crop_size: Optional[int], mode: str): assert mode in ["train", "val", "test"] if crop_size is None: crop_size = img_size if mode == "train": return A.Compose([ A.RandomResizedCrop( crop_size, crop_size, scale=(0.9, 1), p=1, ), A.HorizontalFlip(p=0.5), A.ShiftScaleRotate(p=0.7), A.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=10, val_shift_limit=10, p=0.7), A.RandomBrightnessContrast(brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2), p=0.7), A.CLAHE(clip_limit=(1, 4), p=0.5), A.OneOf( [ A.OpticalDistortion(distort_limit=1.0), A.GridDistortion(num_steps=5, distort_limit=1.0), A.ElasticTransform(alpha=3), ], p=0.4, ), A.OneOf( [ A.GaussNoise(var_limit=[10, 50]), A.GaussianBlur(), A.MotionBlur(), A.MedianBlur(), ], p=0.4, ), A.ToGray(p=0.5), A.ToSepia(p=0.5), A.Cutout( max_h_size=int(crop_size * 0.075), max_w_size=int(crop_size * 0.075), num_holes=10, p=0.5, ), A.Normalize(mean=IMAGENET_DEFAULT_MEAN, std=IMAGENET_DEFAULT_STD), ToTensorV2(), ], ) if mode in ["val", "test"]: return A.Compose([ A.Resize(img_size, img_size), A.CenterCrop( crop_size, crop_size, p=1 if crop_size != img_size else 0), A.Normalize(mean=IMAGENET_DEFAULT_MEAN, std=IMAGENET_DEFAULT_STD), ToTensorV2(), ], )
def pet_augmentation(): transform_list = [ albu.Resize(100, 100), albu.HorizontalFlip(p=0.5), albu.ToSepia(p=0.2), albu.ToGray(p=0.3), albu.RandomRotate90(p=0.5), albu.VerticalFlip(p=0.2) ] return albu.Compose(transform_list)
def pet_augmentation(): transform_list = [ albu.Resize(100, 100), albu.HorizontalFlip(p=0.5), albu.ToSepia(p=0.2), albu.ToGray(p=0.3), albu.RandomRotate90(p=0.5), albu.VerticalFlip(p=0.2), albu.GaussianBlur(blur_limit=10,p=0.5,always_apply=False) ] return albu.Compose(transform_list)
def get_image_augmentation(): """ Augmentations just for input and output images (not for masks) """ image_transform = [ albu.OneOf([ albu.Blur(p=0.2, blur_limit=(3, 5)), albu.GaussNoise(p=0.2, var_limit=(10.0, 50.0)), albu.ISONoise(p=0.2, intensity=(0.1, 0.5), color_shift=(0.01, 0.05)), albu.ImageCompression(p=0.2, quality_lower=90, quality_upper=100, compression_type=0), albu.MultiplicativeNoise(p=0.2, multiplier=(0.9, 1.1), per_channel=True, elementwise=True), ], p=1), albu.OneOf([ albu.HueSaturationValue(p=0.2, hue_shift_limit=(-10, 10), sat_shift_limit=(-10, 10), val_shift_limit=(-10, 10)), albu.RandomBrightness(p=0.3, limit=(-0.1, 0.1)), albu.RandomGamma(p=0.3, gamma_limit=(80, 100), eps=1e-07), albu.ToGray(p=0.1), albu.ToSepia(p=0.1), ], p=1) ] return albu.Compose(image_transform, additional_targets={ 'image1': 'image', 'image2': 'image' })
logging.basicConfig(stream=sys.stdout, level=logging.INFO) log = logging.getLogger() weak_aug_tf = A.Compose([ A.HorizontalFlip(p=0.5), A.ShiftScaleRotate(scale_limit=0, rotate_limit=12.5, p=0.5), base_tf ]) strong_aug_tf = A.Compose([ A.ShiftScaleRotate(), A.OneOf([ A.CLAHE(), A.Solarize(), A.ColorJitter(), A.ToGray(), A.ToSepia(), A.RandomBrightness(), A.RandomGamma(), ]), A.CoarseDropout(max_height=4, max_width=4, max_holes=3, p=0.25), base_tf ]) def train_epoch_fixmatch(epoch, model, ema_model, train_dl_l, train_dl_ul, optimizer, sched, conf_thresh,
def __init__(self, dataframe, image_dir, transforms=None): super().__init__() self.df = dataframe self.image_ids = dataframe['image_id'].unique() self.image_ids = shuffle(self.image_ids) self.labels = [np.zeros( (0, 5), dtype=np.float32)] * len(self.image_ids) self.img_size = 1024 im_w = 1024 im_h = 1024 for i, img_id in enumerate(self.image_ids): records = self.df[self.df['image_id'] == img_id] boxes = records[['x', 'y', 'w', 'h']].values boxes[:, 2] = boxes[:, 0] + boxes[:, 2] boxes[:, 3] = boxes[:, 1] + boxes[:, 3] boxesyolo = [] for box in boxes: x1, y1, x2, y2 = box xc, yc, w, h = 0.5 * x1 / im_w + 0.5 * x2 / im_w, 0.5 * y1 / im_h + 0.5 * y2 / im_h, abs( x2 / im_w - x1 / im_w), abs(y2 / im_h - y1 / im_h) boxesyolo.append([1, xc, yc, w, h]) self.labels[i] = np.array(boxesyolo) self.image_dir = image_dir self.transforms = transforms self.mosaic = False self.augment = True self.aug = A.Compose( [ A.Resize(config.CROP_SIZE, config.CROP_SIZE, always_apply=True), A.OneOf([ A.RandomBrightnessContrast(brightness_limit=0.4, contrast_limit=0.4), A.RandomGamma(gamma_limit=(50, 150)), A.NoOp() ]), A.OneOf([ A.RGBShift( r_shift_limit=20, b_shift_limit=15, g_shift_limit=15), A.HueSaturationValue(hue_shift_limit=5, sat_shift_limit=5), A.NoOp() ]), A.OneOf([A.ChannelShuffle(), A.CLAHE(clip_limit=4), A.NoOp()]), A.OneOf([A.JpegCompression(), A.Blur(blur_limit=4), A.NoOp()]), A.OneOf([A.ToGray(), A.ToSepia(), A.NoOp()], p=0.2), A.GaussNoise(), A.Cutout(num_holes=8, max_h_size=64, max_w_size=64, fill_value=0, p=0.5), A.Normalize( config.MODEL_MEAN, config.MODEL_STD, always_apply=True), ToTensorV2(p=1.0) ], bbox_params={ 'format': config.DATA_FMT, 'min_area': 1, 'min_visibility': 0.5, 'label_fields': ['labels'] }, p=1.0)
def get_config(runner, raw_uri, processed_uri, root_uri, test=False, external_model=False, external_loss=False, augment=False): debug = False train_scene_info = get_scene_info(join(processed_uri, 'train-scenes.csv')) val_scene_info = get_scene_info(join(processed_uri, 'val-scenes.csv')) log_tensorboard = True run_tensorboard = True class_config = ClassConfig(names=['no_building', 'building']) if test: debug = True train_scene_info = train_scene_info[0:1] val_scene_info = val_scene_info[0:1] def make_scene(scene_info): (raster_uri, label_uri) = scene_info raster_uri = join(raw_uri, raster_uri) label_uri = join(processed_uri, label_uri) aoi_uri = join(raw_uri, aoi_path) if test: crop_uri = join(processed_uri, 'crops', os.path.basename(raster_uri)) label_crop_uri = join(processed_uri, 'crops', os.path.basename(label_uri)) save_image_crop(raster_uri, crop_uri, label_uri=label_uri, label_crop_uri=label_crop_uri, size=600, min_features=20, class_config=class_config) raster_uri = crop_uri label_uri = label_crop_uri id = os.path.splitext(os.path.basename(raster_uri))[0] raster_source = RasterioSourceConfig(channel_order=[0, 1, 2], uris=[raster_uri]) label_source = ChipClassificationLabelSourceConfig( vector_source=GeoJSONVectorSourceConfig(uri=label_uri, default_class_id=1, ignore_crs_field=True), ioa_thresh=0.5, use_intersection_over_cell=False, pick_min_class_id=False, background_class_id=0, infer_cells=True) return SceneConfig(id=id, raster_source=raster_source, label_source=label_source, aoi_uris=[aoi_uri]) chip_sz = 200 train_scenes = [make_scene(info) for info in train_scene_info] val_scenes = [make_scene(info) for info in val_scene_info] dataset = DatasetConfig(class_config=class_config, train_scenes=train_scenes, validation_scenes=val_scenes) if external_model: model = ClassificationModelConfig(external_def=ExternalModuleConfig( github_repo='lukemelas/EfficientNet-PyTorch', # uri='s3://raster-vision-ahassan/models/EfficientNet-PyTorch.zip', name='efficient_net', entrypoint='efficientnet_b0', force_reload=False, entrypoint_kwargs={ 'num_classes': len(class_config.names), 'pretrained': 'imagenet' })) else: model = ClassificationModelConfig(backbone=Backbone.resnet50) if external_loss: external_loss_def = ExternalModuleConfig( github_repo='AdeelH/pytorch-multi-class-focal-loss', name='focal_loss', entrypoint='focal_loss', force_reload=False, entrypoint_kwargs={ 'alpha': [.75, .25], 'gamma': 2 }) else: external_loss_def = None solver = SolverConfig(lr=1e-4, num_epochs=20, test_num_epochs=4, batch_sz=32, one_cycle=True, external_loss_def=external_loss_def) if augment: mu = np.array((0.485, 0.456, 0.406)) std = np.array((0.229, 0.224, 0.225)) aug_transform = A.Compose([ A.Flip(), A.Transpose(), A.RandomRotate90(), A.ShiftScaleRotate(), A.OneOf([ A.ChannelShuffle(), A.CLAHE(), A.FancyPCA(), A.HueSaturationValue(), A.RGBShift(), A.ToGray(), A.ToSepia(), ]), A.OneOf([ A.RandomBrightness(), A.RandomGamma(), ]), A.OneOf([ A.GaussNoise(), A.ISONoise(), A.RandomFog(), ]), A.OneOf([ A.Blur(), A.MotionBlur(), A.ImageCompression(), A.Downscale(), ]), A.CoarseDropout(max_height=32, max_width=32, max_holes=5) ]) base_transform = A.Normalize(mean=mu.tolist(), std=std.tolist()) plot_transform = A.Normalize(mean=(-mu / std).tolist(), std=(1 / std).tolist(), max_pixel_value=1.) else: aug_transform = None base_transform = None plot_transform = None backend = PyTorchChipClassificationConfig( model=model, solver=solver, log_tensorboard=log_tensorboard, run_tensorboard=run_tensorboard, test_mode=test, base_transform=A.to_dict(base_transform), aug_transform=A.to_dict(aug_transform), plot_options=PlotOptions(transform=A.to_dict(plot_transform))) config = ChipClassificationConfig(root_uri=root_uri, dataset=dataset, backend=backend, train_chip_sz=chip_sz, predict_chip_sz=chip_sz) return config
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
import albumentations as A from albumentations.pytorch import ToTensorV2 train_transform = A.Compose([ A.ChannelShuffle(p=0.1), A.GaussNoise(p=0.1), A.GaussianBlur(p=0.1), A.HueSaturationValue(p=0.1), A.IAAAdditiveGaussianNoise(p=0.1), A.IAASharpen(p=0.5), A.ISONoise(p=0.3), A.RandomBrightness(p=0.8), A.RandomBrightnessContrast(p=0.2), A.ToSepia(p=0.1), A.Resize(299, 299), A.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ToTensorV2(), ]) val_transform = A.Compose([ A.Resize(299, 299), A.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ToTensorV2(), ])
# Enables the inbuilt cuDNN auto-tuner to find the best algorithm to use for your hardware. cudnn.benchmark = True ground_truth = pd.read_csv("../dataset/ground-truth.csv") ground_truth = ground_truth.sample(frac=1) ground_truth.reset_index(inplace=True, drop=True) train_dataset, validation_dataset, test_dataset = split_dataset( ground_truth, 0.1, 0.1) dataset_transform = A.Compose([ A.ShiftScaleRotate(p=0.6, shift_limit=0.1, rotate_limit=15), A.RandomBrightnessContrast(p=0.7), A.ToGray(p=0.3), A.ToSepia(p=0.2), ToTensorV2(), ]) test_dataset_transform = A.Compose([ToTensorV2()]) train_dataset = RotatedImagesDataset("../dataset/images", train_dataset, dataset_transform) validation_dataset = RotatedImagesDataset("../dataset/images", validation_dataset, dataset_transform) test_dataset = RotatedImagesDataset("../dataset/images", test_dataset, test_dataset_transform) params = { "device": "cuda", "learning_rate": 1e-4, "batch_size": 64,
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() ])