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()
])
