def __init__(self, args):
self.args = args
self.args.start_epoch = 0
self.args.cuda = True
# data transforms
input_transform = transform.Compose([
transform.ToTensor(),
transform.Normalize([.490, .490, .490], [.247, .247, .247])
]) # TODO: change mean and std
# dataset
train_chain = Compose([
HorizontalFlip(p=0.5),
OneOf([
ElasticTransform(
alpha=300, sigma=300 * 0.05, alpha_affine=300 * 0.03),
GridDistortion(),
OpticalDistortion(distort_limit=2, shift_limit=0.5),
],
p=0.3),
RandomSizedCrop(
min_max_height=(900, 1024), height=1024, width=1024, p=0.5),
ShiftScaleRotate(rotate_limit=20, p=0.5),
Resize(self.args.size, self.args.size)
],
p=1)
val_chain = Compose([Resize(self.args.size, self.args.size)], p=1)
num_fold = self.args.num_fold
df_train = pd.read_csv(os.path.join(args.imagelist_path, 'train.csv'))
df_val = pd.read_csv(os.path.join(args.imagelist_path, 'val.csv'))
df_full = pd.concat((df_train, df_val), ignore_index=True, axis=0)
df_full['lbl'] = (df_full['mask_name'].astype(str) == '-1').astype(int)
skf = StratifiedKFold(8, shuffle=True, random_state=777)
train_ids, val_ids = list(
skf.split(df_full['mask_name'], df_full['lbl']))[num_fold]
df_test = pd.read_csv(
os.path.join(args.imagelist_path, 'test_true.csv'))
df_new_train = pd.concat((df_full.iloc[train_ids], df_test),
ignore_index=True,
axis=0,
sort=False)
df_new_val = df_full.iloc[val_ids]
df_new_train.to_csv(f'/tmp/train_new_pneumo_{num_fold}.csv')
df_new_val.to_csv(f'/tmp/val_new_pneumo_{num_fold}.csv')
trainset = SegmentationDataset(f'/tmp/train_new_pneumo_{num_fold}.csv',
args.image_path,
args.masks_path,
input_transform=input_transform,
transform_chain=train_chain,
base_size=1024)
testset = SegmentationDataset(f'/tmp/val_new_pneumo_{num_fold}.csv',
args.image_path,
args.masks_path,
input_transform=input_transform,
transform_chain=val_chain,
base_size=1024)
imgs = trainset.mask_img_map[:, [0, 3]]
weights = make_weights_for_balanced_classes(imgs, 2)
weights = torch.DoubleTensor(weights)
train_sampler = (torch.utils.data.sampler.WeightedRandomSampler(
weights, len(weights)))
# dataloader
kwargs = {'num_workers': args.workers, 'pin_memory': True}
self.trainloader = data.DataLoader(
trainset,
batch_size=args.batch_size,
drop_last=True,
sampler=train_sampler, #shuffle=True,
**kwargs)
self.valloader = data.DataLoader(testset,
batch_size=args.batch_size,
drop_last=False,
shuffle=False,
**kwargs)
self.nclass = 1
if self.args.model == 'unet':
model = UNet(n_classes=self.nclass, norm_layer=SyncBatchNorm)
params_list = [
{
'params': model.parameters(),
'lr': args.lr
},
]
elif self.args.model == 'encnet':
model = EncNet(
nclass=self.nclass,
backbone=args.backbone,
aux=args.aux,
se_loss=args.se_loss,
norm_layer=SyncBatchNorm #nn.BatchNorm2d
)
# optimizer using different LR
params_list = [
{
'params': model.pretrained.parameters(),
'lr': args.lr
},
]
if hasattr(model, 'head'):
params_list.append({
'params': model.head.parameters(),
'lr': args.lr * 10
})
if hasattr(model, 'auxlayer'):
params_list.append({
'params': model.auxlayer.parameters(),
'lr': args.lr * 10
})
print(model)
optimizer = torch.optim.SGD(params_list,
lr=args.lr,
momentum=0.9,
weight_decay=args.wd)
# criterions
if self.nclass == 1:
self.criterion = SegmentationLossesBCE(se_loss=args.se_loss,
aux=args.aux,
nclass=self.nclass,
se_weight=args.se_weight,
aux_weight=args.aux_weight,
use_dice=args.use_dice)
else:
self.criterion = SegmentationLosses(
se_loss=args.se_loss,
aux=args.aux,
nclass=self.nclass,
se_weight=args.se_weight,
aux_weight=args.aux_weight,
)
self.model, self.optimizer = model, optimizer
self.best_pred = 0.0
self.model = DataParallelModel(self.model).cuda()
self.criterion = DataParallelCriterion(self.criterion).cuda()
# resuming checkpoint
if args.resume is not None:
if not os.path.isfile(args.resume):
raise RuntimeError("=> no checkpoint found at '{}'".format(
args.resume))
checkpoint = torch.load(args.resume) #, map_location='cpu')
self.args.start_epoch = checkpoint['epoch']
state_dict = {k: v for k, v in checkpoint['state_dict'].items()}
self.model.load_state_dict(state_dict)
self.optimizer.load_state_dict(checkpoint['optimizer'])
for g in self.optimizer.param_groups:
g['lr'] = args.lr
self.best_pred = checkpoint['best_pred']
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
print(f'Best dice: {checkpoint["best_pred"]}')
print(f'LR: {get_lr(self.optimizer):.5f}')
self.scheduler = ReduceLROnPlateau(self.optimizer,
mode='min',
factor=0.8,
patience=4,
threshold=0.001,
threshold_mode='abs',
min_lr=0.00001)
self.logger = Logger(args.logger_dir)
self.step_train = 0
self.best_loss = 20
self.step_val = 0
def make_prediction(
device_num: int,
equalization: bool = False,
normalization: bool = False,
):
device = torch.device(f'cuda:{device_num}')
trn_lbl_df = load_trn_lbl_df()
trn_hdr_df = pd.read_pickle(TRN_HDR_DF_PATH)
tst_hdr_df = pd.read_pickle(TST_HDR_DF_PATH)
trn_df = pd.concat([trn_hdr_df, trn_lbl_df], axis=1, join='inner')
trn_outlier_mask, tst_outlier_mask = get_outlier(trn_df, tst_hdr_df)
valid_trn_df = trn_df[~trn_outlier_mask]
trn_dset_kwargs = {
'training': True,
'dataframe': valid_trn_df,
'window_ranges': DEFAULT_WINDOW_RANGES,
'equalization': equalization,
'regularize_dim': 512,
'low_memory': True,
}
tst_dset_kwargs = {
'training': False,
'dataframe': tst_hdr_df,
'window_ranges': DEFAULT_WINDOW_RANGES,
'equalization': equalization,
'regularize_dim': 512,
'low_memory': True,
}
if normalization:
channel_avgs, channel_stds, nan_sample_ids = \
normalize_dset(trn_dset_kwargs, num_workers=-1, batch_size=128)
valid_trn_df.drop(nan_sample_ids, inplace=True)
trn_transform = Compose([
Resize(IMG_DIM, IMG_DIM),
Normalize(mean=channel_avgs, std=channel_stds),
HorizontalFlip(),
RandomBrightnessContrast(),
ShiftScaleRotate(),
ToTensor()
])
tst_transform = Compose([
Resize(IMG_DIM, IMG_DIM),
Normalize(mean=channel_avgs, std=channel_stds),
ToTensor()
])
else:
trn_transform = Compose([
Resize(IMG_DIM, IMG_DIM),
HorizontalFlip(),
RandomBrightnessContrast(),
ShiftScaleRotate(),
ToTensor()
])
tst_transform = Compose([Resize(IMG_DIM, IMG_DIM), ToTensor()])
trn_dset = ICHDataset(**trn_dset_kwargs, transform=trn_transform)
tst_dset = ICHDataset(**tst_dset_kwargs, transform=tst_transform)
dldr_kwargs = {
'batch_size': 32,
'num_workers': 32,
'pin_memory': True,
'timeout': 1000,
}
trn_dldr = DataLoader(trn_dset, **dldr_kwargs)
tst_dldr = DataLoader(tst_dset, **dldr_kwargs)
model = torch.hub.load(
'facebookresearch/WSL-Images',
f'resnext101_32x{NUM_CARDINALITY}d_wsl',
).to(device)
model.fc = torch.nn.Linear(2048, len(DIAGNOSIS)).to(device)
criterion = torch.nn.BCEWithLogitsLoss(
weight=torch.FloatTensor([2, 1, 1, 1, 1, 1]).to(device))
optim = torch.optim.Adam(params=model.parameters(), lr=2e-5)
amp.initialize(model, optim, opt_level='O1')
for epoch in range(NUM_EPOCHS):
print('Epoch {}/{}'.format(epoch, NUM_EPOCHS - 1))
print('-' * 10)
# model.train()
# tr_loss = 0
#
# trn_iter = tqdm(trn_dldr, desc="Iteration")
#
# for step, batch in enumerate(trn_iter):
#
# inputs = batch["image"]
# labels = batch["labels"]
#
# inputs = inputs.to(device, dtype=torch.float)
# labels = labels.to(device, dtype=torch.float)
#
# outputs = model(inputs)
# loss = criterion(outputs, labels)
#
# loss.backward()
#
# tr_loss += loss.item()
#
# optim.step()
# optim.zero_grad()
#
# if epoch == 1 and step > 6000:
# epoch_loss = tr_loss / 6000
# print('Training Loss: {:.4f}'.format(epoch_loss))
# break
#
# epoch_loss = tr_loss / len(trn_dldr)
# print('Training Loss: {:.4f}'.format(epoch_loss))
with torch.no_grad():
model.eval()
ids = []
predictions = []
tst_iter = tqdm(tst_dldr, desc="Iteration")
for step, batch in enumerate(tst_iter):
inputs = batch['image']
ids.extend(batch['id'])
inputs = inputs.to(device, dtype=torch.float)
# labels = labels.to(device, dtype=torch.float)
predictions.extend(torch.sigmoid(model(inputs)).tolist())
pred_df = pd.DataFrame(predictions, columns=DIAGNOSIS, index=ids)
pred_df.index.name = 'ID'
masked_pred_df = pred_df.copy(deep=True)
masked_pred_df.loc[tst_outlier_mask] = \
[[0, 0, 0, 0, 0, 0]] * tst_outlier_mask.sum()
print(pred_df.head())
print(masked_pred_df.head())
tst_lbl_df_to_submission_csv(
pred_df, f'./e_{equalization}_n_{normalization}_{epoch+1}.csv')
tst_lbl_df_to_submission_csv(
masked_pred_df,
f'./masked_e_{equalization}_n_{normalization}_{epoch+1}.csv')
import random
random.seed(1000)
from albumentations import (Compose, HorizontalFlip, CLAHE, HueSaturationValue,
RandomBrightness, RandomContrast, RandomGamma,
RandomRotate90, VerticalFlip, RandomCrop, ToFloat,
ShiftScaleRotate, GaussianBlur)
AUGMENTATIONS_TRAIN = Compose([
HorizontalFlip(p=1),
VerticalFlip(p=0.5),
# RandomContrast(limit=0.2, p=0.5),
RandomRotate90(p=0.5),
RandomGamma(gamma_limit=(80, 120), p=0.5),
# RandomBrightness(limit=0.2, p=0.5),
# HueSaturationValue(hue_shift_limit=5, sat_shift_limit=20,
# val_shift_limit=10, p=.9),
# CLAHE(p=1.0, clip_limit=2.0),
ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.1,
rotate_limit=15,
border_mode=cv2.BORDER_REFLECT_101,
p=0.5),
# RandomCrop(227, 227, p=1.0),
# ToFloat(max_value=255)
])
AUGMENTATIONS_TEST = Compose([
# CLAHE(p=1.0, clip_limit=2.0),
# RandomCrop(227, 227, p=1.0),
# ToFloat(max_value=255,p=1)
])
import cv2
from albumentations import Compose, OneOf, Normalize, ShiftScaleRotate
from albumentations import GaussNoise, OpticalDistortion, GridDistortion
from albumentations import Cutout, Rotate, ElasticTransform, IAAAffine, IAAPerspective
augmix_transform = [
ShiftScaleRotate(rotate_limit=15, p=1),
OpticalDistortion(p=1),
Cutout(max_h_size=8, max_w_size=8, p=1),
# GridDistortion(p=1),
Rotate(limit=15, p=1)
]
faa_transform = Compose([
# GaussNoise(p=0.2),
GridDistortion(num_steps=6, distort_limit=0.046, p=0.02),
# OneOf([
# OpticalDistortion(p=1),
# ElasticTransform(p=1),
# ], p=0.2),
Cutout(num_holes=7, max_h_size=18, max_w_size=2, p=0.05),
])
train_transform = Compose([
ShiftScaleRotate(rotate_limit=15, p=0.5),
# GaussNoise(p=0.2),
# GridDistortion(p=0.5),
# OneOf([
# OpticalDistortion(p=1),
# ElasticTransform(p=1),
# ], p=0.2),
from albumentations import Compose, Resize, RandomCrop, Flip, HorizontalFlip, VerticalFlip, Transpose, RandomRotate90, \
ShiftScaleRotate, OneOf, OpticalDistortion, Blur, MotionBlur, GaussianBlur
from albumentations.pytorch import ToTensor
train_aug = Compose([
RandomCrop(height=96, width=96, p=0.2),
OneOf([
VerticalFlip(p=0.2),
HorizontalFlip(p=0.3),
Transpose(p=0.2),
RandomRotate90(p=0.2),
],
p=0.3),
ShiftScaleRotate(p=0.2),
OneOf([
Blur(p=0.2),
MotionBlur(p=0.2),
GaussianBlur(p=0.2),
OpticalDistortion(p=0.2),
],
p=0.3),
Resize(128, 128, always_apply=True),
ToTensor()
])
valid_aug = Compose([Resize(128, 128, always_apply=True), ToTensor()])
def get_transforms(*, data):
if data == 'train':
return Compose(
[
#Resize(CFG.size, CFG.size),
RandomResizedCrop(CFG.size, CFG.size, scale=(0.85, 1.0)),
HorizontalFlip(p=0.5),
RandomBrightnessContrast(p=0.2,
brightness_limit=(-0.2, 0.2),
contrast_limit=(-0.2, 0.2)),
HueSaturationValue(p=0.2,
hue_shift_limit=0.2,
sat_shift_limit=0.2,
val_shift_limit=0.2),
ShiftScaleRotate(p=0.2,
shift_limit=0.0625,
scale_limit=0.2,
rotate_limit=20),
CoarseDropout(p=0.2),
Cutout(p=0.2,
max_h_size=16,
max_w_size=16,
fill_value=(0., 0., 0.),
num_holes=16),
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensorV2(),
],
additional_targets={'image_annot': 'image'})
elif data == 'check':
return Compose(
[
#Resize(CFG.size, CFG.size),
RandomResizedCrop(CFG.size, CFG.size, scale=(0.85, 1.0)),
HorizontalFlip(p=0.5),
RandomBrightnessContrast(p=0.2,
brightness_limit=(-0.2, 0.2),
contrast_limit=(-0.2, 0.2)),
HueSaturationValue(p=0.2,
hue_shift_limit=0.2,
sat_shift_limit=0.2,
val_shift_limit=0.2),
ShiftScaleRotate(p=0.2,
shift_limit=0.0625,
scale_limit=0.2,
rotate_limit=20),
CoarseDropout(p=0.2),
Cutout(p=0.2,
max_h_size=16,
max_w_size=16,
fill_value=(0., 0., 0.),
num_holes=16),
#Normalize(
# mean=[0.485, 0.456, 0.406],
# std=[0.229, 0.224, 0.225],
#),
ToTensorV2(),
],
additional_targets={'image_annot': 'image'})
elif data == 'valid':
return Compose([
Resize(CFG.size, CFG.size),
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensorV2(),
])
def generate_transforms(image_size):
# train_transform = Compose(
# [
# Resize(height=int(image_size[0]), width=int(image_size[1])),
# OneOf([RandomBrightness(limit=0.1, p=1), RandomContrast(limit=0.1, p=1)]),
# OneOf([MotionBlur(blur_limit=3), MedianBlur(blur_limit=3), GaussianBlur(blur_limit=3)], p=0.5),
# VerticalFlip(p=0.5),
# HorizontalFlip(p=0.5),
# # Transpose(p=0.5),
# HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5),
# CoarseDropout(p=0.5),
# Cutout(p=0.5),
# ShiftScaleRotate(
# shift_limit=0.2,
# scale_limit=0.2,
# rotate_limit=20,
# interpolation=cv2.INTER_LINEAR,
# border_mode=cv2.BORDER_REFLECT_101,
# 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),
# ]
# )
train_transform = Compose(
[
RandomResizedCrop(int(image_size[0]),
int(image_size[1]),
scale=(0.08, 1.0),
ratio=(0.75, 1.3333333333333333)),
Transpose(p=0.5),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
ShiftScaleRotate(p=0.5),
HueSaturationValue(hue_shift_limit=0.2,
sat_shift_limit=0.2,
val_shift_limit=0.2,
p=0.5),
RandomBrightnessContrast(brightness_limit=(-0.1, 0.1),
contrast_limit=(-0.1, 0.1),
p=0.5),
Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
max_pixel_value=255.0,
p=1.0),
# CoarseDropout(p=0.5),
# Cutout(p=0.5),
# ToTensorV2(p=1.0),
],
p=1.)
val_transform = Compose([
Resize(height=int(image_size[0]), width=int(image_size[1])),
Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225),
max_pixel_value=255.0,
p=1.0),
])
return {
"train_transforms": train_transform,
"val_transforms": val_transform
}
bad_images = [
'046586a', '1588d4c', '1e40a05', '41f92e5', '449b792', '563fc48',
'8bd81ce', 'b092cc1', 'c0306e5', 'c26c635', 'e04fea3', 'e5f2f24',
'eda52f2', 'fa645da'
]
AUGMENTATIONS_TRAIN = Compose([
RandomRotate90(p=0.25),
RandomResizedCrop(
height=TRAIN_SHAPE[0], width=TRAIN_SHAPE[1], scale=(0.8, 1.0)),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
ShiftScaleRotate(shift_limit=(-0.2, 0.2),
scale_limit=(-0.2, 0.2),
rotate_limit=(-20, 20),
border_mode=0,
interpolation=1,
p=0.25),
OneOf([
RandomBrightnessContrast(brightness_limit=(-0.2, 0.2),
contrast_limit=(-0.2, 0.2)),
RandomGamma(),
CLAHE()
],
p=0.4),
OneOf([
ElasticTransform(
p=0.2, alpha=120, sigma=120 * 0.1, alpha_affine=120 * 0.03),
GridDistortion(p=0.5),
OpticalDistortion(border_mode=0,
distort_limit=0.05,
train = train.set_index('Image').loc[png].reset_index()
# get fold
valdf = train[train['fold'] == fold].reset_index(drop=True)
trndf = train[train['fold'] != fold].reset_index(drop=True)
# Data loaders
mean_img = [0.22363983, 0.18190407, 0.2523437]
std_img = [0.32451536, 0.2956294, 0.31335256]
transform_train = Compose([
#ShiftScaleRotate(),
#CenterCrop(height = SIZE//10, width = SIZE//10, p=0.3),
HorizontalFlip(p=0.5),
ShiftScaleRotate(shift_limit=0.05,
scale_limit=0.05,
rotate_limit=20,
p=0.3,
border_mode=cv2.BORDER_REPLICATE),
Transpose(p=0.5),
Normalize(mean=mean_img, std=std_img, max_pixel_value=255.0, p=1.0),
ToTensor()
])
HFLIPVAL = 1.0 if HFLIP == 'T' else 0.0
TRANSPOSEVAL = 1.0 if TRANSPOSE == 'P' else 0.0
transform_test = Compose([
HorizontalFlip(p=HFLIPVAL),
Transpose(p=TRANSPOSEVAL),
Normalize(mean=mean_img, std=std_img, max_pixel_value=255.0, p=1.0),
ToTensor()
])
def train_transform(self):
# albumentations transforms cfg
at_cfg = self.cfg.abtfs
height, width = self.img_size
transforms_list = [Resize(height, width), Flip()]
# random_grid_shuffle
if at_cfg.random_grid_shuffle.enable:
grid = at_cfg.random_grid_shuffle.grid
grid = (grid, grid)
transforms_list.append(RandomGridShuffle((grid)))
# channel_shuffle
if at_cfg.channel_shuffle.enable:
transforms_list.append(ChannelShuffle(p=1))
# channel_dropout
if at_cfg.channel_dropout.enable:
drop_range = at_cfg.channel_dropout.drop_range
fill_value = at_cfg.channel_dropout.fill_value
transforms_list.append(ChannelDropout(drop_range, fill_value, p=1))
# noise
if at_cfg.noise.enable:
transforms_list.append(
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
], p=1))
# blur
if at_cfg.blur.enable:
transforms_list.append(
OneOf([
MotionBlur(),
Blur(blur_limit=3, ),
], p=1))
# rotate
if at_cfg.rotate.enable:
transforms_list.append(
ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.2,
rotate_limit=45,
p=1))
# distortion
if at_cfg.distortion.enable:
transforms_list.append(
OneOf([
OpticalDistortion(p=0.3),
GridDistortion(p=.3),
], p=1))
# bright
if at_cfg.bright.enable:
transforms_list.append(
OneOf([
CLAHE(clip_limit=2),
RandomBrightnessContrast(p=0.8),
],
p=1))
# hue color
if at_cfg.hue.enable:
transforms_list.append(HueSaturationValue(p=0.3))
# cutout
if at_cfg.cutout.enable:
num_holes = at_cfg.cutout.num_holes
size = at_cfg.cutout.size
fill_value = at_cfg.cutout.fill_value
transforms_list.append(Cutout(num_holes, size, size, fill_value,
1))
transforms_list.append(self.normalize)
transforms_list.append(ToTensor())
return Compose(transforms_list)
def imgClassificationfolder(self,
img_path,
model_list=None,
tfms=True,
advance_augmentation=False,
size=224,
bs=16,
epochs=1,
test_size=0.3):
"""
RETURNS MODEL
model_list: list of names of all models that need to be trained
Call Model_Names() function to get the list of available models
img_path: path to the images root folder containing the individual image folders
tfms: augmentation transforms. Possible methods are True or False
advance_augmentation: Should we apply advance data augmentation?
size: individual image size in dataloader. Default size set to 224
bs:batch size
epochs:number of epochs for which the individual models need to be trained
test_size:test size for ranking the models
"""
dictionary = {}
dictionary["models"] = [
resnet18, resnet34, resnet50, resnet101, resnet152, densenet121,
densenet169, densenet201, densenet161, vgg16_bn, vgg19_bn
]
dictionary["model_names"] = [
'resnet18', 'resnet34', 'resnet50', 'resnet101', 'resnet152',
'densenet121', 'densenet169', 'densenet201', 'densenet161',
'vgg16_bn', 'vgg19_bn'
]
dictionary["efficientnets"] = [
"efficientnet-b{}".format(i) for i in range(0, 8)
]
accuracy = []
roc_auc = []
list_names = []
path = ''
if model_list is None:
model_list = dictionary["model_names"]
if tfms == True:
if advance_augmentation:
tfms = get_transforms(do_flip=True,
max_lighting=0.2,
max_zoom=1.1,
max_warp=0.15,
max_rotate=45,
xtra_tfms=[
alb_tfm2fastai(ElasticTransform()),
alb_tfm2fastai(GridDistortion()),
alb_tfm2fastai(OpticalDistortion()),
alb_tfm2fastai(MedianBlur()),
alb_tfm2fastai(ToGray()),
alb_tfm2fastai(JpegCompression()),
alb_tfm2fastai(Transpose()),
alb_tfm2fastai(ShiftScaleRotate()),
alb_tfm2fastai(Normalize()),
alb_tfm2fastai(Blur()),
alb_tfm2fastai(CLAHE()),
alb_tfm2fastai(RGBShift()),
alb_tfm2fastai(ChannelShuffle()),
alb_tfm2fastai(RandomContrast()),
alb_tfm2fastai(RandomBrightness())
])
else:
tfms = get_transforms(do_flip=True,
max_lighting=0.2,
max_zoom=1.1,
max_warp=0.15,
max_rotate=45)
else:
tfms = False
data = ImageDataBunch.from_folder(
img_path,
valid_pct=test_size,
ds_tfms=tfms,
size=224,
num_workers=4).normalize(imagenet_stats)
print("Loaded dataset\n")
print("Labels classified from the source are {}\n".format(
data.classes))
max_score = 0
for model in model_list:
if model in dictionary["model_names"]:
print("Started training {}\n".format(model))
acc, auroc, names, model = self.res_dense_vgg(
data, eval(model), epochs)
accuracy.append(acc)
roc_auc.append(auroc)
list_names.append(names)
if model in dictionary['efficientnets']:
print("Started training {}\n".format(model))
acc, auroc, names, model = self.eff(data, model, epochs)
accuracy.append(acc)
roc_auc.append(auroc)
list_names.append(names)
if acc > max_score:
best_model = model
max_score = acc
else:
del model
df = pd.DataFrame(list(zip(model_list, accuracy, roc_auc)),
columns=['Model', 'Accuracy', 'ROAUC'])
df.sort_values('Accuracy', inplace=True, ascending=False)
self.plot_table(df)
return best_model
def _get_data_loader(imgs, trn_df, vld_df):
from albumentations import (
Rotate, HorizontalFlip, IAAPerspective, ShiftScaleRotate, CLAHE,
RandomRotate90, Transpose, ShiftScaleRotate, Blur, OpticalDistortion,
GridDistortion, HueSaturationValue, IAAAdditiveGaussianNoise,
GaussNoise, MotionBlur, MedianBlur, RandomBrightnessContrast,
IAAPiecewiseAffine, IAASharpen, IAAEmboss, Flip, OneOf, Compose)
from albumentations.pytorch import ToTensor, ToTensorV2
train_transforms = Compose([
Rotate(20),
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
], p=0.2),
OneOf([
MotionBlur(p=.2),
MedianBlur(blur_limit=3, p=0.1),
Blur(blur_limit=3, p=0.1),
],
p=0.2),
ShiftScaleRotate(
shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2),
OneOf([
OpticalDistortion(p=0.3),
GridDistortion(p=.1),
IAAPiecewiseAffine(p=0.3),
],
p=0.2),
OneOf([
CLAHE(clip_limit=2),
IAASharpen(),
IAAEmboss(),
RandomBrightnessContrast(),
],
p=0.3),
HueSaturationValue(p=0.3),
ToTensor()
],
p=1.0)
valid_transforms = Compose([ToTensor()])
from torch.utils.data import Dataset, DataLoader
trn_dataset = BangaliDataset(imgs=imgs,
label_df=trn_df,
transform=train_transforms)
vld_dataset = BangaliDataset(imgs=imgs,
label_df=vld_df,
transform=valid_transforms)
trn_loader = DataLoader(trn_dataset,
shuffle=True,
num_workers=NUM_WORKERS,
batch_size=BATCH_SIZE)
vld_loader = DataLoader(vld_dataset,
shuffle=False,
num_workers=NUM_WORKERS,
batch_size=BATCH_SIZE)
return trn_loader, vld_loader
def __init__(self, shift_limit=0.01, scale_limit=0.2, rotate_limit=180, apply_prob=1.0):
self.aug = Compose([ShiftScaleRotate(shift_limit=shift_limit, scale_limit=scale_limit,
rotate_limit=rotate_limit, border_mode=cv2.BORDER_CONSTANT, value=0)],
p=apply_prob, keypoint_params={'format': 'xy'})
def build_databunch(cfg, tmp_dir):
dataset = cfg.data.dataset
validate_dataset(dataset)
img_sz = cfg.data.img_sz
batch_sz = cfg.solver.batch_sz
num_workers = cfg.data.num_workers
data_cache_dir = '/opt/data/data-cache'
if cfg.data.dataset == pascal2007:
if cfg.base_uri.startswith('s3://'):
data_dir = join(data_cache_dir, 'pascal2007-data')
if not os.path.isdir(data_dir):
print('Downloading pascal2007.zip...')
zip_path = download_if_needed(
join(cfg.base_uri, 'pascal2007.zip'), data_cache_dir)
unzip(zip_path, data_dir)
else:
data_dir = join(cfg.base_uri, 'data', 'pascal_2007')
train_dir = join(data_dir, 'train')
train_anns = [
join(data_dir, 'train.json'),
join(data_dir, 'valid.json')
]
test_dir = join(data_dir, 'test')
test_anns = [join(data_dir, 'test.json')]
label_names = get_label_names(train_anns[0])
aug_transforms = []
if cfg.data.train_aug.hflip:
aug_transforms.append(HorizontalFlip(p=0.5))
if cfg.data.train_aug.rgb_shift:
aug_transforms.append(RGBShift(20, 20, 20, p=0.5))
if cfg.data.train_aug.shift_scale_rotate:
aug_transforms.append(
ShiftScaleRotate(shift_limit=0.1,
scale_limit=0.3,
rotate_limit=0,
border_mode=cv2.BORDER_CONSTANT))
basic_transforms = [Resize(img_sz, img_sz), ToTensor()]
aug_transforms.extend(basic_transforms)
bbox_params = BboxParams(format='coco',
min_area=0.,
min_visibility=0.2,
label_fields=['labels'])
aug_transforms = Compose(aug_transforms, bbox_params=bbox_params)
transforms = Compose(basic_transforms, bbox_params=bbox_params)
train_ds, valid_ds, test_ds = None, None, None
if cfg.overfit_mode:
train_ds = CocoDataset(train_dir, train_anns, transforms=transforms)
train_ds = Subset(train_ds, range(batch_sz))
test_ds = train_ds
elif cfg.test_mode:
train_ds = CocoDataset(train_dir,
train_anns,
transforms=aug_transforms)
train_ds = Subset(train_ds, range(batch_sz))
valid_ds = train_ds
test_ds = train_ds
else:
train_ds = CocoDataset(train_dir,
train_anns,
transforms=aug_transforms)
test_ds = CocoDataset(test_dir, test_anns, transforms=transforms)
valid_ds = Subset(test_ds, range(len(test_ds.imgs) // 5))
train_dl = DataLoader(train_ds, shuffle=True, collate_fn=collate_fn, batch_size=batch_sz, num_workers=num_workers, pin_memory=True) \
if train_ds else None
valid_dl = DataLoader(valid_ds, collate_fn=collate_fn, batch_size=batch_sz, num_workers=num_workers, pin_memory=True) \
if valid_ds else None
test_dl = DataLoader(test_ds, collate_fn=collate_fn, batch_size=batch_sz, num_workers=num_workers, pin_memory=True) \
if test_ds else None
return DataBunch(train_ds, train_dl, valid_ds, valid_dl, test_ds, test_dl,
label_names)
def __init__(self,
split: Callable[[str], str] = lambda x: path.splitext(x)[0],
suffix: str = '.gt.txt',
normalization: Optional[str] = None,
whitespace_normalization: bool = True,
reorder: bool = True,
im_transforms: Callable[[Any],
torch.Tensor] = transforms.Compose(
[]),
preload: bool = True,
augmentation: bool = False) -> None:
"""
Reads a list of image-text pairs and creates a ground truth set.
Args:
split (func): Function for generating the base name without
extensions from paths
suffix (str): Suffix to attach to image base name for text
retrieval
mode (str): Image color space. Either RGB (color) or L
(grayscale/bw). Only L is compatible with vertical
scaling/dewarping.
scale (int, tuple): Target height or (width, height) of dewarped
line images. Vertical-only scaling is through
CenterLineNormalizer, resizing with Lanczos
interpolation. Set to 0 to disable.
normalization (str): Unicode normalization for gt
whitespace_normalization (str): Normalizes unicode whitespace and
strips whitespace.
reorder (bool): Whether to rearrange code points in "display"/LTR
order
im_transforms (func): Function taking an PIL.Image and returning a
tensor suitable for forward passes.
preload (bool): Enables preloading and preprocessing of image files.
"""
self.suffix = suffix
self.split = lambda x: split(x) + self.suffix
self._images = [] # type: Union[List[Image], List[torch.Tensor]]
self._gt = [] # type: List[str]
self.alphabet = Counter() # type: Counter
self.text_transforms = [] # type: List[Callable[[str], str]]
# split image transforms into two. one part giving the final PIL image
# before conversion to a tensor and the actual tensor conversion part.
self.head_transforms = transforms.Compose(im_transforms.transforms[:2])
self.tail_transforms = transforms.Compose(im_transforms.transforms[2:])
self.aug = None
self.preload = preload
self.seg_type = 'bbox'
# built text transformations
if normalization:
self.text_transforms.append(
lambda x: unicodedata.normalize(cast(str, normalization), x))
if whitespace_normalization:
self.text_transforms.append(
lambda x: regex.sub('\s', ' ', x).strip())
if reorder:
self.text_transforms.append(bd.get_display)
if augmentation:
from albumentations import (
Compose,
ToFloat,
FromFloat,
Flip,
OneOf,
MotionBlur,
MedianBlur,
Blur,
ShiftScaleRotate,
OpticalDistortion,
ElasticTransform,
RandomBrightnessContrast,
)
self.aug = Compose([
ToFloat(),
OneOf([
MotionBlur(p=0.2),
MedianBlur(blur_limit=3, p=0.1),
Blur(blur_limit=3, p=0.1),
],
p=0.2),
ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.2,
rotate_limit=45,
p=0.2),
OneOf([
OpticalDistortion(p=0.3),
ElasticTransform(p=0.1),
],
p=0.2),
],
p=0.5)
self.im_mode = '1'
"2017-08-04",
"2017-08-19",
)
rgb_file_path = f"{args.root}/train_rgb.csv"
nir_file_path = f"{args.root}/train_b08.csv"
additional_targets = {
f"image{n}": "image"
for n, _ in enumerate(dates[:-1])
}
data_transform = Compose(
[
RandomCrop(128, 128),
VerticalFlip(p=0.3),
Transpose(p=0.3),
ShiftScaleRotate(p=0.3),
RandomRotate90(p=0.3),
GridDistortion(p=0.3),
ElasticTransform(p=0.3),
Normalize(),
],
additional_targets=additional_targets,
)
val_transform = Compose(
[RandomCrop(128, 128), Normalize()],
additional_targets=additional_targets)
#fold_sets = [[(0, 1, 2), (0, 1, 2)]]
fold_sets = [[(1, 2), (0, )], [(0, 2), (1, )], [(0, 1), (2, )]]
# # KOSTIL' ALERT
def __init__(self,
imgs: Sequence[str] = None,
suffix: str = '.path',
line_width: int = 4,
im_transforms: Callable[[Any],
torch.Tensor] = transforms.Compose(
[]),
mode: str = 'path',
augmentation: bool = False,
valid_baselines: Sequence[str] = None,
merge_baselines: Dict[str, Sequence[str]] = None,
valid_regions: Sequence[str] = None,
merge_regions: Dict[str, Sequence[str]] = None):
"""
Reads a list of image-json pairs and creates a data set.
Args:
imgs (list):
suffix (int): Suffix to attach to image base name to load JSON
files from.
line_width (int): Height of the baseline in the scaled input.
target_size (tuple): Target size of the image as a (height, width) tuple.
mode (str): Either path, alto, page, xml, or None. In alto, page,
and xml mode the baseline paths and image data is
retrieved from an ALTO/PageXML file. In `None` mode
data is iteratively added through the `add` method.
augmentation (bool): Enable/disable augmentation.
valid_baselines (list): Sequence of valid baseline identifiers. If
`None` all are valid.
merge_baselines (dict): Sequence of baseline identifiers to merge.
Note that merging occurs after entities not
in valid_* have been discarded.
valid_regions (list): Sequence of valid region identifiers. If
`None` all are valid.
merge_regions (dict): Sequence of region identifiers to merge.
Note that merging occurs after entities not
in valid_* have been discarded.
"""
super().__init__()
self.mode = mode
self.im_mode = '1'
self.aug = None
self.targets = []
# n-th entry contains semantic of n-th class
self.class_mapping = {
'aux': {
'_start_separator': 0,
'_end_separator': 1
},
'baselines': {},
'regions': {}
}
self.class_stats = {
'baselines': defaultdict(int),
'regions': defaultdict(int)
}
self.num_classes = 2
self.mbl_dict = merge_baselines if merge_baselines is not None else {}
self.mreg_dict = merge_regions if merge_regions is not None else {}
self.valid_baselines = valid_baselines
self.valid_regions = valid_regions
if mode in ['alto', 'page', 'xml']:
if mode == 'alto':
fn = parse_alto
elif mode == 'page':
fn = parse_page
elif mode == 'xml':
fn = parse_xml
im_paths = []
self.targets = []
for img in imgs:
try:
data = fn(img)
im_paths.append(data['image'])
lines = defaultdict(list)
for line in data['lines']:
if valid_baselines is None or line[
'script'] in valid_baselines:
lines[self.mbl_dict.get(line['script'],
line['script'])].append(
line['baseline'])
self.class_stats['baselines'][self.mbl_dict.get(
line['script'], line['script'])] += 1
regions = defaultdict(list)
for k, v in data['regions'].items():
if valid_regions is None or k in valid_regions:
regions[self.mreg_dict.get(k, k)].extend(v)
self.class_stats['regions'][self.mreg_dict.get(
k, k)] += len(v)
data['regions'] = regions
self.targets.append({
'baselines': lines,
'regions': data['regions']
})
except KrakenInputException as e:
logger.warning(e)
continue
# get line types
imgs = im_paths
# calculate class mapping
line_types = set()
region_types = set()
for page in self.targets:
for line_type in page['baselines'].keys():
line_types.add(line_type)
for reg_type in page['regions'].keys():
region_types.add(reg_type)
idx = -1
for idx, line_type in enumerate(line_types):
self.class_mapping['baselines'][
line_type] = idx + self.num_classes
self.num_classes += idx + 1
idx = -1
for idx, reg_type in enumerate(region_types):
self.class_mapping['regions'][
reg_type] = idx + self.num_classes
self.num_classes += idx + 1
elif mode == 'path':
pass
elif mode is None:
imgs = []
else:
raise Exception('invalid dataset mode')
if augmentation:
from albumentations import (
Compose,
ToFloat,
FromFloat,
RandomRotate90,
Flip,
OneOf,
MotionBlur,
MedianBlur,
Blur,
ShiftScaleRotate,
OpticalDistortion,
ElasticTransform,
RandomBrightnessContrast,
HueSaturationValue,
)
self.aug = Compose([
ToFloat(),
RandomRotate90(),
Flip(),
OneOf([
MotionBlur(p=0.2),
MedianBlur(blur_limit=3, p=0.1),
Blur(blur_limit=3, p=0.1),
],
p=0.2),
ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.2,
rotate_limit=45,
p=0.2),
OneOf([
OpticalDistortion(p=0.3),
ElasticTransform(p=0.1),
],
p=0.2),
HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=0.1,
val_shift_limit=0.1,
p=0.3),
],
p=0.5)
self.imgs = imgs
self.line_width = line_width
# split image transforms into two. one part giving the final PIL image
# before conversion to a tensor and the actual tensor conversion part.
self.head_transforms = transforms.Compose(im_transforms.transforms[:2])
self.tail_transforms = transforms.Compose(im_transforms.transforms[2:])
self.seg_type = None
while True:
batch_indices = np.random.choice(x_len, size=batch_size)
for idx in batch_indices:
batch_y.append(y[idx])
batch_x.append(aug(image=x[idx])['image'] / 255.0)
batch_x, batch_y = np.stack(batch_x), np.stack(batch_y)
yield batch_x, batch_y
batch_x, batch_y = [], []
aug_for_train = albu.Compose([
HorizontalFlip(p=0.5),
ShiftScaleRotate(shift_limit=0.1, scale_limit=0.25, rotate_limit=20,
p=0.5),
GridDistortion(p=0.5)
])
aug_for_valid = albu.Compose([])
train_gen = input_generator(x_train, y_train, aug_for_train, batch_size)
valid_gen = input_generator(x_test, y_test, aug_for_valid, batch_size)
def display_training_result(history):
plt.figure(figsize=(16, 12))
plt.subplot(2, 1, 1)
plt.plot(history.history['loss'], label='train_loss', color='g')
plt.plot(history.history['val_loss'], label='valid_loss', color='r')
from albumentations import Compose, Resize, RandomCrop, Flip, HorizontalFlip, VerticalFlip, Transpose, RandomRotate90, \
ShiftScaleRotate, OneOf, Blur, MotionBlur, MedianBlur, GaussianBlur, RandomBrightnessContrast
from albumentations.pytorch import ToTensor
train_aug = Compose([
RandomCrop(height=96, width=96, p=0.4),
OneOf([
VerticalFlip(p=0.2),
HorizontalFlip(p=0.3),
Transpose(p=0.2),
RandomRotate90(p=0.2),
],
p=0.5),
ShiftScaleRotate(p=0.5),
OneOf([
Blur(p=0.2),
MotionBlur(p=0.2),
MedianBlur(p=0.2),
GaussianBlur(p=0.2),
],
p=0.4),
RandomBrightnessContrast(p=0.5, brightness_limit=0.4, contrast_limit=0.4),
Resize(128, 128, always_apply=True),
ToTensor()
])
valid_aug = Compose([Resize(128, 128, always_apply=True), ToTensor()])
def train_transform(self):
height, width = self.img_size
transforms_list = [Resize(height, width), Flip()]
# random_grid_shuffle
if self.random_grid_shuffle['enable']:
grid = self.random_grid_shuffle['grid']
grid = (grid, grid)
transforms_list.append(RandomGridShuffle((grid)))
# channel_shuffle
if self.channel_shuffle['enable']:
transforms_list.append(ChannelShuffle(p=1))
# channel_dropout
if self.channel_dropout['enable']:
drop_range = self.channel_dropout.drop_range
fill_value = self.channel_dropout.fill_value
transforms_list.append(ChannelDropout(drop_range, fill_value, p=1))
# noise
if self.noise['enable']:
transforms_list.append(
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
], p=1))
# blur
if self.blur['enable']:
transforms_list.append(
OneOf([
MotionBlur(),
Blur(blur_limit=3, ),
], p=1))
# rotate
if self.rotate['enable']:
params = {
key: value
for key, value in self.rotate.items() if key != 'enable'
}
transforms_list.append(ShiftScaleRotate(**params))
# distortion
if self.distortion['enable']:
transforms_list.append(
OneOf([
OpticalDistortion(p=0.3),
GridDistortion(p=.3),
], p=1))
# bright
if self.bright['enable']:
transforms_list.append(
OneOf([
CLAHE(clip_limit=self.bright['clip_limit']),
RandomBrightnessContrast(p=0.8),
],
p=1))
# hue color
if self.hue['enable']:
transforms_list.append(HueSaturationValue(p=0.3))
# cutout
if self.cutout['enable']:
num_holes = self.cutout['num_holes']
size = self.cutout['size']
fill_value = self.cutout['fill_value']
transforms_list.append(Cutout(num_holes, size, size, fill_value,
1))
transforms_list.append(self.normalize)
transforms_list.append(ToTensor())
return Compose(transforms_list)
from albumentations import Compose, Resize, RandomCrop, Flip, HorizontalFlip, VerticalFlip, Transpose, RandomRotate90, \
ShiftScaleRotate, OneOf, Blur, MotionBlur, MedianBlur, GaussianBlur, RandomBrightness, RandomBrightnessContrast, \
Normalize
from albumentations.pytorch import ToTensor
train_aug = Compose([
OneOf([
VerticalFlip(p=0.2),
HorizontalFlip(p=0.3),
Transpose(p=0.2),
RandomRotate90(p=0.2),
],
p=0.4),
ShiftScaleRotate(p=0.4),
OneOf([
Blur(p=0.2),
MotionBlur(p=0.2),
MedianBlur(p=0.2),
GaussianBlur(p=0.2),
],
p=0.4),
RandomBrightnessContrast(p=0.4, brightness_limit=0.4, contrast_limit=0.4),
Resize(128, 128, always_apply=True),
Normalize(mean=0.06922848809290576, std=0.20515700083327537),
ToTensor()
])
valid_aug = Compose([
Resize(128, 128, always_apply=True),
Normalize(mean=0.06922848809290576, std=0.20515700083327537),
ToTensor()
def Shift_Scale_Rotate(img):
transform = Compose([HorizontalFlip(), ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.5, rotate_limit=45, interpolation=2),
RandomCrop(img.shape[1], img.shape[1])])
Aug_img = transform(image=img)
return Aug_img
holdout = pd.read_csv(config['PATH_DATA'] + 'holdout.csv')
holdout['is_valid'] = True
train_df = train_df.append(holdout)
print('train_df.shape:', train_df.shape)
nunique = list(train_df.nunique())[1:-2]
print('nunique:', nunique)
# --- IMAGE DATABUNCH ---
if not config['FINETUNE']:
train_tf = Compose([
OneOf([
ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.1,
rotate_limit=15,
always_apply=True),
IAAPerspective(always_apply=True),
IAAPiecewiseAffine(always_apply=True)
],
p=0.5)
])
def new_open_image(fn: PathOrStr,
div: bool = True,
convert_mode: str = 'L',
after_open: Callable = None,
transforms=True) -> Image:
"Return `Image` object created from image in file `fn`."
with warnings.catch_warnings():
warnings.simplefilter("ignore",
GridDistortion,
OpticalDistortion,
RandomSizedCrop,
OneOf,
CLAHE,
RandomContrast,
RandomGamma,
RandomBrightness,
ShiftScaleRotate
)
aug = Compose(
[
VerticalFlip(p=0.5),
HorizontalFlip(p=0.5),
ShiftScaleRotate(shift_limit=0.0625,scale_limit=0.5,rotate_limit=45,p=0.5),
GridDistortion(p=0.5),
# RandomRotate90(p=0.5),
# ], p=0.8),
# RandomContrast(p=0.5),
# RandomBrightness(p=0.5),
# RandomGamma(p=0.5),
],
p=0.5)
def augment_flips_color(p=.5):
return Compose([
VerticalFlip(p=0.5),
HorizontalFlip(p=0.5),
#GridDistortion(p=0.5),
ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.50, rotate_limit=10, p=0.5),
def train(model, cfg, model_cfg, start_epoch=0):
cfg.batch_size = 28 if cfg.batch_size < 1 else cfg.batch_size
cfg.val_batch_size = cfg.batch_size
cfg.input_normalization = model_cfg.input_normalization
crop_size = model_cfg.crop_size
loss_cfg = edict()
loss_cfg.instance_loss = SigmoidBinaryCrossEntropyLoss()
loss_cfg.instance_loss_weight = 1.0
num_epochs = 120
num_masks = 1
train_augmentator = Compose([
Flip(),
RandomRotate90(),
ShiftScaleRotate(shift_limit=0.03,
scale_limit=0,
rotate_limit=(-3, 3),
border_mode=0,
p=0.75),
PadIfNeeded(
min_height=crop_size[0], min_width=crop_size[1], border_mode=0),
RandomCrop(*crop_size),
RandomBrightnessContrast(brightness_limit=(-0.25, 0.25),
contrast_limit=(-0.15, 0.4),
p=0.75),
RGBShift(r_shift_limit=10, g_shift_limit=10, b_shift_limit=10, p=0.75)
],
p=1.0)
val_augmentator = Compose([
PadIfNeeded(
min_height=crop_size[0], min_width=crop_size[1], border_mode=0),
RandomCrop(*crop_size)
],
p=1.0)
def scale_func(image_shape):
return random.uniform(0.75, 1.25)
points_sampler = MultiPointSampler(model_cfg.num_max_points,
prob_gamma=0.7,
merge_objects_prob=0.15,
max_num_merged_objects=2)
trainset = SBDDataset(
cfg.SBD_PATH,
split='train',
num_masks=num_masks,
augmentator=train_augmentator,
points_from_one_object=False,
input_transform=model_cfg.input_transform,
min_object_area=80,
keep_background_prob=0.0,
image_rescale=scale_func,
points_sampler=points_sampler,
samples_scores_path='./models/sbd/sbd_samples_weights.pkl',
samples_scores_gamma=1.25)
valset = SBDDataset(cfg.SBD_PATH,
split='val',
augmentator=val_augmentator,
num_masks=num_masks,
points_from_one_object=False,
input_transform=model_cfg.input_transform,
min_object_area=80,
image_rescale=scale_func,
points_sampler=points_sampler)
optimizer_params = {'lr': 5e-4, 'betas': (0.9, 0.999), 'eps': 1e-8}
lr_scheduler = partial(torch.optim.lr_scheduler.MultiStepLR,
milestones=[100],
gamma=0.1)
trainer = ISTrainer(model,
cfg,
model_cfg,
loss_cfg,
trainset,
valset,
optimizer_params=optimizer_params,
lr_scheduler=lr_scheduler,
checkpoint_interval=5,
image_dump_interval=200,
metrics=[AdaptiveIoU()],
max_interactive_points=model_cfg.num_max_points)
logger.info(f'Starting Epoch: {start_epoch}')
logger.info(f'Total Epochs: {num_epochs}')
for epoch in range(start_epoch, num_epochs):
trainer.training(epoch)
trainer.validation(epoch)
def get_transforms(phase_config):
list_transforms = []
if phase_config.Resize.p > 0:
list_transforms.append(
Resize(phase_config.Resize.height, phase_config.Resize.width, p=1))
if phase_config.HorizontalFlip:
list_transforms.append(HorizontalFlip())
if phase_config.VerticalFlip:
list_transforms.append(VerticalFlip())
if phase_config.RandomCropScale:
if phase_config.Resize.p > 0:
height = phase_config.Resize.height
width = phase_config.Resize.width
else:
height = HEIGHT
width = WIDTH
list_transforms.append(
RandomSizedCrop(min_max_height=(int(height * 0.90), height),
height=height,
width=width,
w2h_ratio=width / height))
if phase_config.ShiftScaleRotate:
list_transforms.append(ShiftScaleRotate(p=1))
if phase_config.RandomCrop.p > 0:
list_transforms.append(
RandomCrop(phase_config.RandomCrop.height,
phase_config.RandomCrop.width,
p=1))
if phase_config.Noise:
list_transforms.append(
OneOf([
GaussNoise(),
IAAAdditiveGaussianNoise(),
], p=0.5), )
if phase_config.Contrast:
list_transforms.append(
OneOf([
RandomContrast(0.5),
RandomGamma(),
RandomBrightness(),
],
p=0.5), )
if phase_config.Blur:
list_transforms.append(
OneOf([
MotionBlur(p=.2),
MedianBlur(blur_limit=3, p=0.1),
Blur(blur_limit=3, p=0.1),
],
p=0.5))
if phase_config.Distort:
list_transforms.append(
OneOf([
OpticalDistortion(p=0.3),
GridDistortion(p=.1),
IAAPiecewiseAffine(p=0.3),
],
p=0.5))
if phase_config.Cutout.num_holes > 0:
num_holes = phase_config.Cutout.num_holes
hole_size = phase_config.Cutout.hole_size
list_transforms.append(Cutout(num_holes, hole_size))
list_transforms.extend([
Normalize(mean=phase_config.mean, std=phase_config.std, p=1),
ToTensor(),
])
return Compose(list_transforms)
# Also prepare the test data
test[['ID','Image','Diagnosis']] = test['ID'].str.split('_', expand=True)
test['Image'] = 'ID_' + test['Image']
test = test[['Image', 'Label']]
test.drop_duplicates(inplace=True)
test.to_csv('test.csv', index=False)
# Data loaders
transform_train = Compose([CenterCrop(200, 200),
#Resize(224, 224),
HorizontalFlip(),
RandomBrightnessContrast(),
ShiftScaleRotate(),
ToTensor()
])
transform_test= Compose([CenterCrop(200, 200),
#Resize(224, 224),
ToTensor()
])
train_dataset = IntracranialDataset(
csv_file='train.csv', data_dir=dir_train_img, transform=transform_train, labels=True)
test_dataset = IntracranialDataset(
csv_file='test.csv', data_dir=dir_test_img, transform=transform_test, labels=False)
data_loader_train = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=False, num_workers=8)
def __init__(self,
normalization: Optional[str] = None,
whitespace_normalization: bool = True,
reorder: bool = True,
im_transforms: Callable[[Any],
torch.Tensor] = transforms.Compose(
[]),
preload: bool = True,
augmentation: bool = False) -> None:
self._images = [] # type: Union[List[Image], List[torch.Tensor]]
self._gt = [] # type: List[str]
self.alphabet = Counter() # type: Counter
self.text_transforms = [] # type: List[Callable[[str], str]]
# split image transforms into two. one part giving the final PIL image
# before conversion to a tensor and the actual tensor conversion part.
self.head_transforms = transforms.Compose(im_transforms.transforms[:2])
self.tail_transforms = transforms.Compose(im_transforms.transforms[2:])
self.transforms = im_transforms
self.preload = preload
self.aug = None
self.seg_type = 'baselines'
# built text transformations
if normalization:
self.text_transforms.append(
lambda x: unicodedata.normalize(cast(str, normalization), x))
if whitespace_normalization:
self.text_transforms.append(
lambda x: regex.sub('\s', ' ', x).strip())
if reorder:
self.text_transforms.append(bd.get_display)
if augmentation:
from albumentations import (
Compose,
ToFloat,
FromFloat,
Flip,
OneOf,
MotionBlur,
MedianBlur,
Blur,
ShiftScaleRotate,
OpticalDistortion,
ElasticTransform,
RandomBrightnessContrast,
)
self.aug = Compose([
ToFloat(),
OneOf([
MotionBlur(p=0.2),
MedianBlur(blur_limit=3, p=0.1),
Blur(blur_limit=3, p=0.1),
],
p=0.2),
ShiftScaleRotate(
shift_limit=0.0625, scale_limit=0.2, rotate_limit=3,
p=0.2),
OneOf([
OpticalDistortion(p=0.3),
ElasticTransform(p=0.1),
],
p=0.2),
],
p=0.5)
self.im_mode = '1'
def aug_baseline_simple(image, mask):
aug = Compose([HorizontalFlip(), VerticalFlip(), ShiftScaleRotate()])
aug_img = aug(image=image, mask=mask)
return aug_img['image'], aug_img['mask']
aug = Compose([
RandomRotate90(),
Flip(),
Transpose(),
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
], p=0.2),
OneOf([
MotionBlur(p=.2),
MedianBlur(blur_limit=3, p=.1),
Blur(blur_limit=3, p=.1),
],
p=0.2),
ShiftScaleRotate(
shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=.2),
OneOf([
OpticalDistortion(p=0.3),
GridDistortion(p=.1),
IAAPiecewiseAffine(p=0.3),
],
p=0.2),
OneOf([
CLAHE(clip_limit=2),
IAASharpen(),
IAAEmboss(),
RandomContrast(),
RandomBrightness(),
],
p=0.3),
HueSaturationValue(p=0.3),
