def get_train_transforms(): return A.Compose([ A.RandomSizedCrop((140, 140), width=160, height=160, p=0.25), A.OneOf([ A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.9), A.RandomBrightnessContrast( brightness_limit=0.2, contrast_limit=0.2, p=0.9), ], p=0.9), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.Rotate(limit=45, p=1), A.ChannelShuffle(p=0.05), A.FancyPCA(), A.GaussNoise(p=0.25), A.Blur(blur_limit=4, p=0.1), A.Cutout(num_holes=8, max_h_size=4, max_w_size=4, fill_value=0, p=0.1), A.Resize( 160, 160, ), A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), ToTensorV2(p=1.0), ], p=1.0)
def get_valid_aug(RESOLUTION=380): return A.Compose([ # A.SmallestMaxSize(max_size=RESOLUTION*2, interpolation=cv2.INTER_CUBIC, \ # always_apply=True), # A.OneOf([ # A.CenterCrop(RESOLUTION,RESOLUTION, always_apply=True), # A.RandomResizedCrop(RESOLUTION,RESOLUTION, scale=(0.4, 1.0), \ # always_apply=True, interpolation=cv2.INTER_CUBIC), # ], p=1.0), A.LongestMaxSize(max_size=RESOLUTION, interpolation=cv2.INTER_CUBIC, \ always_apply=True), A.PadIfNeeded(min_height=RESOLUTION, min_width=RESOLUTION, always_apply=True, border_mode=cv2.BORDER_CONSTANT), # A.Resize(RESOLUTION, RESOLUTION, p=1.0, interpolation=cv2.INTER_CUBIC), A.HorizontalFlip(p=0.5), A.FancyPCA(p=1.0, alpha=0.5), A.HueSaturationValue( hue_shift_limit=0.1, sat_shift_limit=0.1, val_shift_limit=0.1, p=0.5 ), A.RandomBrightnessContrast( brightness_limit=(-0.1,0.1), contrast_limit=(-0.1, 0.1), p=0.5 ), A.Sharpen(p=1.0, alpha=(0.1, 0.3), lightness=(0.3, 0.9)) ], p=1.0)
def get_medium_augmentations(image_size): min_size = min(image_size[0], image_size[1]) return A.Compose([ A.OneOf([A.RandomSizedCrop(min_max_height=(int(min_size* 0.85), min_size), height=image_size[0], width=image_size[1]), A.Resize(image_size[0], image_size[1]), A.CenterCrop(image_size[0], image_size[1]) ], p = 1.0), A.OneOf([ A.RandomBrightnessContrast(brightness_limit=0.15, contrast_limit=0.5), A.RandomGamma(gamma_limit=(50, 150)), A.NoOp() ], p = 1.0), A.OneOf([A.CLAHE(p=0.5, clip_limit=(10, 10), tile_grid_size=(3, 3)), A.FancyPCA(alpha=0.4), A.NoOp(), ], p = 1.0), A.OneOf([A.HorizontalFlip(), A.VerticalFlip(), A.RandomRotate90(), A.NoOp() ], p = 1.0) ])
def get_medium_augmentations(image_size): return A.Compose([ A.OneOf([ A.ShiftScaleRotate(shift_limit=0.05, scale_limit=0.1, rotate_limit=15, border_mode=cv2.BORDER_CONSTANT, value=0), A.OpticalDistortion(distort_limit=0.11, shift_limit=0.15, border_mode=cv2.BORDER_CONSTANT, value=0), A.NoOp() ]), A.RandomSizedCrop(min_max_height=(int(image_size[0] * 0.75), image_size[0]), height=image_size[0], width=image_size[1], p=0.3), A.OneOf([ A.RandomBrightnessContrast(brightness_limit=0.5, contrast_limit=0.4), A.RandomGamma(gamma_limit=(50, 150)), A.NoOp() ]), A.OneOf([ A.FancyPCA(alpha_std=4), 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.CLAHE(), A.NoOp() ]), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5) ])
def create_generalization_transform(): return A.Compose([ A.Blur(blur_limit=(5, 10), p=0.7), A.OneOf([ A.RandomBrightnessContrast(), A.FancyPCA(), A.HueSaturationValue() ], p=0.7), A.OpticalDistortion(distort_limit=(1., 2.), border_mode=cv2.BORDER_CONSTANT, p=0.5) ])
def create_train_transforms(self, crop_size): transforms = [ A.OneOf([ RandomCrop(crop_size, crop_size, p=0.3), RandomSizedCropAroundBbox(min_max_height=(int( crop_size * 0.65), int(crop_size * 1.4)), height=crop_size, width=crop_size, p=0.7) ], p=1), A.Rotate(20, p=0.2, border_mode=cv2.BORDER_CONSTANT), A.HorizontalFlip(), A.VerticalFlip(), A.RandomRotate90(), A.RandomBrightnessContrast(), A.RandomGamma(), A.FancyPCA(p=0.2) ] return A.Compose(transforms, additional_targets={'labels': 'mask'})
def compose_transform_tr(self): composed_transforms = A.Compose([ # A.HorizontalFlip(), # A.Rotate(), # A.RandomScale(0.2), A.LongestMaxSize(self.base_size, always_apply=True), A.PadIfNeeded(self.base_size, self.base_size, always_apply=True, border_mode=cv2.BORDER_CONSTANT), # A.RandomSizedCrop((self.args.crop_size, self.args.crop_size),height=self.args.crop_size, width=self.args.crop_size), A.RandomBrightnessContrast(), A.HueSaturationValue(), A.FancyPCA(), A.RandomGamma(), A.GaussianBlur(), A.Normalize(), ToTensorV2() ]) return composed_transforms
def create_data_transforms(args, split='train'): """Create data transofrms Args: args: data transforms configs split (str, optional): split for train, val or test. Defaults to 'train'. Returns: albumentation: pytorch data augmentations """ base_transform = create_base_transforms(args, split=split) if split == 'train': aug_transform = alb.Compose([ alb.Rotate(limit=30), alb.Cutout(1, 25, 25, p=0.1), alb.RandomResizedCrop(256, 256, scale=(0.5, 1.0), p=0.5), alb.Resize(args.image_size, args.image_size), alb.HorizontalFlip(), alb.ToGray(p=0.1), alb.GaussNoise(p=0.1), alb.OneOf([ alb.RandomBrightnessContrast(), alb.FancyPCA(), alb.HueSaturationValue(), ], p=0.7), alb.GaussianBlur(blur_limit=3, p=0.05), ]) data_transform = alb.Compose([*aug_transform, *base_transform]) elif split == 'val': data_transform = base_transform elif split == 'test': data_transform = base_transform return data_transform
def get_train_aug(RESOLUTION=300): return A.Compose([ A.SmallestMaxSize(max_size=RESOLUTION*2, interpolation=cv2.INTER_CUBIC, \ always_apply=True), A.RandomResizedCrop(RESOLUTION,RESOLUTION, scale=(0.7, 1), \ interpolation=cv2.INTER_CUBIC), A.Resize(RESOLUTION, RESOLUTION, p=1.0, interpolation=cv2.INTER_CUBIC), A.FancyPCA(p=0.8, alpha=0.5), # A.Transpose(p=0.7), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.1), A.ShiftScaleRotate(p=0.7), A.HueSaturationValue( hue_shift_limit=0.3, sat_shift_limit=0.3, val_shift_limit=0.3, p=0.7 ), A.RandomBrightnessContrast( brightness_limit=(-0.2,0.2), contrast_limit=(-0.2, 0.2), p=0.7 ), A.CoarseDropout(p=0.8, max_holes=30), A.Cutout(p=0.8, max_h_size=40, max_w_size=40), A.OneOf([ A.OpticalDistortion(p=0.3), A.GridDistortion(p=.1), A.IAAPiecewiseAffine(p=0.3), ], p=0.6), A.Sharpen(p=1.0, alpha=(0.1,0.3), lightness=(0.3, 0.9)), A.OneOf([ A.IAAAdditiveGaussianNoise(p=1.0), A.GaussNoise(p=1.0), A.MotionBlur(always_apply=False, p=1.0, blur_limit=(3, 3)) ], p=0.5), ], p=1.0)
def hard_augmentations(mask_dropout=True) -> List[A.DualTransform]: return [ # D4 Augmentations A.RandomRotate90(p=1), A.Transpose(p=0.5), # Spatial augmentations A.OneOf( [ A.ShiftScaleRotate(scale_limit=0.2, rotate_limit=45, border_mode=cv2.BORDER_REFLECT101), A.ElasticTransform(border_mode=cv2.BORDER_REFLECT101, alpha_affine=5), ] ), # Color augmentations A.OneOf( [ A.RandomBrightnessContrast(brightness_by_max=True), A.CLAHE(), A.FancyPCA(), A.HueSaturationValue(), A.RGBShift(), A.RandomGamma(), ] ), # Dropout & Shuffle A.OneOf( [ A.RandomGridShuffle(), A.CoarseDropout(), A.MaskDropout(max_objects=2, mask_fill_value=0) if mask_dropout else A.NoOp(), ] ), # Add occasion blur A.OneOf([A.GaussianBlur(), A.GaussNoise(), A.IAAAdditiveGaussianNoise()]), # Weather effects A.RandomFog(fog_coef_lower=0.01, fog_coef_upper=0.3, p=0.1), ]
def get_train_aug(RESOLUTION=300): return A.Compose([ A.LongestMaxSize(max_size=RESOLUTION*2, interpolation=cv2.INTER_CUBIC, \ always_apply=True), A.PadIfNeeded(min_height=RESOLUTION*2, min_width=RESOLUTION*2, always_apply=True, border_mode=cv2.BORDER_CONSTANT), A.RandomResizedCrop(RESOLUTION,RESOLUTION, scale=(0.7, 1), \ interpolation=cv2.INTER_CUBIC), A.Resize(RESOLUTION, RESOLUTION, p=1.0, interpolation=cv2.INTER_CUBIC), A.FancyPCA(p=0.8, alpha=0.5), # A.Transpose(p=0.7), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.1), A.ShiftScaleRotate(p=0.4, rotate_limit=12), A.HueSaturationValue( always_apply=False, p=0.3, hue_shift_limit=(-20, 20), sat_shift_limit=(-30, 30), val_shift_limit=(-20, 20)), # A.HueSaturationValue( # hue_shift_limit=0.4, #.3 # sat_shift_limit=0.4, #.3 # val_shift_limit=0.4, #.3 # p=0.7 # ), A.RandomBrightnessContrast( brightness_limit=(-0.5,0.5), #-.2,.2 contrast_limit=(-0.4, 0.4), #-.2,.2 #p=0.6 ), A.CoarseDropout(p=0.8, max_holes=30), # A.Cutout(p=0.8, max_h_size=40, max_w_size=40), A.Cutout(p=1, max_h_size=60, max_w_size=30, num_holes=6, fill_value=[106,87,55]), A.Cutout(p=1, max_h_size=30, max_w_size=60, num_holes=6, fill_value=[106,87,55]), A.OneOf([ A.OpticalDistortion(always_apply=False, p=1.0, distort_limit=(-0.6599999666213989, 0.6800000071525574), shift_limit=(-0.6699999570846558, 0.4599999785423279), interpolation=0, border_mode=0, value=(0, 0, 0), mask_value=None), # A.OpticalDistortion(p=0.5, distort_limit=0.15, shift_limit=0.15), # A.GridDistortion(p=0.5, distort_limit=0.5), A.GridDistortion(always_apply=False, p=1.0, num_steps=6, distort_limit=(-0.4599999785423279, 0.5), interpolation=0, border_mode=0, value=(0, 0, 0), mask_value=None), # A.IAAPiecewiseAffine(p=0.5, scale=(0.1, 0.14)), ], p=0.6), A.Sharpen(p=1.0, alpha=(0.1,0.3), lightness=(0.3, 0.9)), A.GaussNoise(var_limit=(300.0, 500.0), p=0.4), A.ISONoise(always_apply=False, p=0.4, intensity=(0.10000000149011612, 1.399999976158142), color_shift=(0.009999999776482582, 0.4000000059604645)), A.OneOf([ A.Equalize(always_apply=False, p=1.0, mode='cv', by_channels=True), A.Solarize(always_apply=False, p=1.0, threshold=(67, 120)), # A.IAAAdditiveGaussianNoise(p=1.0), A.GaussNoise(p=1.0), A.MotionBlur(always_apply=False, p=1.0, blur_limit=(5, 20)) ], p=0.5), ], p=1.0)
albumentations.OneOf([ albumentations.CenterCrop(height=250, width=200), albumentations.CenterCrop(height=200, width=250), ], 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) ], p=0.5), albumentations.GaussianBlur(p=0.05), albumentations.HueSaturationValue(p=0.5), albumentations.RGBShift(p=0.5), albumentations.FancyPCA(alpha=0.1, always_apply=False, p=0.5), albumentations.Resize(IMG_SIZE, IMG_SIZE) ]) test_datagen = ImageDataAugmentor( rescale=1. / 255, augment=AUGMENTATIONS, validation_split=VAL_SPLIT, ) test_sub_generator = test_datagen.flow_from_dataframe( dataframe=sample_submission, directory=DATA_PATH + 'test_upload/', x_col="Id", y_col=None, shuffle=False,
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
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() ])
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 train_function(gpu, world_size, node_rank, gpus, fold_number, group_name): 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 ) device = torch.device("cuda:{}".format(gpu) if torch.cuda.is_available() else "cpu") batch_size = 64 width_size = 416 init_lr = 1e-4 end_lr = 1e-6 n_epochs = 20 emb_size = 512 margin = 0.5 dropout = 0.0 iters_to_accumulate = 1 if rank == 0: wandb.init(project='shopee_effnet0', group=group_name, job_type=str(fold_number)) checkpoints_dir_name = 'effnet0_{}_{}_{}'.format(width_size, dropout, group_name) os.makedirs(checkpoints_dir_name, exist_ok=True) wandb.config.model_name = checkpoints_dir_name wandb.config.batch_size = batch_size wandb.config.width_size = width_size wandb.config.init_lr = init_lr wandb.config.n_epochs = n_epochs wandb.config.emb_size = emb_size wandb.config.dropout = dropout wandb.config.iters_to_accumulate = iters_to_accumulate wandb.config.optimizer = 'adam' wandb.config.scheduler = 'ShopeeScheduler' df = pd.read_csv('../../dataset/reliable_validation_tm.csv') train_df = df[df['fold_group'] != fold_number] train_transforms = alb.Compose([ alb.RandomResizedCrop(width_size, width_size), alb.ShiftScaleRotate(shift_limit=0.1, rotate_limit=30), alb.HorizontalFlip(), alb.OneOf([ alb.Sequential([ alb.HueSaturationValue(hue_shift_limit=50), alb.RandomBrightnessContrast(), ]), alb.FancyPCA(), alb.ChannelDropout(), alb.ChannelShuffle(), alb.RGBShift() ]), alb.CoarseDropout(max_height=int(width_size*0.1), max_width=int(width_size*0.1)), alb.OneOf([ alb.ElasticTransform(), alb.OpticalDistortion(), alb.GridDistortion() ]), alb.Resize(width_size, width_size), alb.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), ToTensorV2() ]) train_set = ImageDataset(train_df, train_df, '../../dataset/train_images', train_transforms) sampler = DistributedSampler(train_set, num_replicas=world_size, rank=rank, shuffle=True) train_dataloader = DataLoader(train_set, batch_size=batch_size // world_size, shuffle=False, num_workers=4, sampler=sampler) # valid_df = df[df['fold_strat'] == fold_number] valid_transforms = alb.Compose([ alb.Resize(width_size, width_size), alb.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), ToTensorV2() ]) # valid_set = ImageDataset(train_df, valid_df, '../../dataset/train_images', valid_transforms) # valid_dataloader = DataLoader(valid_set, batch_size=batch_size // world_size, shuffle=False, num_workers=4) test_df = df[df['fold_group'] == fold_number] test_set = ImageDataset(test_df, test_df, '../../dataset/train_images', valid_transforms) test_dataloader = DataLoader(test_set, batch_size=batch_size // world_size, shuffle=False, num_workers=4) model = EfficientNetArcFace(emb_size, train_df['label_group'].nunique(), device, dropout=dropout, backbone='tf_efficientnet_b0_ns', pretrained=True, margin=margin, is_amp=True) model = SyncBatchNorm.convert_sync_batchnorm(model) model.to(device) model = DistributedDataParallel(model, device_ids=[gpu]) scaler = GradScaler() criterion = CrossEntropyLoss() # criterion = LabelSmoothLoss(smoothing=0.1) optimizer = optim.Adam(model.parameters(), lr=init_lr) # scheduler = CosineAnnealingLR(optimizer, T_max=n_epochs, eta_min=end_lr, # last_epoch=-1) # scheduler = CosineAnnealingWarmRestarts(optimizer, T_0=2000, T_mult=1, # eta_min=end_lr, last_epoch=-1) scheduler = ShopeeScheduler(optimizer, lr_start=init_lr, lr_max=init_lr*batch_size, lr_min=end_lr) for epoch in range(n_epochs): train_loss, train_duration, train_f1 = train_one_epoch( model, train_dataloader, optimizer, criterion, device, scaler, scheduler=None, iters_to_accumulate=iters_to_accumulate) scheduler.step() if rank == 0: # valid_loss, valid_duration, valid_f1 = evaluate(model, valid_dataloader, criterion, device) embeddings = get_embeddings(model, test_dataloader, device) embeddings_f1 = validate_embeddings_f1(embeddings, test_df) wandb.log({'train_loss': train_loss, 'train_f1': train_f1, 'embeddings_f1': embeddings_f1, 'epoch': epoch}) filename = '{}_foldnum{}_epoch{}_train_loss{}_f1{}'.format( checkpoints_dir_name, fold_number+1, epoch+1, round(train_loss, 3), round(embeddings_f1, 3)) torch.save(model.module.state_dict(), os.path.join(checkpoints_dir_name, '{}.pth'.format(filename))) # np.savez_compressed(os.path.join(checkpoints_dir_name, '{}.npz'.format(filename)), embeddings=embeddings) print('FOLD NUMBER %d\tEPOCH %d:\t' 'TRAIN [duration %.3f sec, loss: %.3f, avg f1: %.3f]\t' 'VALID EMBEDDINGS [avg f1: %.3f]\tCurrent time %s' % (fold_number + 1, epoch + 1, train_duration, train_loss, train_f1, embeddings_f1, str(datetime.now(timezone('Europe/Moscow'))))) if rank == 0: wandb.finish()
import numpy as np import albumentations as A example_rgb_transform = A.Compose([ A.Flip(), A.Transpose(), A.RandomRotate90(), A.ShiftScaleRotate(), A.OneOf([ A.CLAHE(), A.FancyPCA(), A.HueSaturationValue(hue_shift_limit=10), 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(), ]),
train_transforms = A.Compose([ A.HorizontalFlip(p=0.3), A.RandomBrightnessContrast(p=0.1), A.OneOf( [ A.ShiftScaleRotate( rotate_limit=18, p=1, border_mode=cv.BORDER_CONSTANT), A.IAAAffine(shear=10, p=1, mode="constant"), #A.Perspective(scale=(0.05, 0.15), keep_size=True, pad_mode=0, pad_val=0, # mask_pad_val=0, fit_output=False, interpolation=1, always_apply=False, p=1), ], p=1.0, ), A.OneOf( [ A.FancyPCA(alpha=0.1, always_apply=False, p=1), A.Blur(p=1), A.ToGray(p=0.8), A.ColorJitter( brightness=0.1, contrast=0.1, saturation=0.1, hue=0.1, p=1), A.ChannelDropout((1, 1), fill_value=0, always_apply=False, p=1), ], p=0.3, ), A.OneOf( [ #A.GaussNoise (var_limit=(10.0, 50.0), mean=0, per_channel=True, always_apply=False, p=0.5), A.Equalize(mode='cv', by_channels=True, mask=None, mask_params=(), always_apply=False,