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,
